github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/worker/uniter/actions/resolver_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package actions_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/worker/uniter/actions"
    11  	"github.com/juju/juju/worker/uniter/operation"
    12  	"github.com/juju/juju/worker/uniter/remotestate"
    13  	"github.com/juju/juju/worker/uniter/resolver"
    14  )
    15  
    16  type actionsSuite struct{}
    17  
    18  var _ = gc.Suite(&actionsSuite{})
    19  
    20  func (s *actionsSuite) TestNoActions(c *gc.C) {
    21  	actionResolver := actions.NewResolver()
    22  	localState := resolver.LocalState{}
    23  	remoteState := remotestate.Snapshot{}
    24  	_, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
    25  	c.Assert(err, gc.DeepEquals, resolver.ErrNoOperation)
    26  }
    27  
    28  func (s *actionsSuite) TestActionStateKindContinue(c *gc.C) {
    29  	actionResolver := actions.NewResolver()
    30  	localState := resolver.LocalState{
    31  		State: operation.State{
    32  			Kind: operation.Continue,
    33  		},
    34  	}
    35  	remoteState := remotestate.Snapshot{
    36  		Actions: []string{"actionA", "actionB"},
    37  	}
    38  	op, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
    39  	c.Assert(err, jc.ErrorIsNil)
    40  	c.Assert(op, jc.DeepEquals, mockOp("actionA"))
    41  }
    42  
    43  func (s *actionsSuite) TestActionRunHook(c *gc.C) {
    44  	actionResolver := actions.NewResolver()
    45  	localState := resolver.LocalState{
    46  		State: operation.State{
    47  			Kind: operation.RunHook,
    48  			Step: operation.Pending,
    49  		},
    50  	}
    51  	remoteState := remotestate.Snapshot{
    52  		Actions: []string{"actionA", "actionB"},
    53  	}
    54  	op, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
    55  	c.Assert(err, jc.ErrorIsNil)
    56  	c.Assert(op, jc.DeepEquals, mockOp("actionA"))
    57  }
    58  
    59  func (s *actionsSuite) TestNextAction(c *gc.C) {
    60  	actionResolver := actions.NewResolver()
    61  	localState := resolver.LocalState{
    62  		State: operation.State{
    63  			Kind: operation.Continue,
    64  		},
    65  		CompletedActions: map[string]struct{}{"actionA": {}},
    66  	}
    67  	remoteState := remotestate.Snapshot{
    68  		Actions: []string{"actionA", "actionB"},
    69  	}
    70  	op, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
    71  	c.Assert(err, jc.ErrorIsNil)
    72  	c.Assert(op, jc.DeepEquals, mockOp("actionB"))
    73  }
    74  
    75  func (s *actionsSuite) TestActionStateKindRunAction(c *gc.C) {
    76  	actionResolver := actions.NewResolver()
    77  	var actionA string = "actionA"
    78  
    79  	localState := resolver.LocalState{
    80  		State: operation.State{
    81  			Kind:     operation.RunAction,
    82  			ActionId: &actionA,
    83  		},
    84  		CompletedActions: map[string]struct{}{},
    85  	}
    86  	remoteState := remotestate.Snapshot{
    87  		Actions: []string{},
    88  	}
    89  	op, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
    90  	c.Assert(err, jc.ErrorIsNil)
    91  	c.Assert(op, jc.DeepEquals, mockOp("actionA"))
    92  }
    93  
    94  func (s *actionsSuite) TestActionStateKindRunActionPendingRemote(c *gc.C) {
    95  	actionResolver := actions.NewResolver()
    96  	var actionA string = "actionA"
    97  
    98  	localState := resolver.LocalState{
    99  		State: operation.State{
   100  			Kind:     operation.RunAction,
   101  			ActionId: &actionA,
   102  		},
   103  		CompletedActions: map[string]struct{}{},
   104  	}
   105  	remoteState := remotestate.Snapshot{
   106  		Actions: []string{"actionA", "actionB"},
   107  	}
   108  	op, err := actionResolver.NextOp(localState, remoteState, &mockOperations{})
   109  	c.Assert(err, jc.ErrorIsNil)
   110  	c.Assert(op, jc.DeepEquals, mockFailAction("actionA"))
   111  }
   112  
   113  type mockOperations struct {
   114  	operation.Factory
   115  }
   116  
   117  func (m *mockOperations) NewAction(id string) (operation.Operation, error) {
   118  	return mockOp(id), nil
   119  }
   120  
   121  func (m *mockOperations) NewFailAction(id string) (operation.Operation, error) {
   122  	return mockFailAction(id), nil
   123  }
   124  
   125  func mockOp(name string) operation.Operation {
   126  	return &mockOperation{name: name}
   127  }
   128  
   129  func mockFailAction(name string) operation.Operation {
   130  	return &mockFailOp{name: name}
   131  }
   132  
   133  type mockOperation struct {
   134  	operation.Operation
   135  	name string
   136  }
   137  
   138  func (op *mockOperation) String() string {
   139  	return op.name
   140  }
   141  
   142  type mockFailOp struct {
   143  	operation.Operation
   144  	name string
   145  }
   146  
   147  func (op *mockFailOp) String() string {
   148  	return op.name
   149  }