← 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/client_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/client_test.go
26
26
        "github.com/juju/juju/apiserver/params"
27
27
        "github.com/juju/juju/apiserver/testing"
28
28
        "github.com/juju/juju/constraints"
29
 
        "github.com/juju/juju/core/description"
30
29
        "github.com/juju/juju/environs"
31
30
        "github.com/juju/juju/environs/config"
32
31
        "github.com/juju/juju/environs/manual"
33
32
        toolstesting "github.com/juju/juju/environs/tools/testing"
34
33
        "github.com/juju/juju/instance"
35
34
        "github.com/juju/juju/network"
 
35
        "github.com/juju/juju/permission"
36
36
        "github.com/juju/juju/rpc"
37
37
        "github.com/juju/juju/state"
38
38
        "github.com/juju/juju/state/multiwatcher"
129
129
 
130
130
        localUser1 := s.makeLocalModelUser(c, "ralphdoe", "Ralph Doe")
131
131
        localUser2 := s.makeLocalModelUser(c, "samsmith", "Sam Smith")
132
 
        remoteUser1 := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "bobjohns@ubuntuone", DisplayName: "Bob Johns", Access: description.WriteAccess})
133
 
        remoteUser2 := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "nicshaw@idprovider", DisplayName: "Nic Shaw", Access: description.WriteAccess})
 
132
        remoteUser1 := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "bobjohns@ubuntuone", DisplayName: "Bob Johns", Access: permission.WriteAccess})
 
133
        remoteUser2 := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "nicshaw@idprovider", DisplayName: "Nic Shaw", Access: permission.WriteAccess})
134
134
 
135
135
        results, err := s.client.ModelUserInfo()
136
136
        c.Assert(err, jc.ErrorIsNil)
137
137
        var expected params.ModelUserInfoResults
