})
})
})
Describe("Execute", func() {
var (
org models.Organization
err error
)
BeforeEach(func() {
flagContext.Parse("the-user-name", "the-org-name", "the-space-name", "SpaceManager")
cmd.Requirements(factory, flagContext)
org = models.Organization{}
org.GUID = "the-org-guid"
org.Name = "the-org-name"
organizationRequirement.GetOrganizationReturns(org)
})
JustBeforeEach(func() {
err = cmd.Execute(flagContext)
})
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.UnsetSpaceRoleByGUIDCallCount()).To(BeZero())
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",
Type: coreconfig.AuthPromptTypeText,
. "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")
orgRepo.FindByNameReturns(models.Organization{}, orgError)
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"))
})
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(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Incorrect Usage"))
Expect(err.Error()).To(ContainSubstring("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() {
testcmd.RunCLICommand("orgs", []string{}, requirementsFactory, updateCommandDependency, true, ui)
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",
ServicePlanGUID: "private-service-plan-guid",
deps.UI = ui
deps.RepoLocator = deps.RepoLocator.SetOrganizationRepository(orgRepo)
deps.Config = config
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete-org").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{
Inputs: []string{"y"},
}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = new(requirementsfakes.FakeFactory)
org = models.Organization{}
org.Name = "org-to-delete"
org.GUID = "org-to-delete-guid"
orgRepo = new(organizationsfakes.FakeOrganizationRepository)
orgRepo.ListOrgsReturns([]models.Organization{org}, nil)
orgRepo.FindByNameReturns(org, nil)
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("delete-org", args, requirementsFactory, updateCommandDependency, false, ui)
}
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("some-org-name")).To(BeFalse())
})
})
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{}
user4.Username = "******"
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.FindByNameInOrgReturns(models.Space{}, errors.NewModelNotFoundError("Space", "space-name"))
})
It("fails and tells the user", func() {
runCommand("sec group", "org-name", "space-name")
name, orgGUID := fakeSpaceRepo.FindByNameInOrgArgsForCall(0)
Expect(name).To(Equal("space-name"))
Expect(orgGUID).To(Equal("org-guid"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Space", "space-name", "not found"},
))
Context("checks login", func() {
It("passes when logged in", func() {
Expect(runCommand("my-org", "example.com")).To(BeTrue())
Expect(requirementsFactory.OrganizationName).To(Equal("my-org"))
})
It("fails when not logged in", func() {
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: false}
Expect(runCommand("my-org", "example.com")).To(BeFalse())
})
})
It("creates a domain", func() {
org := models.Organization{}
org.Name = "myOrg"
org.GUID = "myOrg-guid"
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, Organization: org}
runCommand("myOrg", "example.com")
domainName, domainOwningOrgGUID := domainRepo.CreateArgsForCall(0)
Expect(domainName).To(Equal("example.com"))
Expect(domainOwningOrgGUID).To(Equal("myOrg-guid"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Creating domain", "example.com", "myOrg", "my-user"},
[]string{"OK"},
))
})
})
"domains": [{
"metadata": { "guid": "domain1-guid" },
"entity": { "name": "cfapps.io" }
}],
"space_quota_definitions":[{
"metadata": {"guid": "space-quota1-guid"},
"entity": {"name": "space-quota1"}
}]
}
}]}`},
})
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"))