← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/client/api_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/client/api_test.go
22
22
        "github.com/juju/juju/mongo"
23
23
        "github.com/juju/juju/state"
24
24
        "github.com/juju/juju/state/multiwatcher"
 
25
        "github.com/juju/juju/state/presence"
25
26
        "github.com/juju/juju/status"
26
27
        coretesting "github.com/juju/juju/testing"
27
28
        "github.com/juju/juju/testing/factory"
112
113
func setDefaultStatus(c *gc.C, entity setStatuser) {
113
114
        now := time.Now()
114
115
        s := status.StatusInfo{
115
 
                Status:  status.StatusStarted,
 
116
                Status:  status.Started,
116
117
                Message: "",
117
118
                Since:   &now,
118
119
        }
160
161
var scenarioStatus = &params.FullStatus{
161
162
        Model: params.ModelStatusInfo{
162
163
                Name:        "controller",
163
 
                Cloud:       "dummy",
 
164
                CloudTag:    "cloud-dummy",
164
165
                CloudRegion: "dummy-region",
165
166
                Version:     "1.2.3",
166
167
        },
173
174
                                Data:   make(map[string]interface{}),
174
175
                        },
175
176
                        InstanceStatus: params.DetailedStatus{
176
 
                                Status: status.StatusPending.String(),
 
177
                                Status: status.Pending.String(),
177
178
                                Data:   make(map[string]interface{}),
178
179
                        },
179
180
                        Series:     "quantal",
190
191
                                Data:   make(map[string]interface{}),
191
192
                        },
192
193
                        InstanceStatus: params.DetailedStatus{
193
 
                                Status: status.StatusPending.String(),
 
194
                                Status: status.Pending.String(),
194
195
                                Data:   make(map[string]interface{}),
195
196
                        },
196
197
                        Series:     "quantal",
207
208
                                Data:   make(map[string]interface{}),
208
209
                        },
209
210
                        InstanceStatus: params.DetailedStatus{
210
 
                                Status: status.StatusPending.String(),
 
211
                                Status: status.Pending.String(),
211
212
                                Data:   make(map[string]interface{}),
212
213
                        },
213
214
                        Series:     "quantal",
226
227
                        },
227
228
                        SubordinateTo: []string{"wordpress"},
228
229
                        Status: params.DetailedStatus{
229
 
                                Status: "unknown",
230
 
                                Info:   "Waiting for agent initialization to finish",
 
230
                                Status: "waiting",
 
231
                                Info:   "waiting for machine",
231
232
                                Data:   map[string]interface{}{},
232
233
                        },
233
234
                },
238
239
                        SubordinateTo: []string{},
239
240
                        Units:         map[string]params.UnitStatus{},
240
241
                        Status: params.DetailedStatus{
241
 
                                Status: "unknown",
242
 
                                Info:   "Waiting for agent initialization to finish",
 
242
                                Status: "waiting",
 
243
                                Info:   "waiting for machine",
243
244
                                Data:   map[string]interface{}{},
244
245
                        },
245
246
                },
270
271
                                        Subordinates: map[string]params.UnitStatus{
271
272
                                                "logging/0": {
272
273
                                                        WorkloadStatus: params.DetailedStatus{
273
 
                                                                Status: "unknown",
274
 
                                                                Info:   "Waiting for agent initialization to finish",
 
274
                                                                Status: "waiting",
 
275
                                                                Info:   "waiting for machine",
275
276
                                                                Data:   make(map[string]interface{}),
276
277
                                                        },
277
278
                                                        AgentStatus: params.DetailedStatus{
283
284
                                },
284
285
                                "wordpress/1": {
285
286
                                        WorkloadStatus: params.DetailedStatus{
286
 
                                                Status: "unknown",
287
 
                                                Info:   "Waiting for agent initialization to finish",
 
287
                                                Status: "waiting",
 
288
                                                Info:   "waiting for machine",
288
289
                                                Data:   make(map[string]interface{}),
289
290
                                        },
290
291
                                        AgentStatus: params.DetailedStatus{
297
298
                                        Subordinates: map[string]params.UnitStatus{
298
299
                                                "logging/1": {
299
300
                                                        WorkloadStatus: params.DetailedStatus{
300
 
                                                                Status: "unknown",
301
 
                                                                Info:   "Waiting for agent initialization to finish",
 
301
                                                                Status: "waiting",
 
302
                                                                Info:   "waiting for machine",
302
303
                                                                Data:   make(map[string]interface{}),
303
304
                                                        },
304
305
                                                        AgentStatus: params.DetailedStatus{
452
453
                        }
453
454
                        now := time.Now()
454
455
                        sInfo := status.StatusInfo{
455
 
                                Status:  status.StatusError,
 
456
                                Status:  status.Error,
456
457
                                Message: "blam",
457
458
                                Data:    sd,
458
459
                                Since:   &now,
476
477
                s.setAgentPresence(c, wu)
477
478
                add(lu)
478
479
        }
 
480
        allMachines, err := s.State.AllMachines()
 
481
        c.Assert(err, jc.ErrorIsNil)
 
482
        for _, m := range allMachines {
 
483
                s.setAgentPresence(c, m)
 
484
        }
479
485
        return
480
486
}
481
487
 
482
 
func (s *baseSuite) setAgentPresence(c *gc.C, u *state.Unit) {
483
 
        pinger, err := u.SetAgentPresence()
 
488
type presenceEntity interface {
 
489
        SetAgentPresence() (*presence.Pinger, error)
 
490
        WaitAgentPresence(timeout time.Duration) (err error)
 
491
}
 
492
 
 
493
func (s *baseSuite) setAgentPresence(c *gc.C, e presenceEntity) {
 
494
        pinger, err := e.SetAgentPresence()
484
495
        c.Assert(err, jc.ErrorIsNil)
485
496
        s.AddCleanup(func(c *gc.C) {
486
497
                c.Assert(worker.Stop(pinger), jc.ErrorIsNil)
488
499
 
489
500
        s.State.StartSync()
490
501
        s.BackingState.StartSync()
491
 
        err = u.WaitAgentPresence(coretesting.LongWait)
 
502
        err = e.WaitAgentPresence(coretesting.LongWait)
492
503
        c.Assert(err, jc.ErrorIsNil)
493
504
}