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