github.com/jenspinney/cli@v6.42.1-0.20190207184520-7450c600020e+incompatible/cf/commands/user/org_users_test.go (about) 1 package user_test 2 3 import ( 4 "code.cloudfoundry.org/cli/cf/api/apifakes" 5 "code.cloudfoundry.org/cli/cf/commandregistry" 6 "code.cloudfoundry.org/cli/cf/configuration/coreconfig" 7 "code.cloudfoundry.org/cli/cf/models" 8 "code.cloudfoundry.org/cli/cf/requirements" 9 "code.cloudfoundry.org/cli/cf/requirements/requirementsfakes" 10 "code.cloudfoundry.org/cli/cf/trace/tracefakes" 11 testcmd "code.cloudfoundry.org/cli/cf/util/testhelpers/commands" 12 testconfig "code.cloudfoundry.org/cli/cf/util/testhelpers/configuration" 13 testterm "code.cloudfoundry.org/cli/cf/util/testhelpers/terminal" 14 "code.cloudfoundry.org/cli/plugin/models" 15 . "github.com/onsi/ginkgo" 16 . "github.com/onsi/gomega" 17 18 "os" 19 20 . "code.cloudfoundry.org/cli/cf/util/testhelpers/matchers" 21 ) 22 23 var _ = Describe("org-users command", func() { 24 var ( 25 ui *testterm.FakeUI 26 requirementsFactory *requirementsfakes.FakeFactory 27 configRepo coreconfig.Repository 28 userRepo *apifakes.FakeUserRepository 29 deps commandregistry.Dependency 30 ) 31 32 updateCommandDependency := func(pluginCall bool) { 33 deps.UI = ui 34 deps.Config = configRepo 35 deps.RepoLocator = deps.RepoLocator.SetUserRepository(userRepo) 36 37 commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("org-users").SetDependency(deps, pluginCall)) 38 } 39 40 BeforeEach(func() { 41 ui = &testterm.FakeUI{} 42 userRepo = new(apifakes.FakeUserRepository) 43 configRepo = testconfig.NewRepositoryWithDefaults() 44 requirementsFactory = new(requirementsfakes.FakeFactory) 45 deps = commandregistry.NewDependency(os.Stdout, new(tracefakes.FakePrinter), "") 46 }) 47 48 runCommand := func(args ...string) bool { 49 return testcmd.RunCLICommand("org-users", args, requirementsFactory, updateCommandDependency, false, ui) 50 } 51 52 Describe("requirements", func() { 53 It("fails with usage when invoked without an org name", func() { 54 requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) 55 runCommand() 56 Expect(ui.Outputs()).To(ContainSubstrings( 57 []string{"Incorrect Usage", "Requires an argument"}, 58 )) 59 }) 60 61 It("fails when not logged in", func() { 62 requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) 63 Expect(runCommand("say-hello-to-my-little-org")).To(BeFalse()) 64 }) 65 }) 66 67 Context("when logged in and given an org with no users in a particular role", func() { 68 var ( 69 user1, user2 models.UserFields 70 ) 71 72 BeforeEach(func() { 73 org := models.Organization{} 74 org.Name = "the-org" 75 org.GUID = "the-org-guid" 76 77 user1 = models.UserFields{} 78 user1.Username = "user1" 79 user2 = models.UserFields{} 80 user2.Username = "user2" 81 82 requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) 83 organizationReq := new(requirementsfakes.FakeOrganizationRequirement) 84 organizationReq.GetOrganizationReturns(org) 85 requirementsFactory.NewOrganizationRequirementReturns(organizationReq) 86 }) 87 88 Context("shows friendly messaage when no users in ORG_MANAGER role", func() { 89 It("shows the special users in the given org", func() { 90 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 91 userFields := map[models.Role][]models.UserFields{ 92 models.RoleOrgManager: {}, 93 models.RoleBillingManager: {user1}, 94 models.RoleOrgAuditor: {user2}, 95 }[roleName] 96 return userFields, nil 97 } 98 99 runCommand("the-org") 100 101 Expect(userRepo.ListUsersInOrgForRoleWithNoUAACallCount()).To(Equal(3)) 102 for i, expectedRole := range []models.Role{models.RoleOrgManager, models.RoleBillingManager, models.RoleOrgAuditor} { 103 orgGUID, actualRole := userRepo.ListUsersInOrgForRoleWithNoUAAArgsForCall(i) 104 Expect(orgGUID).To(Equal("the-org-guid")) 105 Expect(actualRole).To(Equal(expectedRole)) 106 } 107 108 Expect(ui.Outputs()).To(BeInDisplayOrder( 109 []string{"Getting users in org", "the-org", "my-user"}, 110 []string{"ORG MANAGER"}, 111 []string{" No ORG MANAGER found"}, 112 []string{"BILLING MANAGER"}, 113 []string{" user1"}, 114 []string{"ORG AUDITOR"}, 115 []string{" user2"}, 116 )) 117 }) 118 }) 119 120 Context("shows friendly messaage when no users in BILLING_MANAGER role", func() { 121 It("shows the special users in the given org", func() { 122 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 123 userFields := map[models.Role][]models.UserFields{ 124 models.RoleOrgManager: {user1}, 125 models.RoleBillingManager: {}, 126 models.RoleOrgAuditor: {user2}, 127 }[roleName] 128 return userFields, nil 129 } 130 131 runCommand("the-org") 132 133 Expect(userRepo.ListUsersInOrgForRoleWithNoUAACallCount()).To(Equal(3)) 134 for i, expectedRole := range []models.Role{models.RoleOrgManager, models.RoleBillingManager, models.RoleOrgAuditor} { 135 orgGUID, actualRole := userRepo.ListUsersInOrgForRoleWithNoUAAArgsForCall(i) 136 Expect(orgGUID).To(Equal("the-org-guid")) 137 Expect(actualRole).To(Equal(expectedRole)) 138 } 139 140 Expect(ui.Outputs()).To(BeInDisplayOrder( 141 []string{"Getting users in org", "the-org", "my-user"}, 142 []string{"ORG MANAGER"}, 143 []string{" user1"}, 144 []string{"BILLING MANAGER"}, 145 []string{" No BILLING MANAGER found"}, 146 []string{"ORG AUDITOR"}, 147 []string{" user2"}, 148 )) 149 }) 150 }) 151 152 Context("shows friendly messaage when no users in ORG_AUDITOR role", func() { 153 It("shows the special users in the given org", func() { 154 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 155 userFields := map[models.Role][]models.UserFields{ 156 models.RoleOrgManager: {user1}, 157 models.RoleBillingManager: {user2}, 158 models.RoleOrgAuditor: {}, 159 }[roleName] 160 return userFields, nil 161 } 162 163 runCommand("the-org") 164 165 Expect(userRepo.ListUsersInOrgForRoleWithNoUAACallCount()).To(Equal(3)) 166 for i, expectedRole := range []models.Role{models.RoleOrgManager, models.RoleBillingManager, models.RoleOrgAuditor} { 167 orgGUID, actualRole := userRepo.ListUsersInOrgForRoleWithNoUAAArgsForCall(i) 168 Expect(orgGUID).To(Equal("the-org-guid")) 169 Expect(actualRole).To(Equal(expectedRole)) 170 } 171 Expect(ui.Outputs()).To(BeInDisplayOrder( 172 []string{"Getting users in org", "the-org", "my-user"}, 173 []string{"ORG MANAGER"}, 174 []string{" user1"}, 175 []string{"BILLING MANAGER"}, 176 []string{" user2"}, 177 []string{"ORG AUDITOR"}, 178 []string{" No ORG AUDITOR found"}, 179 )) 180 }) 181 }) 182 183 }) 184 185 Context("when logged in and given an org with users", func() { 186 BeforeEach(func() { 187 org := models.Organization{} 188 org.Name = "the-org" 189 org.GUID = "the-org-guid" 190 191 user := models.UserFields{Username: "user1"} 192 user2 := models.UserFields{Username: "user2"} 193 user3 := models.UserFields{Username: "user3"} 194 user4 := models.UserFields{Username: "user4"} 195 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 196 userFields := map[models.Role][]models.UserFields{ 197 models.RoleOrgManager: {user, user2}, 198 models.RoleBillingManager: {user4}, 199 models.RoleOrgAuditor: {user3}, 200 }[roleName] 201 return userFields, nil 202 } 203 204 requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) 205 organizationReq := new(requirementsfakes.FakeOrganizationRequirement) 206 organizationReq.GetOrganizationReturns(org) 207 requirementsFactory.NewOrganizationRequirementReturns(organizationReq) 208 }) 209 210 It("shows the special users in the given org", func() { 211 runCommand("the-org") 212 213 orgGUID, _ := userRepo.ListUsersInOrgForRoleWithNoUAAArgsForCall(0) 214 Expect(orgGUID).To(Equal("the-org-guid")) 215 Expect(ui.Outputs()).To(ContainSubstrings( 216 []string{"Getting users in org", "the-org", "my-user"}, 217 []string{"ORG MANAGER"}, 218 []string{"user1"}, 219 []string{"user2"}, 220 []string{"BILLING MANAGER"}, 221 []string{"user4"}, 222 []string{"ORG AUDITOR"}, 223 []string{"user3"}, 224 )) 225 }) 226 227 Context("when the -a flag is provided", func() { 228 BeforeEach(func() { 229 user := models.UserFields{Username: "user1"} 230 user2 := models.UserFields{Username: "user2"} 231 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 232 userFields := map[models.Role][]models.UserFields{ 233 models.RoleOrgUser: {user, user2}, 234 }[roleName] 235 return userFields, nil 236 } 237 }) 238 239 It("lists all org users, regardless of role", func() { 240 runCommand("-a", "the-org") 241 242 orgGUID, _ := userRepo.ListUsersInOrgForRoleWithNoUAAArgsForCall(0) 243 Expect(orgGUID).To(Equal("the-org-guid")) 244 Expect(ui.Outputs()).To(ContainSubstrings( 245 []string{"Getting users in org", "the-org", "my-user"}, 246 []string{"USERS"}, 247 []string{"user1"}, 248 []string{"user2"}, 249 )) 250 }) 251 }) 252 }) 253 254 Describe("when invoked by a plugin", func() { 255 var ( 256 pluginUserModel []plugin_models.GetOrgUsers_Model 257 ) 258 259 BeforeEach(func() { 260 configRepo.SetAPIVersion("2.22.0") 261 }) 262 263 Context("single roles", func() { 264 265 BeforeEach(func() { 266 org := models.Organization{} 267 org.Name = "the-org" 268 org.GUID = "the-org-guid" 269 270 // org managers 271 user := models.UserFields{} 272 user.Username = "user1" 273 user.GUID = "1111" 274 275 user2 := models.UserFields{} 276 user2.Username = "user2" 277 user2.GUID = "2222" 278 279 // billing manager 280 user3 := models.UserFields{} 281 user3.Username = "user3" 282 user3.GUID = "3333" 283 284 // auditors 285 user4 := models.UserFields{} 286 user4.Username = "user4" 287 user4.GUID = "4444" 288 289 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 290 userFields := map[models.Role][]models.UserFields{ 291 models.RoleOrgManager: {user, user2}, 292 models.RoleBillingManager: {user4}, 293 models.RoleOrgAuditor: {user3}, 294 models.RoleOrgUser: {user3}, 295 }[roleName] 296 return userFields, nil 297 } 298 299 requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) 300 organizationReq := new(requirementsfakes.FakeOrganizationRequirement) 301 organizationReq.GetOrganizationReturns(org) 302 requirementsFactory.NewOrganizationRequirementReturns(organizationReq) 303 pluginUserModel = []plugin_models.GetOrgUsers_Model{} 304 deps.PluginModels.OrgUsers = &pluginUserModel 305 }) 306 307 It("populates the plugin model with users with single roles", func() { 308 testcmd.RunCLICommand("org-users", []string{"the-org"}, requirementsFactory, updateCommandDependency, true, ui) 309 Expect(pluginUserModel).To(HaveLen(4)) 310 311 for _, u := range pluginUserModel { 312 switch u.Username { 313 case "user1": 314 Expect(u.Guid).To(Equal("1111")) 315 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgManager"})) 316 case "user2": 317 Expect(u.Guid).To(Equal("2222")) 318 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgManager"})) 319 case "user3": 320 Expect(u.Guid).To(Equal("3333")) 321 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgAuditor"})) 322 case "user4": 323 Expect(u.Guid).To(Equal("4444")) 324 Expect(u.Roles).To(ConsistOf([]string{"RoleBillingManager"})) 325 default: 326 Fail("unexpected user: " + u.Username) 327 } 328 } 329 330 }) 331 332 It("populates the plugin model with users with single roles -a flag", func() { 333 testcmd.RunCLICommand("org-users", []string{"-a", "the-org"}, requirementsFactory, updateCommandDependency, true, ui) 334 Expect(pluginUserModel).To(HaveLen(1)) 335 Expect(pluginUserModel[0].Username).To(Equal("user3")) 336 Expect(pluginUserModel[0].Guid).To(Equal("3333")) 337 Expect(pluginUserModel[0].Roles[0]).To(Equal("RoleOrgUser")) 338 }) 339 340 }) 341 342 Context("multiple roles", func() { 343 344 BeforeEach(func() { 345 org := models.Organization{} 346 org.Name = "the-org" 347 org.GUID = "the-org-guid" 348 349 // org managers 350 user := models.UserFields{} 351 user.Username = "user1" 352 user.GUID = "1111" 353 user.IsAdmin = true 354 355 user2 := models.UserFields{} 356 user2.Username = "user2" 357 user2.GUID = "2222" 358 359 // billing manager 360 user3 := models.UserFields{} 361 user3.Username = "user3" 362 user3.GUID = "3333" 363 364 // auditors 365 user4 := models.UserFields{} 366 user4.Username = "user4" 367 user4.GUID = "4444" 368 369 userRepo.ListUsersInOrgForRoleWithNoUAAStub = func(_ string, roleName models.Role) ([]models.UserFields, error) { 370 userFields := map[models.Role][]models.UserFields{ 371 models.RoleOrgManager: {user, user2, user3, user4}, 372 models.RoleBillingManager: {user2, user4}, 373 models.RoleOrgAuditor: {user, user3}, 374 models.RoleOrgUser: {user, user2, user3, user4}, 375 }[roleName] 376 return userFields, nil 377 } 378 379 requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) 380 organizationReq := new(requirementsfakes.FakeOrganizationRequirement) 381 organizationReq.GetOrganizationReturns(org) 382 requirementsFactory.NewOrganizationRequirementReturns(organizationReq) 383 pluginUserModel = []plugin_models.GetOrgUsers_Model{} 384 deps.PluginModels.OrgUsers = &pluginUserModel 385 }) 386 387 It("populates the plugin model with users with multiple roles", func() { 388 testcmd.RunCLICommand("org-users", []string{"the-org"}, requirementsFactory, updateCommandDependency, true, ui) 389 390 Expect(pluginUserModel).To(HaveLen(4)) 391 for _, u := range pluginUserModel { 392 switch u.Username { 393 case "user1": 394 Expect(u.Guid).To(Equal("1111")) 395 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgManager", "RoleOrgAuditor"})) 396 Expect(u.IsAdmin).To(BeTrue()) 397 case "user2": 398 Expect(u.Guid).To(Equal("2222")) 399 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgManager", "RoleBillingManager"})) 400 case "user3": 401 Expect(u.Guid).To(Equal("3333")) 402 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgAuditor", "RoleOrgManager"})) 403 case "user4": 404 Expect(u.Guid).To(Equal("4444")) 405 Expect(u.Roles).To(ConsistOf([]string{"RoleBillingManager", "RoleOrgManager"})) 406 default: 407 Fail("unexpected user: " + u.Username) 408 } 409 } 410 411 }) 412 413 It("populates the plugin model with users with multiple roles -a flag", func() { 414 testcmd.RunCLICommand("org-users", []string{"-a", "the-org"}, requirementsFactory, updateCommandDependency, true, ui) 415 416 Expect(pluginUserModel).To(HaveLen(4)) 417 for _, u := range pluginUserModel { 418 switch u.Username { 419 case "user1": 420 Expect(u.Guid).To(Equal("1111")) 421 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgUser"})) 422 case "user2": 423 Expect(u.Guid).To(Equal("2222")) 424 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgUser"})) 425 case "user3": 426 Expect(u.Guid).To(Equal("3333")) 427 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgUser"})) 428 case "user4": 429 Expect(u.Guid).To(Equal("4444")) 430 Expect(u.Roles).To(ConsistOf([]string{"RoleOrgUser"})) 431 default: 432 Fail("unexpected user: " + u.Username) 433 } 434 } 435 436 }) 437 438 }) 439 440 }) 441 })