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

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package operation_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	utilexec "github.com/juju/utils/exec"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/worker/uniter/operation"
    14  	"github.com/juju/juju/worker/uniter/runner"
    15  )
    16  
    17  type RunCommandsSuite struct {
    18  	testing.IsolationSuite
    19  }
    20  
    21  var _ = gc.Suite(&RunCommandsSuite{})
    22  
    23  func (s *RunCommandsSuite) TestPrepareError(c *gc.C) {
    24  	runnerFactory := &MockRunnerFactory{
    25  		MockNewCommandRunner: &MockNewCommandRunner{err: errors.New("blooey")},
    26  	}
    27  	factory := operation.NewFactory(nil, runnerFactory, nil, nil, nil)
    28  	sendResponse := func(*utilexec.ExecResponse, error) { panic("not expected") }
    29  	op, err := factory.NewCommands(someCommandArgs, sendResponse)
    30  	c.Assert(err, jc.ErrorIsNil)
    31  
    32  	newState, err := op.Prepare(operation.State{})
    33  	c.Assert(err, gc.ErrorMatches, "blooey")
    34  	c.Assert(newState, gc.IsNil)
    35  	c.Assert(*runnerFactory.MockNewCommandRunner.gotInfo, gc.Equals, runner.CommandInfo{
    36  		RelationId:      123,
    37  		RemoteUnitName:  "foo/456",
    38  		ForceRemoteUnit: true,
    39  	})
    40  }
    41  
    42  func (s *RunCommandsSuite) TestPrepareSuccess(c *gc.C) {
    43  	runnerFactory := &MockRunnerFactory{
    44  		MockNewCommandRunner: &MockNewCommandRunner{},
    45  	}
    46  	factory := operation.NewFactory(nil, runnerFactory, nil, nil, nil)
    47  	sendResponse := func(*utilexec.ExecResponse, error) { panic("not expected") }
    48  	op, err := factory.NewCommands(someCommandArgs, sendResponse)
    49  	c.Assert(err, jc.ErrorIsNil)
    50  
    51  	newState, err := op.Prepare(operation.State{})
    52  	c.Assert(err, jc.ErrorIsNil)
    53  	c.Assert(newState, gc.IsNil)
    54  	c.Assert(*runnerFactory.MockNewCommandRunner.gotInfo, gc.Equals, runner.CommandInfo{
    55  		RelationId:      123,
    56  		RemoteUnitName:  "foo/456",
    57  		ForceRemoteUnit: true,
    58  	})
    59  }
    60  
    61  func (s *RunCommandsSuite) TestExecuteRebootErrors(c *gc.C) {
    62  	for _, sendErr := range []error{runner.ErrRequeueAndReboot, runner.ErrReboot} {
    63  		runnerFactory := NewRunCommandsRunnerFactory(
    64  			&utilexec.ExecResponse{Code: 101}, sendErr,
    65  		)
    66  		callbacks := &RunCommandsCallbacks{}
    67  		factory := operation.NewFactory(nil, runnerFactory, callbacks, nil, nil)
    68  		sendResponse := &MockSendResponse{}
    69  		op, err := factory.NewCommands(someCommandArgs, sendResponse.Call)
    70  		c.Assert(err, jc.ErrorIsNil)
    71  		_, err = op.Prepare(operation.State{})
    72  		c.Assert(err, jc.ErrorIsNil)
    73  
    74  		newState, err := op.Execute(operation.State{})
    75  		c.Assert(newState, gc.IsNil)
    76  		c.Assert(err, jc.ErrorIsNil)
    77  		c.Assert(*runnerFactory.MockNewCommandRunner.runner.MockRunCommands.gotCommands, gc.Equals, "do something")
    78  		c.Assert(*sendResponse.gotResponse, gc.DeepEquals, &utilexec.ExecResponse{Code: 101})
    79  		c.Assert(*sendResponse.gotErr, gc.Equals, operation.ErrNeedsReboot)
    80  	}
    81  }
    82  
    83  func (s *RunCommandsSuite) TestExecuteOtherError(c *gc.C) {
    84  	runnerFactory := NewRunCommandsRunnerFactory(
    85  		nil, errors.New("sneh"),
    86  	)
    87  	callbacks := &RunCommandsCallbacks{}
    88  	factory := operation.NewFactory(nil, runnerFactory, callbacks, nil, nil)
    89  	sendResponse := &MockSendResponse{}
    90  	op, err := factory.NewCommands(someCommandArgs, sendResponse.Call)
    91  	c.Assert(err, jc.ErrorIsNil)
    92  	_, err = op.Prepare(operation.State{})
    93  	c.Assert(err, jc.ErrorIsNil)
    94  
    95  	newState, err := op.Execute(operation.State{})
    96  	c.Assert(newState, gc.IsNil)
    97  	c.Assert(err, jc.ErrorIsNil)
    98  	c.Assert(*runnerFactory.MockNewCommandRunner.runner.MockRunCommands.gotCommands, gc.Equals, "do something")
    99  	c.Assert(*sendResponse.gotResponse, gc.IsNil)
   100  	c.Assert(*sendResponse.gotErr, gc.ErrorMatches, "sneh")
   101  }
   102  
   103  func (s *RunCommandsSuite) TestExecuteSuccess(c *gc.C) {
   104  	runnerFactory := NewRunCommandsRunnerFactory(
   105  		&utilexec.ExecResponse{Code: 222}, nil,
   106  	)
   107  	callbacks := &RunCommandsCallbacks{}
   108  	factory := operation.NewFactory(nil, runnerFactory, callbacks, nil, nil)
   109  	sendResponse := &MockSendResponse{}
   110  	op, err := factory.NewCommands(someCommandArgs, sendResponse.Call)
   111  	c.Assert(err, jc.ErrorIsNil)
   112  	_, err = op.Prepare(operation.State{})
   113  	c.Assert(err, jc.ErrorIsNil)
   114  
   115  	newState, err := op.Execute(operation.State{})
   116  	c.Assert(newState, gc.IsNil)
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	c.Assert(*runnerFactory.MockNewCommandRunner.runner.MockRunCommands.gotCommands, gc.Equals, "do something")
   119  	c.Assert(*sendResponse.gotResponse, gc.DeepEquals, &utilexec.ExecResponse{Code: 222})
   120  	c.Assert(*sendResponse.gotErr, jc.ErrorIsNil)
   121  }
   122  
   123  func (s *RunCommandsSuite) TestCommit(c *gc.C) {
   124  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   125  	sendResponse := func(*utilexec.ExecResponse, error) { panic("not expected") }
   126  	op, err := factory.NewCommands(someCommandArgs, sendResponse)
   127  	c.Assert(err, jc.ErrorIsNil)
   128  	newState, err := op.Commit(operation.State{})
   129  	c.Assert(newState, gc.IsNil)
   130  	c.Assert(err, jc.ErrorIsNil)
   131  }
   132  
   133  func (s *RunCommandsSuite) TestNeedsGlobalMachineLock(c *gc.C) {
   134  	factory := operation.NewFactory(nil, nil, nil, nil, nil)
   135  	sendResponse := &MockSendResponse{}
   136  	op, err := factory.NewCommands(someCommandArgs, sendResponse.Call)
   137  	c.Assert(err, jc.ErrorIsNil)
   138  	c.Assert(op.NeedsGlobalMachineLock(), jc.IsTrue)
   139  }