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{}
requirementsFactory.LoginSuccess = true
runCommand("username", "org", "space", "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
org := models.Organization{}
org.Guid = "my-org-guid"
org.Name = "my-org"
requirementsFactory.UserFields = models.UserFields{Guid: "my-user-guid", Username: "******"}
requirementsFactory.Organization = org
spaceRepo.FindByNameInOrgSpace = models.Space{}
spaceRepo.FindByNameInOrgSpace.Guid = "my-space-guid"
spaceRepo.FindByNameInOrgSpace.Name = "my-space"
spaceRepo.FindByNameInOrgSpace.Organization = org.OrganizationFields
})
It("sets the given space role on the given user", func() {
runCommand("some-user", "some-org", "some-space", "SpaceManager")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Assigning role ", "SpaceManager", "my-user", "my-org", "my-space", "current-user"},
Context("checks login", func() {
It("passes when logged in", func() {
runCommand("my-org", "example.com")
Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
Expect(requirementsFactory.OrganizationName).To(Equal("my-org"))
})
It("fails when not logged in", func() {
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: false}
runCommand("my-org", "example.com")
Expect(testcmd.CommandDidPassRequirements).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")
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"},
))
})
})
"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"))
Expect(org.Domains[0].Guid).To(Equal("domain1-guid"))
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
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
runCommand("say-hello-to-my-little-org")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
Context("when logged in and given an org with users", func() {
BeforeEach(func() {
org := models.Organization{}
org.Name = "the-org"
org.Guid = "the-org-guid"
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},
}
plan1 = models.ServicePlanFields{
Name: "service-plan1",
Guid: "service-plan1-guid",
ServiceOfferingGuid: "service-guid1",
}
plan2 = models.ServicePlanFields{
Name: "service-plan2",
Guid: "service-plan2-guid",
ServiceOfferingGuid: "service-guid1",
}
planRepo.SearchReturns = map[string][]models.ServicePlanFields{
"service-guid1": []models.ServicePlanFields{plan1, plan2},
}
org1 = models.Organization{}
org1.Name = "org1"
org1.Guid = "org1-guid"
org2 = models.Organization{}
org2.Name = "org2"
org2.Guid = "org2-guid"
/**
orgRepo.Organizations = []models.Organization{
org1,
org2,
}
**/
visibilityRepo.ListReturns([]models.ServicePlanVisibilityFields{
{ServicePlanGuid: "service-plan1-guid", OrganizationGuid: "org1-guid"},
{ServicePlanGuid: "service-plan1-guid", OrganizationGuid: "org2-guid"},
}, nil)
. "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 := &test_org.FakeOrganizationRepository{}
orgReq := NewOrganizationRequirement("my-org-name", ui, orgRepo)
orgRepo.ListOrgsReturns([]models.Organization{org}, nil)
orgRepo.FindByNameReturns(org, nil)
Expect(orgReq.Execute()).To(BeTrue())
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() {
orgRepo := &test_org.FakeOrganizationRepository{}
orgRepo = &test_org.FakeOrganizationRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
})
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.LoginSuccess = false
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
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(
[]string{"Getting orgs as my-user"},
org models.Organization
)
BeforeEach(func() {
Flags = []string{}
Config = testconfig.NewRepository()
ui = &testterm.FakeUI{}
authRepo = &testapi.FakeAuthenticationRepository{
AccessToken: "my_access_token",
RefreshToken: "my_refresh_token",
Config: Config,
}
endpointRepo = &testapi.FakeEndpointRepo{}
org = models.Organization{}
org.Name = "my-new-org"
org.Guid = "my-new-org-guid"
orgRepo = &fake_organizations.FakeOrganizationRepository{}
orgRepo.ListOrgsReturns([]models.Organization{org}, nil)
space := models.Space{}
space.Guid = "my-space-guid"
space.Name = "my-space"
spaceRepo = &testapi.FakeSpaceRepository{
Spaces: []models.Space{space},
}
authRepo.GetLoginPromptsReturns.Prompts = map[string]core_config.AuthPrompt{
"username": core_config.AuthPrompt{
org2 models.Organization
visibility1 models.ServicePlanVisibilityFields
)
BeforeEach(func() {
servicePlanRepo = &testapi.FakeServicePlanRepo{}
servicePlanVisibilityRepo = &testapi.FakeServicePlanVisibilityRepository{}
orgRepo = &fake_orgs.FakeOrganizationRepository{}
planBuilder = &fake_plan_builder.FakePlanBuilder{}
serviceBuilder = &fake_service_builder.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",
callRenameOrg([]string{})
Expect(ui.FailedWithUsage).To(BeTrue())
callRenameOrg([]string{"foo"})
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails requirements when not logged in", func() {
callRenameOrg([]string{"my-org", "my-new-org"})
Expect(testcmd.CommandDidPassRequirements).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() {
callRenameOrg([]string{"the-old-org-name", "the-new-org-name"})
Expect(testcmd.CommandDidPassRequirements).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"},
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"},
))
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) {
cmd := NewDeleteOrg(ui, config, orgRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
}
It("fails requirements when not logged in", func() {
runCommand("some-org-name")
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"))
})
