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

     1  // Copyright 2019 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package modelgeneration_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/modelgeneration"
    15  	"github.com/juju/juju/apiserver/common"
    16  	"github.com/juju/juju/apiserver/params"
    17  )
    18  
    19  type modelGenerationSuite struct {
    20  	tag     names.ModelTag
    21  	fCaller *mocks.MockFacadeCaller
    22  }
    23  
    24  var _ = gc.Suite(&modelGenerationSuite{})
    25  
    26  func (s *modelGenerationSuite) SetUpTest(c *gc.C) {
    27  	s.tag = names.NewModelTag("deadbeef-abcd-4fd2-967d-db9663db7bea")
    28  }
    29  
    30  func (s *modelGenerationSuite) TearDownTest(c *gc.C) {
    31  	s.fCaller = nil
    32  }
    33  
    34  func (s *modelGenerationSuite) setUpMocks(c *gc.C) *gomock.Controller {
    35  	ctrl := gomock.NewController(c)
    36  
    37  	caller := mocks.NewMockAPICallCloser(ctrl)
    38  	caller.EXPECT().BestFacadeVersion(gomock.Any()).Return(0).AnyTimes()
    39  
    40  	s.fCaller = mocks.NewMockFacadeCaller(ctrl)
    41  	s.fCaller.EXPECT().RawAPICaller().Return(caller).AnyTimes()
    42  
    43  	return ctrl
    44  }
    45  
    46  func (s *modelGenerationSuite) TestAddGeneration(c *gc.C) {
    47  	defer s.setUpMocks(c).Finish()
    48  
    49  	resultSource := params.ErrorResult{}
    50  	arg := params.Entity{Tag: s.tag.String()}
    51  
    52  	s.fCaller.EXPECT().FacadeCall("AddGeneration", arg, gomock.Any()).SetArg(2, resultSource).Return(nil)
    53  
    54  	api := modelgeneration.NewStateFromCaller(s.fCaller)
    55  	err := api.AddGeneration(s.tag.Id())
    56  	c.Assert(err, gc.IsNil)
    57  }
    58  
    59  func (s *modelGenerationSuite) TestAdvanceGenerationNoAutoComplete(c *gc.C) {
    60  	defer s.setUpMocks(c).Finish()
    61  
    62  	resultsSource := params.AdvanceGenerationResult{
    63  		AdvanceResults: params.ErrorResults{Results: []params.ErrorResult{
    64  			{Error: nil},
    65  			{Error: nil},
    66  		}},
    67  	}
    68  	arg := params.AdvanceGenerationArg{
    69  		Model: params.Entity{Tag: s.tag.String()},
    70  		Entities: []params.Entity{
    71  			{Tag: "unit-mysql-0"},
    72  			{Tag: "application-mysql"},
    73  		},
    74  	}
    75  
    76  	s.fCaller.EXPECT().FacadeCall("AdvanceGeneration", arg, gomock.Any()).SetArg(2, resultsSource).Return(nil)
    77  
    78  	api := modelgeneration.NewStateFromCaller(s.fCaller)
    79  	completed, err := api.AdvanceGeneration(s.tag.Id(), []string{"mysql/0", "mysql"})
    80  	c.Assert(err, gc.IsNil)
    81  	c.Check(completed, jc.IsFalse)
    82  }
    83  
    84  func (s *modelGenerationSuite) TestAdvanceGenerationAdvanceError(c *gc.C) {
    85  	defer s.setUpMocks(c).Finish()
    86  
    87  	api := modelgeneration.NewStateFromCaller(s.fCaller)
    88  	completed, err := api.AdvanceGeneration(s.tag.Id(), []string{"mysql/0", "mysql", "machine-3"})
    89  	c.Assert(err, gc.ErrorMatches, "Must be application or unit")
    90  	c.Check(completed, jc.IsFalse)
    91  }
    92  
    93  func (s *modelGenerationSuite) TestAdvanceGenerationAutoComplete(c *gc.C) {
    94  	defer s.setUpMocks(c).Finish()
    95  
    96  	resultsSource := params.AdvanceGenerationResult{
    97  		AdvanceResults: params.ErrorResults{Results: []params.ErrorResult{
    98  			{Error: nil},
    99  			{Error: nil},
   100  		}},
   101  		CompleteResult: params.BoolResult{Result: true},
   102  	}
   103  	arg := params.AdvanceGenerationArg{
   104  		Model: params.Entity{Tag: s.tag.String()},
   105  		Entities: []params.Entity{
   106  			{Tag: "unit-mysql-0"},
   107  			{Tag: "application-mysql"},
   108  		},
   109  	}
   110  
   111  	s.fCaller.EXPECT().FacadeCall("AdvanceGeneration", arg, gomock.Any()).SetArg(2, resultsSource).Return(nil)
   112  
   113  	api := modelgeneration.NewStateFromCaller(s.fCaller)
   114  	completed, err := api.AdvanceGeneration(s.tag.Id(), []string{"mysql/0", "mysql"})
   115  	c.Assert(err, gc.IsNil)
   116  	c.Check(completed, jc.IsTrue)
   117  }
   118  
   119  func (s *modelGenerationSuite) TestAdvanceGenerationAutoCompleteError(c *gc.C) {
   120  	defer s.setUpMocks(c).Finish()
   121  
   122  	resultsSource := params.AdvanceGenerationResult{
   123  		AdvanceResults: params.ErrorResults{Results: []params.ErrorResult{
   124  			{Error: nil},
   125  			{Error: nil},
   126  		}},
   127  		CompleteResult: params.BoolResult{Error: common.ServerError(errors.New("auto-complete go boom"))},
   128  	}
   129  	arg := params.AdvanceGenerationArg{
   130  		Model: params.Entity{Tag: s.tag.String()},
   131  		Entities: []params.Entity{
   132  			{Tag: "unit-mysql-0"},
   133  			{Tag: "application-mysql"},
   134  		},
   135  	}
   136  
   137  	s.fCaller.EXPECT().FacadeCall("AdvanceGeneration", arg, gomock.Any()).SetArg(2, resultsSource).Return(nil)
   138  
   139  	api := modelgeneration.NewStateFromCaller(s.fCaller)
   140  	completed, err := api.AdvanceGeneration(s.tag.Id(), []string{"mysql/0", "mysql"})
   141  	c.Assert(err, gc.ErrorMatches, "auto-complete go boom")
   142  	c.Check(completed, jc.IsFalse)
   143  }
   144  
   145  func (s *modelGenerationSuite) TestCancelGeneration(c *gc.C) {
   146  	defer s.setUpMocks(c).Finish()
   147  
   148  	resultSource := params.ErrorResult{}
   149  	arg := params.Entity{Tag: s.tag.String()}
   150  
   151  	s.fCaller.EXPECT().FacadeCall("CancelGeneration", arg, gomock.Any()).SetArg(2, resultSource).Return(nil)
   152  
   153  	api := modelgeneration.NewStateFromCaller(s.fCaller)
   154  	err := api.CancelGeneration(s.tag.Id())
   155  	c.Assert(err, gc.IsNil)
   156  }
   157  
   158  func (s *modelGenerationSuite) TestHasNextGeneration(c *gc.C) {
   159  	defer s.setUpMocks(c).Finish()
   160  
   161  	resultSource := params.BoolResult{Result: true}
   162  	arg := params.Entity{Tag: s.tag.String()}
   163  
   164  	s.fCaller.EXPECT().FacadeCall("HasNextGeneration", arg, gomock.Any()).SetArg(2, resultSource).Return(nil)
   165  
   166  	api := modelgeneration.NewStateFromCaller(s.fCaller)
   167  	has, err := api.HasNextGeneration(s.tag.Id())
   168  	c.Assert(err, gc.IsNil)
   169  	c.Check(has, jc.IsTrue)
   170  }