developmentSpaceFields.GUID = "dev-space-guid-1"
stagingSpaceFields := models.SpaceFields{}
stagingSpaceFields.Name = "staging"
stagingSpaceFields.GUID = "staging-space-guid-1"
domainFields := models.DomainFields{}
domainFields.Name = "cfapps.io"
domainFields.GUID = "1111"
domainFields.OwningOrganizationGUID = "my-org-guid"
domainFields.Shared = true
cfAppDomainFields := models.DomainFields{}
cfAppDomainFields.Name = "cf-app.com"
cfAppDomainFields.GUID = "2222"
cfAppDomainFields.OwningOrganizationGUID = "my-org-guid"
cfAppDomainFields.Shared = false
org := models.Organization{}
org.Name = "my-org"
org.GUID = "my-org-guid"
org.QuotaDefinition = models.QuotaFields{
Name: "cantina-quota",
MemoryLimit: 512,
InstanceMemoryLimit: 256,
RoutesLimit: 2,
ServicesLimit: 5,
NonBasicServicesAllowed: true,
AppInstanceLimit: 7,
}
org.Spaces = []models.SpaceFields{developmentSpaceFields, stagingSpaceFields}
org.Domains = []models.DomainFields{domainFields, cfAppDomainFields}
org.SpaceQuotas = []models.SpaceQuota{
{Name: "space-quota-1", GUID: "space-quota-1-guid", MemoryLimit: 512, InstanceMemoryLimit: -1},
testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/cloudfoundry/cli/testhelpers/matchers"
)
var _ = Describe("Login Command", func() {
var (
Flags []string
Config coreconfig.Repository
ui *testterm.FakeUI
authRepo *authenticationfakes.FakeAuthenticationRepository
endpointRepo *coreconfigfakes.FakeEndpointRepository
orgRepo *organizationsfakes.FakeOrganizationRepository
spaceRepo *apifakes.FakeSpaceRepository
org models.Organization
deps commandregistry.Dependency
minCLIVersion string
minRecommendedCLIVersion string
)
updateCommandDependency := func(pluginCall bool) {
deps.UI = ui
deps.Config = Config
deps.RepoLocator = deps.RepoLocator.SetEndpointRepository(endpointRepo)
deps.RepoLocator = deps.RepoLocator.SetAuthenticationRepository(authRepo)
deps.RepoLocator = deps.RepoLocator.SetOrganizationRepository(orgRepo)
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
It("returns a UserRequirement", func() {
actualRequirements := cmd.Requirements(factory, flagContext)
Expect(factory.NewUserRequirementCallCount()).To(Equal(1))
actualUsername, actualWantGUID := factory.NewUserRequirementArgsForCall(0)
Expect(actualUsername).To(Equal("the-user-name"))
Expect(actualWantGUID).To(BeTrue())
Expect(actualRequirements).To(ContainElement(userRequirement))
})
})
})
})
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)
})
runCommand("username", "org", "role")
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"},
))
Context("when the user is logged in", func() {
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())
"github.com/cloudfoundry/cli/cf/configuration/coreconfig"
"github.com/cloudfoundry/cli/cf/models"
testcmd "github.com/cloudfoundry/cli/testhelpers/commands"
testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
. "github.com/cloudfoundry/cli/testhelpers/matchers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("delete-org command", func() {
var (
config coreconfig.Repository
ui *testterm.FakeUI
requirementsFactory *requirementsfakes.FakeFactory
orgRepo *organizationsfakes.FakeOrganizationRepository
org models.Organization
deps commandregistry.Dependency
)
updateCommandDependency := func(pluginCall bool) {
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"},
}
testcmd "github.com/cloudfoundry/cli/testhelpers/commands"
testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
testreq "github.com/cloudfoundry/cli/testhelpers/requirements"
testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
. "github.com/cloudfoundry/cli/cf/commands/organization"
. "github.com/cloudfoundry/cli/testhelpers/matchers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("delete-org command", func() {
var (
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{}
userRepo := &testapi.FakeUserRepository{}
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},
Expect("some-org").To(Equal(requirementsFactory.OrganizationName))
})
})
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 = "******"
[]string{"Incorrect Usage", "Requires", "arguments"},
))
callRenameOrg([]string{"foo"})
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails requirements when not logged in", func() {
Expect(callRenameOrg([]string{"my-org", "my-new-org"})).To(BeFalse())
})
Context("when logged in and given an org to rename", func() {
BeforeEach(func() {
org := models.Organization{}
org.Name = "the-old-org-name"
org.Guid = "the-old-org-guid"
requirementsFactory.Organization = org
requirementsFactory.LoginSuccess = true
})
It("passes requirements", func() {
Expect(callRenameOrg([]string{"the-old-org-name", "the-new-org-name"})).To(BeTrue())
})
It("renames an organization", func() {
targetedOrgName := configRepo.OrganizationFields().Name
callRenameOrg([]string{"the-old-org-name", "the-new-org-name"})
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Renaming org", "the-old-org-name", "the-new-org-name", "my-user"},
developmentSpaceFields.Guid = "dev-space-guid-1"
stagingSpaceFields := models.SpaceFields{}
stagingSpaceFields.Name = "staging"
stagingSpaceFields.Guid = "staging-space-guid-1"
domainFields := models.DomainFields{}
domainFields.Name = "cfapps.io"
domainFields.Guid = "1111"
domainFields.OwningOrganizationGuid = "my-org-guid"
domainFields.Shared = true
cfAppDomainFields := models.DomainFields{}
cfAppDomainFields.Name = "cf-app.com"
cfAppDomainFields.Guid = "2222"
cfAppDomainFields.OwningOrganizationGuid = "my-org-guid"
cfAppDomainFields.Shared = false
org := models.Organization{}
org.Name = "my-org"
org.Guid = "my-org-guid"
org.QuotaDefinition = models.NewQuotaFields("cantina-quota", 512, 256, 2, 5, true)
org.Spaces = []models.SpaceFields{developmentSpaceFields, stagingSpaceFields}
org.Domains = []models.DomainFields{domainFields, cfAppDomainFields}
org.SpaceQuotas = []models.SpaceQuota{
{Name: "space-quota-1", Guid: "space-quota-1-guid", MemoryLimit: 512, InstanceMemoryLimit: -1},
{Name: "space-quota-2", Guid: "space-quota-2-guid", MemoryLimit: 256, InstanceMemoryLimit: 128},
}
requirementsFactory.LoginSuccess = true
requirementsFactory.Organization = org
})
It("shows the org with the given name", func() {
runCommand("org", "quota", "extra-stuff")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-org", "my-quota")).To(BeFalse())
})
Context("when logged in", func() {
BeforeEach(func() {
org := models.Organization{}
org.Name = "my-org"
org.GUID = "my-org-guid"
orgReq := new(requirementsfakes.FakeOrganizationRequirement)
orgReq.GetOrganizationReturns(org)
requirementsFactory.NewOrganizationRequirementReturns(orgReq)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
})
It("assigns a quota to an org", func() {
quota := models.QuotaFields{Name: "my-quota", GUID: "my-quota-guid"}
quotaRepo.FindByNameReturns(quota, nil)
runCommand("my-org", "my-quota")
})
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"},
It("fails when not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).To(BeFalse())
})
It("should fail with usage when provided any arguments", func() {
requirementsFactory.LoginSuccess = true
Expect(runCommand("blahblah")).To(BeFalse())
Expect(ui.FailedWithUsage).To(BeTrue())
})
})
Context("when there are orgs to be listed", func() {
BeforeEach(func() {
org1 := models.Organization{}
org1.Name = "Organization-1"
org2 := models.Organization{}
org2.Name = "Organization-2"
org3 := models.Organization{}
org3.Name = "Organization-3"
orgRepo.ListOrgsReturns([]models.Organization{org1, org2, org3}, nil)
})
It("lists orgs", func() {
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
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{}
})
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"},
service2 := models.ServiceOffering{ServiceOfferingFields: models.ServiceOfferingFields{Label: "my-service2", Guid: "service-guid2"}}
serviceRepo.FindServiceOfferingByLabelServiceOffering = service2
servicePlanRepo.SearchReturns = map[string][]models.ServicePlanFields{
"service-guid": {{Name: "service-plan", Guid: "service-plan-guid"}, {Name: "other-plan", Guid: "other-plan-guid"}},
"service-guid2": {{Name: "service-plan2", Guid: "service-plan2-guid"}},
}
servicePlanVisibilityRepo.ListReturns([]models.ServicePlanVisibilityFields{
{ServicePlanGuid: "service-plan2-guid", OrganizationGuid: "org-guid"},
{ServicePlanGuid: "service-plan2-guid", OrganizationGuid: "org2-guid"},
}, nil)
org1 := models.Organization{}
org1.Name = "org1"
org1.Guid = "org-guid"
org2 := models.Organization{}
org2.Name = "org2"
org2.Guid = "org2-guid"
orgRepo.Organizations = []models.Organization{
org1,
org2,
}
})
Describe("GetBrokerWithSingleService", func() {
It("Returns a single broker contained in a slice with all dependencies populated", func() {
},
"spaces": [{
"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))
Context("when the user is logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
})
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)
})
It("it updates the organization in the config", func() {
callTarget([]string{"-o", "my-organization"})
Expect(orgRepo.FindByNameArgsForCall(0)).To(Equal("my-organization"))
Expect(ui.ShowConfigurationCalled).To(BeTrue())
Expect(config.OrganizationFields().Guid).To(Equal("my-organization-guid"))
})
var _ = Describe("Service Plans", func() {
var (
actor actors.ServicePlanActor
servicePlanRepo *testapi.FakeServicePlanRepo
servicePlanVisibilityRepo *testapi.FakeServicePlanVisibilityRepository
orgRepo *fake_orgs.FakeOrganizationRepository
planBuilder *fake_plan_builder.FakePlanBuilder
serviceBuilder *fake_service_builder.FakeServiceBuilder
privateServicePlanVisibilityFields models.ServicePlanVisibilityFields
publicServicePlanVisibilityFields models.ServicePlanVisibilityFields
limitedServicePlanVisibilityFields models.ServicePlanVisibilityFields
publicServicePlan models.ServicePlanFields
privateServicePlan models.ServicePlanFields
limitedServicePlan models.ServicePlanFields
publicService models.ServiceOffering
mixedService models.ServiceOffering
privateService models.ServiceOffering
publicAndLimitedService models.ServiceOffering
org1 models.Organization
org2 models.Organization
visibility1 models.ServicePlanVisibilityFields
)
BeforeEach(func() {
var _ = Describe("Service Plans", func() {
var (
actor actors.ServicePlanActor
servicePlanRepo *apifakes.OldFakeServicePlanRepo
servicePlanVisibilityRepo *apifakes.FakeServicePlanVisibilityRepository
orgRepo *organizationsfakes.FakeOrganizationRepository
planBuilder *planbuilderfakes.FakePlanBuilder
serviceBuilder *servicebuilderfakes.FakeServiceBuilder
privateServicePlanVisibilityFields models.ServicePlanVisibilityFields
publicServicePlanVisibilityFields models.ServicePlanVisibilityFields
limitedServicePlanVisibilityFields models.ServicePlanVisibilityFields
publicServicePlan models.ServicePlanFields
privateServicePlan models.ServicePlanFields
limitedServicePlan models.ServicePlanFields
publicService models.ServiceOffering
mixedService models.ServiceOffering
privateService models.ServiceOffering
publicAndLimitedService models.ServiceOffering
org1 models.Organization
org2 models.Organization
visibility1 models.ServicePlanVisibilityFields
)
BeforeEach(func() {
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 = "******"
It("should fail with usage when provided any arguments", func() {
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
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("OrganizationRequirement", func() {
var (
ui *testterm.FakeUI
)
BeforeEach(func() {
ui = new(testterm.FakeUI)
})
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"
orgRepo := &testapi.FakeOrgRepository{Organizations: []models.Organization{org}}
orgReq := NewOrganizationRequirement("my-org-name", ui, orgRepo)
Expect(orgReq.Execute()).To(BeTrue())
Expect(orgRepo.FindByNameName).To(Equal("my-org-name"))
Expect(orgReq.GetOrganization()).To(Equal(org))
})
})
It("fails when the org with the given name does not exist", func() {
orgRepo := &testapi.FakeOrgRepository{FindByNameNotFound: true}
testassert.AssertPanic(testterm.FailedWasCalled, func() {
BeforeEach(func() {
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("some-org").To(Equal(requirementsFactory.OrganizationName))
})
})
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 = "******"
"github.com/cloudfoundry/cli/cf/api/organizations/organizationsfakes"
"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() {
Expect(runCommand("my-org", "my-quota")).To(BeFalse())
})
Context("when logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
})
It("passes requirements when provided two args", func() {
passed := runCommand("my-org", "my-quota")
Expect(passed).To(BeTrue())
Expect(requirementsFactory.OrganizationName).To(Equal("my-org"))
})
It("assigns a quota to an org", func() {
org := models.Organization{}
org.Name = "my-org"
org.Guid = "my-org-guid"
quota := models.QuotaFields{Name: "my-quota", Guid: "my-quota-guid"}
quotaRepo.FindByNameReturns(quota, nil)
requirementsFactory.Organization = org
runCommand("my-org", "my-quota")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Setting quota", "my-quota", "my-org", "my-user"},
[]string{"OK"},
))
[]string{"Incorrect Usage", "Requires an argument"},
))
})
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) {
}],
"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))
