func callUnsetSpaceRole(args []string, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository, requirementsFactory *testreq.FakeReqFactory) (*testterm.FakeUI, bool) {
ui := &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUnsetSpaceRole(ui, config, spaceRepo, userRepo)
passed := testcmd.RunCommand(cmd, args, requirementsFactory)
return ui, passed
}
func callCreateServiceBroker(args []string, requirementsFactory *testreq.FakeReqFactory, serviceBrokerRepo *testapi.FakeServiceBrokerRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewCreateServiceBroker(ui, config, serviceBrokerRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callStop(args []string, requirementsFactory *testreq.FakeReqFactory, appRepo api.ApplicationRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewStop(ui, configRepo, appRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callRestart(args []string, requirementsFactory *testreq.FakeReqFactory, starter ApplicationStarter, stopper ApplicationStopper) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewRestart(ui, starter, stopper)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callPassword(inputs []string, deps passwordDeps) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{Inputs: inputs}
cmd := NewPassword(ui, deps.PwdRepo, deps.Config)
testcmd.RunCommand(cmd, []string{}, deps.ReqFactory)
return
}
func callUpdateServiceAuthToken(args []string, requirementsFactory *testreq.FakeReqFactory, authTokenRepo *testapi.FakeAuthTokenRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUpdateServiceAuthToken(ui, config, authTokenRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callDeleteOrphanedRoutes(confirmation string, args []string, reqFactory *testreq.FakeReqFactory, routeRepo *testapi.FakeRouteRepository) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{Inputs: []string{confirmation}}
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewDeleteOrphanedRoutes(ui, configRepo, routeRepo)
testcmd.RunCommand(cmd, args, reqFactory)
return
}
func callShowSpace(args []string, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewShowSpace(ui, config)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callShareDomain(args []string, requirementsFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "******"})
cmd := NewCreateSharedDomain(fakeUI, configRepo, domainRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callOrgUsers(args []string, requirementsFactory *testreq.FakeReqFactory, userRepo *testapi.FakeUserRepository) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewOrgUsers(ui, config, userRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callMapRoute(args []string, requirementsFactory *testreq.FakeReqFactory, routeRepo *testapi.FakeRouteRepository, createRoute *testcmd.FakeRouteCreator) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewMapRoute(ui, configRepo, routeRepo, createRoute)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callUpdateUserProvidedService(args []string, requirementsFactory *testreq.FakeReqFactory, userProvidedServiceInstanceRepo api.UserProvidedServiceInstanceRepository) (fakeUI *testterm.FakeUI) {
fakeUI = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUpdateUserProvidedService(fakeUI, config, userProvidedServiceInstanceRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callListServiceBrokers(args []string, serviceBrokerRepo *testapi.FakeServiceBrokerRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewListServiceBrokers(ui, config, serviceBrokerRepo)
testcmd.RunCommand(cmd, args, &testreq.FakeReqFactory{})
return
}
func callApi(args []string, config configuration.ReadWriter, endpointRepo *testapi.FakeEndpointRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewApi(ui, config, endpointRepo)
requirementsFactory := &testreq.FakeReqFactory{}
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callUpdateBuildpack(args []string, requirementsFactory *testreq.FakeReqFactory, fakeRepo *testapi.FakeBuildpackRepository,
fakeBitsRepo *testapi.FakeBuildpackBitsRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewUpdateBuildpack(ui, fakeRepo, fakeBitsRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callLogs(args []string, requirementsFactory *testreq.FakeReqFactory, logsRepo *testapi.FakeLogsRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewLogs(ui, configRepo, logsRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callFiles(args []string, requirementsFactory *testreq.FakeReqFactory, appFilesRepo *testapi.FakeAppFilesRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewFiles(ui, configRepo, appFilesRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callUnbindService(args []string, requirementsFactory *testreq.FakeReqFactory, serviceBindingRepo api.ServiceBindingRepository) (fakeUI *testterm.FakeUI) {
fakeUI = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUnbindService(fakeUI, config, serviceBindingRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callListServiceAuthTokens(requirementsFactory *testreq.FakeReqFactory, authTokenRepo *testapi.FakeAuthTokenRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewListServiceAuthTokens(ui, config, authTokenRepo)
testcmd.RunCommand(cmd, []string{}, requirementsFactory)
return
}
func callRenameService(args []string, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI, serviceRepo *testapi.FakeServiceRepo) {
ui = &testterm.FakeUI{}
serviceRepo = &testapi.FakeServiceRepo{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewRenameService(ui, config, serviceRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callStart(args []string, config configuration.Reader, requirementsFactory *testreq.FakeReqFactory, displayApp ApplicationDisplayer, appRepo api.ApplicationRepository, appInstancesRepo api.AppInstancesRepository, logRepo api.LogsRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewStart(ui, config, displayApp, appRepo, appInstancesRepo, logRepo)
cmd.StagingTimeout = 50 * time.Millisecond
cmd.StartupTimeout = 50 * time.Millisecond
cmd.PingerThrottle = 50 * time.Millisecond
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callSetSpaceRole(args []string, requirementsFactory *testreq.FakeReqFactory, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithDefaults()
accessToken, err := testconfig.EncodeAccessToken(configuration.TokenInfo{
Username: "******",
})
Expect(err).NotTo(HaveOccurred())
configRepo.SetAccessToken(accessToken)
cmd := NewSetSpaceRole(ui, configRepo, spaceRepo, userRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callListDomains(args []string, requirementsFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "******"})
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
cmd := domain.NewListDomains(fakeUI, configRepo, domainRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callCreateOrg(args []string, requirementsFactory *testreq.FakeReqFactory, orgRepo *testapi.FakeOrgRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
space := models.SpaceFields{}
space.Name = "my-space"
organization := models.OrganizationFields{}
organization.Name = "my-org"
token := configuration.TokenInfo{Username: "******"}
config := testconfig.NewRepositoryWithAccessToken(token)
config.SetSpaceFields(space)
config.SetOrganizationFields(organization)
cmd := NewCreateOrg(fakeUI, config, orgRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callShowOrg(args []string, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
token := configuration.TokenInfo{Username: "******"}
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo := testconfig.NewRepositoryWithAccessToken(token)
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
cmd := NewShowOrg(ui, configRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callDeleteSharedDomain(args []string, inputs []string, deps deleteSharedDomainDependencies) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{
Inputs: inputs,
}
configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "******"})
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
cmd := domain.NewDeleteSharedDomain(ui, configRepo, deps.domainRepo)
testcmd.RunCommand(cmd, args, deps.requirementsFactory)
return
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
serviceRepo = &testapi.FakeServiceRepo{}
serviceInstance := models.ServiceInstance{}
serviceInstance.Guid = "fake-instance-guid"
serviceRepo.FindInstanceByNameMap = generic.NewMap()
serviceRepo.FindInstanceByNameMap.Set("fake-service-instance", serviceInstance)
serviceKeyRepo = testapi.NewFakeServiceKeyRepo()
cmd = NewListServiceKeys(ui, config, serviceRepo, serviceKeyRepo)
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true, ServiceInstanceNotFound: false}
requirementsFactory.ServiceInstance = serviceInstance
})
var callListServiceKeys = func(args []string) bool {
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: false}
Expect(callListServiceKeys([]string{"fake-service-instance", "fake-service-key"})).To(BeFalse())
})
It("requires one argument to run", func() {
Expect(callListServiceKeys([]string{})).To(BeFalse())
Expect(callListServiceKeys([]string{"fake-arg-one"})).To(BeTrue())
Expect(callListServiceKeys([]string{"fake-arg-one", "fake-arg-two"})).To(BeFalse())
})
It("fails when service instance is not found", func() {
appRepo *testapi.FakeApplicationRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
app = models.Application{}
app.Name = "my-app"
app.Guid = "my-app-guid"
appRepo = &testapi.FakeApplicationRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewSetEnv(ui, configRepo, appRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when login is not successful", func() {
requirementsFactory.Application = app
requirementsFactory.TargetedSpaceSuccess = true
runCommand("hey", "gabba", "gabba")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when a space is not targeted", func() {
requirementsFactory.Application = app
requirementsFactory.LoginSuccess = true
var (
ui *testterm.FakeUI
configRepo configuration.ReadWriter
domainRepo *testapi.FakeDomainRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
domainRepo = &testapi.FakeDomainRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewListDomains(ui, configRepo, domainRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when an org is not targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
quotaRepo *fakes.FakeSpaceQuotaRepository
configRepo configuration.ReadWriter
)
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
quotaRepo = &fakes.FakeSpaceQuotaRepository{}
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewShowSpace(ui, configRepo, quotaRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
runCommand("some-space")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when an org is not targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand("some-space")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})