github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/api/upgradeseries/upgradeseries_test.go (about)

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package upgradeseries_test
     5  
     6  import (
     7  	"github.com/golang/mock/gomock"
     8  	"github.com/juju/errors"
     9  	jc "github.com/juju/testing/checkers"
    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/upgradeseries"
    15  	"github.com/juju/juju/apiserver/params"
    16  	"github.com/juju/juju/core/model"
    17  	jujutesting "github.com/juju/juju/testing"
    18  )
    19  
    20  type upgradeSeriesSuite struct {
    21  	jujutesting.BaseSuite
    22  
    23  	tag                                  names.Tag
    24  	args                                 params.Entities
    25  	upgradeSeriesStartUnitCompletionArgs params.UpgradeSeriesStartUnitCompletionParam
    26  }
    27  
    28  var _ = gc.Suite(&upgradeSeriesSuite{})
    29  
    30  func (s *upgradeSeriesSuite) SetUpTest(c *gc.C) {
    31  	s.tag = names.NewMachineTag("0")
    32  	s.args = params.Entities{Entities: []params.Entity{{Tag: s.tag.String()}}}
    33  	s.upgradeSeriesStartUnitCompletionArgs = params.UpgradeSeriesStartUnitCompletionParam{
    34  		Entities: []params.Entity{{Tag: s.tag.String()}},
    35  	}
    36  	s.BaseSuite.SetUpTest(c)
    37  }
    38  
    39  func (s *upgradeSeriesSuite) TestMachineStatus(c *gc.C) {
    40  	ctrl := gomock.NewController(c)
    41  	defer ctrl.Finish()
    42  
    43  	fCaller := mocks.NewMockFacadeCaller(ctrl)
    44  
    45  	resultSource := params.UpgradeSeriesStatusResults{
    46  		Results: []params.UpgradeSeriesStatusResult{{
    47  			Status: model.UpgradeSeriesPrepareStarted,
    48  		}},
    49  	}
    50  	fCaller.EXPECT().FacadeCall("MachineStatus", s.args, gomock.Any()).SetArg(2, resultSource)
    51  
    52  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
    53  	status, err := api.MachineStatus()
    54  	c.Assert(err, gc.IsNil)
    55  	c.Check(status, gc.Equals, model.UpgradeSeriesPrepareStarted)
    56  }
    57  
    58  func (s *upgradeSeriesSuite) TestMachineStatusNotFound(c *gc.C) {
    59  	ctrl := gomock.NewController(c)
    60  	defer ctrl.Finish()
    61  
    62  	fCaller := mocks.NewMockFacadeCaller(ctrl)
    63  
    64  	resultSource := params.UpgradeSeriesStatusResults{
    65  		Results: []params.UpgradeSeriesStatusResult{{
    66  			Error: &params.Error{
    67  				Code:    params.CodeNotFound,
    68  				Message: "did not find",
    69  			},
    70  		}},
    71  	}
    72  	fCaller.EXPECT().FacadeCall("MachineStatus", s.args, gomock.Any()).SetArg(2, resultSource)
    73  
    74  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
    75  	status, err := api.MachineStatus()
    76  	c.Assert(err, gc.ErrorMatches, "did not find")
    77  	c.Check(errors.IsNotFound(err), jc.IsTrue)
    78  	c.Check(string(status), gc.Equals, "")
    79  }
    80  
    81  func (s *upgradeSeriesSuite) TestSetMachineStatus(c *gc.C) {
    82  	ctrl := gomock.NewController(c)
    83  	defer ctrl.Finish()
    84  
    85  	fCaller := mocks.NewMockFacadeCaller(ctrl)
    86  
    87  	args := params.UpgradeSeriesStatusParams{
    88  		Params: []params.UpgradeSeriesStatusParam{
    89  			{Status: model.UpgradeSeriesCompleteStarted, Entity: s.args.Entities[0]},
    90  		},
    91  	}
    92  	resultSource := params.ErrorResults{Results: []params.ErrorResult{{}}}
    93  	fCaller.EXPECT().FacadeCall("SetMachineStatus", args, gomock.Any()).SetArg(2, resultSource)
    94  
    95  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
    96  	err := api.SetMachineStatus(model.UpgradeSeriesCompleteStarted, "")
    97  	c.Assert(err, gc.IsNil)
    98  }
    99  
   100  func (s *upgradeSeriesSuite) TestTargetSeries(c *gc.C) {
   101  	ctrl := gomock.NewController(c)
   102  	defer ctrl.Finish()
   103  
   104  	fCaller := mocks.NewMockFacadeCaller(ctrl)
   105  
   106  	resultSource := params.StringResults{
   107  		Results: []params.StringResult{{
   108  			Result: "bionic",
   109  		}},
   110  	}
   111  	fCaller.EXPECT().FacadeCall("TargetSeries", s.args, gomock.Any()).SetArg(2, resultSource)
   112  
   113  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
   114  	target, err := api.TargetSeries()
   115  	c.Assert(err, gc.IsNil)
   116  	c.Check(target, gc.Equals, "bionic")
   117  }
   118  
   119  func (s *upgradeSeriesSuite) TestUnitsPrepared(c *gc.C) {
   120  	ctrl := gomock.NewController(c)
   121  	defer ctrl.Finish()
   122  
   123  	fCaller := mocks.NewMockFacadeCaller(ctrl)
   124  
   125  	r0 := names.NewUnitTag("redis/0")
   126  	r1 := names.NewUnitTag("redis/1")
   127  
   128  	resultSource := params.EntitiesResults{
   129  		Results: []params.EntitiesResult{{Entities: []params.Entity{
   130  			{Tag: r0.String()},
   131  			{Tag: r1.String()},
   132  		}}},
   133  	}
   134  	fCaller.EXPECT().FacadeCall("UnitsPrepared", s.args, gomock.Any()).SetArg(2, resultSource)
   135  
   136  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
   137  	units, err := api.UnitsPrepared()
   138  	c.Assert(err, gc.IsNil)
   139  
   140  	expected := []names.UnitTag{r0, r1}
   141  	c.Check(units, jc.SameContents, expected)
   142  }
   143  
   144  func (s *upgradeSeriesSuite) TestUnitsCompleted(c *gc.C) {
   145  	ctrl := gomock.NewController(c)
   146  	defer ctrl.Finish()
   147  
   148  	fCaller := mocks.NewMockFacadeCaller(ctrl)
   149  
   150  	p0 := names.NewUnitTag("postgres/0")
   151  	p1 := names.NewUnitTag("postgres/1")
   152  	p2 := names.NewUnitTag("postgres/2")
   153  
   154  	resultSource := params.EntitiesResults{
   155  		Results: []params.EntitiesResult{{Entities: []params.Entity{
   156  			{Tag: p0.String()},
   157  			{Tag: p1.String()},
   158  			{Tag: p2.String()},
   159  		}}},
   160  	}
   161  	fCaller.EXPECT().FacadeCall("UnitsCompleted", s.args, gomock.Any()).SetArg(2, resultSource)
   162  
   163  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
   164  	units, err := api.UnitsCompleted()
   165  	c.Assert(err, gc.IsNil)
   166  
   167  	expected := []names.UnitTag{p0, p1, p2}
   168  	c.Check(units, jc.SameContents, expected)
   169  }
   170  
   171  func (s *upgradeSeriesSuite) TestStartUnitCompletion(c *gc.C) {
   172  	ctrl := gomock.NewController(c)
   173  	defer ctrl.Finish()
   174  
   175  	fCaller := mocks.NewMockFacadeCaller(ctrl)
   176  
   177  	resultSource := params.ErrorResults{Results: []params.ErrorResult{{}}}
   178  	fCaller.EXPECT().FacadeCall("StartUnitCompletion", s.upgradeSeriesStartUnitCompletionArgs, gomock.Any()).SetArg(2, resultSource)
   179  
   180  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
   181  	err := api.StartUnitCompletion("")
   182  	c.Assert(err, gc.IsNil)
   183  }
   184  
   185  func (s *upgradeSeriesSuite) TestFinishUpgradeSeries(c *gc.C) {
   186  	ctrl := gomock.NewController(c)
   187  	defer ctrl.Finish()
   188  
   189  	fCaller := mocks.NewMockFacadeCaller(ctrl)
   190  
   191  	args := params.UpdateSeriesArgs{
   192  		Args: []params.UpdateSeriesArg{
   193  			{Series: "xenial", Entity: s.args.Entities[0]},
   194  		},
   195  	}
   196  	resultSource := params.ErrorResults{Results: []params.ErrorResult{{}}}
   197  	fCaller.EXPECT().FacadeCall("FinishUpgradeSeries", args, gomock.Any()).SetArg(2, resultSource)
   198  
   199  	api := upgradeseries.NewStateFromCaller(fCaller, s.tag)
   200  	err := api.FinishUpgradeSeries("xenial")
   201  	c.Assert(err, gc.IsNil)
   202  }