github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/worker/uniter/upgradeseries/resolver_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/juju/charm/v12/hooks"
     8  	"github.com/juju/loggo"
     9  	"github.com/juju/testing"
    10  	"go.uber.org/mock/gomock"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/core/model"
    14  	"github.com/juju/juju/worker/uniter/hook"
    15  	"github.com/juju/juju/worker/uniter/operation"
    16  	"github.com/juju/juju/worker/uniter/operation/mocks"
    17  	"github.com/juju/juju/worker/uniter/remotestate"
    18  	"github.com/juju/juju/worker/uniter/resolver"
    19  	"github.com/juju/juju/worker/uniter/upgradeseries"
    20  )
    21  
    22  type ResolverSuite struct {
    23  	testing.IsolationSuite
    24  }
    25  
    26  var _ = gc.Suite(&ResolverSuite{})
    27  
    28  func (ResolverSuite) NewResolver() resolver.Resolver {
    29  	logger := loggo.GetLogger("test")
    30  	logger.SetLogLevel(loggo.TRACE)
    31  	return upgradeseries.NewResolver(logger)
    32  }
    33  
    34  func (s ResolverSuite) TestNextOpWithValidationStatus(c *gc.C) {
    35  	ctrl := gomock.NewController(c)
    36  	defer ctrl.Finish()
    37  
    38  	mockFactory := mocks.NewMockFactory(ctrl)
    39  	res := s.NewResolver()
    40  	_, err := res.NextOp(resolver.LocalState{}, remotestate.Snapshot{
    41  		UpgradeMachineStatus: model.UpgradeSeriesValidate,
    42  	}, mockFactory)
    43  	c.Assert(err, gc.Equals, resolver.ErrDoNotProceed)
    44  }
    45  
    46  func (s ResolverSuite) TestNextOpWithRemoveStateCompleted(c *gc.C) {
    47  	ctrl := gomock.NewController(c)
    48  	defer ctrl.Finish()
    49  
    50  	mockFactory := mocks.NewMockFactory(ctrl)
    51  	res := s.NewResolver()
    52  	_, err := res.NextOp(resolver.LocalState{}, remotestate.Snapshot{
    53  		UpgradeMachineStatus: model.UpgradeSeriesPrepareCompleted,
    54  	}, mockFactory)
    55  	c.Assert(err, gc.Equals, resolver.ErrDoNotProceed)
    56  }
    57  
    58  func (s ResolverSuite) TestNextOpWithPreSeriesUpgrade(c *gc.C) {
    59  	ctrl := gomock.NewController(c)
    60  	defer ctrl.Finish()
    61  
    62  	mockOp := mocks.NewMockOperation(ctrl)
    63  
    64  	mockFactory := mocks.NewMockFactory(ctrl)
    65  	mockFactory.EXPECT().NewRunHook(hook.Info{Kind: hooks.PreSeriesUpgrade}).Return(mockOp, nil)
    66  
    67  	res := s.NewResolver()
    68  	op, err := res.NextOp(resolver.LocalState{
    69  		State: operation.State{
    70  			Kind: operation.Continue,
    71  		},
    72  		UpgradeMachineStatus: model.UpgradeSeriesNotStarted,
    73  	}, remotestate.Snapshot{
    74  		UpgradeMachineStatus: model.UpgradeSeriesPrepareStarted,
    75  	}, mockFactory)
    76  	c.Assert(err, gc.IsNil)
    77  	c.Assert(op, gc.NotNil)
    78  }
    79  
    80  func (s ResolverSuite) TestNextOpWithPostSeriesUpgrade(c *gc.C) {
    81  	ctrl := gomock.NewController(c)
    82  	defer ctrl.Finish()
    83  
    84  	mockOp := mocks.NewMockOperation(ctrl)
    85  
    86  	mockFactory := mocks.NewMockFactory(ctrl)
    87  	mockFactory.EXPECT().NewRunHook(hook.Info{Kind: hooks.PostSeriesUpgrade}).Return(mockOp, nil)
    88  
    89  	res := s.NewResolver()
    90  	op, err := res.NextOp(resolver.LocalState{
    91  		State: operation.State{
    92  			Kind: operation.Continue,
    93  		},
    94  		UpgradeMachineStatus: model.UpgradeSeriesNotStarted,
    95  	}, remotestate.Snapshot{
    96  		UpgradeMachineStatus: model.UpgradeSeriesCompleteStarted,
    97  	}, mockFactory)
    98  	c.Assert(err, gc.IsNil)
    99  	c.Assert(op, gc.NotNil)
   100  }
   101  
   102  func (s ResolverSuite) TestNextOpWithFinishUpgradeSeries(c *gc.C) {
   103  	ctrl := gomock.NewController(c)
   104  	defer ctrl.Finish()
   105  
   106  	mockOp := mocks.NewMockOperation(ctrl)
   107  
   108  	mockFactory := mocks.NewMockFactory(ctrl)
   109  	mockFactory.EXPECT().NewNoOpFinishUpgradeSeries().Return(mockOp, nil)
   110  
   111  	res := s.NewResolver()
   112  	op, err := res.NextOp(resolver.LocalState{
   113  		State: operation.State{
   114  			Kind: operation.Continue,
   115  		},
   116  		UpgradeMachineStatus: model.UpgradeSeriesCompleted,
   117  	}, remotestate.Snapshot{
   118  		UpgradeMachineStatus: model.UpgradeSeriesNotStarted,
   119  	}, mockFactory)
   120  	c.Assert(err, gc.IsNil)
   121  	c.Assert(op, gc.NotNil)
   122  }
   123  
   124  func (s ResolverSuite) TestNextOpWithNoState(c *gc.C) {
   125  	ctrl := gomock.NewController(c)
   126  	defer ctrl.Finish()
   127  
   128  	mockFactory := mocks.NewMockFactory(ctrl)
   129  
   130  	res := s.NewResolver()
   131  	_, err := res.NextOp(resolver.LocalState{}, remotestate.Snapshot{}, mockFactory)
   132  	c.Assert(err, gc.Equals, resolver.ErrNoOperation)
   133  }