← 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/client_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/client_test.go
5
5
 
6
6
import (
7
7
        "fmt"
8
 
        "regexp"
9
8
        "sort"
10
9
        "strconv"
11
10
        "strings"
14
13
        "github.com/juju/errors"
15
14
        "github.com/juju/names"
16
15
        jc "github.com/juju/testing/checkers"
 
16
        "github.com/juju/version"
17
17
        gc "gopkg.in/check.v1"
18
18
        "gopkg.in/juju/charm.v6-unstable"
19
19
 
34
34
        "github.com/juju/juju/state"
35
35
        "github.com/juju/juju/state/multiwatcher"
36
36
        "github.com/juju/juju/state/presence"
 
37
        "github.com/juju/juju/status"
37
38
        coretesting "github.com/juju/juju/testing"
38
39
        "github.com/juju/juju/testing/factory"
39
 
        "github.com/juju/juju/version"
 
40
        jujuversion "github.com/juju/juju/version"
40
41
)
41
42
 
42
43
type Killer interface {
160
161
        return modelUser
161
162
}
162
163
 
163
 
func (s *serverSuite) TestShareModelAddMissingLocalFails(c *gc.C) {
164
 
        args := params.ModifyModelUsers{
165
 
                Changes: []params.ModifyModelUser{{
166
 
                        UserTag: names.NewLocalUserTag("foobar").String(),
167
 
                        Action:  params.AddModelUser,
168
 
                }}}
169
 
 
170
 
        result, err := s.client.ShareModel(args)
171
 
        c.Assert(err, jc.ErrorIsNil)
172
 
        expectedErr := `could not share model: user "foobar" does not exist locally: user "foobar" not found`
173
 
        c.Assert(result.OneError(), gc.ErrorMatches, expectedErr)
174
 
        c.Assert(result.Results, gc.HasLen, 1)
175
 
        c.Assert(result.Results[0].Error, gc.ErrorMatches, expectedErr)
176
 
}
177
 
 
178
 
func (s *serverSuite) TestUnshareModel(c *gc.C) {
179
 
        user := s.Factory.MakeModelUser(c, nil)
180
 
        _, err := s.State.ModelUser(user.UserTag())
181
 
        c.Assert(err, jc.ErrorIsNil)
182
 
 
183
 
        args := params.ModifyModelUsers{
184
 
                Changes: []params.ModifyModelUser{{
185
 
                        UserTag: user.UserTag().String(),
186
 
                        Action:  params.RemoveModelUser,
187
 
                }}}
188
 
 
189
 
        result, err := s.client.ShareModel(args)
190
 
        c.Assert(err, jc.ErrorIsNil)
191
 
        c.Assert(result.OneError(), gc.IsNil)
192
 
        c.Assert(result.Results, gc.HasLen, 1)
193
 
        c.Assert(result.Results[0].Error, gc.IsNil)
194
 
 
195
 
        _, err = s.State.ModelUser(user.UserTag())
196
 
        c.Assert(errors.IsNotFound(err), jc.IsTrue)
197
 
}
198
 
 
199
 
func (s *serverSuite) TestUnshareModelMissingUser(c *gc.C) {
200
 
        user := names.NewUserTag("bob")
201
 
        args := params.ModifyModelUsers{
202
 
                Changes: []params.ModifyModelUser{{
203
 
                        UserTag: user.String(),
204
 
                        Action:  params.RemoveModelUser,
205
 
                }}}
206
 
 
207
 
        result, err := s.client.ShareModel(args)
208
 
        c.Assert(err, jc.ErrorIsNil)
209
 
        c.Assert(result.OneError(), gc.ErrorMatches, `could not unshare model: env user "bob@local" does not exist: transaction aborted`)
210
 
 
211
 
        c.Assert(result.Results, gc.HasLen, 1)
212
 
        c.Assert(result.Results[0].Error, gc.NotNil)
213
 
 
214
 
        _, err = s.State.ModelUser(user)
215
 
        c.Assert(errors.IsNotFound(err), jc.IsTrue)
216
 
}
217
 
 
218
 
