← Back to branch summary

~themue/juju-core/go-state-lifecycle-relation

« back to all changes in this revision

Viewing changes to cmd/juju/status_test.go

  • Committer: Frank Mueller
  • Date: 2012-08-21 08:48:07 UTC
  • mfrom: (354.1.63 juju-core)
  • Revision ID: themue@gmail.com-20120821084807-l97cttfvqwa3omge
state: merged trunk to stay up-to-date

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd/juju/status_test.go
16
16
        "launchpad.net/juju-core/juju"
17
17
        "launchpad.net/juju-core/state"
18
18
        coretesting "launchpad.net/juju-core/testing"
 
19
        "launchpad.net/juju-core/version"
19
20
)
20
21
 
21
22
type StatusSuite struct {
95
96
                map[string]interface{}{
96
97
                        "machines": map[int]interface{}{
97
98
                                0: map[string]interface{}{
98
 
                                        "dns-name":    "palermo-0.dns",
99
 
                                        "instance-id": "palermo-0",
 
99
                                        "dns-name":               "palermo-0.dns",
 
100
                                        "instance-id":            "palermo-0",
 
101
                                        "agent-version":          "0.0.0",
 
102
                                        "proposed-agent-version": "0.0.0",
 
103
                                },
 
104
                        },
 
105
                        "services": make(map[string]interface{}),
 
106
                },
 
107
        },
 
108
        {
 
109
                "simulate the MA setting the version",
 
110
                func(st *state.State, conn *juju.Conn, c *C) {
 
111
                        m, err := st.Machine(0)
 
112
                        c.Assert(err, IsNil)
 
113
                        t := &state.Tools{
 
114
                                Binary: version.Binary{
 
115
                                        Number: version.MustParse("1.2.3"),
 
116
                                        Series: "gutsy",
 
117
                                        Arch:   "ppc",
 
118
                                },
 
119
                                URL: "http://canonical.com/",
 
120
                        }
 
121
                        err = m.SetAgentTools(t)
 
122
                        c.Assert(err, IsNil)
 
123
                },
 
124
                map[string]interface{}{
 
125
                        "machines": map[int]interface{}{
 
126
                                0: map[string]interface{}{
 
127
                                        "dns-name":               "palermo-0.dns",
 
128
                                        "instance-id":            "palermo-0",
 
129
                                        "agent-version":          "1.2.3",
 
130
                                        "proposed-agent-version": "0.0.0",
 
131
                                },
 
132
                        },
 
133
                        "services": make(map[string]interface{}),
 
134
                },
 
135
        },
 
136
        {
 
137
                "simulate setting the proposed version",
 
138
                func(st *state.State, conn *juju.Conn, c *C) {
 
139
                        m, err := st.Machine(0)
 
140
                        c.Assert(err, IsNil)
 
141
                        t := &state.Tools{
 
142
                                Binary: version.Binary{
 
143
                                        Number: version.MustParse("2.0.3"),
 
144
                                        Series: "gutsy",
 
145
                                        Arch:   "ppc",
 
146
                                },
 
147
                                URL: "http://canonical.com/",
 
148
                        }
 
149
                        err = m.ProposeAgentTools(t)
 
150
                        c.Assert(err, IsNil)
 
151
                },
 
152
                map[string]interface{}{
 
153
                        "machines": map[int]interface{}{
 
154
                                0: map[string]interface{}{
 
155
                                        "dns-name":               "palermo-0.dns",
 
156
                                        "instance-id":            "palermo-0",
 
157
                                        "agent-version":          "1.2.3",
 
158
                                        "proposed-agent-version": "2.0.3",
100
159
                                },
101
160
                        },
102
161
                        "services": make(map[string]interface{}),
123
182
                map[string]interface{}{
124
183
                        "machines": map[int]interface{}{
125
184
                                0: map[string]interface{}{
126
 
                                        "dns-name":    "palermo-0.dns",
127
 
                                        "instance-id": "palermo-0",
128
 
                                },
129
 
                        },
130
 
                        "services": map[string]interface{}{
131
 
                                "dummy-service": map[string]interface{}{
132
 
                                        "charm":   "dummy",
133
 
                                        "exposed": false,
134
 
                                },
135
 
                                "exposed-service": map[string]interface{}{
136
 
                                        "charm":   "dummy",
137
 
                                        "exposed": true,
138
 
                                },
139
 
                        },
140
 
                },
141
 
        },
 
185
                                        "dns-name":               "palermo-0.dns",
 
186
                                        "instance-id":            "palermo-0",
 
187
                                        "agent-version":          "1.2.3",
 
188
                                        "proposed-agent-version": "2.0.3",
 
189
                                },
 
190
                        },
 
191
                        "services": map[string]interface{}{
 
192
                                "dummy-service": map[string]interface{}{
 
193
                                        "charm":   "dummy",
 
194
                                        "exposed": false,
 
195
                                },
 
196
                                "exposed-service": map[string]interface{}{
 
197
                                        "charm":   "dummy",
 
198
                                        "exposed": true,
 
199
                                },
 
200
                        },
 
201
                },
 
202
        },
 
