← 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/api/uniter/unit_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/api/uniter/unit_test.go
22
22
        "github.com/juju/juju/juju/testing"
23
23
        "github.com/juju/juju/network"
24
24
        "github.com/juju/juju/state"
 
25
        "github.com/juju/juju/status"
25
26
        jujufactory "github.com/juju/juju/testing/factory"
26
27
        "github.com/juju/juju/watcher/watchertest"
27
28
)
62
63
func (s *unitSuite) TestSetAgentStatus(c *gc.C) {
63
64
        statusInfo, err := s.wordpressUnit.AgentStatus()
64
65
        c.Assert(err, jc.ErrorIsNil)
65
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusAllocating)
 
66
        c.Assert(statusInfo.Status, gc.Equals, status.StatusAllocating)
66
67
        c.Assert(statusInfo.Message, gc.Equals, "")
67
68
        c.Assert(statusInfo.Data, gc.HasLen, 0)
68
69
 
69
70
        unitStatusInfo, err := s.wordpressUnit.Status()
70
71
        c.Assert(err, jc.ErrorIsNil)
71
 
        c.Assert(unitStatusInfo.Status, gc.Equals, state.StatusUnknown)
 
72
        c.Assert(unitStatusInfo.Status, gc.Equals, status.StatusUnknown)
72
73
        c.Assert(unitStatusInfo.Message, gc.Equals, "Waiting for agent initialization to finish")
73
74
        c.Assert(unitStatusInfo.Data, gc.HasLen, 0)
74
75
 
75
 
        err = s.apiUnit.SetAgentStatus(params.StatusIdle, "blah", nil)
 
76
        err = s.apiUnit.SetAgentStatus(status.StatusIdle, "blah", nil)
76
77
        c.Assert(err, jc.ErrorIsNil)
77
78
 
78
79
        statusInfo, err = s.wordpressUnit.AgentStatus()
79
80
        c.Assert(err, jc.ErrorIsNil)
80
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusIdle)
 
81
        c.Assert(statusInfo.Status, gc.Equals, status.StatusIdle)
81
82
        c.Assert(statusInfo.Message, gc.Equals, "blah")
82
83
        c.Assert(statusInfo.Data, gc.HasLen, 0)
83
84
        c.Assert(statusInfo.Since, gc.NotNil)
85
86
        // Ensure that unit has not changed.
86
87
        unitStatusInfo, err = s.wordpressUnit.Status()
87
88
        c.Assert(err, jc.ErrorIsNil)
88
 
        c.Assert(unitStatusInfo.Status, gc.Equals, state.StatusUnknown)
 
89
        c.Assert(unitStatusInfo.Status, gc.Equals, status.StatusUnknown)
89
90
        c.Assert(unitStatusInfo.Message, gc.Equals, "Waiting for agent initialization to finish")
90
91
        c.Assert(unitStatusInfo.Data, gc.HasLen, 0)
91
92
}
93
94
func (s *unitSuite) TestSetUnitStatus(c *gc.C) {
94
95
        statusInfo, err := s.wordpressUnit.Status()
95
96
        c.Assert(err, jc.ErrorIsNil)
96
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusUnknown)
 
97
        c.Assert(statusInfo.Status, gc.Equals, status.StatusUnknown)
97
98
        c.Assert(statusInfo.Message, gc.Equals, "Waiting for agent initialization to finish")
98
99
        c.Assert(statusInfo.Data, gc.HasLen, 0)
99
100
 
100
101
        agentStatusInfo, err := s.wordpressUnit.AgentStatus()
101
102
        c.Assert(err, jc.ErrorIsNil)
102
 
        c.Assert(agentStatusInfo.Status, gc.Equals, state.StatusAllocating)
 
103
        c.Assert(agentStatusInfo.Status, gc.Equals, status.StatusAllocating)
103
104
        c.Assert(agentStatusInfo.Message, gc.Equals, "")
104
105
        c.Assert(agentStatusInfo.Data, gc.HasLen, 0)
105
106
 
106
 
        err = s.apiUnit.SetUnitStatus(params.StatusActive, "blah", nil)
 
107
        err = s.apiUnit.SetUnitStatus(status.StatusActive, "blah", nil)
107
108
        c.Assert(err, jc.ErrorIsNil)
108
109
 
109
110
        statusInfo, err = s.wordpressUnit.Status()
110
111
        c.Assert(err, jc.ErrorIsNil)
111
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusActive)
 
112
        c.Assert(statusInfo.Status, gc.Equals, status.StatusActive)