func (s *serverSuite) TestShareModelAddLocalUser(c *gc.C) {
219
 
        user := s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar", NoModelUser: true})
220
 
        args := params.ModifyModelUsers{
221
 
                Changes: []params.ModifyModelUser{{
222
 
                        UserTag: user.Tag().String(),
223
 
                        Action:  params.AddModelUser,
224
 
                }}}
225
 
 
226
 
        result, err := s.client.ShareModel(args)
227
 
        c.Assert(err, jc.ErrorIsNil)
228
 
        c.Assert(result.OneError(), gc.IsNil)
229
 
        c.Assert(result.Results, gc.HasLen, 1)
230
 
        c.Assert(result.Results[0].Error, gc.IsNil)
231
 
 
232
 
        modelUser, err := s.State.ModelUser(user.UserTag())
233
 
        c.Assert(err, jc.ErrorIsNil)
234
 
        c.Assert(modelUser.UserName(), gc.Equals, user.UserTag().Canonical())
235
 
        c.Assert(modelUser.CreatedBy(), gc.Equals, "admin@local")
236
 
        lastConn, err := modelUser.LastConnection()
237
 
        c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
238
 
        c.Assert(lastConn, gc.Equals, time.Time{})
239
 
}
240
 
 
241
 
func (s *serverSuite) TestShareModelAddRemoteUser(c *gc.C) {
242
 
        user := names.NewUserTag("foobar@ubuntuone")
243
 
        args := params.ModifyModelUsers{
244
 
                Changes: []params.ModifyModelUser{{
245
 
                        UserTag: user.String(),
246
 
                        Action:  params.AddModelUser,
247
 
                }}}
248
 
 
249
 
        result, err := s.client.ShareModel(args)
250
 
        c.Assert(err, jc.ErrorIsNil)
251
 
        c.Assert(result.OneError(), gc.IsNil)
252
 
        c.Assert(result.Results, gc.HasLen, 1)
253
 
        c.Assert(result.Results[0].Error, gc.IsNil)
254
 
 
255
 
        modelUser, err := s.State.ModelUser(user)
256
 
        c.Assert(err, jc.ErrorIsNil)
257
 
        c.Assert(modelUser.UserName(), gc.Equals, user.Canonical())
258
 
        c.Assert(modelUser.CreatedBy(), gc.Equals, "admin@local")
259
 
        lastConn, err := modelUser.LastConnection()
260
 
        c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
261
 
        c.Assert(lastConn.IsZero(), jc.IsTrue)
262
 
}
263
 
 
264
 
func (s *serverSuite) TestShareModelAddUserTwice(c *gc.C) {
265
 
        user := s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar"})
266
 
        args := params.ModifyModelUsers{
267
 
                Changes: []params.ModifyModelUser{{
268
 
                        UserTag: user.Tag().String(),
269
 
                        Action:  params.AddModelUser,
270
 
                }}}
271
 
 
272
 
        _, err := s.client.ShareModel(args)
273
 
        c.Assert(err, jc.ErrorIsNil)
274
 
 
275
 
        result, err := s.client.ShareModel(args)
276
 
        c.Assert(err, jc.ErrorIsNil)
277
 
        c.Assert(result.OneError(), gc.ErrorMatches, "could not share model: model user \"foobar@local\" already exists")
278
 
        c.Assert(result.Results, gc.HasLen, 1)
279
 
        c.Assert(result.Results[0].Error, gc.ErrorMatches, "could not share model: model user \"foobar@local\" already exists")
280
 
        c.Assert(result.Results[0].Error.Code, gc.Matches, params.CodeAlreadyExists)
281
 
 
282
 
        modelUser, err := s.State.ModelUser(user.UserTag())
283
 
        c.Assert(err, jc.ErrorIsNil)
284
 
        c.Assert(modelUser.UserName(), gc.Equals, user.UserTag().Canonical())
285
 
}
286
 
 
287
 
