github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/status_unit_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  	"time"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/state"
    13  	"github.com/juju/juju/status"
    14  )
    15  
    16  type UnitStatusSuite struct {
    17  	ConnSuite
    18  	unit *state.Unit
    19  }
    20  
    21  var _ = gc.Suite(&UnitStatusSuite{})
    22  
    23  func (s *UnitStatusSuite) SetUpTest(c *gc.C) {
    24  	s.ConnSuite.SetUpTest(c)
    25  	s.unit = s.Factory.MakeUnit(c, nil)
    26  }
    27  
    28  func (s *UnitStatusSuite) TestInitialStatus(c *gc.C) {
    29  	s.checkInitialStatus(c)
    30  }
    31  
    32  func (s *UnitStatusSuite) checkInitialStatus(c *gc.C) {
    33  	statusInfo, err := s.unit.Status()
    34  	c.Check(err, jc.ErrorIsNil)
    35  	checkInitialWorkloadStatus(c, statusInfo)
    36  }
    37  
    38  func (s *UnitStatusSuite) TestSetUnknownStatus(c *gc.C) {
    39  	err := s.unit.SetStatus(status.Status("vliegkat"), "orville", nil)
    40  	c.Check(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`)
    41  
    42  	s.checkInitialStatus(c)
    43  }
    44  
    45  func (s *UnitStatusSuite) TestSetOverwritesData(c *gc.C) {
    46  	err := s.unit.SetStatus(status.StatusActive, "healthy", map[string]interface{}{
    47  		"pew.pew": "zap",
    48  	})
    49  	c.Check(err, jc.ErrorIsNil)
    50  
    51  	s.checkGetSetStatus(c)
    52  }
    53  
    54  func (s *UnitStatusSuite) TestGetSetStatusAlive(c *gc.C) {
    55  	s.checkGetSetStatus(c)
    56  }
    57  
    58  func (s *UnitStatusSuite) checkGetSetStatus(c *gc.C) {
    59  	err := s.unit.SetStatus(status.StatusActive, "healthy", map[string]interface{}{
    60  		"$ping": map[string]interface{}{
    61  			"foo.bar": 123,
    62  		},
    63  	})
    64  	c.Check(err, jc.ErrorIsNil)
    65  
    66  	unit, err := s.State.Unit(s.unit.Name())
    67  	c.Assert(err, jc.ErrorIsNil)
    68  
    69  	statusInfo, err := unit.Status()
    70  	c.Check(err, jc.ErrorIsNil)
    71  	c.Check(statusInfo.Status, gc.Equals, status.StatusActive)
    72  	c.Check(statusInfo.Message, gc.Equals, "healthy")
    73  	c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{
    74  		"$ping": map[string]interface{}{
    75  			"foo.bar": 123,
    76  		},
    77  	})
    78  	c.Check(statusInfo.Since, gc.NotNil)
    79  }
    80  
    81  func (s *UnitStatusSuite) TestGetSetStatusDying(c *gc.C) {
    82  	preventUnitDestroyRemove(c, s.unit)
    83  	err := s.unit.Destroy()
    84  	c.Assert(err, jc.ErrorIsNil)
    85  
    86  	s.checkGetSetStatus(c)
    87  }
    88  
    89  func (s *UnitStatusSuite) TestGetSetStatusDead(c *gc.C) {
    90  	preventUnitDestroyRemove(c, s.unit)
    91  	err := s.unit.Destroy()
    92  	c.Assert(err, jc.ErrorIsNil)
    93  	err = s.unit.EnsureDead()
    94  	c.Assert(err, jc.ErrorIsNil)
    95  
    96  	// NOTE: it would be more technically correct to reject status updates
    97  	// while Dead, but it's easier and clearer, not to mention more efficient,
    98  	// to just depend on status doc existence.
    99  	s.checkGetSetStatus(c)
   100  }
   101  
   102  func (s *UnitStatusSuite) TestGetSetStatusGone(c *gc.C) {
   103  	err := s.unit.Destroy()
   104  	c.Assert(err, jc.ErrorIsNil)
   105  
   106  	err = s.unit.SetStatus(status.StatusActive, "not really", nil)
   107  	c.Check(err, gc.ErrorMatches, `cannot set status: unit not found`)
   108  
   109  	statusInfo, err := s.unit.Status()
   110  	c.Check(err, gc.ErrorMatches, `cannot get status: unit not found`)
   111  	c.Check(statusInfo, gc.DeepEquals, status.StatusInfo{})
   112  }
   113  
   114  func (s *UnitStatusSuite) TestSetUnitStatusSince(c *gc.C) {
   115  	now := time.Now()
   116  	err := s.unit.SetStatus(status.StatusMaintenance, "", nil)
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	statusInfo, err := s.unit.Status()
   119  	c.Assert(err, jc.ErrorIsNil)
   120  	firstTime := statusInfo.Since
   121  	c.Assert(firstTime, gc.NotNil)
   122  	c.Assert(timeBeforeOrEqual(now, *firstTime), jc.IsTrue)
   123  
   124  	// Setting the same status a second time also updates the timestamp.
   125  	err = s.unit.SetStatus(status.StatusMaintenance, "", nil)
   126  	c.Assert(err, jc.ErrorIsNil)
   127  	statusInfo, err = s.unit.Status()
   128  	c.Assert(err, jc.ErrorIsNil)
   129  	c.Assert(timeBeforeOrEqual(*firstTime, *statusInfo.Since), jc.IsTrue)
   130  }
   131  
   132  func (s *UnitStatusSuite) TestStatusHistoryInitial(c *gc.C) {
   133  	history, err := s.unit.StatusHistory(1)
   134  	c.Check(err, jc.ErrorIsNil)
   135  	c.Assert(history, gc.HasLen, 1)
   136  
   137  	checkInitialWorkloadStatus(c, history[0])
   138  }
   139  
   140  func (s *UnitStatusSuite) TestStatusHistoryShort(c *gc.C) {
   141  	primeUnitStatusHistory(c, s.unit, 5)
   142  
   143  	history, err := s.unit.StatusHistory(10)
   144  	c.Check(err, jc.ErrorIsNil)
   145  	c.Assert(history, gc.HasLen, 6)
   146  
   147  	checkInitialWorkloadStatus(c, history[5])
   148  	history = history[:5]
   149  	for i, statusInfo := range history {
   150  		checkPrimedUnitStatus(c, statusInfo, 4-i)
   151  	}
   152  }
   153  
   154  func (s *UnitStatusSuite) TestStatusHistoryLong(c *gc.C) {
   155  	primeUnitStatusHistory(c, s.unit, 25)
   156  
   157  	history, err := s.unit.StatusHistory(15)
   158  	c.Check(err, jc.ErrorIsNil)
   159  	c.Check(history, gc.HasLen, 15)
   160  	for i, statusInfo := range history {
   161  		checkPrimedUnitStatus(c, statusInfo, 24-i)
   162  	}
   163  }