← 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/modelmanager/modelmanager_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/modelmanager/modelmanager_test.go
19
19
        "github.com/juju/juju/apiserver/params"
20
20
        apiservertesting "github.com/juju/juju/apiserver/testing"
21
21
        "github.com/juju/juju/cloud"
22
 
        "github.com/juju/juju/core/description"
23
22
        "github.com/juju/juju/environs"
24
23
        "github.com/juju/juju/environs/config"
25
24
        jujutesting "github.com/juju/juju/juju/testing"
 
25
        "github.com/juju/juju/permission"
26
26
        "github.com/juju/juju/state/stateenvirons"
27
27
        "github.com/juju/juju/status"
28
28
        jujuversion "github.com/juju/juju/version"
79
79
                        life:  state.Alive,
80
80
                        cfg:   cfg,
81
81
                        status: status.StatusInfo{
82
 
                                Status: status.StatusAvailable,
 
82
                                Status: status.Available,
83
83
                                Since:  &time.Time{},
84
84
                        },
85
85
                        users: []*mockModelUser{{
86
86
                                userName: "admin",
87
 
                                access:   description.AdminAccess,
 
87
                                access:   permission.AdminAccess,
88
88
                        }, {
89
89
                                userName: "otheruser",
90
 
                                access:   description.WriteAccess,
 
90
                                access:   permission.WriteAccess,
91
91
                        }},
92
92
                },
93
93
                model: &mockModel{
96
96
                        tag:   coretesting.ModelTag,
97
97
                        cfg:   cfg,
98
98
                        status: status.StatusInfo{
99
 
                                Status: status.StatusAvailable,
 
99
                                Status: status.Available,
100
100
                                Since:  &time.Time{},
101
101
                        },
102
102
                        users: []*mockModelUser{{
103
103
                                userName: "admin",
104
 
                                access:   description.AdminAccess,
 
104
                                access:   permission.AdminAccess,
105
105
                        }, {
106
106
                                userName: "otheruser",
107
 
                                access:   description.WriteAccess,
 
107
                                access:   permission.WriteAccess,
108
108
                        }},
109
109
                },
110
110
                cred: cloud.NewEmptyCredential(),
389
389
        result, err := s.api.UnsetModelDefaults(args)
390
390
        c.Assert(err, jc.ErrorIsNil)
391
391
        c.Assert(result.OneError(), jc.ErrorIsNil)
392
 
        c.Assert(s.st.cfgDefaults, jc.DeepEquals, config.ModelDefaultAttributes{
393
 
                "attr2": {
 
392
        want := config.ModelDefaultAttributes{
 
393
                "attr": config.AttributeDefaultValues{
 
394
                        Regions: []config.RegionDefaultValue{
 
395
                                config.RegionDefaultValue{
 
396
                                        Name:  "dummy",
 
397
                                        Value: "val++"},
 
398
                        }},
 
399
                "attr2": config.AttributeDefaultValues{
 
400
                        Default:    "val2",
394
401
                        Controller: "val3",
395
 
                        Default:    "val2",
396
 
                        Regions: []config.RegionDefaultValue{{
397
 
                                Name:  "left",
398
 
                                Value: "spam"}}},
399
 
        })
 
402
                        Regions: []config.RegionDefaultValue{
 
403
                                config.RegionDefaultValue{
 
404
                                        Name:  "left",
 
405
                                        Value: "spam"}}}}
 
406
        c.Assert(s.st.cfgDefaults, jc.DeepEquals, want)
400
407
}
401
408
 