112
113
        c.Assert(statusInfo.Message, gc.Equals, "blah")
113
114
        c.Assert(statusInfo.Data, gc.HasLen, 0)
114
115
        c.Assert(statusInfo.Since, gc.NotNil)
116
117
        // Ensure unit's agent has not changed.
117
118
        agentStatusInfo, err = s.wordpressUnit.AgentStatus()
118
119
        c.Assert(err, jc.ErrorIsNil)
119
 
        c.Assert(agentStatusInfo.Status, gc.Equals, state.StatusAllocating)
 
120
        c.Assert(agentStatusInfo.Status, gc.Equals, status.StatusAllocating)
120
121
        c.Assert(agentStatusInfo.Message, gc.Equals, "")
121
122
        c.Assert(agentStatusInfo.Data, gc.HasLen, 0)
122
123
}
123
124
 
124
125
func (s *unitSuite) TestUnitStatus(c *gc.C) {
125
 
        err := s.wordpressUnit.SetStatus(state.StatusMaintenance, "blah", nil)
 
126
        err := s.wordpressUnit.SetStatus(status.StatusMaintenance, "blah", nil)
126
127
        c.Assert(err, jc.ErrorIsNil)
127
128
 
128
129
        result, err := s.apiUnit.UnitStatus()
130
131
        c.Assert(result.Since, gc.NotNil)
131
132
        result.Since = nil
132
133
        c.Assert(result, gc.DeepEquals, params.StatusResult{
133
 
                Status: params.StatusMaintenance,
 
134
                Status: status.StatusMaintenance,
134
135
                Info:   "blah",
135
136
                Data:   map[string]interface{}{},
136
137
        })
222
223
 
223
224
        // Change something other than the lifecycle and make sure it's
224
225
        // not detected.
225
 
        err = s.apiUnit.SetAgentStatus(params.StatusIdle, "not really", nil)
 
226
        err = s.apiUnit.SetAgentStatus(status.StatusIdle, "not really", nil)
226
227
        c.Assert(err, jc.ErrorIsNil)
227
228
        wc.AssertNoChange()
228
229
 
302
303
        c.Assert(address, gc.Equals, "1.2.3.4")
303
304
}
304
305
 
 
306
func (s *unitSuite) TestNetworkConfig(c *gc.C) {
 
307
        // Set some provider addresses bound to both "public" and "internal"
 
308
        // spaces.
 
309
        addresses := []network.Address{
 
310
                network.NewAddressOnSpace("public", "8.8.8.8"),
 
311
                network.NewAddressOnSpace("", "8.8.4.4"),
 
312
                network.NewAddressOnSpace("internal", "10.0.0.1"),
 
313
                network.NewAddressOnSpace("internal", "10.0.0.2"),
 
314
                network.NewAddressOnSpace("public", "fc00::1"),
 
315
        }
 
316
        err := s.wordpressMachine.SetProviderAddresses(addresses...)
 
317
        c.Assert(err, jc.ErrorIsNil)
 
318
 
 
319
        netConfig, err := s.apiUnit.NetworkConfig("db") // relation name, bound to "internal"
 
320
        c.Assert(err, jc.ErrorIsNil)
 
321
        c.Assert(netConfig, jc.DeepEquals, []params.NetworkConfig{
 
322
                {Address: "10.0.0.1"},
 
323
                {Address: "10.0.0.2"},
 
324
        })
 
325
 
 
326
        netConfig, err = s.apiUnit.NetworkConfig("admin-api") // extra-binding name, bound to "public"
 
327
        c.Assert(err, jc.ErrorIsNil)
 
328
        c.Assert(netConfig, jc.DeepEquals, []params.NetworkConfig{
 
329
                {Address: "8.8.8.8"},
 
330
                {Address: "fc00::1"},
 
331
        })
 
332
 
 
333
        netConfig, err = s.apiUnit.NetworkConfig("unknown")
 
334
        c.Assert(err, gc.ErrorMatches, `binding name "unknown" not defined by the unit's charm`)
 
335
        c.Assert(netConfig, gc.IsNil)
 
336
 
 
337
        netConfig, err = s.apiUnit.NetworkConfig("")
 
338
        c.Assert(err, gc.ErrorMatches, "binding name cannot be empty")
 
339
        c.Assert(netConfig, gc.IsNil)
 
340
}
 
341
 
305
342
func (s *unitSuite) TestAvailabilityZone(c *gc.C) {
306
343
        uniter.PatchUnitResponse(s, s.apiUnit, "AvailabilityZone",
307
344
                func(result interface{}) error {