github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/api/usermanager/client_test.go (about) 1 // Copyright 2014 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package usermanager_test 5 6 import ( 7 "github.com/juju/errors" 8 jc "github.com/juju/testing/checkers" 9 gc "gopkg.in/check.v1" 10 11 "github.com/juju/juju/api/usermanager" 12 "github.com/juju/juju/apiserver/params" 13 jujutesting "github.com/juju/juju/juju/testing" 14 "github.com/juju/juju/testing/factory" 15 ) 16 17 type usermanagerSuite struct { 18 jujutesting.JujuConnSuite 19 20 usermanager *usermanager.Client 21 } 22 23 var _ = gc.Suite(&usermanagerSuite{}) 24 25 func (s *usermanagerSuite) SetUpTest(c *gc.C) { 26 s.JujuConnSuite.SetUpTest(c) 27 s.usermanager = usermanager.NewClient(s.OpenControllerAPI(c)) 28 c.Assert(s.usermanager, gc.NotNil) 29 } 30 31 func (s *usermanagerSuite) TearDownTest(c *gc.C) { 32 s.usermanager.Close() 33 s.JujuConnSuite.TearDownTest(c) 34 } 35 36 func (s *usermanagerSuite) TestAddUser(c *gc.C) { 37 tag, _, err := s.usermanager.AddUser("foobar", "Foo Bar", "password") 38 c.Assert(err, jc.ErrorIsNil) 39 40 user, err := s.State.User(tag) 41 c.Assert(err, jc.ErrorIsNil) 42 c.Assert(user.Name(), gc.Equals, "foobar") 43 c.Assert(user.DisplayName(), gc.Equals, "Foo Bar") 44 c.Assert(user.PasswordValid("password"), jc.IsTrue) 45 } 46 47 func (s *usermanagerSuite) TestAddExistingUser(c *gc.C) { 48 s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar"}) 49 50 _, _, err := s.usermanager.AddUser("foobar", "Foo Bar", "password") 51 c.Assert(err, gc.ErrorMatches, "failed to create user: user already exists") 52 } 53 54 func (s *usermanagerSuite) TestAddUserResponseError(c *gc.C) { 55 usermanager.PatchResponses(s, s.usermanager, 56 func(interface{}) error { 57 return errors.New("call error") 58 }, 59 ) 60 _, _, err := s.usermanager.AddUser("foobar", "Foo Bar", "password") 61 c.Assert(err, gc.ErrorMatches, "call error") 62 } 63 64 func (s *usermanagerSuite) TestAddUserResultCount(c *gc.C) { 65 usermanager.PatchResponses(s, s.usermanager, 66 func(result interface{}) error { 67 if result, ok := result.(*params.AddUserResults); ok { 68 result.Results = make([]params.AddUserResult, 2) 69 return nil 70 } 71 return errors.New("wrong result type") 72 }, 73 ) 74 _, _, err := s.usermanager.AddUser("foobar", "Foo Bar", "password") 75 c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2") 76 } 77 78 func (s *usermanagerSuite) TestRemoveUser(c *gc.C) { 79 tag, _, err := s.usermanager.AddUser("jjam", "Jimmy Jam", "password") 80 c.Assert(err, jc.ErrorIsNil) 81 82 // Ensure the user exists. 83 user, err := s.State.User(tag) 84 c.Assert(err, jc.ErrorIsNil) 85 c.Assert(user.Name(), gc.Equals, "jjam") 86 c.Assert(user.DisplayName(), gc.Equals, "Jimmy Jam") 87 88 // Delete the user. 89 err = s.usermanager.RemoveUser(tag.Name()) 90 c.Assert(err, jc.ErrorIsNil) 91 92 // Assert that the user is gone. 93 _, err = s.State.User(tag) 94 c.Assert(err, jc.Satisfies, errors.IsUserNotFound) 95 96 err = user.Refresh() 97 c.Check(err, jc.ErrorIsNil) 98 c.Assert(user.IsDeleted(), jc.IsTrue) 99 } 100 101 func (s *usermanagerSuite) TestDisableUser(c *gc.C) { 102 user := s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar"}) 103 104 err := s.usermanager.DisableUser(user.Name()) 105 c.Assert(err, jc.ErrorIsNil) 106 107 err = user.Refresh() 108 c.Assert(err, jc.ErrorIsNil) 109 c.Assert(user.IsDisabled(), jc.IsTrue) 110 } 111 112 func (s *usermanagerSuite) TestDisableUserBadName(c *gc.C) { 113 err := s.usermanager.DisableUser("not!good") 114 c.Assert(err, gc.ErrorMatches, `"not!good" is not a valid username`) 115 } 116 117 func (s *usermanagerSuite) TestEnableUser(c *gc.C) { 118 user := s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar", Disabled: true}) 119 120 err := s.usermanager.EnableUser(user.Name()) 121 c.Assert(err, jc.ErrorIsNil) 122 123 err = user.Refresh() 124 c.Assert(err, jc.ErrorIsNil) 125 c.Assert(user.IsDisabled(), jc.IsFalse) 126 } 127 128 func (s *usermanagerSuite) TestEnableUserBadName(c *gc.C) { 129 err := s.usermanager.EnableUser("not!good") 130 c.Assert(err, gc.ErrorMatches, `"not!good" is not a valid username`) 131 } 132 133 func (s *usermanagerSuite) TestCantRemoveAdminUser(c *gc.C) { 134 err := s.usermanager.DisableUser(s.AdminUserTag(c).Name()) 135 c.Assert(err, gc.ErrorMatches, "failed to disable user: cannot disable controller model owner") 136 } 137 138 func (s *usermanagerSuite) TestUserInfo(c *gc.C) { 139 user := s.Factory.MakeUser(c, &factory.UserParams{ 140 Name: "foobar", DisplayName: "Foo Bar"}) 141 142 obtained, err := s.usermanager.UserInfo([]string{"foobar"}, usermanager.AllUsers) 143 c.Assert(err, jc.ErrorIsNil) 144 expected := []params.UserInfo{ 145 { 146 Username: "foobar", 147 DisplayName: "Foo Bar", 148 Access: "login", 149 CreatedBy: s.AdminUserTag(c).Name(), 150 DateCreated: user.DateCreated(), 151 }, 152 } 153 154 c.Assert(obtained, jc.DeepEquals, expected) 155 } 156 157 func (s *usermanagerSuite) TestUserInfoMoreThanOneResult(c *gc.C) { 158 usermanager.PatchResponses(s, s.usermanager, 159 func(result interface{}) error { 160 if result, ok := result.(*params.UserInfoResults); ok { 161 result.Results = make([]params.UserInfoResult, 2) 162 result.Results[0].Result = ¶ms.UserInfo{Username: "first"} 163 result.Results[1].Result = ¶ms.UserInfo{Username: "second"} 164 return nil 165 } 166 return errors.New("wrong result type") 167 }, 168 ) 169 obtained, err := s.usermanager.UserInfo(nil, usermanager.AllUsers) 170 c.Assert(err, jc.ErrorIsNil) 171 172 expected := []params.UserInfo{ 173 {Username: "first"}, 174 {Username: "second"}, 175 } 176 177 c.Assert(obtained, jc.DeepEquals, expected) 178 } 179 180 func (s *usermanagerSuite) TestUserInfoMoreThanOneError(c *gc.C) { 181 usermanager.PatchResponses(s, s.usermanager, 182 func(result interface{}) error { 183 if result, ok := result.(*params.UserInfoResults); ok { 184 result.Results = make([]params.UserInfoResult, 2) 185 result.Results[0].Error = ¶ms.Error{Message: "first error"} 186 result.Results[1].Error = ¶ms.Error{Message: "second error"} 187 return nil 188 } 189 return errors.New("wrong result type") 190 }, 191 ) 192 _, err := s.usermanager.UserInfo([]string{"foo", "bar"}, usermanager.AllUsers) 193 c.Assert(err, gc.ErrorMatches, "foo: first error, bar: second error") 194 } 195 196 func (s *usermanagerSuite) TestSetUserPassword(c *gc.C) { 197 tag := s.AdminUserTag(c) 198 err := s.usermanager.SetPassword(tag.Name(), "new-password") 199 c.Assert(err, jc.ErrorIsNil) 200 user, err := s.State.User(tag) 201 c.Assert(err, jc.ErrorIsNil) 202 c.Assert(user.PasswordValid("new-password"), jc.IsTrue) 203 } 204 205 func (s *usermanagerSuite) TestSetUserPasswordCanonical(c *gc.C) { 206 tag := s.AdminUserTag(c) 207 err := s.usermanager.SetPassword(tag.Id(), "new-password") 208 c.Assert(err, jc.ErrorIsNil) 209 user, err := s.State.User(tag) 210 c.Assert(err, jc.ErrorIsNil) 211 c.Assert(user.PasswordValid("new-password"), jc.IsTrue) 212 } 213 214 func (s *usermanagerSuite) TestSetUserPasswordBadName(c *gc.C) { 215 err := s.usermanager.SetPassword("not!good", "new-password") 216 c.Assert(err, gc.ErrorMatches, `"not!good" is not a valid username`) 217 }