github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/worker/uniter/operation/leader_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package operation_test
     5  
     6  import (
     7  	"github.com/juju/testing"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  	"gopkg.in/juju/charm.v5/hooks"
    11  
    12  	"github.com/juju/juju/worker/uniter/hook"
    13  	"github.com/juju/juju/worker/uniter/operation"
    14  )
    15  
    16  type LeaderSuite struct {
    17  	testing.IsolationSuite
    18  }
    19  
    20  var _ = gc.Suite(&LeaderSuite{})
    21  
    22  func (s *LeaderSuite) TestAcceptLeadership_Prepare_BadState(c *gc.C) {
    23  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
    24  	op, err := factory.NewAcceptLeadership()
    25  	c.Assert(err, jc.ErrorIsNil)
    26  
    27  	newState, err := op.Prepare(operation.State{})
    28  	c.Check(newState, gc.IsNil)
    29  	// accept is only valid in Continue mode, when we're sure nothing is queued
    30  	// or in progress.
    31  	c.Check(err, gc.Equals, operation.ErrCannotAcceptLeadership)
    32  }
    33  
    34  func (s *LeaderSuite) TestAcceptLeadership_Prepare_NotLeader(c *gc.C) {
    35  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
    36  	op, err := factory.NewAcceptLeadership()
    37  	c.Assert(err, jc.ErrorIsNil)
    38  
    39  	newState, err := op.Prepare(operation.State{Kind: operation.Continue})
    40  	c.Check(newState, gc.IsNil)
    41  	// *execute* is currently just a no-op -- all the meat happens in commit.
    42  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
    43  }
    44  
    45  func (s *LeaderSuite) TestAcceptLeadership_Prepare_AlreadyLeader(c *gc.C) {
    46  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
    47  	op, err := factory.NewAcceptLeadership()
    48  	c.Assert(err, jc.ErrorIsNil)
    49  
    50  	newState, err := op.Prepare(operation.State{
    51  		Kind:   operation.Continue,
    52  		Leader: true,
    53  	})
    54  	c.Check(newState, gc.IsNil)
    55  	// *execute* is currently just a no-op -- all the meat happens in commit.
    56  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
    57  }
    58  
    59  func (s *LeaderSuite) TestAcceptLeadership_Commit_NotLeader_BlankSlate(c *gc.C) {
    60  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
    61  	op, err := factory.NewAcceptLeadership()
    62  	c.Assert(err, jc.ErrorIsNil)
    63  	_, err = op.Prepare(operation.State{Kind: operation.Continue})
    64  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
    65  
    66  	newState, err := op.Commit(operation.State{
    67  		Kind: operation.Continue,
    68  	})
    69  	c.Check(err, jc.ErrorIsNil)
    70  	c.Check(newState, gc.DeepEquals, &operation.State{
    71  		Kind:   operation.RunHook,
    72  		Step:   operation.Queued,
    73  		Hook:   &hook.Info{Kind: hook.LeaderElected},
    74  		Leader: true,
    75  	})
    76  }
    77  
    78  func (s *LeaderSuite) TestAcceptLeadership_Commit_NotLeader_Preserve(c *gc.C) {
    79  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
    80  	op, err := factory.NewAcceptLeadership()
    81  	c.Assert(err, jc.ErrorIsNil)
    82  	_, err = op.Prepare(operation.State{Kind: operation.Continue})
    83  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
    84  
    85  	newState, err := op.Commit(operation.State{
    86  		Kind:               operation.Continue,
    87  		Started:            true,
    88  		CollectMetricsTime: 1234567,
    89  		Hook:               &hook.Info{Kind: hooks.Install},
    90  	})
    91  	c.Check(err, jc.ErrorIsNil)
    92  	c.Check(newState, gc.DeepEquals, &operation.State{
    93  		Kind:               operation.RunHook,
    94  		Step:               operation.Queued,
    95  		Hook:               &hook.Info{Kind: hook.LeaderElected},
    96  		Leader:             true,
    97  		Started:            true,
    98  		CollectMetricsTime: 1234567,
    99  	})
   100  }
   101  
   102  func (s *LeaderSuite) TestAcceptLeadership_Commit_AlreadyLeader(c *gc.C) {
   103  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   104  	op, err := factory.NewAcceptLeadership()
   105  	c.Assert(err, jc.ErrorIsNil)
   106  	_, err = op.Prepare(operation.State{Kind: operation.Continue})
   107  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
   108  
   109  	newState, err := op.Commit(operation.State{
   110  		Kind:   operation.Continue,
   111  		Leader: true,
   112  	})
   113  	c.Check(newState, gc.IsNil)
   114  	c.Check(err, jc.ErrorIsNil)
   115  }
   116  
   117  func (s *LeaderSuite) TestAcceptLeadership_DoesNotNeedGlobalMachineLock(c *gc.C) {
   118  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   119  	op, err := factory.NewAcceptLeadership()
   120  	c.Assert(err, jc.ErrorIsNil)
   121  	c.Assert(op.NeedsGlobalMachineLock(), jc.IsFalse)
   122  }
   123  
   124  func (s *LeaderSuite) TestResignLeadership_Prepare_Leader(c *gc.C) {
   125  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   126  	op, err := factory.NewResignLeadership()
   127  	c.Assert(err, jc.ErrorIsNil)
   128  
   129  	newState, err := op.Prepare(operation.State{Leader: true})
   130  	c.Check(newState, gc.IsNil)
   131  	c.Check(err, jc.ErrorIsNil)
   132  }
   133  
   134  func (s *LeaderSuite) TestResignLeadership_Prepare_NotLeader(c *gc.C) {
   135  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   136  	op, err := factory.NewResignLeadership()
   137  	c.Assert(err, jc.ErrorIsNil)
   138  
   139  	newState, err := op.Prepare(operation.State{})
   140  	c.Check(newState, gc.IsNil)
   141  	c.Check(err, gc.Equals, operation.ErrSkipExecute)
   142  }
   143  
   144  func (s *LeaderSuite) TestResignLeadership_Execute(c *gc.C) {
   145  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   146  	op, err := factory.NewResignLeadership()
   147  	c.Assert(err, jc.ErrorIsNil)
   148  
   149  	_, err = op.Prepare(operation.State{Leader: true})
   150  	c.Check(err, jc.ErrorIsNil)
   151  
   152  	// Execute is a no-op (which logs that we should run leader-deposed)
   153  	newState, err := op.Execute(operation.State{})
   154  	c.Check(newState, gc.IsNil)
   155  	c.Check(err, jc.ErrorIsNil)
   156  }
   157  
   158  func (s *LeaderSuite) TestResignLeadership_Commit_ClearLeader(c *gc.C) {
   159  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   160  	op, err := factory.NewResignLeadership()
   161  	c.Assert(err, jc.ErrorIsNil)
   162  
   163  	newState, err := op.Commit(operation.State{Leader: true})
   164  	c.Check(newState, gc.DeepEquals, &operation.State{})
   165  	c.Check(err, jc.ErrorIsNil)
   166  }
   167  
   168  func (s *LeaderSuite) TestResignLeadership_Commit_PreserveOthers(c *gc.C) {
   169  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   170  	op, err := factory.NewResignLeadership()
   171  	c.Assert(err, jc.ErrorIsNil)
   172  
   173  	newState, err := op.Commit(overwriteState)
   174  	c.Check(newState, gc.DeepEquals, &overwriteState)
   175  	c.Check(err, jc.ErrorIsNil)
   176  }
   177  
   178  func (s *LeaderSuite) TestResignLeadership_Commit_All(c *gc.C) {
   179  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   180  	op, err := factory.NewResignLeadership()
   181  	c.Assert(err, jc.ErrorIsNil)
   182  
   183  	leaderState := overwriteState
   184  	leaderState.Leader = true
   185  	newState, err := op.Commit(leaderState)
   186  	c.Check(newState, gc.DeepEquals, &overwriteState)
   187  	c.Check(err, jc.ErrorIsNil)
   188  }
   189  
   190  func (s *LeaderSuite) TestResignLeadership_DoesNotNeedGlobalMachineLock(c *gc.C) {
   191  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   192  	op, err := factory.NewResignLeadership()
   193  	c.Assert(err, jc.ErrorIsNil)
   194  	c.Assert(op.NeedsGlobalMachineLock(), jc.IsFalse)
   195  }