← 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/state/modeluser_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/state/modeluser_test.go
13
13
        gc "gopkg.in/check.v1"
14
14
        "gopkg.in/juju/names.v2"
15
15
 
16
 
        "github.com/juju/juju/core/description"
 
16
        "github.com/juju/juju/permission"
17
17
        "github.com/juju/juju/state"
18
18
        "github.com/juju/juju/storage"
19
19
        "github.com/juju/juju/testing"
27
27
var _ = gc.Suite(&ModelUserSuite{})
28
28
 
29
29
func (s *ModelUserSuite) TestAddModelUser(c *gc.C) {
30
 
        now := state.NowToTheSecond()
 
30
        now := s.State.NowToTheSecond()
31
31
        user := s.Factory.MakeUser(c,
32
32
                &factory.UserParams{
33
33
                        Name:        "validusername",
39
39
                state.UserAccessSpec{
40
40
                        User:      user.UserTag(),
41
41
                        CreatedBy: createdBy.UserTag(),
42
 
                        Access:    description.WriteAccess,
 
42
                        Access:    permission.WriteAccess,
43
43
                })
44
44
        c.Assert(err, jc.ErrorIsNil)
45
45
 
47
47
        c.Assert(modelUser.Object, gc.Equals, s.modelTag)
48
48
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
49
49
        c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
50
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
50
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
51
51
        c.Assert(modelUser.CreatedBy.Id(), gc.Equals, "createdby@local")
52
52
        c.Assert(modelUser.DateCreated.Equal(now) || modelUser.DateCreated.After(now), jc.IsTrue)
53
53
        when, err := s.State.LastModelConnection(modelUser.UserTag)
60
60
        c.Assert(modelUser.Object, gc.Equals, s.modelTag)
61
61
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
62
62
        c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
63
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
63
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
64
64
        c.Assert(modelUser.CreatedBy.Id(), gc.Equals, "createdby@local")
65
65
        c.Assert(modelUser.DateCreated.Equal(now) || modelUser.DateCreated.After(now), jc.IsTrue)
66
66
        when, err = s.State.LastModelConnection(modelUser.UserTag)
80
80
                state.UserAccessSpec{
81
81
                        User:      user.UserTag(),
82
82
                        CreatedBy: createdBy.UserTag(),
83
 
                        Access:    description.ReadAccess,
 
83
                        Access:    permission.ReadAccess,
84
84
                })
85
85
        c.Assert(err, jc.ErrorIsNil)
86
86
 
87
87
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
88
88
        c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
89
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
89
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
90
90
 
91
91
        // Make sure that it is set when we read the user out.
92
92
        modelUser, err = s.State.UserAccess(user.UserTag(), s.State.ModelTag())
93
93
        c.Assert(err, jc.ErrorIsNil)
94
94
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
95
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
95
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
96
96
}
97
97
 
98
98
func (s *ModelUserSuite) TestAddReadWriteModelUser(c *gc.C) {
107
107
                state.UserAccessSpec{
108
108
                        User:      user.UserTag(),
109
109
                        CreatedBy: createdBy.UserTag(),
110
 
                        Access:    description.WriteAccess,
 
110
                        Access:    permission.WriteAccess,
111
111
                })
112
112
        c.Assert(err, jc.ErrorIsNil)
113
113
 
114
114
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
115
115
        c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
116
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
116
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
117
117
 
118
118
        // Make sure that it is set when we read the user out.
119
119
        modelUser, err = s.State.UserAccess(user.UserTag(), s.State.ModelTag())
120
120
        c.Assert(err, jc.ErrorIsNil)
121
121
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
122
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
122
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
123
123
}
124
124
 
125
125
func (s *ModelUserSuite) TestAddAdminModelUser(c *gc.C) {
134
134
                state.UserAccessSpec{
135
135
                        User:      user.UserTag(),
136
136
                        CreatedBy: createdBy.UserTag(),
137
 
                        Access:    description.AdminAccess,
 
137
                        Access:    permission.AdminAccess,
138
138
                })
139
139
        c.Assert(err, jc.ErrorIsNil)
140
140
 
141
141
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
142
142
        c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
143
 
        c.Assert(modelUser.Access, gc.Equals, description.AdminAccess)
 
143
        c.Assert(modelUser.Access, gc.Equals, permission.AdminAccess)
144
144
 
145
145
        // Make sure that it is set when we read the user out.
146
146
        modelUser, err = s.State.UserAccess(user.UserTag(), s.State.ModelTag())
147
147
        c.Assert(err, jc.ErrorIsNil)
148
148
        c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
149
 
        c.Assert(modelUser.Access, gc.Equals, description.AdminAccess)
 
149
        c.Assert(modelUser.Access, gc.Equals, permission.AdminAccess)
150
150
}
151
151
 
152
152
func (s *ModelUserSuite) TestDefaultAccessModelUser(c *gc.C) {
161
161
                state.UserAccessSpec{
162
162
                        User:      user.UserTag(),
163
163
                        CreatedBy: createdBy.UserTag(),
164
 
                        Access:    description.ReadAccess,
 
164
                        Access:    permission.ReadAccess,
165
165
                })
166
166
        c.Assert(err, jc.ErrorIsNil)
167
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
167
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
168
168
}
169
169
 
