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"})) }) })