})
Context("when the user is not logged in", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
})
It("fails requirements", func() {
Expect(runCommand("my-quota", "-m", "50G")).To(BeFalse())
})
})
Context("when the user is logged in", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewMinAPIVersionRequirementReturns(requirements.Passing{})
})
It("fails requirements when called without a quota name", func() {
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("creates a quota with a given name", func() {
runCommand("my-quota")
Expect(quotaRepo.CreateArgsForCall(0).Name).To(Equal("my-quota"))
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating quota", "my-quota", "my-user", "..."},
[]string{"OK"},
deps.UI = ui
deps.RepoLocator = deps.RepoLocator.SetServiceRepository(serviceRepo)
deps.Config = config
deps.PlanBuilder = planBuilder
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("update-service").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
requirementsFactory.NewMinAPIVersionRequirementReturns(requirements.Passing{Type: "minAPIVersionReq"})
serviceRepo = new(apifakes.FakeServiceRepository)
planBuilder = new(planbuilderfakes.FakePlanBuilder)
offering1 = models.ServiceOffering{}
offering1.Label = "cleardb"
offering1.Plans = []models.ServicePlanFields{{
Name: "spark",
GUID: "cleardb-spark-guid",
}, {
Name: "flare",
GUID: "cleardb-flare-guid",
},
}
RepoLocator: repoLocator,
}
reqFactory = new(requirementsfakes.FakeFactory)
loginReq = new(requirementsfakes.FakeRequirement)
loginReq.ExecuteReturns(nil)
reqFactory.NewLoginRequirementReturns(loginReq)
targetedOrgReq = new(requirementsfakes.FakeTargetedOrgRequirement)
targetedOrgReq.ExecuteReturns(nil)
reqFactory.NewTargetedOrgRequirementReturns(targetedOrgReq)
minApiVersionReq = new(requirementsfakes.FakeRequirement)
minApiVersionReq.ExecuteReturns(nil)
reqFactory.NewMinAPIVersionRequirementReturns(minApiVersionReq)
cmd = spacequota.CreateSpaceQuota{}
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
})
Describe("Requirements", func() {
BeforeEach(func() {
cmd.SetDependency(deps, false)
})
Context("when not exactly one arg is provided", func() {
It("fails", func() {
flagContext.Parse()
_, err := cmd.Requirements(reqFactory, flagContext)
Expect(err).To(HaveOccurred())
Expect(ui.Outputs()).To(ContainSubstrings(
ui = new(testterm.FakeUI)
routingAPIRepo = new(apifakes.FakeRoutingAPIRepository)
config = testconfig.NewRepositoryWithDefaults()
repoLocator = api.RepositoryLocator{}.SetRoutingAPIRepository(routingAPIRepo)
deps = commandregistry.Dependency{
UI: ui,
Config: config,
RepoLocator: repoLocator,
}
minAPIVersionRequirement = new(requirementsfakes.FakeRequirement)
loginRequirement = new(requirementsfakes.FakeRequirement)
routingAPIEndpoingRequirement = new(requirementsfakes.FakeRequirement)
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
requirementsFactory.NewLoginRequirementReturns(loginRequirement)
requirementsFactory.NewRoutingAPIRequirementReturns(routingAPIEndpoingRequirement)
cmd = new(routergroups.RouterGroups)
cmd = cmd.SetDependency(deps, false).(*routergroups.RouterGroups)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
})
Describe("Requirements", func() {
It("fails if the user is not logged in", func() {
cmd.Requirements(requirementsFactory, flagContext)
Expect(requirementsFactory.NewLoginRequirementCallCount()).To(Equal(1))
})
It("fails with usage if space quota name is not provided", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedOrgRequirementReturns(new(requirementsfakes.FakeTargetedOrgRequirement))
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
Context("the minimum API version requirement", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedOrgRequirementReturns(new(requirementsfakes.FakeTargetedOrgRequirement))
requirementsFactory.NewMinAPIVersionRequirementReturns(requirements.Failing{Message: "not min api"})
})
It("fails when the -a option is provided", func() {
Expect(runCommand("my-quota", "-a", "10")).To(BeFalse())
Expect(requirementsFactory.NewMinAPIVersionRequirementCallCount()).To(Equal(1))
option, version := requirementsFactory.NewMinAPIVersionRequirementArgsForCall(0)
Expect(option).To(Equal("Option '-a'"))
Expect(version).To(Equal(cf.SpaceAppInstanceLimitMinimumAPIVersion))
})
It("does not fail when the -a option is not provided", func() {
Expect(runCommand("my-quota", "-m", "10G")).To(BeTrue())
})
})
})
