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  })