deps.RepoLocator = deps.RepoLocator.SetAuthenticationRepository(authRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("oauth-token").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} fakeLogger := new(tracefakes.FakePrinter) authRepo = new(authenticationfakes.FakeRepository) configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) deps = commandregistry.NewDependency(os.Stdout, fakeLogger, "") }) runCommand := func() bool { return testcmd.RunCLICommand("oauth-token", []string{}, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails when the user is not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).ToNot(HavePassedRequirements()) }) }) Describe("when logged in", func() { BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) }) It("fails if oauth refresh fails", func() {
serviceRepo = &apifakes.FakeServiceRepository{} serviceInstance := models.ServiceInstance{} serviceInstance.GUID = "fake-instance-guid" serviceInstance.Name = "fake-service-instance" serviceRepo.FindInstanceByNameReturns(serviceInstance, nil) serviceKeyRepo = apifakes.NewFakeServiceKeyRepo() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{}) serviceInstanceReq := new(requirementsfakes.FakeServiceInstanceRequirement) requirementsFactory.NewServiceInstanceRequirementReturns(serviceInstanceReq) serviceInstanceReq.GetServiceInstanceReturns(serviceInstance) }) var callCreateService = func(args []string) bool { return testcmd.RunCLICommand("create-service-key", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(callCreateService([]string{"fake-service-instance", "fake-service-key"})).To(BeFalse()) }) It("requires two arguments to run", func() { Expect(callCreateService([]string{})).To(BeFalse()) Expect(callCreateService([]string{"fake-arg-one"})).To(BeFalse()) Expect(callCreateService([]string{"fake-arg-one", "fake-arg-two", "fake-arg-three"})).To(BeFalse()) }) It("fails when service instance is not found", func() {
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetBuildpackRepository(buildpackRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("buildpacks").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} buildpackRepo = new(apifakes.OldFakeBuildpackRepository) requirementsFactory = new(requirementsfakes.FakeFactory) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("buildpacks", args, requirementsFactory, updateCommandDependency, false, ui) } 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")
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetEnvironmentVariableGroupsRepository(environmentVariableGroupRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("staging-environment-variable-group").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) environmentVariableGroupRepo = new(environmentvariablegroupsfakes.FakeRepository) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("staging-environment-variable-group", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("requires the user to be logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).ToNot(HavePassedRequirements()) }) Context("when arguments are provided", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &environmentvariablegroup.StagingEnvironmentVariableGroup{} cmd.SetDependency(deps, false)
{Name: "service-plan-d", Free: true}}, ServiceOfferingFields: models.ServiceOfferingFields{ Label: "aaa-my-service-offering", Description: "service offering 2 description", }, } fakeServiceOfferings = []models.ServiceOffering{serviceWithAPaidPlan, service2} }) Describe("Requirements", func() { Context("when the an API endpoint is not targeted", func() { It("does not meet its requirements", func() { config = testconfig.NewRepository() requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Failing{Message: "no api"}) Expect(testcmd.RunCLICommand("marketplace", []string{}, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse()) }) Context("when arguments are provided", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &service.MarketplaceServices{} cmd.SetDependency(deps, false) flagContext = flags.NewFlagContext(cmd.MetaData().Flags) }) It("should fail with usage", func() { flagContext.Parse("blahblah")
OriginalCommand = commandregistry.Commands.FindCommand("restart") appRestarter = new(applicationfakes.FakeRestarter) //setup fakes to correctly interact with commandregistry appRestarter.SetDependencyStub = func(_ commandregistry.Dependency, _ bool) commandregistry.Command { return appRestarter } appRestarter.MetaDataReturns(commandregistry.CommandMetadata{Name: "restart"}) }) AfterEach(func() { commandregistry.Register(OriginalCommand) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("copy-source", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirement failures", func() { It("when not logged in", func() { requirementsFactory.NewUsageRequirementReturns(requirements.Passing{}) requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand("source-app", "target-app")).ToNot(HavePassedRequirements()) }) It("when a space is not targeted", func() { requirementsFactory.NewUsageRequirementReturns(requirements.Passing{}) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"}) Expect(runCommand("source-app", "target-app")).ToNot(HavePassedRequirements()) })
config = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) authRepo = new(authenticationfakes.FakeRepository) authRepo.AuthenticateStub = func(credentials map[string]string) error { config.SetAccessToken("my-access-token") config.SetRefreshToken("my-refresh-token") return nil } fakeLogger = new(tracefakes.FakePrinter) deps = commandregistry.NewDependency(os.Stdout, fakeLogger, "") }) Describe("requirements", func() { It("fails with usage when given too few arguments", func() { testcmd.RunCLICommand("auth", []string{}, requirementsFactory, updateCommandDependency, false, ui) Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "arguments"}, )) }) It("fails if the user has not set an api endpoint", func() { requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Failing{Message: "no api set"}) Expect(testcmd.RunCLICommand("auth", []string{"username", "password"}, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse()) }) }) Context("when an api endpoint is targeted", func() { BeforeEach(func() { requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Passing{})
application.GUID = "my-app-guid" application.InstanceCount = 1 applicationReq := new(requirementsfakes.FakeApplicationRequirement) applicationReq.GetApplicationReturns(application) requirementsFactory.NewApplicationRequirementReturns(applicationReq) }) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = config deps.RepoLocator = deps.RepoLocator.SetAppInstancesRepository(appInstancesRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("restart-app-instance").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("restart-app-instance", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails if not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand("my-app", "0")).To(BeFalse()) }) It("fails if a space is not targeted", func() { requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not targeting space"}) Expect(runCommand("my-app", "0")).To(BeFalse()) }) It("fails when there is not exactly two arguments", func() { Expect(runCommand("my-app")).To(BeFalse())
deps.RepoLocator = deps.RepoLocator.SetBuildpackRepository(repo) deps.RepoLocator = deps.RepoLocator.SetBuildpackBitsRepository(bitsRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("create-buildpack").SetDependency(deps, pluginCall)) } 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)
var ( pwDeps passwordDeps ui *testterm.FakeUI deps commandregistry.Dependency ) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = pwDeps.Config deps.RepoLocator = deps.RepoLocator.SetPasswordRepository(pwDeps.PwdRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("passwd").SetDependency(deps, pluginCall)) } callPassword := func(inputs []string, pwDeps passwordDeps) (*testterm.FakeUI, bool) { ui = &testterm.FakeUI{Inputs: inputs} passed := testcmd.RunCLICommand("passwd", []string{}, pwDeps.ReqFactory, updateCommandDependency, false, ui) return ui, passed } BeforeEach(func() { pwDeps = getPasswordDeps() }) It("does not pass requirements if you are not logged in", func() { pwDeps.ReqFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) _, passed := callPassword([]string{}, pwDeps) Expect(passed).To(BeFalse()) }) Context("when logged in successfully", func() { BeforeEach(func() {
} BeforeEach(func() { org := models.OrganizationFields{} org.Name = "MyOrg" space := models.SpaceFields{} space.Name = "MySpace" config = testconfig.NewRepository() config.SetAccessToken("MyAccessToken") config.SetOrganizationFields(org) config.SetSpaceFields(space) ui = &testterm.FakeUI{} testcmd.RunCLICommand("logout", []string{}, nil, updateCommandDependency, false, ui) }) It("clears access token from the config", func() { Expect(config.AccessToken()).To(Equal("")) }) It("clears organization fields from the config", func() { Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{})) }) It("clears space fields from the config", func() { Expect(config.SpaceFields()).To(Equal(models.SpaceFields{})) }) })
deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetServiceBrokerRepository(serviceBrokerRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("rename-service-broker").SetDependency(deps, pluginCall)) } BeforeEach(func() { configRepo = testconfig.NewRepositoryWithDefaults() ui = &testterm.FakeUI{} requirementsFactory = new(requirementsfakes.FakeFactory) serviceBrokerRepo = new(apifakes.FakeServiceBrokerRepository) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("rename-service-broker", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails with usage when not invoked with exactly two args", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) runCommand("welp") 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("okay", "DO---IIIIT")).To(BeFalse()) })
BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) appRepo = new(applicationsfakes.FakeRepository) }) updateCommandDependency := func(pluginCall bool) { 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"})
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("config").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) }) runCommand := func(args ...string) { testcmd.RunCLICommand("config", args, requirementsFactory, updateCommandDependency, false, ui) } It("fails requirements when no flags are provided", func() { runCommand() Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage"}, )) }) Context("--async-timeout flag", func() { It("stores the timeout in minutes when the --async-timeout flag is provided", func() { runCommand("--async-timeout", "12") Expect(configRepo.AsyncTimeout()).Should(Equal(uint(12))) })
deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetSpaceQuotaRepository(quotaRepo) deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("unset-space-quota").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() quotaRepo = new(spacequotasfakes.FakeSpaceQuotaRepository) spaceRepo = new(spacesfakes.FakeSpaceRepository) requirementsFactory = new(requirementsfakes.FakeFactory) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("unset-space-quota", args, requirementsFactory, updateCommandDependency, false, ui) } It("fails with usage when provided too many or two few args", func() { runCommand("space") Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "arguments"}, )) runCommand("space", "quota", "extra-stuff") Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "arguments"}, )) }) Describe("requirements", func() {
deps.ServiceHandler = actor deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("service-access").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} actor = new(actorsfakes.FakeServiceActor) requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) authRepo = new(authenticationfakes.FakeRepository) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("service-access", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("requires the user to be logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).ToNot(HavePassedRequirements()) }) Context("when arguments are provided", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &serviceaccess.ServiceAccess{} cmd.SetDependency(deps, false)
deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetFeatureFlagRepository(flagRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("disable-feature-flag").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) flagRepo = new(featureflagsfakes.FakeFeatureFlagRepository) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("disable-feature-flag", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("requires the user to be logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).ToNot(HavePassedRequirements()) }) It("fails with usage if a single feature is not specified", func() { runCommand() Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires an argument"}, )) }) })
deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("unbind-security-group").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} requirementsFactory = new(requirementsfakes.FakeFactory) securityGroupRepo = new(securitygroupsfakes.FakeSecurityGroupRepo) orgRepo = new(organizationsfakes.FakeOrganizationRepository) spaceRepo = new(spacesapifakes.FakeSpaceRepository) secBinder = new(spacesfakes.FakeSecurityGroupSpaceBinder) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("unbind-security-group", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("should fail if not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand("my-group")).To(BeFalse()) }) It("should fail with usage when not provided with any arguments", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) runCommand() Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "arguments"}, )) })
deps.RepoLocator = deps.RepoLocator.SetServiceAuthTokenRepository(authTokenRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete-service-auth-token").SetDependency(deps, pluginCall)) } BeforeEach(func() { 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()) })
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetDomainRepository(domainRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete-shared-domain").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} domainRepo = new(apifakes.FakeDomainRepository) requirementsFactory = new(requirementsfakes.FakeFactory) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("delete-shared-domain", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails if you are not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand("foo.com")).To(BeFalse()) }) It("fails if an organiztion is not targeted", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) targetedOrganizationReq := new(requirementsfakes.FakeTargetedOrgRequirement) targetedOrganizationReq.ExecuteReturns(errors.New("not targeted")) requirementsFactory.NewTargetedOrgRequirementReturns(targetedOrganizationReq)
deps.Config = config commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("migrate-service-instances").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} config = testconfig.NewRepository() serviceRepo = new(apifakes.FakeServiceRepository) requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) args = []string{} }) Describe("requirements", func() { It("requires you to be logged in", func() { Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse()) }) It("requires five arguments to run", func() { args = []string{"one", "two", "three"} Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse()) }) It("requires CC API version 2.47 or lower", func() { requirementsFactory.NewMaxAPIVersionRequirementReturns(requirements.Failing{Message: "max api version not met"}) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) args = []string{"one", "two", "three", "four", "five"} ui.Inputs = append(ui.Inputs, "no") Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse())
) BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) }) 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())
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = config commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("list-plugin-repos").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} requirementsFactory = new(requirementsfakes.FakeFactory) config = testconfig.NewRepositoryWithDefaults() }) var callListPluginRepos = func(args ...string) bool { return testcmd.RunCLICommand("list-plugin-repos", args, requirementsFactory, updateCommandDependency, false, ui) } It("lists all added plugin repo in a table", func() { config.SetPluginRepo(models.PluginRepo{ Name: "repo1", URL: "http://url1.com", }) config.SetPluginRepo(models.PluginRepo{ Name: "repo2", URL: "http://url2.com", }) callListPluginRepos() Expect(ui.Outputs()).To(ContainSubstrings(
deps.Config = config commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("curl").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} config = testconfig.NewRepository() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Passing{}) 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() {
pluginFile, err = ioutil.TempFile("./", "test_plugin") Expect(err).ToNot(HaveOccurred()) if runtime.GOOS != "windows" { err = os.Chmod(test_1, 0700) Expect(err).ToNot(HaveOccurred()) } }) AfterEach(func() { os.Remove(filepath.Join(curDir, pluginFile.Name())) os.Remove(homeDir) }) 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'"})) })
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("stacks").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} config = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) repo = new(stacksfakes.FakeStackRepository) }) Describe("login requirements", func() { It("fails if the user is not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(testcmd.RunCLICommand("stacks", []string{}, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse()) }) Context("when arguments are provided", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &commands.ListStacks{} cmd.SetDependency(deps, false) flagContext = flags.NewFlagContext(cmd.MetaData().Flags) }) It("should fail with usage", func() { flagContext.Parse("blahblah")
app2.Name = "Application-2" app2.GUID = "Application-2-guid" app2.State = "started" app2.RunningInstances = 1 app2.InstanceCount = 2 app2.Memory = 256 app2.DiskQuota = 1024 app2.Routes = app2Routes appSummaryRepo.GetSummariesInCurrentSpaceApps = []models.Application{app, app2} deps = commandregistry.NewDependency(os.Stdout, new(tracefakes.FakePrinter), "") }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("apps", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &application.ListApps{} cmd.SetDependency(deps, false) flagContext = flags.NewFlagContext(cmd.MetaData().Flags) }) It("requires the user to be logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetUserRepository(userRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("org-users").SetDependency(deps, pluginCall)) } BeforeEach(func() { 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()) })
BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) spaceRepo = new(spacesfakes.FakeSpaceRepository) }) updateCommandDependency := func(pluginCall bool) { 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"})
spaceRepo.ListSpacesStub = listSpacesStub([]models.Space{space1, space2}) spaceRepo.FindByNameStub = func(name string) (models.Space, error) { m := map[string]models.Space{ space1.Name: space1, space2.Name: space2, } return m[name], nil } }) It("lets the user select an org and space by number", func() { orgRepo.FindByNameReturns(org2, nil) OUT_OF_RANGE_CHOICE := "3" ui.Inputs = []string{"api.example.com", "*****@*****.**", "password", OUT_OF_RANGE_CHOICE, "2", OUT_OF_RANGE_CHOICE, "1"} testcmd.RunCLICommand("login", Flags, nil, updateCommandDependency, false, ui) Expect(ui.Outputs()).To(ContainSubstrings( []string{"Select an org"}, []string{"1. some-org"}, []string{"2. my-new-org"}, []string{"Select a space"}, []string{"1. my-space"}, []string{"2. some-space"}, )) Expect(Config.OrganizationFields().GUID).To(Equal("my-new-org-guid")) Expect(Config.SpaceFields().GUID).To(Equal("my-space-guid")) Expect(Config.AccessToken()).To(Equal("my_access_token")) Expect(Config.RefreshToken()).To(Equal("my_refresh_token"))