func (s *serverSuite) TestShareModelInvalidTags(c *gc.C) {
288
 
        for _, testParam := range []struct {
289
 
                tag      string
290
 
                validTag bool
291
 
        }{{
292
 
                tag:      "unit-foo/0",
293
 
                validTag: true,
294
 
        }, {
295
 
                tag:      "service-foo",
296
 
                validTag: true,
297
 
        }, {
298
 
                tag:      "relation-wordpress:db mysql:db",
299
 
                validTag: true,
300
 
        }, {
301
 
                tag:      "machine-0",
302
 
                validTag: true,
303
 
        }, {
304
 
                tag:      "user@local",
305
 
                validTag: false,
306
 
        }, {
307
 
                tag:      "user-Mua^h^h^h^arh",
308
 
                validTag: true,
309
 
        }, {
310
 
                tag:      "user@",
311
 
                validTag: false,
312
 
        }, {
313
 
                tag:      "user@ubuntuone",
314
 
                validTag: false,
315
 
        }, {
316
 
                tag:      "user@ubuntuone",
317
 
                validTag: false,
318
 
        }, {
319
 
                tag:      "@ubuntuone",
320
 
                validTag: false,
321
 
        }, {
322
 
                tag:      "in^valid.",
323
 
                validTag: false,
324
 
        }, {
325
 
                tag:      "",
326
 
                validTag: false,
327
 
        },
328
 
        } {
329
 
                var expectedErr string
330
 
                errPart := `could not share model: "` + regexp.QuoteMeta(testParam.tag) + `" is not a valid `
331
 
 
332
 
                if testParam.validTag {
333
 
 
334
 
                        // The string is a valid tag, but not a user tag.
335
 
                        expectedErr = errPart + `user tag`
336
 
                } else {
337
 
 
338
 
                        // The string is not a valid tag of any kind.
339
 
                        expectedErr = errPart + `tag`
340
 
                }
341
 
 
342
 
                args := params.ModifyModelUsers{
343
 
                        Changes: []params.ModifyModelUser{{
344
 
                                UserTag: testParam.tag,
345
 
                                Action:  params.AddModelUser,
346
 
                        }}}
347
 
 
348
 
                _, err := s.client.ShareModel(args)
349
 
                result, err := s.client.ShareModel(args)
350
 
                c.Assert(err, jc.ErrorIsNil)
351
 
                c.Assert(result.OneError(), gc.ErrorMatches, expectedErr)
352
 
                c.Assert(result.Results, gc.HasLen, 1)
353
 
                c.Assert(result.Results[0].Error, gc.ErrorMatches, expectedErr)
354
 
        }
355
 
}
356
 
 
357
 
func (s *serverSuite) TestShareModelZeroArgs(c *gc.C) {
358
 
        args := params.ModifyModelUsers{Changes: []params.ModifyModelUser{{}}}
359
 
 
360
 
        _, err := s.client.ShareModel(args)
361
 
        result, err := s.client.ShareModel(args)
362
 
        c.Assert(err, jc.ErrorIsNil)
363
 
        expectedErr := `could not share model: "" is not a valid tag`
364
 
        c.Assert(result.OneError(), gc.ErrorMatches, expectedErr)
365
 
        c.Assert(result.Results, gc.HasLen, 1)
366
 
        c.Assert(result.Results[0].Error, gc.ErrorMatches, expectedErr)
367
 
}
368
 
 
369
 
