github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/cmd/juju/commands/resolved_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package commands
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/cmd/envcmd"
    11  	jujutesting "github.com/juju/juju/juju/testing"
    12  	"github.com/juju/juju/state"
    13  	"github.com/juju/juju/testcharms"
    14  	"github.com/juju/juju/testing"
    15  )
    16  
    17  type ResolvedSuite struct {
    18  	jujutesting.RepoSuite
    19  	CmdBlockHelper
    20  }
    21  
    22  func (s *ResolvedSuite) SetUpTest(c *gc.C) {
    23  	s.RepoSuite.SetUpTest(c)
    24  	s.CmdBlockHelper = NewCmdBlockHelper(s.APIState)
    25  	c.Assert(s.CmdBlockHelper, gc.NotNil)
    26  	s.AddCleanup(func(*gc.C) { s.CmdBlockHelper.Close() })
    27  }
    28  
    29  var _ = gc.Suite(&ResolvedSuite{})
    30  
    31  func runResolved(c *gc.C, args []string) error {
    32  	_, err := testing.RunCommand(c, envcmd.Wrap(&ResolvedCommand{}), args...)
    33  	return err
    34  }
    35  
    36  var resolvedTests = []struct {
    37  	args []string
    38  	err  string
    39  	unit string
    40  	mode state.ResolvedMode
    41  }{
    42  	{
    43  		err: `no unit specified`,
    44  	}, {
    45  		args: []string{"jeremy-fisher"},
    46  		err:  `invalid unit name "jeremy-fisher"`,
    47  	}, {
    48  		args: []string{"jeremy-fisher/99"},
    49  		err:  `unit "jeremy-fisher/99" not found`,
    50  	}, {
    51  		args: []string{"dummy/0"},
    52  		err:  `unit "dummy/0" is not in an error state`,
    53  		unit: "dummy/0",
    54  		mode: state.ResolvedNone,
    55  	}, {
    56  		args: []string{"dummy/1", "--retry"},
    57  		err:  `unit "dummy/1" is not in an error state`,
    58  		unit: "dummy/1",
    59  		mode: state.ResolvedNone,
    60  	}, {
    61  		args: []string{"dummy/2"},
    62  		unit: "dummy/2",
    63  		mode: state.ResolvedNoHooks,
    64  	}, {
    65  		args: []string{"dummy/2", "--retry"},
    66  		err:  `cannot set resolved mode for unit "dummy/2": already resolved`,
    67  		unit: "dummy/2",
    68  		mode: state.ResolvedNoHooks,
    69  	}, {
    70  		args: []string{"dummy/3", "--retry"},
    71  		unit: "dummy/3",
    72  		mode: state.ResolvedRetryHooks,
    73  	}, {
    74  		args: []string{"dummy/3"},
    75  		err:  `cannot set resolved mode for unit "dummy/3": already resolved`,
    76  		unit: "dummy/3",
    77  		mode: state.ResolvedRetryHooks,
    78  	}, {
    79  		args: []string{"dummy/4", "roflcopter"},
    80  		err:  `unrecognized args: \["roflcopter"\]`,
    81  	},
    82  }
    83  
    84  func (s *ResolvedSuite) TestResolved(c *gc.C) {
    85  	testcharms.Repo.CharmArchivePath(s.SeriesPath, "dummy")
    86  	err := runDeploy(c, "-n", "5", "local:dummy", "dummy")
    87  	c.Assert(err, jc.ErrorIsNil)
    88  
    89  	for _, name := range []string{"dummy/2", "dummy/3", "dummy/4"} {
    90  		u, err := s.State.Unit(name)
    91  		c.Assert(err, jc.ErrorIsNil)
    92  		err = u.SetAgentStatus(state.StatusError, "lol borken", nil)
    93  		c.Assert(err, jc.ErrorIsNil)
    94  	}
    95  
    96  	for i, t := range resolvedTests {
    97  		c.Logf("test %d: %v", i, t.args)
    98  		err := runResolved(c, t.args)
    99  		if t.err != "" {
   100  			c.Assert(err, gc.ErrorMatches, t.err)
   101  		} else {
   102  			c.Assert(err, jc.ErrorIsNil)
   103  		}
   104  		if t.unit != "" {
   105  			unit, err := s.State.Unit(t.unit)
   106  			c.Assert(err, jc.ErrorIsNil)
   107  			c.Assert(unit.Resolved(), gc.Equals, t.mode)
   108  		}
   109  	}
   110  }
   111  
   112  func (s *ResolvedSuite) TestBlockResolved(c *gc.C) {
   113  	testcharms.Repo.CharmArchivePath(s.SeriesPath, "dummy")
   114  	err := runDeploy(c, "-n", "5", "local:dummy", "dummy")
   115  	c.Assert(err, jc.ErrorIsNil)
   116  
   117  	for _, name := range []string{"dummy/2", "dummy/3", "dummy/4"} {
   118  		u, err := s.State.Unit(name)
   119  		c.Assert(err, jc.ErrorIsNil)
   120  		err = u.SetAgentStatus(state.StatusError, "lol borken", nil)
   121  		c.Assert(err, jc.ErrorIsNil)
   122  	}
   123  
   124  	// Block operation
   125  	s.BlockAllChanges(c, "TestBlockResolved")
   126  	err = runResolved(c, []string{"dummy/2"})
   127  	s.AssertBlocked(c, err, ".*TestBlockResolved.*")
   128  }