402
409
func (s *modelManagerSuite) TestBlockUnsetModelDefaults(c *gc.C) {
1004
1011
 
1005
1012
func (s *modelManagerStateSuite) TestRevokeAdminLeavesReadAccess(c *gc.C) {
1006
1013
        s.setAPIUser(c, s.AdminUserTag(c))
1007
 
        user := s.Factory.MakeModelUser(c, &factory.ModelUserParams{Access: description.WriteAccess})
 
1014
        user := s.Factory.MakeModelUser(c, &factory.ModelUserParams{Access: permission.WriteAccess})
1008
1015
 
1009
1016
        err := s.revoke(c, user.UserTag, params.ModelWriteAccess, user.Object.(names.ModelTag))
1010
1017
        c.Assert(err, gc.IsNil)
1011
1018
 
1012
1019
        modelUser, err := s.State.UserAccess(user.UserTag, user.Object)
1013
1020
        c.Assert(err, jc.ErrorIsNil)
1014
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
1021
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
1015
1022
}
1016
1023
 
1017
1024
func (s *modelManagerStateSuite) TestRevokeReadRemovesModelUser(c *gc.C) {
1051
1058
        c.Assert(err, gc.ErrorMatches, `user already has "read" access or greater`)
1052
1059
}
1053
1060
 
1054
 
func (s *modelManagerStateSuite) assertNewUser(c *gc.C, modelUser description.UserAccess, userTag, creatorTag names.UserTag) {
 
1061
func (s *modelManagerStateSuite) assertNewUser(c *gc.C, modelUser permission.UserAccess, userTag, creatorTag names.UserTag) {
1055
1062
        c.Assert(modelUser.UserTag, gc.Equals, userTag)
1056
1063
        c.Assert(modelUser.CreatedBy, gc.Equals, creatorTag)
1057
1064
        _, err := s.State.LastModelConnection(modelUser.UserTag)
1078
1085
        modelUser, err := st.UserAccess(user.UserTag(), st.ModelTag())
1079
1086
        c.Assert(err, jc.ErrorIsNil)
1080
1087
        s.assertNewUser(c, modelUser, user.UserTag(), apiUser)
1081
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
1088
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
1082
1089
        s.setAPIUser(c, user.UserTag())
1083
1090
        s.assertModelAccess(c, st)
1084
1091
}
1097
1104
        c.Assert(err, jc.ErrorIsNil)
1098
1105
 
1099
1106
        s.assertNewUser(c, modelUser, userTag, apiUser)
1100
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
1107
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
1101
1108
        s.setAPIUser(c, userTag)
1102
1109
        s.assertModelAccess(c, st)
1103
1110
}
1114
1121
        modelUser, err := st.UserAccess(user.UserTag(), st.ModelTag())
1115
1122
        c.Assert(err, jc.ErrorIsNil)
1116
1123
        s.assertNewUser(c, modelUser, user.UserTag(), apiUser)
1117
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
1124
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
1118
1125
        s.setAPIUser(c, user.UserTag())
1119
1126
        s.assertModelAccess(c, st)
1120
1127
}
1124
1131
        st := s.Factory.MakeModel(c, nil)
1125
1132
        defer st.Close()
1126
1133
        stFactory := factory.NewFactory(st)
1127
 
        user := stFactory.MakeModelUser(c, &factory.ModelUserParams{Access: description.ReadAccess})
 
1134
        user := stFactory.MakeModelUser(c, &factory.ModelUserParams{Access: permission.ReadAccess})
1128
1135
 
1129
1136
        err := s.grant(c, user.UserTag, params.ModelWriteAccess, st.ModelTag())
1130
1137
        c.Assert(err, jc.ErrorIsNil)
1131
1138
 
1132
1139
        modelUser, err := st.UserAccess(user.UserTag, st.ModelTag())
1133
1140
        c.Assert(err, jc.ErrorIsNil)
1134
 
        c.Assert(modelUser.Access, gc.Equals, description.WriteAccess)
 
1141
        c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
1135
1142
}
1136
1143
 
1137
1144
func (s *modelManagerStateSuite) TestGrantToModelNoAccess(c *gc.C) {
1157
1164
 
1158
1165
        stFactory := factory.NewFactory(st)
1159
1166
        stFactory.MakeModelUser(c, &factory.ModelUserParams{
1160
 
                User: apiUser.Canonical(), Access: description.ReadAccess})
 
1167
                User: apiUser.Canonical(), Access: permission.ReadAccess})
1161
1168
 
1162
1169
        other := names.NewUserTag("other@remote")
1163
1170
        err := s.grant(c, other, params.ModelReadAccess, st.ModelTag())
1173
1180
        s.setAPIUser(c, apiUser)
1174
1181
        stFactory := factory.NewFactory(st)
1175
1182
        stFactory.MakeModelUser(c, &factory.ModelUserParams{
1176
 
                User: apiUser.Canonical(), Access: description.AdminAccess})
 
1183
                User: apiUser.Canonical(), Access: permission.AdminAccess})
1177
1184
 
1178
1185
        other := names.NewUserTag("other@remote")
1179
1186
        err := s.grant(c, other, params.ModelReadAccess, st.ModelTag())
1182
1189
        modelUser, err := st.UserAccess(other, st.ModelTag())
1183
1190
        c.Assert(err, jc.ErrorIsNil)
1184
1191
        s.assertNewUser(c, modelUser, other, apiUser)
1185
 
        c.Assert(modelUser.Access, gc.Equals, description.ReadAccess)
 
1192
        c.Assert(modelUser.Access, gc.Equals, permission.ReadAccess)
1186
1193
}
1187
1194
 
1188
1195
func (s *modelManagerStateSuite) TestGrantModelInvalidUserTag(c *gc.C) {
1259
1266
 
1260
1267
        result, err := s.modelmanager.ModifyModelAccess(args)
1261
1268
        c.Assert(err, jc.ErrorIsNil)
1262
 
        expectedErr := `could not modify model access: invalid model access permission ""`
 
1269
        expectedErr := `could not modify model access: "" model access not valid`
1263
1270
        c.Assert(result.OneError(), gc.ErrorMatches, expectedErr)
1264
1271
}
1265
1272