138
138
        for _, r := range []struct {
139
 
                user description.UserAccess
 
139
                user permission.UserAccess
140
140
                info *params.ModelUserInfo
141
141
        }{
142
142
                {
185
185
        c.Assert(results, jc.DeepEquals, expected)
186
186
}
187
187
 
188
 
func lastConnPointer(c *gc.C, modelUser description.UserAccess, st *state.State) *time.Time {
 
188
func lastConnPointer(c *gc.C, modelUser permission.UserAccess, st *state.State) *time.Time {
189
189
        lastConn, err := st.LastModelConnection(modelUser.UserTag)
190
190
        if err != nil {
191
191
                if state.IsNeverConnectedError(err) {
204
204
func (a ByUserName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
205
205
func (a ByUserName) Less(i, j int) bool { return a[i].Result.UserName < a[j].Result.UserName }
206
206
 
207
 
func (s *serverSuite) makeLocalModelUser(c *gc.C, username, displayname string) description.UserAccess {
 
207
func (s *serverSuite) makeLocalModelUser(c *gc.C, username, displayname string) permission.UserAccess {
208
208
        // factory.MakeUser will create an ModelUser for a local user by defalut
209
209
        user := s.Factory.MakeUser(c, &factory.UserParams{Name: username, DisplayName: displayname})
210
210
        modelUser, err := s.State.UserAccess(user.UserTag(), s.State.ModelTag())
453
453
        s.assertForceDestroyMachines(c)
454
454
}
455
455
 
456
 
func (s *clientSuite) testClientUnitResolved(c *gc.C, retry bool, expectedResolvedMode state.ResolvedMode) {
 
456
func (s *clientSuite) testClientUnitResolved(c *gc.C, noretry bool, expectedResolvedMode state.ResolvedMode) {
457
457
        // Setup:
458
458
        s.setUpScenario(c)
459
459
        u, err := s.State.Unit("wordpress/0")
460
460
        c.Assert(err, jc.ErrorIsNil)
461
461
        now := time.Now()
462
462
        sInfo := status.StatusInfo{
463
 
                Status:  status.StatusError,
 
463
                Status:  status.Error,
464
464
                Message: "gaaah",
465
465
                Since:   &now,
466
466
        }
467
467
        err = u.SetAgentStatus(sInfo)
468
468
        c.Assert(err, jc.ErrorIsNil)
469
469
        // Code under test:
470
 
        err = s.APIState.Client().Resolved("wordpress/0", retry)
 
470
        err = s.APIState.Client().Resolved("wordpress/0", noretry)
471
471
        c.Assert(err, jc.ErrorIsNil)
472
472
        // Freshen the unit's state.
473
473
        err = u.Refresh()
479
479
}
480
480
 
481
481
func (s *clientSuite) TestClientUnitResolved(c *gc.C) {
482
 
        s.testClientUnitResolved(c, false, state.ResolvedNoHooks)
 
482
        s.testClientUnitResolved(c, true, state.ResolvedNoHooks)
483
483
}
484
484
 
485
485
func (s *clientSuite) TestClientUnitResolvedRetry(c *gc.C) {
486
 
        s.testClientUnitResolved(c, true, state.ResolvedRetryHooks)
 
486
        s.testClientUnitResolved(c, false, state.ResolvedRetryHooks)
487
487
}
488
488
 
489
489
func (s *clientSuite) setupResolved(c *gc.C) *state.Unit {
492
492
        c.Assert(err, jc.ErrorIsNil)
493
493
        now := time.Now()
494
494
        sInfo := status.StatusInfo{
495
 
                Status:  status.StatusError,
 
495
                Status:  status.Error,
496
496
                Message: "gaaah",
497
497
                Since:   &now,
498
498
        }
502
502
}
503
503
 
504
504
func (s *clientSuite) assertResolved(c *gc.C, u *state.Unit) {
505
 
        err := s.APIState.Client().Resolved("wordpress/0", true)
 
505
        err := s.APIState.Client().Resolved("wordpress/0", false)
506
506
        c.Assert(err, jc.ErrorIsNil)
507
507
        // Freshen the unit's state.
508
508
        err = u.Refresh()
514
514
}
515
515
 
516
516
func (s *clientSuite) assertResolvedBlocked(c *gc.C, u *state.Unit, msg string) {
517
 
        err := s.APIState.Client().Resolved("wordpress/0", true)
 
517
        err := s.APIState.Client().Resolved("wordpress/0", false)
518
518
        s.AssertBlocked(c, err, msg)
519
519
}
520
520
 
594
594
                        Id:         m.Id(),
595
595
                        InstanceId: "i-0",
596
596
                        AgentStatus: multiwatcher.StatusInfo{
597
 
                                Current: status.StatusPending,
 
597
                                Current: status.Pending,
598
598
                        },
599
599
                        InstanceStatus: multiwatcher.StatusInfo{
600
 
                                Current: status.StatusPending,
 
600
                                Current: status.Pending,
601
601
                        },
602
602
                        Life:                    multiwatcher.Life("alive"),
603
603
                        Series:                  "quantal",
617
617
 
618
618
func (s *clientSuite) TestClientSetModelConstraints(c *gc.C) {
619
619
        // Set constraints for the model.
620
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
620
        cons, err := constraints.Parse("mem=4096", "cores=2")
621
621
        c.Assert(err, jc.ErrorIsNil)
622
622
        err = s.APIState.Client().SetModelConstraints(cons)
623
623
        c.Assert(err, jc.ErrorIsNil)
630
630
 
631
631
func (s *clientSuite) assertSetModelConstraints(c *gc.C) {
632
632
        // Set constraints for the model.
633
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
633
        cons, err := constraints.Parse("mem=4096", "cores=2")
634
634
        c.Assert(err, jc.ErrorIsNil)
635
635
        err = s.APIState.Client().SetModelConstraints(cons)
636
636
        c.Assert(err, jc.ErrorIsNil)
642
642
 
643
643
func (s *clientSuite) assertSetModelConstraintsBlocked(c *gc.C, msg string) {
644
644
        // Set constraints for the model.
645
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
645
        cons, err := constraints.Parse("mem=4096", "cores=2")
646
646
        c.Assert(err, jc.ErrorIsNil)
647
647
        err = s.APIState.Client().SetModelConstraints(cons)
648
648
        s.AssertBlocked(c, err, msg)
665
665
 
666
666
func (s *clientSuite) TestClientGetModelConstraints(c *gc.C) {
667
667
        // Set constraints for the model.
668
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
668
        cons, err := constraints.Parse("mem=4096", "cores=2")
669
669
        c.Assert(err, jc.ErrorIsNil)
670
670
        err = s.State.SetModelConstraints(cons)
671
671
        c.Assert(err, jc.ErrorIsNil)
1219
1219
        c.Assert(err, jc.ErrorIsNil)
1220
1220
        now := time.Now()
1221
1221
        sInfo := status.StatusInfo{
1222
 
                Status:  status.StatusError,
 
1222
                Status:  status.Error,
1223
1223
                Message: "error",
1224
1224
                Since:   &now,
1225
1225
        }
1230
1230
 
1231
1231
        statusInfo, err := machine.Status()
1232
1232
        c.Assert(err, jc.ErrorIsNil)
1233
 
        c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
1233
        c.Assert(statusInfo.Status, gc.Equals, status.Error)
1234
1234
        c.Assert(statusInfo.Message, gc.Equals, "error")
1235
1235
        c.Assert(statusInfo.Data["transient"], jc.IsTrue)
1236
1236
}
1240
1240
        c.Assert(err, jc.ErrorIsNil)
1241
1241
        now := time.Now()
1242
1242
        sInfo := status.StatusInfo{
1243
 
                Status:  status.StatusError,
 
1243
                Status:  status.Error,
1244
1244
                Message: "error",
1245
1245
                Since:   &now,
1246
1246
        }
1254
1254
        c.Assert(err, jc.ErrorIsNil)
1255
1255
        statusInfo, err := machine.Status()
1256
1256
        c.Assert(err, jc.ErrorIsNil)
1257
 
        c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
1257
        c.Assert(statusInfo.Status, gc.Equals, status.Error)
1258
1258
        c.Assert(statusInfo.Message, gc.Equals, "error")
1259
1259
        c.Assert(statusInfo.Data["transient"], jc.IsTrue)
1260
1260
}