github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/common/leadership_test.go (about)

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package common_test
     5  
     6  import (
     7  	"github.com/golang/mock/gomock"
     8  	"github.com/juju/errors"
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/utils"
    11  	gc "gopkg.in/check.v1"
    12  	"gopkg.in/juju/names.v2"
    13  
    14  	"github.com/juju/juju/apiserver/common"
    15  	commonmocks "github.com/juju/juju/apiserver/common/mocks"
    16  	"github.com/juju/juju/apiserver/params"
    17  	apiservertesting "github.com/juju/juju/apiserver/testing"
    18  	"github.com/juju/juju/core/leadership/mocks"
    19  	coretesting "github.com/juju/juju/testing"
    20  )
    21  
    22  type LeadershipSuite struct {
    23  	coretesting.BaseSuite
    24  
    25  	backend *commonmocks.MockLeadershipPinningBackend
    26  	machine *commonmocks.MockLeadershipMachine
    27  	pinner  *mocks.MockPinner
    28  
    29  	modelTag    names.ModelTag
    30  	authTag     names.Tag
    31  	api         common.LeadershipPinningAPI
    32  	machineApps []string
    33  }
    34  
    35  var _ = gc.Suite(&LeadershipSuite{})
    36  
    37  func (s *LeadershipSuite) SetUpSuite(c *gc.C) {
    38  	s.BaseSuite.SetUpSuite(c)
    39  
    40  	s.modelTag = names.NewModelTag(utils.MustNewUUID().String())
    41  	s.machineApps = []string{"mysql", "redis", "wordpress"}
    42  }
    43  
    44  func (s *LeadershipSuite) SetUpTest(c *gc.C) {
    45  	s.BaseSuite.SetUpTest(c)
    46  	s.authTag = nil
    47  }
    48  
    49  func (s *LeadershipSuite) TestPinnedLeadershipSuccess(c *gc.C) {
    50  	s.authTag = names.NewUserTag("admin")
    51  	defer s.setup(c).Finish()
    52  
    53  	pinned := map[string][]string{"redis": {"machine-0", "machine-1"}}
    54  	s.pinner.EXPECT().PinnedLeadership().Return(pinned)
    55  
    56  	res, err := s.api.PinnedLeadership()
    57  	c.Assert(err, jc.ErrorIsNil)
    58  	c.Check(res.Result, gc.DeepEquals, pinned)
    59  }
    60  
    61  func (s *LeadershipSuite) TestPinnedLeadershipPermissionDenied(c *gc.C) {
    62  	defer s.setup(c).Finish()
    63  
    64  	_, err := s.api.PinnedLeadership()
    65  	c.Check(err, gc.ErrorMatches, "permission denied")
    66  }
    67  
    68  func (s *LeadershipSuite) TestPinMachineApplicationsSuccess(c *gc.C) {
    69  	defer s.setup(c).Finish()
    70  
    71  	for _, app := range s.machineApps {
    72  		s.pinner.EXPECT().PinLeadership(app, s.authTag.String()).Return(nil)
    73  	}
    74  
    75  	res, err := s.api.PinMachineApplications()
    76  	c.Assert(err, jc.ErrorIsNil)
    77  	c.Check(res, gc.DeepEquals, params.PinApplicationsResults{Results: s.pinApplicationsSuccessResults()})
    78  }
    79  
    80  func (s *LeadershipSuite) TestPinMachineApplicationsPartialError(c *gc.C) {
    81  	defer s.setup(c).Finish()
    82  
    83  	errorRes := errors.New("boom")
    84  	s.pinner.EXPECT().PinLeadership("mysql", s.authTag.String()).Return(nil)
    85  	s.pinner.EXPECT().PinLeadership("redis", s.authTag.String()).Return(nil)
    86  	s.pinner.EXPECT().PinLeadership("wordpress", s.authTag.String()).Return(errorRes)
    87  
    88  	res, err := s.api.PinMachineApplications()
    89  	c.Assert(err, jc.ErrorIsNil)
    90  
    91  	results := s.pinApplicationsSuccessResults()
    92  	results[2].Error = common.ServerError(errorRes)
    93  	c.Check(res, gc.DeepEquals, params.PinApplicationsResults{Results: results})
    94  }
    95  
    96  func (s *LeadershipSuite) TestUnpinMachineApplicationsSuccess(c *gc.C) {
    97  	defer s.setup(c).Finish()
    98  
    99  	for _, app := range s.machineApps {
   100  		s.pinner.EXPECT().UnpinLeadership(app, s.authTag.String()).Return(nil)
   101  	}
   102  
   103  	res, err := s.api.UnpinMachineApplications()
   104  	c.Assert(err, jc.ErrorIsNil)
   105  	c.Check(res, gc.DeepEquals, params.PinApplicationsResults{Results: s.pinApplicationsSuccessResults()})
   106  }
   107  
   108  func (s *LeadershipSuite) TestUnpinMachineApplicationsPartialError(c *gc.C) {
   109  	defer s.setup(c).Finish()
   110  
   111  	errorRes := errors.New("boom")
   112  	s.pinner.EXPECT().UnpinLeadership("mysql", s.authTag.String()).Return(nil)
   113  	s.pinner.EXPECT().UnpinLeadership("redis", s.authTag.String()).Return(errorRes)
   114  	s.pinner.EXPECT().UnpinLeadership("wordpress", s.authTag.String()).Return(nil)
   115  
   116  	res, err := s.api.UnpinMachineApplications()
   117  	c.Assert(err, jc.ErrorIsNil)
   118  
   119  	results := s.pinApplicationsSuccessResults()
   120  	results[1].Error = common.ServerError(errorRes)
   121  	c.Check(res, gc.DeepEquals, params.PinApplicationsResults{Results: results})
   122  }
   123  
   124  func (s *LeadershipSuite) TestPinMachineApplicationsPermissionDenied(c *gc.C) {
   125  	s.authTag = names.NewUserTag("some-random-cat")
   126  	defer s.setup(c).Finish()
   127  
   128  	_, err := s.api.PinMachineApplications()
   129  	c.Assert(err, gc.ErrorMatches, "permission denied")
   130  
   131  	_, err = s.api.UnpinMachineApplications()
   132  	c.Assert(err, gc.ErrorMatches, "permission denied")
   133  }
   134  
   135  func (s *LeadershipSuite) setup(c *gc.C) *gomock.Controller {
   136  	ctrl := gomock.NewController(c)
   137  
   138  	s.backend = commonmocks.NewMockLeadershipPinningBackend(ctrl)
   139  	s.machine = commonmocks.NewMockLeadershipMachine(ctrl)
   140  	s.pinner = mocks.NewMockPinner(ctrl)
   141  
   142  	s.backend.EXPECT().Machine("0").Return(s.machine, nil).AnyTimes()
   143  	s.machine.EXPECT().ApplicationNames().Return(s.machineApps, nil).AnyTimes()
   144  
   145  	if s.authTag == nil {
   146  		s.authTag = names.NewMachineTag("0")
   147  	}
   148  
   149  	var err error
   150  	s.api, err = common.NewLeadershipPinningAPI(
   151  		s.backend,
   152  		s.modelTag,
   153  		s.pinner,
   154  		&apiservertesting.FakeAuthorizer{Tag: s.authTag},
   155  	)
   156  	c.Assert(err, jc.ErrorIsNil)
   157  
   158  	return ctrl
   159  }
   160  
   161  func (s *LeadershipSuite) pinApplicationsSuccessResults() []params.PinApplicationResult {
   162  	results := make([]params.PinApplicationResult, len(s.machineApps))
   163  	for i, app := range s.machineApps {
   164  		results[i] = params.PinApplicationResult{ApplicationName: app}
   165  	}
   166  	return results
   167  }