← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/state/status_machine_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/state/status_machine_test.go
8
8
        gc "gopkg.in/check.v1"
9
9
 
10
10
        "github.com/juju/juju/state"
 
11
        "github.com/juju/juju/status"
11
12
)
12
13
 
13
14
type MachineStatusSuite struct {
29
30
func (s *MachineStatusSuite) checkInitialStatus(c *gc.C) {
30
31
        statusInfo, err := s.machine.Status()
31
32
        c.Check(err, jc.ErrorIsNil)
32
 
        c.Check(statusInfo.Status, gc.Equals, state.StatusPending)
 
33
        c.Check(statusInfo.Status, gc.Equals, status.StatusPending)
33
34
        c.Check(statusInfo.Message, gc.Equals, "")
34
35
        c.Check(statusInfo.Data, gc.HasLen, 0)
35
36
        c.Check(statusInfo.Since, gc.NotNil)
36
37
}
37
38
 
38
39
func (s *MachineStatusSuite) TestSetErrorStatusWithoutInfo(c *gc.C) {
39
 
        err := s.machine.SetStatus(state.StatusError, "", nil)
 
40
        err := s.machine.SetStatus(status.StatusError, "", nil)
40
41
        c.Check(err, gc.ErrorMatches, `cannot set status "error" without info`)
41
42
 
42
43
        s.checkInitialStatus(c)
43
44
}
44
45
 
45
46
func (s *MachineStatusSuite) TestSetDownStatus(c *gc.C) {
46
 
        err := s.machine.SetStatus(state.StatusDown, "", nil)
 
47
        err := s.machine.SetStatus(status.StatusDown, "", nil)
47
48
        c.Check(err, gc.ErrorMatches, `cannot set status "down"`)
48
49
 
49
50
        s.checkInitialStatus(c)
50
51
}
51
52
 
52
53
func (s *MachineStatusSuite) TestSetUnknownStatus(c *gc.C) {
53
 
        err := s.machine.SetStatus(state.Status("vliegkat"), "orville", nil)
 
54
        err := s.machine.SetStatus(status.Status("vliegkat"), "orville", nil)
54
55
        c.Assert(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`)
55
56
 
56
57
        s.checkInitialStatus(c)
57
58
}
58
59
 
59
60
func (s *MachineStatusSuite) TestSetOverwritesData(c *gc.C) {
60
 
        err := s.machine.SetStatus(state.StatusStarted, "blah", map[string]interface{}{
 
61
        err := s.machine.SetStatus(status.StatusStarted, "blah", map[string]interface{}{
61
62
                "pew.pew": "zap",
62
63
        })
63
64
        c.Check(err, jc.ErrorIsNil)
70
71
}
71
72
 
72
73
func (s *MachineStatusSuite) checkGetSetStatus(c *gc.C) {
73
 
        err := s.machine.SetStatus(state.StatusStarted, "blah", map[string]interface{}{
 
74
        err := s.machine.SetStatus(status.StatusStarted, "blah", map[string]interface{}{
74
75
                "$foo.bar.baz": map[string]interface{}{
75
76
                        "pew.pew": "zap",
76
77
                },
82
83
 
83
84
        statusInfo, err := machine.Status()
84
85
        c.Check(err, jc.ErrorIsNil)
85
 
        c.Check(statusInfo.Status, gc.Equals, state.StatusStarted)
 
86
        c.Check(statusInfo.Status, gc.Equals, status.StatusStarted)
86
87
        c.Check(statusInfo.Message, gc.Equals, "blah")
87
88
        c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{
88
89
                "$foo.bar.baz": map[string]interface{}{
115
116
        err = s.machine.Remove()
116
117
        c.Assert(err, jc.ErrorIsNil)
117
118
 
118
 
        err = s.machine.SetStatus(state.StatusStarted, "not really", nil)
 
119
        err = s.machine.SetStatus(status.StatusStarted, "not really", nil)
119
120
        c.Check(err, gc.ErrorMatches, `cannot set status: machine not found`)
120
121
 
121
122
        statusInfo, err := s.machine.Status()
122
123
        c.Check(err, gc.ErrorMatches, `cannot get status: machine not found`)
123
 
        c.Check(statusInfo, gc.DeepEquals, state.StatusInfo{})
 
124
        c.Check(statusInfo, gc.DeepEquals, status.StatusInfo{})
124
125
}
125
126
 
126
127
func (s *MachineStatusSuite) TestSetStatusPendingProvisioned(c *gc.C) {
127
 
        err := s.machine.SetStatus(state.StatusPending, "", nil)
 
128
        err := s.machine.SetStatus(status.StatusPending, "", nil)
128
129
        c.Check(err, gc.ErrorMatches, `cannot set status "pending"`)
129
130
}
130
131
 
131
132
func (s *MachineStatusSuite) TestSetStatusPendingUnprovisioned(c *gc.C) {
132
133
        machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
133
134
        c.Assert(err, jc.ErrorIsNil)
134
 
        err = machine.SetStatus(state.StatusPending, "", nil)
 
135
        err = machine.SetStatus(status.StatusPending, "", nil)
135
136
        c.Check(err, jc.ErrorIsNil)
136
137
}