)
var _ = Describe("Api", func() {
var (
config coreconfig.Repository
endpointRepo *coreconfigfakes.FakeEndpointRepository
deps commandregistry.Dependency
requirementsFactory *testreq.FakeReqFactory
ui *testterm.FakeUI
cmd commands.Api
flagContext flags.FlagContext
repoLocator api.RepositoryLocator
)
callApi := func(args []string) {
err := flagContext.Parse(args...)
Expect(err).NotTo(HaveOccurred())
cmd.Execute(flagContext)
}
BeforeEach(func() {
ui = new(testterm.FakeUI)
requirementsFactory = &testreq.FakeReqFactory{}
config = testconfig.NewRepository()
endpointRepo = new(coreconfigfakes.FakeEndpointRepository)
endpointRepo.GetCCInfoStub = func(endpoint string) (*coreconfig.CCInfo, string, error) {
return &coreconfig.CCInfo{
APIVersion: config.APIVersion(),
AuthorizationEndpoint: config.AuthenticationEndpoint(),
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
routingAPIRepo.ListRouterGroupsStub = func(cb func(models.RouterGroup) bool) error {
for _, r := range routerGroups {
if !cb(r) {
break
}
}
return nil
}
})
Describe("Requirements", func() {
Context("when not provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("arg-1", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires DOMAIN as an argument"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("domain-name")
loginRequirement = &passingRequirement{Name: "login-requirement"}
reqFactory.NewLoginRequirementReturns(loginRequirement)
targetedSpaceRequirement = &passingRequirement{Name: "targeted-space-requirement"}
reqFactory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement)
serviceInstanceRequirement = &requirementsfakes.FakeServiceInstanceRequirement{}
reqFactory.NewServiceInstanceRequirementReturns(serviceInstanceRequirement)
})
Describe("Requirements", func() {
BeforeEach(func() {
cmd.SetDependency(deps, pluginCall)
})
Context("when not provided exactly 1 argument", func() {
It("fails", func() {
err := flagContext.Parse("too", "many")
Expect(err).NotTo(HaveOccurred())
Expect(func() { cmd.Requirements(reqFactory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
var actualRequirements []requirements.Requirement
BeforeEach(func() {
err := flagContext.Parse("service-name")
Expect(err).NotTo(HaveOccurred())
actualRequirements = cmd.Requirements(reqFactory, flagContext)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
factory = new(requirementsfakes.FakeFactory)
loginRequirement = &passingRequirement{}
factory.NewLoginRequirementReturns(loginRequirement)
minAPIVersionRequirement = &passingRequirement{}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("service-instance", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires an argument"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("service-instance")
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
cmd = spacequota.SetSpaceQuota{}
cmd.SetDependency(deps, false)
configRepo.UsernameReturns("my-user")
})
Describe("Requirements", func() {
Context("when provided a quota and space", func() {
var reqs []requirements.Requirement
BeforeEach(func() {
flagContext.Parse("space", "space-quota")
reqs = cmd.Requirements(requirementsFactory, flagContext)
})
It("returns a LoginRequirement", func() {
Expect(reqs).To(ContainElement(loginReq))
})
It("requires the user to target an org", func() {
Expect(reqs).To(ContainElement(orgReq))
})
})
Context("when not provided a quota and space", func() {
BeforeEach(func() {
flagContext.Parse("")
Expect(usage).To(ContainElement(" --random-port Create a random port for the TCP route"))
})
It("shows the usage", func() {
Expect(usage).To(ContainElement(" Map an HTTP route:"))
Expect(usage).To(ContainElement(" cf map-route APP_NAME DOMAIN [--hostname HOSTNAME] [--path PATH]"))
Expect(usage).To(ContainElement(" Map a TCP route:"))
Expect(usage).To(ContainElement(" cf map-route APP_NAME DOMAIN (--port PORT | --random-port)"))
})
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires APP_NAME and DOMAIN as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name", "domain-name")
},
}
routingApiRepo.ListRouterGroupsStub = func(cb func(models.RouterGroup) bool) error {
for _, routerGroup := range routerGroups {
if !cb(routerGroup) {
break
}
}
return nil
}
})
Describe("Requirements", func() {
Context("when provided one arg", func() {
BeforeEach(func() {
flagContext.Parse("arg-1")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. No argument required"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided no arguments", func() {
BeforeEach(func() {
flagContext.Parse()
Expect(usage).To(ContainElement(" --port Port used to identify the TCP route"))
})
It("shows the usage", func() {
Expect(usage).To(ContainElement(" Unmap an HTTP route:"))
Expect(usage).To(ContainElement(" cf unmap-route APP_NAME DOMAIN [--hostname HOSTNAME] [--path PATH]"))
Expect(usage).To(ContainElement(" Unmap a TCP route:"))
Expect(usage).To(ContainElement(" cf unmap-route APP_NAME DOMAIN --port PORT"))
})
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires app_name, domain_name as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name", "domain-name")
domainRequirement = new(requirementsfakes.FakeDomainRequirement)
domainRequirement.GetDomainReturns(models.DomainFields{
GUID: "domain-guid",
Name: "domain-name",
})
factory.NewDomainRequirementReturns(domainRequirement)
minAPIVersionRequirement = &passingRequirement{}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
err := flagContext.Parse("space-name")
Expect(err).NotTo(HaveOccurred())
})
It("fails with usage", func() {
Expect(func() {
cmd.Requirements(factory, flagContext)
}).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires SPACE and DOMAIN as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
cmd = "a.CreateQuota{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
loginRequirement = &passingRequirement{Name: "login-requirement"}
requirementsFactory.NewLoginRequirementReturns(loginRequirement)
minAPIVersionRequirement = &passingRequirement{Name: "min-api-version-requirement"}
requirementsFactory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
Context("when not provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("quota", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(requirementsFactory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("quota")
})
targetedSpaceRequirement = &passingRequirement{}
factory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement)
deaApplicationRequirement = new(requirementsfakes.FakeDEAApplicationRequirement)
factory.NewDEAApplicationRequirementReturns(deaApplicationRequirement)
app := models.Application{}
app.InstanceCount = 1
app.GUID = "app-guid"
app.Name = "app-name"
deaApplicationRequirement.GetApplicationReturns(app)
})
Describe("Requirements", func() {
Context("when not provided one or two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name", "the-path", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("app-name")
})
. "github.com/onsi/gomega"
)
var _ = Describe("Flag Constructors", func() {
var (
fc flags.FlagContext
)
BeforeEach(func() {
fc = flags.New()
})
Describe("NewStringFlag()", func() {
It("init the flag context with a new string flagset", func() {
fc.Parse("-s", "test")
Ω(fc.IsSet("s")).To(BeFalse())
Ω(fc.String("s")).To(Equal(""))
fc.NewStringFlag("s", "s2", "setting new string flag")
fc.Parse("-s", "test2")
Ω(fc.IsSet("s")).To(BeTrue())
Ω(fc.IsSet("s2")).To(BeTrue())
Ω(fc.String("s")).To(Equal("test2"))
Ω(fc.String("s2")).To(Equal("test2"))
})
})
Describe("NewStringFlagWithDefault()", func() {
It("init the flag context with a new string flagset with default value", func() {
fc.Parse("-s", "test")
Expect(factory.NewLoginRequirementCallCount()).To(Equal(1))
Expect(actualRequirements).To(ContainElement(loginRequirement))
})
It("returns a TargetedSpaceRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
Expect(factory.NewTargetedSpaceRequirementCallCount()).To(Equal(1))
Expect(actualRequirements).To(ContainElement(targetedSpaceRequirement))
})
Context("when not provided exactly zero args", func() {
BeforeEach(func() {
flagContext.Parse("extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. No argument required"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
})
Describe("Execute", func() {
BeforeEach(func() {
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)
})
runCommand := func(args ...string) error {
err := flagContext.Parse(args...)
if err != nil {
return err
}
cmd.Execute(flagContext)
return nil
}
Describe("login requirements", func() {
It("fails if the user is not logged in", func() {
cmd.Requirements(requirementsFactory, flagContext)
Expect(requirementsFactory.NewLoginRequirementCallCount()).To(Equal(1))
})
factory = new(requirementsfakes.FakeFactory)
endpointRequirement = &passingRequirement{Name: "endpoint-requirement"}
factory.NewAPIEndpointRequirementReturns(endpointRequirement)
})
Describe("Requirements", func() {
It("returns an EndpointRequirement", func() {
actualRequirements := cmd.Requirements(factory, flagContext)
Expect(factory.NewAPIEndpointRequirementCallCount()).To(Equal(1))
Expect(actualRequirements).To(ContainElement(endpointRequirement))
})
Context("when not provided exactly zero args", func() {
BeforeEach(func() {
flagContext.Parse("domain-name")
})
It("fails with usage", func() {
var firstErr error
reqs := cmd.Requirements(factory, flagContext)
for _, req := range reqs {
err := req.Execute()
if err != nil {
firstErr = err
break
}
}
GUID: "fake-domain-guid",
Name: "fake-domain-name",
}
domainRequirement.GetDomainReturns(fakeDomain)
serviceInstanceRequirement = new(requirementsfakes.FakeServiceInstanceRequirement)
factory.NewServiceInstanceRequirementReturns(serviceInstanceRequirement)
minAPIVersionRequirement = &passingRequirement{Name: "min-api-version-requirement"}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("domain-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires DOMAIN and SERVICE_INSTANCE as arguments"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("domain-name", "service-instance")
})
factory = new(requirementsfakes.FakeFactory)
loginRequirement = &passingRequirement{Name: "login-requirement"}
factory.NewLoginRequirementReturns(loginRequirement)
minAPIVersionRequirement = &passingRequirement{Name: "min-api-version-requirement"}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
serviceInstanceRequirement = new(requirementsfakes.FakeServiceInstanceRequirement)
factory.NewServiceInstanceRequirementReturns(serviceInstanceRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("service-instance", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("service-instance")
})
reqFactory.NewLoginRequirementReturns(loginRequirement)
targetedSpaceRequirement = &passingRequirement{Name: "targeted-space-requirement"}
reqFactory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement)
applicationRequirement = new(requirementsfakes.FakeApplicationRequirement)
applicationRequirement.ExecuteReturns(nil)
reqFactory.NewApplicationRequirementReturns(applicationRequirement)
})
Describe("Requirements", func() {
BeforeEach(func() {
cmd.SetDependency(deps, false)
})
Context("when not provided exactly 1 argument", func() {
It("fails", func() {
err := flagContext.Parse("too", "many")
Expect(err).NotTo(HaveOccurred())
Expect(func() { cmd.Requirements(reqFactory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
var actualRequirements []requirements.Requirement
BeforeEach(func() {
err := flagContext.Parse("service-name")
Expect(err).NotTo(HaveOccurred())
actualRequirements = cmd.Requirements(reqFactory, flagContext)
loginRequirement = &passingRequirement{}
factory.NewLoginRequirementReturns(loginRequirement)
userRequirement = new(requirementsfakes.FakeUserRequirement)
userRequirement.ExecuteReturns(nil)
factory.NewUserRequirementReturns(userRequirement)
organizationRequirement = new(requirementsfakes.FakeOrganizationRequirement)
organizationRequirement.ExecuteReturns(nil)
factory.NewOrganizationRequirementReturns(organizationRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly three args", func() {
BeforeEach(func() {
flagContext.Parse("the-user-name", "the-org-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires USERNAME, ORG, ROLE as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided three args", func() {
BeforeEach(func() {
flagContext.Parse("the-user-name", "the-org-name", "OrgManager")
targetedOrgReq.ExecuteReturns(nil)
reqFactory.NewTargetedOrgRequirementReturns(targetedOrgReq)
spaceRequirement = new(requirementsfakes.FakeSpaceRequirement)
spaceRequirement.ExecuteReturns(nil)
reqFactory.NewSpaceRequirementReturns(spaceRequirement)
cmd = space.ShowSpace{}
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
cmd.SetDependency(deps, false)
})
Describe("Requirements", func() {
Context("when the wrong number of args are provided", func() {
BeforeEach(func() {
err := flagContext.Parse()
Expect(err).NotTo(HaveOccurred())
})
It("fails with no args", func() {
Expect(func() { cmd.Requirements(reqFactory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires an argument"},
))
})
})
Context("when provided exactly one arg", func() {
var actualRequirements []requirements.Requirement
BeforeEach(func() {
cmdFlagMap = make(map[string]flags.FlagSet)
cmdFlagMap["name"] = &flags.StringFlag{Name: "name", ShortName: "n", Usage: "test string flag"}
cmdFlagMap["skip"] = &flags.BoolFlag{Name: "skip", Usage: "test bool flag"}
cmdFlagMap["instance"] = &flags.IntFlag{Name: "instance", Usage: "test int flag"}
cmdFlagMap["float"] = &flags.Float64Flag{Name: "float", Usage: "test float64 flag"}
cmdFlagMap["skip2"] = &flags.BoolFlag{Name: "skip2", Usage: "test bool flag"}
cmdFlagMap["slice"] = &flags.StringSliceFlag{Name: "slice", Usage: "test stringSlice flag"}
fCtx = flags.NewFlagContext(cmdFlagMap)
})
It("accepts flags with either single '-' or double '-' ", func() {
err := fCtx.Parse("--name", "blue")
Expect(err).NotTo(HaveOccurred())
err = fCtx.Parse("-name", "")
Expect(err).NotTo(HaveOccurred())
})
It("sets a flag with it's full name", func() {
err := fCtx.Parse("-name", "blue")
Expect(err).NotTo(HaveOccurred())
Expect(fCtx.IsSet("name")).To(BeTrue())
Expect(fCtx.IsSet("n")).To(BeTrue())
Expect(fCtx.String("name")).To(Equal("blue"))
Expect(fCtx.String("n")).To(Equal("blue"))
})
Name: "fake-domain-name",
}
domainRequirement.GetDomainReturns(fakeDomain)
minAPIVersionRequirement = &passingRequirement{Name: "min-api-version-requirement"}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
AfterEach(func() {
command_registry.Register(originalCreateRouteCmd)
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires APP_NAME and DOMAIN as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("app-name", "domain-name")
factory.NewLoginRequirementReturns(loginRequirement)
targetedSpaceRequirement = &passingRequirement{Name: "targeted-space-requirement"}
factory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement)
applicationRequirement = new(requirementsfakes.FakeApplicationRequirement)
application := models.Application{}
application.GUID = "app-guid"
applicationRequirement.GetApplicationReturns(application)
factory.NewApplicationRequirementReturns(applicationRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("app-name", "extra-arg")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires APP_NAME as argument"},
))
})
})
Context("when provided exactly one arg", func() {
BeforeEach(func() {
flagContext.Parse("app-name")
})
fc = flags.New()
fc.NewStringSliceFlag("L", "", "")
fc.NewStringSliceFlag("command", "c", "")
fc.NewIntFlag("app-instance-index", "i", "")
fc.NewBoolFlag("skip-host-validation", "k", "")
fc.NewBoolFlag("skip-remote-execution", "N", "")
fc.NewBoolFlag("request-pseudo-tty", "t", "")
fc.NewBoolFlag("force-pseudo-tty", "tt", "")
fc.NewBoolFlag("disable-pseudo-tty", "T", "")
args = []string{}
parseError = nil
})
JustBeforeEach(func() {
err := fc.Parse(args...)
Expect(err).NotTo(HaveOccurred())
opts, parseError = options.NewSSHOptions(fc)
})
Context("when an app name is provided", func() {
Context("as the only argument", func() {
BeforeEach(func() {
args = append(args, "app-1")
})
It("populates the AppName field", func() {
Expect(parseError).NotTo(HaveOccurred())
Expect(opts.AppName).To(Equal("app-1"))
})
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
factory = &fakerequirements.FakeFactory{}
loginRequirement = &passingRequirement{Name: "login-requirement"}
factory.NewLoginRequirementReturns(loginRequirement)
targetedSpaceRequirement = &passingRequirement{Name: "targeted-space-requirement"}
factory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly four args", func() {
BeforeEach(func() {
flagContext.Parse("service-broker")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires SERVICE_BROKER, USERNAME, PASSWORD, URL as arguments"},
))
})
})
Context("when provided exactly four args", func() {
BeforeEach(func() {
flagContext.Parse("service-broker", "username", "password", "url")
})
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 when the routing API endpoint is not set", func() {
cmd.Requirements(requirementsFactory, flagContext)
Expect(requirementsFactory.NewRoutingAPIRequirementCallCount()).To(Equal(1))
})
It("should fail with usage", func() {
flagContext.Parse("blahblah")
cmd.Requirements(requirementsFactory, flagContext)
Expect(requirementsFactory.NewUsageRequirementCallCount()).To(Equal(1))
})
})
Describe("Execute", func() {
var err error
BeforeEach(func() {
err := flagContext.Parse()
Expect(err).NotTo(HaveOccurred())
})
JustBeforeEach(func() {
loginRequirement = &passingRequirement{}
factory.NewLoginRequirementReturns(loginRequirement)
userRequirement = new(requirementsfakes.FakeUserRequirement)
userRequirement.ExecuteReturns(nil)
factory.NewUserRequirementReturns(userRequirement)
organizationRequirement = new(requirementsfakes.FakeOrganizationRequirement)
organizationRequirement.ExecuteReturns(nil)
factory.NewOrganizationRequirementReturns(organizationRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly four args", func() {
BeforeEach(func() {
flagContext.Parse("the-user-name", "the-org-name", "the-space-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires USERNAME, ORG, SPACE, ROLE as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided four args", func() {
BeforeEach(func() {
flagContext.Parse("the-user-name", "the-org-name", "the-space-name", "SpaceManager")
}
cmd = &commands.Help{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
fakeFactory = &testreq.FakeReqFactory{}
})
AfterEach(func() {
buffer.Close()
})
Context("when no argument is provided", func() {
It("prints the main help menu of the 'cf' app", func() {
flagContext.Parse()
cmd.Execute(flagContext)
Eventually(buffer.Contents()).Should(ContainSubstring("A command line tool to interact with Cloud Foundry"))
Eventually(buffer).Should(gbytes.Say("CF_TRACE=true"))
})
})
Context("when a command name is provided as an argument", func() {
Context("When the command exists", func() {
It("prints the usage help for the command", func() {
flagContext.Parse("target")
cmd.Execute(flagContext)
Expect(fakeUI.SayCallCount()).To(Equal(1))
output, _ := fakeUI.SayArgsForCall(0)
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("buildpacks", args, requirementsFactory, updateCommandDependency, false)
}
Context("when arguments are provided", func() {
var cmd commandregistry.Command
var flagContext flags.FlagContext
BeforeEach(func() {
cmd = &buildpack.ListBuildpacks{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
})
It("should fail with usage", func() {
flagContext.Parse("blahblah")
reqs := cmd.Requirements(requirementsFactory, flagContext)
err := testcmd.RunRequirements(reqs)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Incorrect Usage"))
Expect(err.Error()).To(ContainSubstring("No argument required"))
})
})
It("fails requirements when login fails", func() {
Expect(runCommand()).To(BeFalse())
})
Context("when logged in", func() {
domainRequirement = &fakerequirements.FakeDomainRequirement{}
domainRequirement.GetDomainReturns(models.DomainFields{
Guid: "domain-guid",
Name: "domain-name",
})
factory.NewDomainRequirementReturns(domainRequirement)
minAPIVersionRequirement = &passingRequirement{}
factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement)
})
Describe("Requirements", func() {
Context("when not provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("space-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires SPACE and DOMAIN as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("space-name", "domain-name")