github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/state/status_machine_test.go (about)

     1  // Copyright 2012-2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/state"
    11  	"github.com/juju/juju/status"
    12  	"github.com/juju/juju/testing"
    13  )
    14  
    15  type MachineStatusSuite struct {
    16  	ConnSuite
    17  	machine *state.Machine
    18  }
    19  
    20  var _ = gc.Suite(&MachineStatusSuite{})
    21  
    22  func (s *MachineStatusSuite) SetUpTest(c *gc.C) {
    23  	s.ConnSuite.SetUpTest(c)
    24  	s.machine = s.Factory.MakeMachine(c, nil)
    25  }
    26  
    27  func (s *MachineStatusSuite) TestInitialStatus(c *gc.C) {
    28  	s.checkInitialStatus(c)
    29  }
    30  
    31  func (s *MachineStatusSuite) checkInitialStatus(c *gc.C) {
    32  	statusInfo, err := s.machine.Status()
    33  	c.Check(err, jc.ErrorIsNil)
    34  	c.Check(statusInfo.Status, gc.Equals, status.Pending)
    35  	c.Check(statusInfo.Message, gc.Equals, "")
    36  	c.Check(statusInfo.Data, gc.HasLen, 0)
    37  	c.Check(statusInfo.Since, gc.NotNil)
    38  }
    39  
    40  func (s *MachineStatusSuite) TestSetErrorStatusWithoutInfo(c *gc.C) {
    41  	now := testing.ZeroTime()
    42  	sInfo := status.StatusInfo{
    43  		Status:  status.Error,
    44  		Message: "",
    45  		Since:   &now,
    46  	}
    47  	err := s.machine.SetStatus(sInfo)
    48  	c.Check(err, gc.ErrorMatches, `cannot set status "error" without info`)
    49  
    50  	s.checkInitialStatus(c)
    51  }
    52  
    53  func (s *MachineStatusSuite) TestSetDownStatus(c *gc.C) {
    54  	now := testing.ZeroTime()
    55  	sInfo := status.StatusInfo{
    56  		Status:  status.Down,
    57  		Message: "",
    58  		Since:   &now,
    59  	}
    60  	err := s.machine.SetStatus(sInfo)
    61  	c.Check(err, gc.ErrorMatches, `cannot set status "down"`)
    62  
    63  	s.checkInitialStatus(c)
    64  }
    65  
    66  func (s *MachineStatusSuite) TestSetUnknownStatus(c *gc.C) {
    67  	now := testing.ZeroTime()
    68  	sInfo := status.StatusInfo{
    69  		Status:  status.Status("vliegkat"),
    70  		Message: "orville",
    71  		Since:   &now,
    72  	}
    73  	err := s.machine.SetStatus(sInfo)
    74  	c.Assert(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`)
    75  
    76  	s.checkInitialStatus(c)
    77  }
    78  
    79  func (s *MachineStatusSuite) TestSetOverwritesData(c *gc.C) {
    80  	now := testing.ZeroTime()
    81  	sInfo := status.StatusInfo{
    82  		Status:  status.Started,
    83  		Message: "blah",
    84  		Data: map[string]interface{}{
    85  			"pew.pew": "zap",
    86  		},
    87  		Since: &now,
    88  	}
    89  	err := s.machine.SetStatus(sInfo)
    90  	c.Check(err, jc.ErrorIsNil)
    91  
    92  	s.checkGetSetStatus(c)
    93  }
    94  
    95  func (s *MachineStatusSuite) TestGetSetStatusAlive(c *gc.C) {
    96  	s.checkGetSetStatus(c)
    97  }
    98  
    99  func (s *MachineStatusSuite) checkGetSetStatus(c *gc.C) {
   100  	now := testing.ZeroTime()
   101  	sInfo := status.StatusInfo{
   102  		Status:  status.Started,
   103  		Message: "blah",
   104  		Data: map[string]interface{}{
   105  			"$foo.bar.baz": map[string]interface{}{
   106  				"pew.pew": "zap",
   107  			},
   108  		},
   109  		Since: &now,
   110  	}
   111  	err := s.machine.SetStatus(sInfo)
   112  	c.Check(err, jc.ErrorIsNil)
   113  
   114  	machine, err := s.State.Machine(s.machine.Id())
   115  	c.Assert(err, jc.ErrorIsNil)
   116  
   117  	statusInfo, err := machine.Status()
   118  	c.Check(err, jc.ErrorIsNil)
   119  	c.Check(statusInfo.Status, gc.Equals, status.Started)
   120  	c.Check(statusInfo.Message, gc.Equals, "blah")
   121  	c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{
   122  		"$foo.bar.baz": map[string]interface{}{
   123  			"pew.pew": "zap",
   124  		},
   125  	})
   126  	c.Check(statusInfo.Since, gc.NotNil)
   127  }
   128  
   129  func (s *MachineStatusSuite) TestGetSetStatusDying(c *gc.C) {
   130  	err := s.machine.Destroy()
   131  	c.Assert(err, jc.ErrorIsNil)
   132  
   133  	s.checkGetSetStatus(c)
   134  }
   135  
   136  func (s *MachineStatusSuite) TestGetSetStatusDead(c *gc.C) {
   137  	err := s.machine.EnsureDead()
   138  	c.Assert(err, jc.ErrorIsNil)
   139  
   140  	// NOTE: it would be more technically correct to reject status updates
   141  	// while Dead, but it's easier and clearer, not to mention more efficient,
   142  	// to just depend on status doc existence.
   143  	s.checkGetSetStatus(c)
   144  }
   145  
   146  func (s *MachineStatusSuite) TestGetSetStatusGone(c *gc.C) {
   147  	err := s.machine.EnsureDead()
   148  	c.Assert(err, jc.ErrorIsNil)
   149  	err = s.machine.Remove()
   150  	c.Assert(err, jc.ErrorIsNil)
   151  
   152  	now := testing.ZeroTime()
   153  	sInfo := status.StatusInfo{
   154  		Status:  status.Started,
   155  		Message: "not really",
   156  		Since:   &now,
   157  	}
   158  	err = s.machine.SetStatus(sInfo)
   159  	c.Check(err, gc.ErrorMatches, `cannot set status: machine not found`)
   160  
   161  	statusInfo, err := s.machine.Status()
   162  	c.Check(err, gc.ErrorMatches, `cannot get status: machine not found`)
   163  	c.Check(statusInfo, gc.DeepEquals, status.StatusInfo{})
   164  }
   165  
   166  func (s *MachineStatusSuite) TestSetStatusPendingProvisioned(c *gc.C) {
   167  	now := testing.ZeroTime()
   168  	sInfo := status.StatusInfo{
   169  		Status:  status.Pending,
   170  		Message: "",
   171  		Since:   &now,
   172  	}
   173  	err := s.machine.SetStatus(sInfo)
   174  	c.Check(err, gc.ErrorMatches, `cannot set status "pending"`)
   175  }
   176  
   177  func (s *MachineStatusSuite) TestSetStatusPendingUnprovisioned(c *gc.C) {
   178  	machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
   179  	c.Assert(err, jc.ErrorIsNil)
   180  	now := testing.ZeroTime()
   181  	sInfo := status.StatusInfo{
   182  		Status:  status.Pending,
   183  		Message: "",
   184  		Since:   &now,
   185  	}
   186  	err = machine.SetStatus(sInfo)
   187  	c.Check(err, jc.ErrorIsNil)
   188  }