func (s *serverSuite) TestShareModelInvalidAction(c *gc.C) {
370
 
        var dance params.ModelAction = "dance"
371
 
        args := params.ModifyModelUsers{
372
 
                Changes: []params.ModifyModelUser{{
373
 
                        UserTag: "user-user@local",
374
 
                        Action:  dance,
375
 
                }}}
376
 
 
377
 
        _, err := s.client.ShareModel(args)
378
 
        result, err := s.client.ShareModel(args)
379
 
        c.Assert(err, jc.ErrorIsNil)
380
 
        expectedErr := `unknown action "dance"`
381
 
        c.Assert(result.OneError(), gc.ErrorMatches, expectedErr)
382
 
        c.Assert(result.Results, gc.HasLen, 1)
383
 
        c.Assert(result.Results[0].Error, gc.ErrorMatches, expectedErr)
384
 
}
385
 
 
386
164
func (s *serverSuite) TestSetEnvironAgentVersion(c *gc.C) {
387
165
        args := params.SetModelAgentVersion{
388
166
                Version: version.MustParse("9.8.7"),
559
337
func clearSinceTimes(status *params.FullStatus) {
560
338
        for serviceId, service := range status.Services {
561
339
                for unitId, unit := range service.Units {
562
 
                        unit.Workload.Since = nil
563
 
                        unit.UnitAgent.Since = nil
 
340
                        unit.WorkloadStatus.Since = nil
 
341
                        unit.AgentStatus.Since = nil
564
342
                        for id, subord := range unit.Subordinates {
565
 
                                subord.Workload.Since = nil
566
 
                                subord.UnitAgent.Since = nil
 
343
                                subord.WorkloadStatus.Since = nil
 
344
                                subord.AgentStatus.Since = nil
567
345
                                unit.Subordinates[id] = subord
568
346
                        }
569
347
                        service.Units[unitId] = unit
572
350
                status.Services[serviceId] = service
573
351
        }
574
352
        for id, machine := range status.Machines {
575
 
                machine.Agent.Since = nil
 
353
                machine.AgentStatus.Since = nil
 
354
                machine.InstanceStatus.Since = nil
576
355
                status.Machines[id] = machine
577
356
        }
578
357
}
735
514
        s.setUpScenario(c)
736
515
        u, err := s.State.Unit("wordpress/0")
737
516
        c.Assert(err, jc.ErrorIsNil)
738
 
        err = u.SetAgentStatus(state.StatusError, "gaaah", nil)
 
517
        err = u.SetAgentStatus(status.StatusError, "gaaah", nil)
739
518
        c.Assert(err, jc.ErrorIsNil)
740
519
        // Code under test:
741
520
        err = s.APIState.Client().Resolved("wordpress/0", retry)
761
540
        s.setUpScenario(c)
762
541
        u, err := s.State.Unit("wordpress/0")
763
542
        c.Assert(err, jc.ErrorIsNil)
764
 
        err = u.SetAgentStatus(state.StatusError, "gaaah", nil)
 
543
        err = u.SetAgentStatus(status.StatusError, "gaaah", nil)
765
544
        c.Assert(err, jc.ErrorIsNil)
766
545
        return u
767
546
}
847
626
        }()
848
627
        deltas, err := watcher.Next()
849
628
        c.Assert(err, jc.ErrorIsNil)
 
629
        c.Assert(len(deltas), gc.Equals, 1)
 
630
        d0, ok := deltas[0].Entity.(*multiwatcher.MachineInfo)
 
631
        c.Assert(ok, jc.IsTrue)
 
632
        d0.JujuStatus.Since = nil
 
633
        d0.MachineStatus.Since = nil
850
634
        if !c.Check(deltas, gc.DeepEquals, []multiwatcher.Delta{{
851
635
                Entity: &multiwatcher.MachineInfo{
852
 
                        ModelUUID:               s.State.ModelUUID(),
853
 
                        Id:                      m.Id(),
854
 
                        InstanceId:              "i-0",
855
 
                        Status:                  multiwatcher.Status("pending"),
856
 
                        StatusData:              map[string]interface{}{},
 
636
                        ModelUUID:  s.State.ModelUUID(),
 
637
                        Id:         m.Id(),
 
638
                        InstanceId: "i-0",
 
639
                        JujuStatus: multiwatcher.StatusInfo{
 
640
                                Current: status.StatusPending,
 
641
                                Data:    map[string]interface{}{},
 
642
                        },
 
643
                        MachineStatus: multiwatcher.StatusInfo{
 
644
                                Current: status.StatusPending,
 
645
                                Data:    map[string]interface{}{},
 
646
                        },
857
647
                        Life:                    multiwatcher.Life("alive"),
858
648
                        Series:                  "quantal",
859
649
                        Jobs:                    []multiwatcher.MachineJob{state.JobManageModel.ToParams()},
1300
1090
        apiParams[0].Placement = instance.MustParsePlacement("lxc")
1301
1091
        apiParams[1].Placement = instance.MustParsePlacement("lxc:0")
1302
1092
        apiParams[1].ContainerType = instance.LXC
1303
 
        apiParams[2].Placement = instance.MustParsePlacement("dummymodel:invalid")
1304
 
        apiParams[3].Placement = instance.MustParsePlacement("dummymodel:valid")
 
1093
        apiParams[2].Placement = instance.MustParsePlacement("admin:invalid")
 
1094
        apiParams[3].Placement = instance.MustParsePlacement("admin:valid")
1305
1095
        machines, err := s.APIState.Client().AddMachines(apiParams)
1306
1096
        c.Assert(err, jc.ErrorIsNil)
1307
1097
        c.Assert(len(machines), gc.Equals, 4)
1606
1396
func (s *clientSuite) TestRetryProvisioning(c *gc.C) {
1607
1397
        machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
1608
1398
        c.Assert(err, jc.ErrorIsNil)
1609
 
        err = machine.SetStatus(state.StatusError, "error", nil)
 
1399
        err = machine.SetStatus(status.StatusError, "error", nil)
1610
1400
        c.Assert(err, jc.ErrorIsNil)
1611
1401
        _, err = s.APIState.Client().RetryProvisioning(machine.Tag().(names.MachineTag))
1612
1402
        c.Assert(err, jc.ErrorIsNil)
1613
1403
 
1614
1404
        statusInfo, err := machine.Status()
1615
1405
        c.Assert(err, jc.ErrorIsNil)
1616
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusError)
 
1406
        c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
1617
1407
        c.Assert(statusInfo.Message, gc.Equals, "error")
1618
1408
        c.Assert(statusInfo.Data["transient"], jc.IsTrue)
1619
1409
}
1621
1411
func (s *clientSuite) setupRetryProvisioning(c *gc.C) *state.Machine {
1622
1412
        machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
1623
1413
        c.Assert(err, jc.ErrorIsNil)
1624
 
        err = machine.SetStatus(state.StatusError, "error", nil)
 
1414
        err = machine.SetStatus(status.StatusError, "error", nil)
1625
1415
        c.Assert(err, jc.ErrorIsNil)
1626
1416
        return machine
1627
1417
}
1631
1421
        c.Assert(err, jc.ErrorIsNil)
1632
1422
        statusInfo, err := machine.Status()
1633
1423
        c.Assert(err, jc.ErrorIsNil)
1634
 
        c.Assert(statusInfo.Status, gc.Equals, state.StatusError)
 
1424
        c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
1635
1425
        c.Assert(statusInfo.Message, gc.Equals, "error")
1636
1426
        c.Assert(statusInfo.Data["transient"], jc.IsTrue)
1637
1427
}
1690
1480
 
1691
1481
func (s *clientSuite) TestClientAgentVersion(c *gc.C) {
1692
1482
        current := version.MustParse("1.2.0")
1693
 
        s.PatchValue(&version.Current, current)
 
1483
        s.PatchValue(&jujuversion.Current, current)
1694
1484
        result, err := s.APIState.Client().AgentVersion()
1695
1485
        c.Assert(err, jc.ErrorIsNil)
1696
1486
        c.Assert(result, gc.Equals, current)