func callApi(args []string, config core_config.Repository, endpointRepo *testapi.FakeEndpointRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
// cmd := NewApi(ui, config, endpointRepo)
var cmd command_registry.Command
cmd = Api{}
repoLocator := api.RepositoryLocator{}
repoLocator = repoLocator.SetEndpointRepository(endpointRepo)
deps := command_registry.Dependency{
Ui: ui,
Config: config,
RepoLocator: repoLocator,
}
cmd = cmd.SetDependency(deps, false)
requirementsFactory := &testreq.FakeReqFactory{}
testcmd.RunCliCommand(cmd, args, requirementsFactory)
return
}
requirementsFactory = &testreq.FakeReqFactory{
LoginSuccess: true,
TargetedSpaceSuccess: true,
Application: application,
}
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = config
deps.RepoLocator = deps.RepoLocator.SetAppInstancesRepository(appInstancesRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("restart-app-instance").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("restart-app-instance", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails if not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("my-app", "0")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.TargetedSpaceSuccess = false
Expect(runCommand("my-app", "0")).To(BeFalse())
})
It("fails when there is not exactly two arguments", func() {
Expect(runCommand("my-app")).To(BeFalse())
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetUserRepository(userRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("org-users").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
userRepo = &testapi.FakeUserRepository{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
deps = command_registry.NewDependency()
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("org-users", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when invoked without an org name", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("fails when not logged in", func() {
Expect(runCommand("say-hello-to-my-little-org")).To(BeFalse())
})
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetUserProvidedServiceInstanceRepository(serviceRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("update-user-provided-service").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
serviceRepo = &testapi.FakeUserProvidedServiceInstanceRepository{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("update-user-provided-service", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when not provided the name of the service to update", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails when not logged in", func() {
Expect(runCommand("whoops")).To(BeFalse())
})
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetLogsRepository(logsRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("logs").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
logsRepo = &testapi.FakeLogsRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("logs", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when called without one argument", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("fails requirements when not logged in", func() {
Expect(runCommand("my-app")).To(BeFalse())
})
configRepo core_config.Repository
reqFactory *testreq.FakeReqFactory
deps command_registry.Dependency
)
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetRouteRepository(routeRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("delete-orphaned-routes").SetDependency(deps, pluginCall))
}
callDeleteOrphanedRoutes := func(confirmation string, args []string, reqFactory *testreq.FakeReqFactory, routeRepo *testapi.FakeRouteRepository) (*testterm.FakeUI, bool) {
ui = &testterm.FakeUI{Inputs: []string{confirmation}}
configRepo = testconfig.NewRepositoryWithDefaults()
passed := testcmd.RunCliCommand("delete-orphaned-routes", args, reqFactory, updateCommandDependency, false)
return ui, passed
}
BeforeEach(func() {
routeRepo = &testapi.FakeRouteRepository{}
reqFactory = &testreq.FakeReqFactory{}
})
It("fails requirements when not logged in", func() {
_, passed := callDeleteOrphanedRoutes("y", []string{}, reqFactory, routeRepo)
Expect(passed).To(BeFalse())
})
It("should fail with usage when provided any arguments", func() {
reqFactory.LoginSuccess = true
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("unbind-security-group").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
securityGroupRepo = &fakeSecurityGroup.FakeSecurityGroupRepo{}
orgRepo = &fake_org.FakeOrganizationRepository{}
spaceRepo = &fakes.FakeSpaceRepository{}
secBinder = &fakeBinder.FakeSecurityGroupSpaceBinder{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("unbind-security-group", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("should fail if not logged in", func() {
Expect(runCommand("my-group")).To(BeFalse())
})
It("should fail with usage when not provided with any arguments", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
spaceRepo *testapi.FakeSpaceRepository
deps command_registry.Dependency
)
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetUserRepository(userRepo)
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("unset-space-role").SetDependency(deps, pluginCall))
}
callUnsetSpaceRole := func(args []string, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository, requirementsFactory *testreq.FakeReqFactory) (*testterm.FakeUI, bool) {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
passed := testcmd.RunCliCommand("unset-space-role", args, requirementsFactory, updateCommandDependency, false)
return ui, passed
}
It("fails with usage when not called with exactly four args", func() {
requirementsFactory, spaceRepo, userRepo = getUnsetSpaceRoleDeps()
ui, _ := callUnsetSpaceRole([]string{"username", "org", "space"}, spaceRepo, userRepo, requirementsFactory)
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails requirements when not logged in", func() {
requirementsFactory, spaceRepo, userRepo = getUnsetSpaceRoleDeps()
args := []string{"username", "org", "space", "role"}
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetFeatureFlagRepository(flagRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("disable-feature-flag").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
flagRepo = &fakeflag.FakeFeatureFlagRepository{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("disable-feature-flag", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
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"},
))
})
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetServiceRepository(serviceRepo)
deps.Config = config
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("rename-service").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
serviceRepo = &testapi.FakeServiceRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("rename-service", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("Fails with usage when exactly two parameters not passed", func() {
runCommand("whatever")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails when not logged in", func() {
requirementsFactory.TargetedSpaceSuccess = true
Expect(runCommand("banana", "fppants")).To(BeFalse())
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetDomainRepository(domainRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("delete-shared-domain").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
domainRepo = &testapi.FakeDomainRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("delete-shared-domain", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails if you are not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
Expect(runCommand("foo.com")).To(BeFalse())
})
It("fails if an organiztion is not targeted", func() {
requirementsFactory.LoginSuccess = true
Expect(runCommand("foo.com")).To(BeFalse())
})
})
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetServiceBrokerRepository(serviceBrokerRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("create-service-broker").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
serviceBrokerRepo = &testapi.FakeServiceBrokerRepo{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("create-service-broker", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when called without exactly four args", func() {
requirementsFactory.LoginSuccess = true
runCommand("whoops", "not-enough", "args")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails when not logged in", func() {
Expect(runCommand("Just", "Enough", "Args", "Provided")).To(BeFalse())
})
})
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.SetEnvironmentVariableGroupsRepository(environmentVariableGroupRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("running-environment-variable-group").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
environmentVariableGroupRepo = &test_environmentVariableGroups.FakeEnvironmentVariableGroupsRepository{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("running-environment-variable-group", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).ToNot(HavePassedRequirements())
})
It("should fail with usage when provided any arguments", func() {
requirementsFactory.LoginSuccess = true
Expect(runCommand("blahblah")).To(BeFalse())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "No argument"},
))
})
})
deps.RepoLocator = deps.RepoLocator.SetServiceRepository(serviceRepo)
deps.Config = config
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("migrate-service-instances").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepository()
serviceRepo = &testapi.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())
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetServiceAuthTokenRepository(authTokenRepo)
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("update-service-auth-token").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{Inputs: []string{"y"}}
authTokenRepo = &testapi.FakeAuthTokenRepo{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("update-service-auth-token", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when not provided exactly three args", func() {
requirementsFactory.LoginSuccess = true
runCommand("some-token-label", "a-provider")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails when not logged in", func() {
Expect(runCommand("label", "provider", "token")).To(BeFalse())
})
})
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
appRepo = &testApplication.FakeApplicationRepository{}
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("get-health-check").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("get-health-check", 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{"get-health-check"},
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
Expect(runCommand("my-app")).To(BeFalse())
deps.RepoLocator = deps.RepoLocator.SetAuthenticationRepository(authRepo)
deps.ServiceHandler = actor
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("service-access").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
actor = &testactor.FakeServiceActor{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
authRepo = &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())
})
It("should fail with usage when provided any arguments", func() {
requirementsFactory.LoginSuccess = true
Expect(runCommand("blahblah")).To(BeFalse())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "No argument"},
))
})
})
deps.Config = configRepo
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("delete-route").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{Inputs: []string{"yes"}}
routeRepo = &testapi.FakeRouteRepository{}
requirementsFactory = &testreq.FakeReqFactory{
LoginSuccess: true,
}
})
runCommand := func(args ...string) bool {
configRepo = testconfig.NewRepositoryWithDefaults()
return testcmd.RunCliCommand("delete-route", args, requirementsFactory, updateCommandDependency, false)
}
Context("when not logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = false
})
It("does not pass requirements", func() {
Expect(runCommand("-n", "my-host", "example.com")).To(BeFalse())
})
})
Context("when logged in successfully", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
repo = &testapi.FakeAuthenticationRepository{
Config: config,
AccessToken: "my-access-token",
RefreshToken: "my-refresh-token",
}
deps = command_registry.NewDependency()
})
Describe("requirements", func() {
It("fails with usage when given too few arguments", func() {
testcmd.RunCliCommand("auth", []string{}, requirementsFactory, updateCommandDependency, false)
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails if the user has not set an api endpoint", func() {
Expect(testcmd.RunCliCommand("auth", []string{"username", "password"}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
})
Context("when an api endpoint is targeted", func() {
BeforeEach(func() {
requirementsFactory.ApiEndpointSuccess = true
config.SetApiEndpoint("foo.example.org/authenticate")
ui *testterm.FakeUI
orgRepo *test_org.FakeOrganizationRepository
configRepo core_config.Repository
requirementsFactory *testreq.FakeReqFactory
deps command_registry.Dependency
)
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetOrganizationRepository(orgRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("orgs").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("orgs", args, requirementsFactory, updateCommandDependency, false)
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
orgRepo = &test_org.FakeOrganizationRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
deps = command_registry.NewDependency()
})
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.LoginSuccess = false
)
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = config
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("add-plugin-repo").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
config = testconfig.NewRepositoryWithDefaults()
})
var callAddPluginRepo = func(args []string) bool {
return testcmd.RunCliCommand("add-plugin-repo", args, requirementsFactory, updateCommandDependency, false)
}
Context("When repo server is valid", func() {
BeforeEach(func() {
h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, `{"plugins":[
{
"name":"echo",
"description":"none",
"version":"4",
"binaries":[
{
"platform":"osx",
"url":"https://github.com/simonleung8/cli-plugin-echo/raw/master/bin/osx/echo",
deps.RepoLocator = deps.RepoLocator.SetStackRepository(repo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("stacks").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
repo = &testapi.FakeStackRepository{}
})
Describe("login requirements", func() {
It("fails if the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(testcmd.RunCliCommand("stacks", []string{}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("should fail with usage when provided any arguments", func() {
requirementsFactory.LoginSuccess = true
Expect(testcmd.RunCliCommand("stacks", []string{"etcetc"}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage."},
))
})
})
It("lists the stacks", func() {
stack1 := models.Stack{
Name: "Stack-1",
deps.RepoLocator = deps.RepoLocator.SetUserProvidedServiceInstanceRepository(repo)
deps.Config = config
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("create-user-provided-service").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
repo = &testapi.FakeUserProvidedServiceInstanceRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
})
Describe("login requirements", func() {
It("fails if the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(testcmd.RunCliCommand("create-user-provided-service", []string{"my-service"}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("fails when a space is not targeted", func() {
requirementsFactory.TargetedSpaceSuccess = false
Expect(testcmd.RunCliCommand("create-user-provided-service", []string{"my-service"}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
})
It("creates a new user provided service given just a name", func() {
testcmd.RunCliCommand("create-user-provided-service", []string{"my-custom-service"}, requirementsFactory, updateCommandDependency, false)
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Creating user provided service"},
[]string{"OK"},
))
})
deps.RepoLocator = deps.RepoLocator.SetStackRepository(repo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("stack").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
repo = &testapi.FakeStackRepository{}
})
Describe("login requirements", func() {
It("fails if the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(testcmd.RunCliCommand("stack", []string{}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("fails with usage when not provided exactly one arg", func() {
requirementsFactory.LoginSuccess = true
Expect(testcmd.RunCliCommand("stack", []string{}, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"Incorrect Usage.", "Requires stack name as argument"},
))
})
})
It("returns the stack guid when '--guid' flag is provided", func() {
stack1 := models.Stack{
Name: "Stack-1",
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
spaceRepo = &testapi.FakeSpaceRepository{}
})
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("allow-space-ssh").SetDependency(deps, pluginCall))
}
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("allow-space-ssh", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails with usage when called without enough arguments", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Ω(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
It("fails requirements when not logged in", func() {
Ω(runCommand("my-space")).To(BeFalse())
})
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetSpaceQuotaRepository(quotaRepo)
deps.RepoLocator = deps.RepoLocator.SetSpaceRepository(spaceRepo)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("unset-space-quota").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
quotaRepo = &fakes.FakeSpaceQuotaRepository{}
spaceRepo = &testapi.FakeSpaceRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("unset-space-quota", args, requirementsFactory, updateCommandDependency, false)
}
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() {
}
BeforeEach(func() {
fakeManifest = &testManifest.FakeAppManifest{}
ui = &testterm.FakeUI{}
appSummaryRepo = &testapi.FakeAppSummaryRepo{}
appInstancesRepo = &testAppInstanaces.FakeAppInstancesRepository{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{
LoginSuccess: true,
TargetedSpaceSuccess: true,
}
})
runCommand := func(args ...string) bool {
return testcmd.RunCliCommand("create-app-manifest", args, requirementsFactory, updateCommandDependency, false)
}
Describe("requirements", func() {
It("fails if not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("cf-plays-dwarf-fortress")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.TargetedSpaceSuccess = false
Expect(runCommand("cf-plays-dwarf-fortress")).To(BeFalse())
})
It("fails with usage when not provided exactly one arg", func() {
passed := runCommand()
appInstancesRepo = &testAppInstanaces.FakeAppInstancesRepository{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{
LoginSuccess: true,
TargetedSpaceSuccess: true,
}
app = makeAppWithRoute("my-app")
appSummaryRepo.GetSummarySummary = app
deps = command_registry.NewDependency()
updateCommandDependency(false)
})
runCommand := func(args ...string) bool {
cmd := command_registry.Commands.FindCommand("app")
return testcmd.RunCliCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("fails if not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
requirementsFactory.TargetedSpaceSuccess = false
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails with usage when not provided exactly one arg", func() {
passed := runCommand()
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)
}
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'"}))
})
