github.com/juju/juju@v0.0.0-20240327075706-a90865de2538/worker/stateconverter/converter_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package stateconverter_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	"go.uber.org/mock/gomock"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/core/model"
    13  	"github.com/juju/juju/core/watcher"
    14  	"github.com/juju/juju/rpc/params"
    15  	"github.com/juju/juju/worker/stateconverter"
    16  	"github.com/juju/juju/worker/stateconverter/mocks"
    17  )
    18  
    19  var _ = gc.Suite(&converterSuite{})
    20  
    21  type converterSuite struct {
    22  	machine  *mocks.MockMachine
    23  	machiner *mocks.MockMachiner
    24  }
    25  
    26  func (s *converterSuite) TestSetUp(c *gc.C) {
    27  	defer s.setupMocks(c).Finish()
    28  	s.machiner.EXPECT().Machine(gomock.Any()).Return(s.machine, nil)
    29  	s.machine.EXPECT().Watch().Return(nil, nil)
    30  
    31  	conv := s.newConverter()
    32  	_, err := conv.SetUp()
    33  	c.Assert(err, jc.ErrorIsNil)
    34  }
    35  
    36  func (s *converterSuite) TestSetupMachinerErr(c *gc.C) {
    37  	defer s.setupMocks(c).Finish()
    38  	expectedError := errors.NotValidf("machine tag")
    39  	s.machiner.EXPECT().Machine(gomock.Any()).Return(nil, expectedError)
    40  
    41  	conv := s.newConverter()
    42  	w, err := conv.SetUp()
    43  	c.Assert(err, jc.Satisfies, errors.IsNotValid)
    44  	c.Assert(w, gc.IsNil)
    45  }
    46  
    47  func (s *converterSuite) TestSetupWatchErr(c *gc.C) {
    48  	defer s.setupMocks(c).Finish()
    49  	s.machiner.EXPECT().Machine(gomock.Any()).Return(s.machine, nil)
    50  	expectedError := errors.NotValidf("machine tag")
    51  	s.machine.EXPECT().Watch().Return(nil, expectedError)
    52  
    53  	conv := s.newConverter()
    54  	w, err := conv.SetUp()
    55  	c.Assert(err, jc.Satisfies, errors.IsNotValid)
    56  	c.Assert(w, gc.IsNil)
    57  }
    58  
    59  func (s *converterSuite) TestHandle(c *gc.C) {
    60  	defer s.setupMocks(c).Finish()
    61  	s.machiner.EXPECT().Machine(gomock.Any()).Return(s.machine, nil)
    62  	s.machine.EXPECT().Watch().Return(nil, nil)
    63  	jobs := params.JobsResult{Jobs: []model.MachineJob{model.JobHostUnits, model.JobManageModel}}
    64  	s.machine.EXPECT().Jobs().Return(&jobs, nil)
    65  
    66  	conv := s.newConverter()
    67  	_, err := conv.SetUp()
    68  	c.Assert(err, gc.IsNil)
    69  	err = conv.Handle(nil)
    70  	// Since machine has model.JobManageModel, we expect an error
    71  	// which will get machineTag to restart.
    72  	c.Assert(err.Error(), gc.Equals, "bounce agent to pick up new jobs")
    73  }
    74  
    75  func (s *converterSuite) TestHandleNotController(c *gc.C) {
    76  	defer s.setupMocks(c).Finish()
    77  	s.machiner.EXPECT().Machine(gomock.Any()).Return(s.machine, nil)
    78  	s.machine.EXPECT().Watch().Return(nil, nil)
    79  	jobs := params.JobsResult{Jobs: []model.MachineJob{model.JobHostUnits}}
    80  	s.machine.EXPECT().Jobs().Return(&jobs, nil)
    81  
    82  	conv := s.newConverter()
    83  	_, err := conv.SetUp()
    84  	c.Assert(err, gc.IsNil)
    85  	err = conv.Handle(nil)
    86  	c.Assert(err, gc.IsNil)
    87  }
    88  
    89  func (s *converterSuite) TestHandleJobsError(c *gc.C) {
    90  	defer s.setupMocks(c).Finish()
    91  	s.machiner.EXPECT().Machine(gomock.Any()).Return(s.machine, nil).AnyTimes()
    92  	s.machine.EXPECT().Watch().Return(nil, nil).AnyTimes()
    93  	jobs := params.JobsResult{Jobs: []model.MachineJob{model.JobHostUnits, model.JobManageModel}}
    94  	s.machine.EXPECT().Jobs().Return(&jobs, nil)
    95  	expectedError := errors.New("foo")
    96  	s.machine.EXPECT().Jobs().Return(nil, expectedError)
    97  
    98  	conv := s.newConverter()
    99  	_, err := conv.SetUp()
   100  	c.Assert(err, gc.IsNil)
   101  	err = conv.Handle(nil)
   102  	// Since machine has model.JobManageModel, we expect an error
   103  	// which will get machineTag to restart.
   104  	c.Assert(err.Error(), gc.Equals, "bounce agent to pick up new jobs")
   105  	_, err = conv.SetUp()
   106  	c.Assert(err, gc.IsNil)
   107  	err = conv.Handle(nil)
   108  	c.Assert(errors.Cause(err), gc.Equals, expectedError)
   109  }
   110  
   111  func (s *converterSuite) setupMocks(c *gc.C) *gomock.Controller {
   112  	ctrl := gomock.NewController(c)
   113  	s.machine = mocks.NewMockMachine(ctrl)
   114  	s.machiner = mocks.NewMockMachiner(ctrl)
   115  	return ctrl
   116  }
   117  
   118  func (s *converterSuite) newConverter() watcher.NotifyHandler {
   119  	logger := fakeLogger{}
   120  	return stateconverter.NewConverterForTest(s.machine, s.machiner, &logger)
   121  }