170
170
func (s *ModelUserSuite) TestSetAccessModelUser(c *gc.C) {
179
179
                state.UserAccessSpec{
180
180
                        User:      user.UserTag(),
181
181
                        CreatedBy: createdBy.UserTag(),
182
 
                        Access:    description.AdminAccess,
 
182
                        Access:    permission.AdminAccess,
183
183
                })
184
184
        c.Assert(err, jc.ErrorIsNil)
185
 
        c.Assert(modelUser.Access, gc.Equals, description.AdminAccess)
 
185
        c.Assert(modelUser.Access, gc.Equals, permission.AdminAccess)
186
186
 
187
 
        s.State.SetUserAccess(modelUser.UserTag, s.State.ModelTag(), description.ReadAccess)
 
187
        s.State.SetUserAccess(modelUser.UserTag, s.State.ModelTag(), permission.ReadAccess)
188
188
 
189
189
        modelUser, err = s.State.UserAccess(user.UserTag(), s.State.ModelTag())
190
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
190
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
191
191
}
192
192
 
193
193
func (s *ModelUserSuite) TestCaseUserNameVsId(c *gc.C) {
199
199
                state.UserAccessSpec{
200
200
                        User:      names.NewUserTag("Bob@RandomProvider"),
201
201
                        CreatedBy: model.Owner(),
202
 
                        Access:    description.ReadAccess,
 
202
                        Access:    permission.ReadAccess,
203
203
                })
204
204
        c.Assert(err, gc.IsNil)
205
205
        c.Assert(user.UserName, gc.Equals, "Bob@RandomProvider")
216
216
                state.UserAccessSpec{
217
217
                        User:      names.NewUserTag("boB@ubuntuone"),
218
218
                        CreatedBy: model.Owner(),
219
 
                        Access:    description.ReadAccess,
 
219
                        Access:    permission.ReadAccess,
220
220
                })
221
221
        c.Assert(err, gc.ErrorMatches, `user access "boB@ubuntuone" already exists`)
222
222
        c.Assert(errors.IsAlreadyExists(err), jc.IsTrue)
268
268
                state.UserAccessSpec{
269
269
                        User:      names.NewLocalUserTag("validusername"),
270
270
                        CreatedBy: createdBy.UserTag(),
271
 
                        Access:    description.ReadAccess,
 
271
                        Access:    permission.ReadAccess,
272
272
                })
273
273
        c.Assert(err, gc.ErrorMatches, `user "validusername" does not exist locally: user "validusername" not found`)
274
274
}
280
280
                state.UserAccessSpec{
281
281
                        User:      user.UserTag(),
282
282
                        CreatedBy: names.NewLocalUserTag("createdby"),
283
 
                        Access:    description.ReadAccess,
 
283
                        Access:    permission.ReadAccess,
284
284
                })
285
285
        c.Assert(err, gc.ErrorMatches, `createdBy user "createdby" does not exist locally: user "createdby" not found`)
286
286
}
304
304
}
305
305
 
306
306
func (s *ModelUserSuite) TestUpdateLastConnection(c *gc.C) {
307
 
        now := state.NowToTheSecond()
 
307
        now := s.State.NowToTheSecond()
308
308
        createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
309
309
        user := s.Factory.MakeUser(c, &factory.UserParams{Name: "validusername", Creator: createdBy.Tag()})
310
310
        modelUser, err := s.State.UserAccess(user.UserTag(), s.State.ModelTag())
319
319
}
320
320
 
321
321
func (s *ModelUserSuite) TestUpdateLastConnectionTwoModelUsers(c *gc.C) {
322
 
        now := state.NowToTheSecond()
 
322
        now := s.State.NowToTheSecond()
323
323
 
324
324
        // Create a user and add them to the inital model.
325
325
        createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
335
335
                state.UserAccessSpec{
336
336
                        User:      user.UserTag(),
337
337
                        CreatedBy: createdBy.UserTag(),
338
 
                        Access:    description.ReadAccess,
 
338
                        Access:    permission.ReadAccess,
339
339
                })
340
340
        c.Assert(err, jc.ErrorIsNil)
341
341
 
436
436
                envState.ModelUUID(),
437
437
                state.UserAccessSpec{
438
438
                        User: user, CreatedBy: newEnv.Owner(),
439
 
                        Access: description.ReadAccess,
 
439
                        Access: permission.ReadAccess,
440
440
                })
441
441
        c.Assert(err, jc.ErrorIsNil)
442
442
        return newEnv
482
482
        c.Assert(err, jc.ErrorIsNil)
483
483
        c.Assert(isAdmin, jc.IsFalse)
484
484
 
485
 
        s.State.SetUserAccess(user.UserTag(), s.State.ControllerTag(), description.SuperuserAccess)
 
485
        s.State.SetUserAccess(user.UserTag(), s.State.ControllerTag(), permission.SuperuserAccess)
486
486
        isAdmin, err = s.State.IsControllerAdmin(user.UserTag())
487
487
        c.Assert(err, jc.ErrorIsNil)
488
488
        c.Assert(isAdmin, jc.IsTrue)
489
489
 
490
 
        readonly := s.Factory.MakeModelUser(c, &factory.ModelUserParams{Access: description.ReadAccess})
 
490
        readonly := s.Factory.MakeModelUser(c, &factory.ModelUserParams{Access: permission.ReadAccess})
491
491
        isAdmin, err = s.State.IsControllerAdmin(readonly.UserTag)
492
492
        c.Assert(err, jc.ErrorIsNil)
493
493
        c.Assert(isAdmin, jc.IsFalse)