BeforeEach(func() { Flags = []string{} Config = testconfig.NewRepository() ui = &testterm.FakeUI{} authRepo = new(authenticationfakes.FakeAuthenticationRepository) authRepo.AuthenticateStub = func(credentials map[string]string) error { Config.SetAccessToken("my_access_token") Config.SetRefreshToken("my_refresh_token") return nil } endpointRepo = new(coreconfigfakes.FakeEndpointRepository) minCLIVersion = "1.0.0" minRecommendedCLIVersion = "1.0.0" org = models.Organization{} org.Name = "my-new-org" org.GUID = "my-new-org-guid" orgRepo = &organizationsfakes.FakeOrganizationRepository{} orgRepo.ListOrgsReturns([]models.Organization{org}, nil) space := models.Space{} space.GUID = "my-space-guid" space.Name = "my-space" spaceRepo = new(apifakes.FakeSpaceRepository) spaceRepo.ListSpacesStub = listSpacesStub([]models.Space{space}) authRepo.GetLoginPromptsAndSaveUAAServerURLReturns(map[string]coreconfig.AuthPrompt{ "username": { DisplayName: "Username",
"github.com/cloudfoundry/cli/cf/models" . "github.com/cloudfoundry/cli/cf/requirements" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("OrganizationRequirement", func() { var orgRepo *organizationsfakes.FakeOrganizationRepository BeforeEach(func() { orgRepo = new(organizationsfakes.FakeOrganizationRepository) }) Context("when an org with the given name exists", func() { It("succeeds", func() { org := models.Organization{} org.Name = "my-org-name" org.GUID = "my-org-guid" orgReq := NewOrganizationRequirement("my-org-name", orgRepo) orgRepo.ListOrgsReturns([]models.Organization{org}, nil) orgRepo.FindByNameReturns(org, nil) err := orgReq.Execute() Expect(err).NotTo(HaveOccurred()) Expect(orgRepo.FindByNameArgsForCall(0)).To(Equal("my-org-name")) Expect(orgReq.GetOrganization()).To(Equal(org)) }) }) It("fails when the org with the given name does not exist", func() { orgError := errors.New("not found")
BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) }) var expectOrgToBeCleared = func() { Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{})) } var expectSpaceToBeCleared = func() { Expect(config.SpaceFields()).To(Equal(models.SpaceFields{})) } Context("there are no errors", func() { BeforeEach(func() { org := models.Organization{} org.Name = "my-organization" org.GUID = "my-organization-guid" orgRepo.ListOrgsReturns([]models.Organization{org}, nil) orgRepo.FindByNameReturns(org, nil) config.SetOrganizationFields(models.OrganizationFields{Name: org.Name, GUID: org.GUID}) }) It("it updates the organization in the config", func() { callTarget([]string{"-o", "my-organization"}) Expect(orgRepo.FindByNameCallCount()).To(Equal(1)) Expect(orgRepo.FindByNameArgsForCall(0)).To(Equal("my-organization")) Expect(ui.ShowConfigurationCalled).To(BeTrue()) Expect(config.OrganizationFields().GUID).To(Equal("my-organization-guid"))
orgRepo = new(organizationsfakes.FakeOrganizationRepository) brokerBuilder = new(brokerbuilderfakes.FakeBrokerBuilder) serviceBuilder = new(servicebuilderfakes.FakeServiceBuilder) actor = actors.NewServiceHandler(orgRepo, brokerBuilder, serviceBuilder) serviceBroker1 = models.ServiceBroker{GUID: "my-service-broker-guid1", Name: "my-service-broker1"} service1 = models.ServiceOffering{ServiceOfferingFields: models.ServiceOfferingFields{ Label: "my-service1", GUID: "service-guid1", BrokerGUID: "my-service-broker-guid1"}, } org1 := models.Organization{} org1.Name = "org1" org1.GUID = "org-guid" org2 := models.Organization{} org2.Name = "org2" org2.GUID = "org2-guid" }) Describe("FilterBrokers", func() { Context("when no flags are passed", func() { It("returns all brokers", func() { returnedBrokers := []models.ServiceBroker{serviceBroker1} brokerBuilder.GetAllServiceBrokersReturns(returnedBrokers, nil) brokers, err := actor.FilterBrokers("", "", "") Expect(err).NotTo(HaveOccurred())
Expect(testcmd.CommandDidPassRequirements).To(BeTrue()) Expect(requirementsFactory.UserUsername).To(Equal("username")) Expect(requirementsFactory.OrganizationName).To(Equal("org")) }) }) Context("when logged in", func() { BeforeEach(func() { requirementsFactory.LoginSuccess = true user := models.UserFields{} user.Username = "******" user.Guid = "some-user-guid" org := models.Organization{} org.Name = "some-org" org.Guid = "some-org-guid" requirementsFactory.UserFields = user requirementsFactory.Organization = org }) It("unsets a user's org role", func() { runCommand("my-username", "my-org", "OrgManager") Expect(ui.Outputs).To(ContainSubstrings( []string{"Removing role", "OrgManager", "my-username", "my-org", "my-user"}, []string{"OK"}, )) Expect(userRepo.UnsetOrgRoleRole).To(Equal(models.ORG_MANAGER))
requirementsFactory.LoginSuccess = true Expect(runCommand("blahblah")).To(BeFalse()) Expect(ui.Outputs).To(ContainSubstrings( []string{"Incorrect Usage", "No argument required"}, )) }) }) Describe("when invoked by a plugin", func() { var ( pluginOrgsModel []plugin_models.GetOrgs_Model ) BeforeEach(func() { org1 := models.Organization{} org1.Name = "Organization-1" org1.Guid = "org-1-guid" org2 := models.Organization{} org2.Name = "Organization-2" org3 := models.Organization{} org3.Name = "Organization-3" orgRepo.ListOrgsReturns([]models.Organization{org1, org2, org3}, nil) pluginOrgsModel = []plugin_models.GetOrgs_Model{} deps.PluginModels.Organizations = &pluginOrgsModel }) It("populates the plugin models upon execution", func() {
config core_config.ReadWriter ui *testterm.FakeUI requirementsFactory *testreq.FakeReqFactory orgRepo *test_org.FakeOrganizationRepository org models.Organization ) BeforeEach(func() { ui = &testterm.FakeUI{ Inputs: []string{"y"}, } config = testconfig.NewRepositoryWithDefaults() requirementsFactory = &testreq.FakeReqFactory{} org = models.Organization{} org.Name = "org-to-delete" org.Guid = "org-to-delete-guid" orgRepo = &test_org.FakeOrganizationRepository{} orgRepo.ListOrgsReturns([]models.Organization{org}, nil) orgRepo.FindByNameReturns(org, nil) }) runCommand := func(args ...string) bool { cmd := NewDeleteOrg(ui, config, orgRepo) return testcmd.RunCommand(cmd, args, requirementsFactory) } It("fails requirements when not logged in", func() { Expect(runCommand("some-org-name")).To(BeFalse()) })
args := []string{"Org1"} requirementsFactory.LoginSuccess = false callOrgUsers(args, requirementsFactory, userRepo) Expect(testcmd.CommandDidPassRequirements).To(BeFalse()) requirementsFactory.LoginSuccess = true callOrgUsers(args, requirementsFactory, userRepo) Expect(testcmd.CommandDidPassRequirements).To(BeTrue()) Expect("Org1").To(Equal(requirementsFactory.OrganizationName)) }) It("TestOrgUsers", func() { org := models.Organization{} org.Name = "Found Org" org.Guid = "found-org-guid" userRepo := &testapi.FakeUserRepository{} user := models.UserFields{} user.Username = "******" user2 := models.UserFields{} user2.Username = "******" user3 := models.UserFields{} user3.Username = "******" user4 := models.UserFields{} user4.Username = "******" userRepo.ListUsersByRole = map[string][]models.UserFields{ models.ORG_MANAGER: []models.UserFields{user, user2}, models.BILLING_MANAGER: []models.UserFields{user4}, models.ORG_AUDITOR: []models.UserFields{user3},
}) }) It("fails with usage when not invoked with exactly two args", func() { runCommand("my-org") Expect(ui.Outputs).To(ContainSubstrings( []string{"Incorrect Usage", "Requires arguments"}, )) }) Context("when logged in and given some users in the org and space", func() { BeforeEach(func() { requirementsFactory.LoginSuccess = true org := models.Organization{} org.Name = "Org1" org.Guid = "org1-guid" space := models.Space{} space.Name = "Space1" space.Guid = "space1-guid" requirementsFactory.Organization = org spaceRepo.FindByNameInOrgReturns(space, nil) user := models.UserFields{} user.Username = "******" user2 := models.UserFields{} user2.Username = "******" user3 := models.UserFields{} user3.Username = "******" user4 := models.UserFields{}
var _ = Describe("Testing with ginkgo", func() { It("TestShowOrgRequirements", func() { args := []string{"my-org"} requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true} callShowOrg(args, requirementsFactory) Expect(testcmd.CommandDidPassRequirements).To(BeTrue()) requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: false} callShowOrg(args, requirementsFactory) Expect(testcmd.CommandDidPassRequirements).To(BeFalse()) }) It("TestShowOrgFailsWithUsage", func() { org := models.Organization{} org.Name = "my-org" org.Guid = "my-org-guid" requirementsFactory := &testreq.FakeReqFactory{Organization: org, LoginSuccess: true} args := []string{"my-org"} ui := callShowOrg(args, requirementsFactory) Expect(ui.FailedWithUsage).To(BeFalse()) args = []string{} ui = callShowOrg(args, requirementsFactory) Expect(ui.FailedWithUsage).To(BeTrue()) }) It("TestRunWhenOrganizationExists", func() { developmentSpaceFields := models.SpaceFields{} developmentSpaceFields.Name = "development"
Expect(testcmd.CommandDidPassRequirements).To(BeTrue()) Expect("some-org").To(Equal(requirementsFactory.OrganizationName)) }) }) It("fails with usage when not invoked with exactly two args", func() { runCommand("my-org") Expect(ui.FailedWithUsage).To(BeTrue()) }) Context("when logged in and given some users in the org and space", func() { BeforeEach(func() { requirementsFactory.LoginSuccess = true org := models.Organization{} org.Name = "Org1" org.Guid = "org1-guid" space := models.Space{} space.Name = "Space1" space.Guid = "space1-guid" requirementsFactory.Organization = org spaceRepo.FindByNameInOrgSpace = space user := models.UserFields{} user.Username = "******" user2 := models.UserFields{} user2.Username = "******" user3 := models.UserFields{} user3.Username = "******" user4 := models.UserFields{}
"metadata": { "guid": "space1-guid" }, "entity": { "name": "Space1" } }], "domains": [{ "metadata": { "guid": "domain1-guid" }, "entity": { "name": "cfapps.io" } }] } }]}`}, }) testserver, handler, repo := createOrganizationRepo(req) defer testserver.Close() existingOrg := models.Organization{} existingOrg.Guid = "org1-guid" existingOrg.Name = "Org1" org, apiErr := repo.FindByName("Org1") Expect(handler).To(HaveAllRequestsCalled()) Expect(apiErr).NotTo(HaveOccurred()) Expect(org.Name).To(Equal(existingOrg.Name)) Expect(org.Guid).To(Equal(existingOrg.Guid)) Expect(org.QuotaDefinition.Name).To(Equal("not-your-average-quota")) Expect(org.QuotaDefinition.MemoryLimit).To(Equal(int64(128))) Expect(len(org.Spaces)).To(Equal(1)) Expect(org.Spaces[0].Name).To(Equal("Space1")) Expect(org.Spaces[0].Guid).To(Equal("space1-guid")) Expect(len(org.Domains)).To(Equal(1)) Expect(org.Domains[0].Name).To(Equal("cfapps.io")) Expect(org.Domains[0].Guid).To(Equal("domain1-guid"))
It("fails and tells the user", func() { runCommand("sec group", "org", "space") Expect(fakeOrgRepo.FindByNameArgsForCall(0)).To(Equal("org")) Expect(ui.Outputs).To(ContainSubstrings( []string{"FAILED"}, []string{"Org", "org", "not found"}, )) }) }) Context("when the space does not exist", func() { BeforeEach(func() { org := models.Organization{} org.Name = "org-name" org.Guid = "org-guid" fakeOrgRepo.ListOrgsReturns([]models.Organization{org}, nil) fakeOrgRepo.FindByNameReturns(org, nil) fakeSpaceRepo.FindByNameInOrgError = errors.NewModelNotFoundError("Space", "space-name") }) It("fails and tells the user", func() { runCommand("sec group", "org-name", "space-name") Expect(fakeSpaceRepo.FindByNameInOrgName).To(Equal("space-name")) Expect(fakeSpaceRepo.FindByNameInOrgOrgGuid).To(Equal("org-guid")) Expect(ui.Outputs).To(ContainSubstrings( []string{"FAILED"}, []string{"Space", "space-name", "not found"}, ))
Context("Execute", func() { var org models.Organization BeforeEach(func() { requirementsFactory.LoginSuccess = true requirementsFactory.UserRequirementFails = false requirementsFactory.OrganizationRequirementFails = false flagContext.Parse("the-username", "the-org-name", "the-space-name", "SpaceManager") _, err := cmd.Requirements(requirementsFactory, flagContext) Expect(err).NotTo(HaveOccurred()) org = models.Organization{} org.Guid = "the-org-guid" org.Name = "the-org-name" requirementsFactory.Organization = org }) Context("when the space is not found", func() { BeforeEach(func() { spaceRepo.FindByNameInOrgReturns(models.Space{}, errors.New("space-repo-error")) }) It("doesn't call CC", func() { Expect(userRepo.SetSpaceRoleByGuidCallCount()).To(BeZero()) Expect(userRepo.SetSpaceRoleByUsernameCallCount()).To(BeZero()) }) It("panics and prints a failure message", func() {
org2 models.Organization visibility1 models.ServicePlanVisibilityFields ) BeforeEach(func() { servicePlanRepo = new(apifakes.OldFakeServicePlanRepo) servicePlanVisibilityRepo = new(apifakes.FakeServicePlanVisibilityRepository) orgRepo = new(organizationsfakes.FakeOrganizationRepository) planBuilder = new(planbuilderfakes.FakePlanBuilder) serviceBuilder = new(servicebuilderfakes.FakeServiceBuilder) actor = actors.NewServicePlanHandler(servicePlanRepo, servicePlanVisibilityRepo, orgRepo, planBuilder, serviceBuilder) org1 = models.Organization{} org1.Name = "org-1" org1.GUID = "org-1-guid" org2 = models.Organization{} org2.Name = "org-2" org2.GUID = "org-2-guid" orgRepo.FindByNameReturns(org1, nil) publicServicePlanVisibilityFields = models.ServicePlanVisibilityFields{ GUID: "public-service-plan-visibility-guid", ServicePlanGUID: "public-service-plan-guid", } privateServicePlanVisibilityFields = models.ServicePlanVisibilityFields{ GUID: "private-service-plan-visibility-guid",
)) }) It("fails when not logged in", func() { Expect(runCommand("say-hello-to-my-little-org")).To(BeFalse()) }) }) Context("when logged in and given an org with no users in a particular role", func() { var ( user1, user2 models.UserFields ) BeforeEach(func() { org := models.Organization{} org.Name = "the-org" org.Guid = "the-org-guid" user1 = models.UserFields{} user1.Username = "******" user2 = models.UserFields{} user2.Username = "******" requirementsFactory.LoginSuccess = true requirementsFactory.Organization = org }) Context("shows friendly messaage when no users in ORG_MANAGER role", func() { It("shows the special users in the given org", func() { userRepo.ListUsersInOrgForRoleStub = func(_ string, roleName string) ([]models.UserFields, error) { userFields := map[string][]models.UserFields{
requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true} domainRepo := &testapi.FakeDomainRepository{} ui := callCreateDomain([]string{""}, requirementsFactory, domainRepo) Expect(ui.FailedWithUsage).To(BeTrue()) ui = callCreateDomain([]string{"org1"}, requirementsFactory, domainRepo) Expect(ui.FailedWithUsage).To(BeTrue()) ui = callCreateDomain([]string{"org1", "example.com"}, requirementsFactory, domainRepo) Expect(ui.FailedWithUsage).To(BeFalse()) }) It("TestCreateDomain", func() { org := models.Organization{} org.Name = "myOrg" org.Guid = "myOrg-guid" requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true, Organization: org} domainRepo := &testapi.FakeDomainRepository{} ui := callCreateDomain([]string{"myOrg", "example.com"}, requirementsFactory, domainRepo) Expect(domainRepo.CreateDomainName).To(Equal("example.com")) Expect(domainRepo.CreateDomainOwningOrgGuid).To(Equal("myOrg-guid")) Expect(ui.Outputs).To(ContainSubstrings( []string{"Creating domain", "example.com", "myOrg", "my-user"}, []string{"OK"}, )) }) }) func callCreateDomain(args []string, requirementsFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {