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.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("set-env").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} app = models.Application{} app.Name = "my-app" app.GUID = "my-app-guid" appRepo = new(applicationsfakes.FakeApplicationRepository) requirementsFactory = &testreq.FakeReqFactory{} configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("set-env", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("fails when login is not successful", func() { requirementsFactory.Application = app requirementsFactory.TargetedSpaceSuccess = true Expect(runCommand("hey", "gabba", "gabba")).To(BeFalse()) }) It("fails when a space is not targeted", func() { requirementsFactory.Application = app requirementsFactory.LoginSuccess = true Expect(runCommand("hey", "gabba", "gabba")).To(BeFalse())
deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("routes").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{}) routeRepo = new(apifakes.FakeRouteRepository) domainRepo = new(apifakes.FakeDomainRepository) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("routes", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("login requirements", func() { It("fails if the user is not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).To(BeFalse()) }) It("fails when an org and space is not targeted", func() { requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).To(BeFalse()) }) Context("when arguments are provided", func() {
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = config commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("remove-plugin-repo").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} requirementsFactory = &testreq.FakeReqFactory{} config = testconfig.NewRepositoryWithDefaults() }) var callRemovePluginRepo = func(args ...string) bool { return testcmd.RunCLICommand("remove-plugin-repo", args, requirementsFactory, updateCommandDependency, false) } Context("When repo name is valid", 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", }) })
BeforeEach(func() { ui = &testterm.FakeUI{} config = testconfig.NewRepositoryWithDefaults() serviceRepo = &apifakes.FakeServiceRepository{} serviceInstance := models.ServiceInstance{} serviceInstance.GUID = "fake-service-instance-guid" serviceRepo.FindInstanceByNameReturns(serviceInstance, nil) serviceKeyRepo = apifakes.NewFakeServiceKeyRepo() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{}) }) var callDeleteServiceKey = func(args []string) bool { return testcmd.RunCLICommand("delete-service-key", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements are not satisfied", func() { It("fails when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(callDeleteServiceKey([]string{"fake-service-key-name"})).To(BeFalse()) }) It("requires two arguments and one option to run", func() { Expect(callDeleteServiceKey([]string{})).To(BeFalse()) Expect(callDeleteServiceKey([]string{"fake-arg-one"})).To(BeFalse()) Expect(callDeleteServiceKey([]string{"fake-arg-one", "fake-arg-two", "fake-arg-three"})).To(BeFalse()) }) It("fails when space is not targeted", func() {
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)
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) 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"))
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetBuildpackRepository(buildpackRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete-buildpack").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} buildpackRepo = new(apifakes.OldFakeBuildpackRepository) requirementsFactory = new(requirementsfakes.FakeFactory) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("delete-buildpack", args, requirementsFactory, updateCommandDependency, false, ui) } Context("when the user is not logged in", func() { BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) }) It("fails requirements", func() { Expect(runCommand("-f", "my-buildpack")).To(BeFalse()) }) }) Context("when the user is logged in", func() { BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
deps.RepoLocator = deps.RepoLocator.SetAuthenticationRepository(authRepo) 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 = &testreq.FakeReqFactory{LoginSuccess: true} authRepo = new(authenticationfakes.FakeAuthenticationRepository) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("service-access", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("requires the user to be logged in", func() { requirementsFactory.LoginSuccess = false 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)
} 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{})) }) })
quota models.SpaceQuota quotaPaidService models.SpaceQuota configRepo coreconfig.Repository deps commandregistry.Dependency ) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetSpaceQuotaRepository(quotaRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("update-space-quota").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("update-space-quota", args, requirementsFactory, updateCommandDependency, false) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() quotaRepo = new(spacequotasfakes.FakeSpaceQuotaRepository) requirementsFactory = &testreq.FakeReqFactory{} }) Describe("requirements", func() { It("fails when the user is not logged in", func() { requirementsFactory.LoginSuccess = false requirementsFactory.TargetedOrgSuccess = true Expect(runCommand("my-quota", "-m", "50G")).NotTo(HavePassedRequirements()) })
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("space-users").SetDependency(deps, pluginCall)) } BeforeEach(func() { configRepo = testconfig.NewRepositoryWithDefaults() ui = &testterm.FakeUI{} requirementsFactory = &testreq.FakeReqFactory{} spaceRepo = new(apifakes.FakeSpaceRepository) userRepo = new(apifakes.FakeUserRepository) deps = commandregistry.NewDependency(os.Stdout, new(tracefakes.FakePrinter)) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("space-users", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("fails when not logged in", func() { Expect(runCommand("my-org", "my-space")).To(BeFalse()) }) It("succeeds when logged in", func() { requirementsFactory.LoginSuccess = true passed := runCommand("some-org", "whatever-space") Expect(passed).To(BeTrue()) Expect("some-org").To(Equal(requirementsFactory.OrganizationName)) }) })
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = config deps.RepoLocator = deps.RepoLocator.SetServiceBindingRepository(serviceBindingRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("bind-service").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} config = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) serviceBindingRepo = new(apifakes.FakeServiceBindingRepository) }) var callBindService = func(args []string) bool { return testcmd.RunCLICommand("bind-service", args, requirementsFactory, updateCommandDependency, false, ui) } It("fails requirements when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(callBindService([]string{"service", "app"})).To(BeFalse()) }) Context("when logged in", func() { var ( app models.Application serviceInstance models.ServiceInstance ) BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
) 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))) })
BeforeEach(func() { ui = &testterm.FakeUI{Inputs: []string{"y"}} userRepo = new(apifakes.FakeUserRepository) requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true} configRepo = testconfig.NewRepositoryWithDefaults() token, err := testconfig.EncodeAccessToken(coreconfig.TokenInfo{ UserGUID: "admin-user-guid", Username: "******", }) Expect(err).ToNot(HaveOccurred()) configRepo.SetAccessToken(token) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("delete-user", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("fails when not logged in", func() { requirementsFactory.LoginSuccess = false Expect(runCommand("my-user")).To(BeFalse()) }) It("fails with usage when no arguments are given", func() { runCommand() Expect(ui.Outputs).To(ContainSubstrings( []string{"Incorrect Usage", "Requires an argument"}, )) })
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() { 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("set-health-check").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("set-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("FAKE_APP") Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "argument"}, )) }) It("fails with usage when health_check_type is not provided with 'none' or 'port'", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
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) } 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.LoginSuccess = false
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetFeatureFlagRepository(flagRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("feature-flag").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true} flagRepo = new(featureflagsfakes.FakeFeatureFlagRepository) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("feature-flag", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("requires the user to be logged in", func() { requirementsFactory.LoginSuccess = false Expect(runCommand("foo")).ToNot(HavePassedRequirements()) }) It("requires the user to provide a feature flag", func() { requirementsFactory.LoginSuccess = true Expect(runCommand()).ToNot(HavePassedRequirements()) }) }) Describe("when logged in", func() {
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() {
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetServiceAuthTokenRepository(authTokenRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("service-auth-tokens").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{Inputs: []string{"y"}} authTokenRepo = new(apifakes.OldFakeAuthTokenRepo) configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("service-auth-tokens", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).To(BeFalse()) }) Context("when arguments are provided", func() { var cmd commandregistry.Command var flagContext flags.FlagContext BeforeEach(func() { cmd = &serviceauthtoken.ListServiceAuthTokens{} cmd.SetDependency(deps, false)
updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetSecurityGroupRepository(securityGroupRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("update-security-group").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} requirementsFactory = new(requirementsfakes.FakeFactory) securityGroupRepo = new(securitygroupsfakes.FakeSecurityGroupRepo) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("update-security-group", args, 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("the-security-group")).To(BeFalse()) }) It("fails with usage when a name is not provided", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) runCommand() Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "arguments"}, )) })
configRepo coreconfig.Repository requirementsFactory *requirementsfakes.FakeFactory deps commandregistry.Dependency ) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetRouteRepository(routeRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete-orphaned-routes").SetDependency(deps, pluginCall)) } callDeleteOrphanedRoutes := func(confirmation string, args []string, requirementsFactory *requirementsfakes.FakeFactory, routeRepo *apifakes.FakeRouteRepository) (*testterm.FakeUI, bool) { ui = &testterm.FakeUI{Inputs: []string{confirmation}} configRepo = testconfig.NewRepositoryWithDefaults() passed := testcmd.RunCLICommand("delete-orphaned-routes", args, requirementsFactory, updateCommandDependency, false, ui) return ui, passed } BeforeEach(func() { routeRepo = new(apifakes.FakeRouteRepository) requirementsFactory = new(requirementsfakes.FakeFactory) }) It("fails requirements when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) _, passed := callDeleteOrphanedRoutes("y", []string{}, requirementsFactory, routeRepo) Expect(passed).To(BeFalse()) })
BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = &testreq.FakeReqFactory{} appRepo = new(applicationsfakes.FakeApplicationRepository) }) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("enable-ssh").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("enable-ssh", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("fails with usage when called without enough arguments", func() { requirementsFactory.LoginSuccess = true 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())
deps.RepoLocator = deps.RepoLocator.SetServiceRepository(serviceRepo) 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 = &testreq.FakeReqFactory{LoginSuccess: false} args = []string{} }) Describe("requirements", func() { It("requires you to be logged in", func() { Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse()) }) It("requires five arguments to run", func() { args = []string{"one", "two", "three"} Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse()) }) It("requires CC API version 2.47 or greater", func() { requirementsFactory.MaxAPIVersionSuccess = false requirementsFactory.LoginSuccess = true args = []string{"one", "two", "three", "four", "five"} ui.Inputs = append(ui.Inputs, "no") Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
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())
BeforeEach(func() { ui = &testterm.FakeUI{} configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) spaceRepo = new(apifakes.FakeSpaceRepository) }) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("disallow-space-ssh").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("disallow-space-ssh", args, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) }) It("fails with usage when called without enough arguments", func() { runCommand() Expect(ui.Outputs()).To(ContainSubstrings( []string{"Incorrect Usage", "Requires", "argument"}, )) })
) 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 = &testreq.FakeReqFactory{} }) 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")
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)