203
        {
 
204
                "add two more machines for units",
 
205
                func(st *state.State, conn *juju.Conn, c *C) {
 
206
                        for i := 1; i < 3; i++ {
 
207
                                m, err := st.AddMachine()
 
208
                                c.Assert(err, IsNil)
 
209
                                c.Assert(m.Id(), Equals, i)
 
210
                                inst, err := conn.Environ.StartInstance(m.Id(), nil, nil)
 
211
                                c.Assert(err, IsNil)
 
212
                                err = m.SetInstanceId(inst.Id())
 
213
                                c.Assert(err, IsNil)
 
214
                        }
 
215
                },
 
216
                map[string]interface{}{
 
217
                        "machines": map[int]interface{}{
 
218
                                0: map[string]interface{}{
 
219
                                        "dns-name":               "palermo-0.dns",
 
220
                                        "instance-id":            "palermo-0",
 
221
                                        "agent-version":          "1.2.3",
 
222
                                        "proposed-agent-version": "2.0.3",
 
223
                                },
 
224
                                1: map[string]interface{}{
 
225
                                        "dns-name":               "palermo-1.dns",
 
226
                                        "instance-id":            "palermo-1",
 
227
                                        "agent-version":          "0.0.0",
 
228
                                        "proposed-agent-version": "0.0.0",
 
229
                                },
 
230
                                2: map[string]interface{}{
 
231
                                        "dns-name":               "palermo-2.dns",
 
232
                                        "instance-id":            "palermo-2",
 
233
                                        "agent-version":          "0.0.0",
 
234
                                        "proposed-agent-version": "0.0.0",
 
235
                                },
 
236
                        },
 
237
                        "services": map[string]interface{}{
 
238
                                "dummy-service": map[string]interface{}{
 
239
                                        "charm":   "dummy",
 
240
                                        "exposed": false,
 
241
                                },
 
242
                                "exposed-service": map[string]interface{}{
 
243
                                        "charm":   "dummy",
 
244
                                        "exposed": true,
 
245
                                },
 
246
                        },
 
247
                },
 
248
        },
 
249
        {
 
250
                "add units for services",
 
251
                func(st *state.State, conn *juju.Conn, c *C) {
 
252
                        for i, n := range []string{"dummy-service", "exposed-service"} {
 
253
                                s, err := st.Service(n)
 
254
                                c.Assert(err, IsNil)
 
255
                                u, err := s.AddUnit()
 
256
                                c.Assert(err, IsNil)
 
257
                                m, err := st.Machine(i + 1)
 
258
                                c.Assert(err, IsNil)
 
259
                                err = u.AssignToMachine(m)
 
260
                                c.Assert(err, IsNil)
 
261
 
 
262
                                if n == "exposed-service" {
 
263
                                        err := u.SetStatus("error", "You Require More Vespene Gas")
 
264
                                        c.Assert(err, IsNil)
 
265
                                }
 
266
                        }
 
267
                },
 
268
                map[string]interface{}{
 
269
                        "machines": map[int]interface{}{
 
270
                                0: map[string]interface{}{
 
271
                                        "dns-name":               "palermo-0.dns",
 
272
                                        "instance-id":            "palermo-0",
 
273
                                        "agent-version":          "1.2.3",
 
274
                                        "proposed-agent-version": "2.0.3",
 
275
                                },
 
276
                                1: map[string]interface{}{
 
277
                                        "dns-name":               "palermo-1.dns",
 
278
                                        "instance-id":            "palermo-1",
 
279
                                        "agent-version":          "0.0.0",
 
280
                                        "proposed-agent-version": "0.0.0",
 
281
                                },
 
282
                                2: map[string]interface{}{
 
283
                                        "dns-name":               "palermo-2.dns",
 
284
                                        "instance-id":            "palermo-2",
 
285
                                        "agent-version":          "0.0.0",
 
286
                                        "proposed-agent-version": "0.0.0",
 
287
                                },
 
288
                        },
 
289
                        "services": map[string]interface{}{
 
290
                                "exposed-service": map[string]interface{}{
 
291
                                        "exposed": true,
 
292
                                        "units": map[string]interface{}{
 
293
                                                "exposed-service/0": map[string]interface{}{
 
294
                                                        "agent-version":          "0.0.0",
 
295
                                                        "proposed-agent-version": "0.0.0",
 
296
                                                        "machine":                2,
 
297
                                                        "status":                 "error",
 
298
                                                        "status-info":            "You Require More Vespene Gas",
 
299
                                                },
 
300
                                        },
 
301
                                        "charm": "dummy",
 
302
                                },
 
303
                                "dummy-service": map[string]interface{}{
 
304
                                        "charm":   "dummy",
 
305
                                        "exposed": false,
 
306
                                        "units": map[string]interface{}{
 
307
                                                "dummy-service/0": map[string]interface{}{
 
308
                                                        "agent-version":          "0.0.0",
 
309
                                                        "proposed-agent-version": "0.0.0",
 
310
                                                        "machine":                1,
 
311
                                                        "status":                 "pending",
 
312
                                                },
 
313
                                        },
 
314
                                },
 
315
                        },
 
316
                },
 
317
        },
 
318
 
 
319
        // TODO(dfc) test failing components by destructively mutating zk under the hood
142
320
}
143
321
 
144
322
func (s *StatusSuite) testStatus(format string, marshal func(v interface{}) ([]byte, error), unmarshal func(data []byte, v interface{}) error, c *C) {
165
343
                actual := make(map[string]interface{})
166
344
                err = unmarshal(ctx.Stdout.(*bytes.Buffer).Bytes(), &actual)
167
345
                c.Assert(err, IsNil)
168
 
 
169
346
                c.Assert(actual, DeepEquals, expected)
170
347
        }
171
348
}