← 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/apiserver/client/api_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/apiserver/client/api_test.go
23
23
        "github.com/juju/juju/mongo"
24
24
        "github.com/juju/juju/state"
25
25
        "github.com/juju/juju/state/multiwatcher"
 
26
        "github.com/juju/juju/status"
26
27
        "github.com/juju/juju/storage/poolmanager"
27
28
        "github.com/juju/juju/storage/provider"
28
29
        coretesting "github.com/juju/juju/testing"
107
108
}
108
109
 
109
110
type setStatuser interface {
110
 
        SetStatus(status state.Status, info string, data map[string]interface{}) error
 
111
        SetStatus(statuSettable status.Status, info string, data map[string]interface{}) error
111
112
}
112
113
 
113
114
func setDefaultStatus(c *gc.C, entity setStatuser) {
114
 
        err := entity.SetStatus(state.StatusStarted, "", nil)
 
115
        err := entity.SetStatus(status.StatusStarted, "", nil)
115
116
        c.Assert(err, jc.ErrorIsNil)
116
117
}
117
118
 
153
154
// but this behavior is already tested in cmd/juju/status_test.go and
154
155
// also tested live and it works.
155
156
var scenarioStatus = &params.FullStatus{
156
 
        ModelName: "dummymodel",
 
157
        ModelName: "admin",
157
158
        Machines: map[string]params.MachineStatus{
158
159
                "0": {
159
160
                        Id:         "0",
160
161
                        InstanceId: instance.Id("i-machine-0"),
161
 
                        Agent: params.AgentStatus{
 
162
                        AgentStatus: params.DetailedStatus{
162
163
                                Status: "started",
163
164
                                Data:   make(map[string]interface{}),
164
165
                        },
 
166
                        InstanceStatus: params.DetailedStatus{
 
167
                                Status: status.StatusPending,
 
168
                                Data:   make(map[string]interface{}),
 
169
                        },
165
170
                        Series:     "quantal",
166
171
                        Containers: map[string]params.MachineStatus{},
167
172
                        Jobs:       []multiwatcher.MachineJob{multiwatcher.JobManageModel},
171
176
                "1": {
172
177
                        Id:         "1",
173
178
                        InstanceId: instance.Id("i-machine-1"),
174
 
                        Agent: params.AgentStatus{
 
179
                        AgentStatus: params.DetailedStatus{
175
180
                                Status: "started",
176
181
                                Data:   make(map[string]interface{}),
177
182
                        },
 
183
                        InstanceStatus: params.DetailedStatus{
 
184
                                Status: status.StatusPending,
 
185
                                Data:   make(map[string]interface{}),
 
186
                        },
178
187
                        Series:     "quantal",
179
188
                        Containers: map[string]params.MachineStatus{},
180
189
                        Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
184
193
                "2": {
185
194
                        Id:         "2",
186
195
                        InstanceId: instance.Id("i-machine-2"),
187
 
                        Agent: params.AgentStatus{
 
196
                        AgentStatus: params.DetailedStatus{
188
197
                                Status: "started",
189
198
                                Data:   make(map[string]interface{}),
190
199
                        },
 
200
                        InstanceStatus: params.DetailedStatus{
 
201
                                Status: status.StatusPending,
 
202
                                Data:   make(map[string]interface{}),
 
203
                        },
191
204
                        Series:     "quantal",
192
205
                        Containers: map[string]params.MachineStatus{},
193
206
                        Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
209
222
                        Relations:     map[string][]string{},
210
223
                        SubordinateTo: []string{},
211
224
                        Units:         map[string]params.UnitStatus{},
212
 
                        Status: params.AgentStatus{
 
225
                        Status: params.DetailedStatus{
213
226
                                Status: "unknown",
214
227
                                Info:   "Waiting for agent initialization to finish",
215
228
                                Data:   map[string]interface{}{},
221
234
                                "logging-dir": {"logging"},
222
235
                        },
223
236
                        SubordinateTo: []string{},
224
 
                        Status: params.AgentStatus{
 
237
                        Status: params.DetailedStatus{
225
238
                                Status: "error",
226
239
                                Info:   "blam",
227
240
                                Data:   map[string]interface{}{"remote-unit": "logging/0", "foo": "bar", "relation-id": "0"},
228
241
                        },
229
242
                        Units: map[string]params.UnitStatus{
230
243
                                "wordpress/0": {
231
 
                                        Workload: params.AgentStatus{
 
244
                                        WorkloadStatus: params.DetailedStatus{
232
245
                                                Status: "error",
233
246
                                                Info:   "blam",
234
247
                                                Data:   map[string]interface{}{"relation-id": "0"},
235
248
                                        },
236
 
                                        UnitAgent: params.AgentStatus{
 
249
                                        AgentStatus: params.DetailedStatus{
237
250
                                                Status: "idle",
238
251
                                                Data:   make(map[string]interface{}),
239
252
                                        },
240
 
                                        AgentState:     "error",
241
 
                                        AgentStateInfo: "blam",
242
 
                                        Machine:        "1",
 
253
                                        Machine: "1",
243
254
                                        Subordinates: map[string]params.UnitStatus{
244
255
                                                "logging/0": {
245
 
                                                        AgentState: "pending",
246
 
                                                        Workload: params.AgentStatus{
 
256
                                                        WorkloadStatus: params.DetailedStatus{
247
257
                                                                Status: "unknown",
248
258
                                                                Info:   "Waiting for agent initialization to finish",
249
259
                                                                Data:   make(map[string]interface{}),
250
260
                                                        },
251
 
                                                        UnitAgent: params.AgentStatus{
 
261
                                                        AgentStatus: params.DetailedStatus{
252
262
                                                                Status: "allocating",
253
263
                                                                Data:   map[string]interface{}{},
254
264
                                                        },
256
266
                                        },
257
267
                                },
258
268
                                "wordpress/1": {
259
 
                                        AgentState: "pending",
260
 
                                        Workload: params.AgentStatus{
 
269
                                        WorkloadStatus: params.DetailedStatus{
261
270
                                                Status: "unknown",
262
271
                                                Info:   "Waiting for agent initialization to finish",
263
272
                                                Data:   make(map[string]interface{}),
264
273
                                        },
265
 
                                        UnitAgent: params.AgentStatus{
 
274
                                        AgentStatus: params.DetailedStatus{
266
275
                                                Status: "allocating",
267
276
                                                Info:   "",
268
277
                                                Data:   make(map[string]interface{}),
271
280
                                        Machine: "2",
272
281
                                        Subordinates: map[string]params.UnitStatus{
273
282
                                                "logging/1": {
274
 
                                                        AgentState: "pending",
275
 
                                                        Workload: params.AgentStatus{
 
283
                                                        WorkloadStatus: params.DetailedStatus{
276
284
                                                                Status: "unknown",
277
285
                                                                Info:   "Waiting for agent initialization to finish",
278
286
                                                                Data:   make(map[string]interface{}),
279
287
                                                        },
280
 
                                                        UnitAgent: params.AgentStatus{
 
288
                                                        AgentStatus: params.DetailedStatus{
281
289
                                                                Status: "allocating",
282
290
                                                                Info:   "",
283
291
                                                                Data:   make(map[string]interface{}),
424
432
                                "remote-unit": "logging/0",
425
433
                                "foo":         "bar",
426
434
                        }
427
 
                        err := wu.SetAgentStatus(state.StatusError, "blam", sd)
 
435
                        err := wu.SetAgentStatus(status.StatusError, "blam", sd)
428
436
                        c.Assert(err, jc.ErrorIsNil)
429
437
                }
430
438