github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/api/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  	"errors"
     8  
     9  	"github.com/juju/names/v5"
    10  	jc "github.com/juju/testing/checkers"
    11  	"go.uber.org/mock/gomock"
    12  	gc "gopkg.in/check.v1"
    13  
    14  	"github.com/juju/juju/api/base/mocks"
    15  	"github.com/juju/juju/api/common"
    16  	apiservererrors "github.com/juju/juju/apiserver/errors"
    17  	"github.com/juju/juju/rpc/params"
    18  	coretesting "github.com/juju/juju/testing"
    19  )
    20  
    21  type LeadershipSuite struct {
    22  	coretesting.BaseSuite
    23  
    24  	facade *mocks.MockFacadeCaller
    25  	client *common.LeadershipPinningAPI
    26  
    27  	machineApps []string
    28  }
    29  
    30  var _ = gc.Suite(&LeadershipSuite{})
    31  
    32  func (s *LeadershipSuite) SetUpSuite(c *gc.C) {
    33  	s.BaseSuite.SetUpSuite(c)
    34  	s.machineApps = []string{"mysql", "redis", "wordpress"}
    35  }
    36  
    37  func (s *LeadershipSuite) TestPinnedLeadership(c *gc.C) {
    38  	defer s.setup(c).Finish()
    39  
    40  	pinned := map[string][]string{"redis": {"machine-0", "machine-1"}}
    41  	resultSource := params.PinnedLeadershipResult{Result: pinned}
    42  	s.facade.EXPECT().FacadeCall("PinnedLeadership", nil, gomock.Any()).SetArg(2, resultSource)
    43  
    44  	res, err := s.client.PinnedLeadership()
    45  	c.Assert(err, jc.ErrorIsNil)
    46  	c.Check(res, gc.DeepEquals, map[string][]names.Tag{"redis": {names.NewMachineTag("0"), names.NewMachineTag("1")}})
    47  }
    48  
    49  func (s *LeadershipSuite) TestPinnedLeadershipError(c *gc.C) {
    50  	defer s.setup(c).Finish()
    51  
    52  	resultSource := params.PinnedLeadershipResult{Error: apiservererrors.ServerError(errors.New("splat"))}
    53  	s.facade.EXPECT().FacadeCall("PinnedLeadership", nil, gomock.Any()).SetArg(2, resultSource)
    54  
    55  	_, err := s.client.PinnedLeadership()
    56  	c.Assert(err, gc.ErrorMatches, "splat")
    57  }
    58  
    59  func (s *LeadershipSuite) TestPinMachineApplicationsSuccess(c *gc.C) {
    60  	defer s.setup(c).Finish()
    61  
    62  	resultSource := params.PinApplicationsResults{Results: s.pinApplicationsServerSuccessResults()}
    63  	s.facade.EXPECT().FacadeCall("PinMachineApplications", nil, gomock.Any()).SetArg(2, resultSource)
    64  
    65  	res, err := s.client.PinMachineApplications()
    66  	c.Assert(err, jc.ErrorIsNil)
    67  	c.Check(res, gc.DeepEquals, s.pinApplicationsClientSuccessResults())
    68  }
    69  
    70  func (s *LeadershipSuite) TestPinMachineApplicationsPartialError(c *gc.C) {
    71  	defer s.setup(c).Finish()
    72  
    73  	errorRes := apiservererrors.ServerError(errors.New("boom"))
    74  	results := s.pinApplicationsServerSuccessResults()
    75  	results[2].Error = errorRes
    76  	resultSource := params.PinApplicationsResults{Results: results}
    77  	s.facade.EXPECT().FacadeCall("PinMachineApplications", nil, gomock.Any()).SetArg(2, resultSource)
    78  
    79  	res, err := s.client.PinMachineApplications()
    80  	c.Assert(err, jc.ErrorIsNil)
    81  
    82  	exp := s.pinApplicationsClientSuccessResults()
    83  	exp["wordpress"] = errorRes
    84  	c.Check(res, gc.DeepEquals, exp)
    85  }
    86  
    87  func (s *LeadershipSuite) TestUnpinMachineApplicationsSuccess(c *gc.C) {
    88  	defer s.setup(c).Finish()
    89  
    90  	resultSource := params.PinApplicationsResults{Results: s.pinApplicationsServerSuccessResults()}
    91  	s.facade.EXPECT().FacadeCall("UnpinMachineApplications", nil, gomock.Any()).SetArg(2, resultSource)
    92  
    93  	res, err := s.client.UnpinMachineApplications()
    94  	c.Assert(err, jc.ErrorIsNil)
    95  	c.Check(res, gc.DeepEquals, s.pinApplicationsClientSuccessResults())
    96  }
    97  
    98  func (s *LeadershipSuite) setup(c *gc.C) *gomock.Controller {
    99  	ctrl := gomock.NewController(c)
   100  
   101  	s.facade = mocks.NewMockFacadeCaller(ctrl)
   102  	s.client = common.NewLeadershipPinningAPIFromFacade(s.facade)
   103  
   104  	return ctrl
   105  }
   106  
   107  func (s *LeadershipSuite) TestUnpinMachineApplicationsPartialError(c *gc.C) {
   108  	defer s.setup(c).Finish()
   109  
   110  	errorRes := apiservererrors.ServerError(errors.New("boom"))
   111  	results := s.pinApplicationsServerSuccessResults()
   112  	results[1].Error = errorRes
   113  	resultSource := params.PinApplicationsResults{Results: results}
   114  	s.facade.EXPECT().FacadeCall("UnpinMachineApplications", nil, gomock.Any()).SetArg(2, resultSource)
   115  
   116  	res, err := s.client.UnpinMachineApplications()
   117  	c.Assert(err, jc.ErrorIsNil)
   118  
   119  	exp := s.pinApplicationsClientSuccessResults()
   120  	exp["redis"] = errorRes
   121  	c.Check(res, gc.DeepEquals, exp)
   122  }
   123  
   124  func (s *LeadershipSuite) pinApplicationsServerSuccessResults() []params.PinApplicationResult {
   125  	results := make([]params.PinApplicationResult, len(s.machineApps))
   126  	for i, app := range s.machineApps {
   127  		results[i] = params.PinApplicationResult{ApplicationName: app}
   128  	}
   129  	return results
   130  }
   131  
   132  func (s *LeadershipSuite) pinApplicationsClientSuccessResults() map[string]error {
   133  	results := make(map[string]error, len(s.machineApps))
   134  	for _, app := range s.machineApps {
   135  		results[app] = nil
   136  	}
   137  	return results
   138  }