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)
