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