runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("space-ssh-allowed", args, requirementsFactory, updateCommandDependency, false, ui)
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = new(requirementsfakes.FakeFactory)
})
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-space")).To(BeFalse())
})
It("does not pass requirements if org is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
targetedOrgReq := new(requirementsfakes.FakeTargetedOrgRequirement)
targetedOrgReq.ExecuteReturns(errors.New("no org targeted"))
requirementsFactory.NewTargetedOrgRequirementReturns(targetedOrgReq)
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("install-plugin", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when not provided a path to the plugin executable", func() {
Expect(runCommand()).ToNot(HavePassedRequirements())
})
})
Context("when the -f flag is not provided", func() {
Context("and the user responds with 'y'", func() {
It("continues to install the plugin", func() {
ui.Inputs = []string{"y"}
runCommand("pluggy", "-r", "somerepo")
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Looking up 'pluggy' from repository 'somerepo'"}))
})
})
Context("but the user responds with 'n'", func() {
It("quits with a message", func() {
ui.Inputs = []string{"n"}
runCommand("pluggy", "-r", "somerepo")
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Plugin installation cancelled"}))
})
})
})
Describe("Locating binary file", func() {
Describe("install from plugin repository when '-r' provided", func() {
It("lists buildpacks", func() {
p1 := 5
p2 := 10
p3 := 15
t := true
f := false
buildpackRepo.Buildpacks = []models.Buildpack{
{Name: "Buildpack-1", Position: &p1, Enabled: &t, Locked: &f},
{Name: "Buildpack-2", Position: &p2, Enabled: &f, Locked: &t},
{Name: "Buildpack-3", Position: &p3, Enabled: &t, Locked: &f},
}
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Getting buildpacks"},
[]string{"buildpack", "position", "enabled"},
[]string{"Buildpack-1", "5", "true", "false"},
[]string{"Buildpack-2", "10", "false", "true"},
[]string{"Buildpack-3", "15", "true", "false"},
))
})
It("tells the user if no build packs exist", func() {
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Getting buildpacks"},
[]string{"No buildpacks found"},
))
})
ui = &testterm.FakeUI{Inputs: []string{"y"}}
authTokenRepo = new(apifakes.OldFakeAuthTokenRepo)
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewMaxAPIVersionRequirementReturns(requirements.Passing{})
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("delete-service-auth-token", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when fewer than two arguments are given", func() {
runCommand("yurp")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand()).To(BeFalse())
})
It("requires CC API version 2.47 or lower", func() {
requirementsFactory.NewMaxAPIVersionRequirementReturns(requirements.Failing{Message: "max api 2.47"})
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
Expect(runCommand("one", "two")).To(BeFalse())
})
})
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
logsRepo = new(logsfakes.FakeRepository)
requirementsFactory = new(requirementsfakes.FakeFactory)
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("logs", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when called without one argument", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{})
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"})
Expect(runCommand("--recent", "my-app")).To(BeFalse())
})
deps.UI = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo)
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("disable-ssh").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("disable-ssh", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
Expect(runCommand("my-app", "none")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"})
Expect(runCommand("my-app", "none")).To(BeFalse())
})
})
config.SetSpaceFields(models.SpaceFields{})
spaceRepo.FindByNameReturns(models.Space{}, errors.New("Error finding space by name."))
callTarget([]string{"-o", "my-organization", "-s", "my-space"})
Expect(orgRepo.FindByNameCallCount()).To(Equal(1))
Expect(orgRepo.FindByNameArgsForCall(0)).To(Equal("my-organization"))
Expect(config.OrganizationFields().GUID).To(Equal("my-organization-guid"))
Expect(spaceRepo.FindByNameCallCount()).To(Equal(1))
Expect(spaceRepo.FindByNameArgsForCall(0)).To(Equal("my-space"))
Expect(config.SpaceFields().GUID).To(Equal(""))
Expect(ui.ShowConfigurationCalled).To(BeFalse())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Unable to access space", "my-space"},
))
})
Describe("when there is only a single space", func() {
It("target space automatically ", func() {
space := models.Space{}
space.Name = "my-space"
space.GUID = "my-space-guid"
spaceRepo.FindByNameReturns(space, nil)
spaceRepo.ListSpacesStub = listSpacesStub([]models.Space{space})
callTarget([]string{"-o", "my-organization"})
ServiceInstanceURL: "fake-service-instance-url",
},
Credentials: map[string]interface{}{
"username": "******",
"password": "******",
"host": "fake-host",
"port": "3306",
"database": "fake-db-name",
"uri": "mysql://*****:*****@fake-host:3306/fake-db-name",
},
}
})
It("gets service credential", func() {
callGetServiceKey([]string{"fake-service-instance", "fake-service-key"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Getting key", "fake-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
[]string{"username", "fake-username"},
[]string{"password", "fake-password"},
[]string{"host", "fake-host"},
[]string{"port", "3306"},
[]string{"database", "fake-db-name"},
[]string{"uri", "mysql://*****:*****@fake-host:3306/fake-db-name"},
))
Expect(ui.Outputs()[1]).To(BeEmpty())
Expect(serviceKeyRepo.GetServiceKeyMethod.InstanceGUID).To(Equal("fake-service-instance-guid"))
})
It("gets service guid when '--guid' flag is provided", func() {
callGetServiceKey([]string{"--guid", "fake-service-instance", "fake-service-key"})
},
}, nil
}
return []models.V3Route{
{
Host: "route-2-host",
Path: "",
},
}, nil
}
})
It("prints a table of the results", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
outputs := make([]string, len(ui.Outputs()))
for i := range ui.Outputs() {
outputs[i] = terminal.Decolorize(ui.Outputs()[i])
}
Expect(outputs).To(ConsistOf(
MatchRegexp(`name.*requested state.*instances.*memory.*disk.*urls`),
MatchRegexp("app-1-name.*stopped.*1.*1G.*2G.*route-1-host/route-1-path, route-1-host-2"),
MatchRegexp("app-2-name.*running.*2.*512M.*1G.*route-2-host"),
))
})
})
Context("when getting the routes fails", func() {
BeforeEach(func() {
repository.GetRoutesReturns([]models.V3Route{}, errors.New("get-routes-err"))
})
BeforeEach(func() {
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
repo = new(apifakes.OldFakeBuildpackRepository)
bitsRepo = new(apifakes.FakeBuildpackBitsRepository)
ui = &testterm.FakeUI{}
})
It("fails requirements when the user is not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(testcmd.RunCLICommand("create-buildpack", []string{"my-buildpack", "my-dir", "0"}, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse())
})
It("fails with usage when given fewer than three arguments", func() {
testcmd.RunCLICommand("create-buildpack", []string{}, requirementsFactory, updateCommandDependency, false, ui)
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
Context("when a file is provided", func() {
It("prints error and do not call create buildpack", func() {
bitsRepo.CreateBuildpackZipFileReturns(nil, "", fmt.Errorf("create buildpack error"))
testcmd.RunCLICommand("create-buildpack", []string{"my-buildpack", "file", "5"}, requirementsFactory, updateCommandDependency, false, ui)
Expect(ui.Outputs()).To(ContainSubstrings([]string{"FAILED"}))
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Failed to create a local temporary zip file for the buildpack"}))
Expect(ui.Outputs()).NotTo(ContainSubstrings([]string{"Creating buildpack"}))
})
},
nil,
)
})
It("refreshes the auth token", func() {
runCommand()
Expect(authRepo.RefreshAuthTokenCallCount()).To(Equal(1))
})
Context("when refreshing the auth token fails", func() {
It("fails and returns the error", func() {
authRepo.RefreshAuthTokenReturns("", errors.New("Refreshing went wrong"))
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Refreshing went wrong"},
[]string{"FAILED"},
))
})
})
Context("When no flags are provided", func() {
It("tells the user it is obtaining the service access", func() {
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Getting service access as", "my-user"},
))
})
It("prints all of the brokers", func() {
applicationReq := new(requirementsfakes.FakeApplicationRequirement)
applicationReq.GetApplicationReturns(app)
requirementsFactory.NewApplicationRequirementReturns(applicationReq)
updateCommandDependency(logRepo)
cmd := commandregistry.Commands.FindCommand("start").(*Start)
cmd.StagingTimeout = 0
cmd.PingerThrottle = 1
cmd.StartupTimeout = 1
commandregistry.Register(cmd)
})
It("can still respond to staging failures", func() {
testcmd.RunCLICommandWithoutDependency("start", []string{"my-app"}, requirementsFactory, ui)
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"my-app"},
[]string{"FAILED"},
[]string{"BLAH, FAILED"},
))
})
})
Context("when the timeout happens exactly when the connection is established", func() {
var startWait *sync.WaitGroup
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
configRepo = testconfig.NewRepositoryWithDefaults()
logRepo.TailLogsForStub = func(appGUID string, onConnect func(), logChan chan<- logs.Loggable, errChan chan<- error) {
It("fails when the user is not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"})
Expect(runCommand("my-app")).To(BeFalse())
})
})
It("fails with usage when no app name is given", func() {
passed := runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
Expect(passed).To(BeFalse())
})
It("fails with usage when the app cannot be found", func() {
appRepo.ReadReturns(models.Application{}, errors.NewModelNotFoundError("app", "hocus-pocus"))
runCommand("hocus-pocus")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"not found"},
))
})
deps.UI = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo)
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("get-health-check").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("get-health-check", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"get-health-check"},
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"})
Expect(runCommand("my-app")).To(BeFalse())
})
BeforeEach(func() {
ui = &testterm.FakeUI{}
deps := commandregistry.Dependency{
UI: ui,
}
cmd = &commands.Version{}
cmd.SetDependency(deps, false)
})
Describe("Execute", func() {
var flagContext flags.FlagContext
BeforeEach(func() {
cf.Version = "5.0.0"
cf.Name = "my-special-cf"
cf.BuiltOnDate = "2016-02-29"
})
It("prints the version", func() {
cmd.Execute(flagContext)
Expect(ui.Outputs()).To(Equal([]string{
"my-special-cf version 5.0.0-2016-02-29",
}))
})
})
})
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() {
_, err := cmd.Requirements(factory, flagContext)
Expect(err).To(HaveOccurred())
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")
})
It("returns a LoginRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
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() {
_, err := cmd.Requirements(factory, flagContext)
Expect(err).To(HaveOccurred())
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")
})
It("returns a LoginRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
Expect(factory.NewLoginRequirementCallCount()).To(Equal(1))
BeforeEach(func() {
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
domainRepo = new(apifakes.FakeDomainRepository)
configRepo = testconfig.NewRepositoryWithAccessToken(coreconfig.TokenInfo{Username: "******"})
})
runCommand := func(args ...string) bool {
ui = new(testterm.FakeUI)
return testcmd.RunCLICommand("create-domain", args, requirementsFactory, updateCommandDependency, false, ui)
}
It("fails with usage", func() {
runCommand("")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
runCommand("org1")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
Context("checks login", func() {
It("passes when logged in", func() {
fakeOrgRequirement := new(requirementsfakes.FakeOrganizationRequirement)
fakeOrgRequirement.GetOrganizationReturns(models.Organization{
OrganizationFields: models.OrganizationFields{
Name: "my-org",
Expect(callCreateService([]string{"cleardb", "spark", "my-cleardb-service"})).To(BeFalse())
})
It("fails when a space is not targeted", func() {
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeted"})
Expect(callCreateService([]string{"cleardb", "spark", "my-cleardb-service"})).To(BeFalse())
})
})
It("successfully creates a service", func() {
callCreateService([]string{"cleardb", "spark", "my-cleardb-service"})
spaceGUID, serviceName := serviceBuilder.GetServicesByNameForSpaceWithPlansArgsForCall(0)
Expect(spaceGUID).To(Equal(config.SpaceFields().GUID))
Expect(serviceName).To(Equal("cleardb"))
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service instance", "my-cleardb-service", "my-org", "my-space", "my-user"},
[]string{"OK"},
))
name, planGUID, _, _ := serviceRepo.CreateServiceInstanceArgsForCall(0)
Expect(name).To(Equal("my-cleardb-service"))
Expect(planGUID).To(Equal("cleardb-spark-guid"))
})
Context("when passing in tags", func() {
It("sucessfully creates a service and passes the tags as json", func() {
callCreateService([]string{"cleardb", "spark", "my-cleardb-service", "-t", "tag1, tag2,tag3, tag4"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service instance", "my-cleardb-service", "my-org", "my-space", "my-user"},
[]string{"OK"},
updateCommandDependency := func(pluginCall bool) {
deps.UI = ui
deps.Config = configRepo
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("ssh-enabled").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("ssh-enabled", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
Expect(runCommand("my-app", "none")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"})
Expect(runCommand("my-app", "none")).To(BeFalse())
})
})
callRemovePluginRepo("repo1")
Expect(len(config.PluginRepos())).To(Equal(1))
Expect(config.PluginRepos()[0].Name).To(Equal("repo2"))
Expect(config.PluginRepos()[0].URL).To(Equal("http://server2.org:8080"))
})
})
Context("When named repo doesn't exist", func() {
BeforeEach(func() {
config.SetPluginRepo(models.PluginRepo{
Name: "repo1",
URL: "http://someserver1.com:1234",
})
config.SetPluginRepo(models.PluginRepo{
Name: "repo2",
URL: "http://server2.org:8080",
})
})
It("doesn't change the config the config", func() {
callRemovePluginRepo("fake-repo")
Expect(len(config.PluginRepos())).To(Equal(2))
Expect(config.PluginRepos()[0].Name).To(Equal("repo1"))
Expect(config.PluginRepos()[0].URL).To(Equal("http://someserver1.com:1234"))
Expect(ui.Outputs()).To(ContainSubstrings([]string{"fake-repo", "does not exist as a repo"}))
})
})
})
curlRepo = new(apifakes.OldFakeCurlRepository)
trace.LoggingToStdout = false
})
runCurlWithInputs := func(args []string) bool {
return testcmd.RunCLICommand("curl", args, requirementsFactory, updateCommandDependency, false, ui)
}
runCurlAsPluginWithInputs := func(args []string) bool {
return testcmd.RunCLICommand("curl", args, requirementsFactory, updateCommandDependency, true, ui)
}
It("fails with usage when not given enough input", func() {
runCurlWithInputs([]string{})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "An argument is missing or not correctly enclosed"},
))
})
Context("requirements", func() {
Context("when no api is set", func() {
BeforeEach(func() {
requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Failing{Message: "no api set"})
})
It("fails", func() {
Expect(runCurlWithInputs([]string{"/foo"})).To(BeFalse())
})
})
})
})
Describe("migrating service instances", func() {
BeforeEach(func() {
requirementsFactory.NewMaxAPIVersionRequirementReturns(requirements.Passing{})
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
args = []string{"v1-service-label", "v1-provider-name", "v1-plan-name", "v2-service-label", "v2-plan-name"}
serviceRepo.GetServiceInstanceCountForServicePlanReturns(1, nil)
})
It("displays the warning and the prompt including info about the instances and plan to migrate", func() {
ui.Inputs = []string{""}
testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false, ui)
Expect(ui.Outputs()).To(ContainSubstrings([]string{"WARNING:", "this operation is to replace a service broker"}))
Expect(ui.Prompts).To(ContainSubstrings(
[]string{"Really migrate", "1 service instance",
"from plan", "v1-service-label", "v1-provider-name", "v1-plan-name",
"to", "v2-service-label", "v2-plan-name"},
))
})
Context("when the user confirms", func() {
BeforeEach(func() {
ui.Inputs = []string{"yes"}
})
Context("when the v1 and v2 service instances exists", func() {
BeforeEach(func() {
var findServicePlanByDescriptionCallCount int
factory.NewTargetedOrgRequirementReturns(targetedOrgRequirement)
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("app-name")
})
It("fails with usage", func() {
_, err := cmd.Requirements(factory, flagContext)
Expect(err).To(HaveOccurred())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage. Requires host and domain as arguments"},
))
})
})
Context("when provided exactly two args", func() {
BeforeEach(func() {
flagContext.Parse("domain-name", "host-name")
})
It("returns a LoginRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
Expect(factory.NewLoginRequirementCallCount()).To(Equal(1))
Apps: []models.ApplicationFields{app1, app2},
Port: 9090,
}
cb(route)
cb(route2)
cb(route3)
return nil
}
})
It("lists routes", func() {
runCommand()
Expect(ui.Outputs()).To(BeInDisplayOrder(
[]string{"Getting routes for org my-org / space my-space as my-user ..."},
[]string{"space", "host", "domain", "port", "path", "type", "apps", "service"},
))
Expect(terminal.Decolorize(ui.Outputs()[3])).To(MatchRegexp(`^my-space\s+hostname-1\s+example.com\s+dora\s+test-service\s*$`))
Expect(terminal.Decolorize(ui.Outputs()[4])).To(MatchRegexp(`^my-space\s+hostname-2\s+cookieclicker\.co\s+/foo\s+dora,bora\s*$`))
Expect(terminal.Decolorize(ui.Outputs()[5])).To(MatchRegexp(`^my-space\s+cookieclicker\.co\s+9090\s+tcp\s+dora,bora\s*$`))
})
})
Context("when there are routes in different spaces", func() {
BeforeEach(func() {
routeRepo.ListAllRoutesStub = func(cb func(models.Route) bool) error {
space1 := models.SpaceFields{Name: "space-1"}
OrganizationFields: models.OrganizationFields{
Name: "some-org",
},
},
)
spaceRepo.FindByNameInOrgReturns(
models.Space{
SpaceFields: models.SpaceFields{
Name: "whatever-space",
},
}, nil)
requirementsFactory.NewOrganizationRequirementReturns(organizationReq)
passed := runCommand("some-org", "whatever-space")
Expect(passed).To(BeTrue())
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Getting users in org some-org / space whatever-space as my-user"}))
})
})
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.NewLoginRequirementReturns(requirements.Passing{})
org := models.Organization{}
app = models.Application{}
app.Name = "my-app"
app.GUID = "my-app-guid"
app.State = "started"
})
JustBeforeEach(func() {
appRepo.ReadReturns(app, nil)
applicationReq := new(requirementsfakes.FakeApplicationRequirement)
applicationReq.GetApplicationReturns(app)
requirementsFactory.NewApplicationRequirementReturns(applicationReq)
})
It("fails with usage when the app name is not given", func() {
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("stops the app with the given name", func() {
runCommand("my-app")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Stopping app", "my-app", "my-org", "my-space", "my-user"},
[]string{"OK"},
))
appGUID, _ := appRepo.UpdateArgsForCall(0)
Expect(appGUID).To(Equal("my-app-guid"))
})
ui = &testterm.FakeUI{}
userRepo = new(apifakes.FakeUserRepository)
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = new(requirementsfakes.FakeFactory)
deps = commandregistry.NewDependency(os.Stdout, new(tracefakes.FakePrinter), "")
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("org-users", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when invoked without an org name", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("fails when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
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
)
deps.UI = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("allow-space-ssh").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("allow-space-ssh", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-space")).To(BeFalse())
})
It("does not pass requirements if org is not targeted", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
targetedOrgReq := new(requirementsfakes.FakeTargetedOrgRequirement)
targetedOrgReq.ExecuteReturns(errors.New("no org targeted"))
requirementsFactory.NewTargetedOrgRequirementReturns(targetedOrgReq)
config.SetPluginRepo(models.PluginRepo{
Name: "repo2",
URL: "",
})
})
Context("If repo name is provided by '-r'", func() {
It("list plugins from just the named repo", func() {
err := callRepoPlugins("-r", "repo2")
Expect(err).NotTo(HaveOccurred())
Expect(fakePluginRepo.GetPluginsArgsForCall(0)[0].Name).To(Equal("repo2"))
Expect(len(fakePluginRepo.GetPluginsArgsForCall(0))).To(Equal(1))
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Getting plugins from repository 'repo2'"}))
})
})
Context("If no repo name is provided", func() {
It("list plugins from just the named repo", func() {
err := callRepoPlugins()
Expect(err).NotTo(HaveOccurred())
Expect(fakePluginRepo.GetPluginsArgsForCall(0)[0].Name).To(Equal("repo1"))
Expect(len(fakePluginRepo.GetPluginsArgsForCall(0))).To(Equal(2))
Expect(fakePluginRepo.GetPluginsArgsForCall(0)[1].Name).To(Equal("repo2"))
Expect(ui.Outputs()).To(ContainSubstrings([]string{"Getting plugins from all repositories"}))
})
})
