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 callUnsetSpaceRole(args []string, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUnsetSpaceRole(ui, config, spaceRepo, userRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callSetOrgRole(args []string, requirementsFactory *testreq.FakeReqFactory, userRepo *testapi.FakeUserRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewSetOrgRole(ui, config, userRepo)
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 callApi(args []string, config core_config.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 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 callBindService(args []string, requirementsFactory *testreq.FakeReqFactory, serviceBindingRepo api.ServiceBindingRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewBindService(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 callShowOrg(args []string, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
token := core_config.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
}
var (
ui *testterm.FakeUI
configRepo core_config.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())
})
)
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
accessToken, err := testconfig.EncodeAccessToken(core_config.TokenInfo{Username: "******"})
Expect(err).NotTo(HaveOccurred())
configRepo.SetAccessToken(accessToken)
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
spaceRepo = &testapi.FakeSpaceRepository{}
userRepo = &testapi.FakeUserRepository{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewSetSpaceRole(ui, configRepo, spaceRepo, userRepo), args, requirementsFactory)
}
It("fails with usage when not provided exactly four args", func() {
runCommand("foo", "bar", "baz")
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("does not fail with usage when provided four args", func() {
runCommand("whatever", "these", "are", "args")
Expect(ui.FailedWithUsage).To(BeFalse())
})
Describe("requirements", func() {
It("fails when not logged in", func() {
runCommand("username", "org", "space", "role")
var _ = Describe("quotas command", func() {
var (
ui *testterm.FakeUI
quotaRepo *fakes.FakeQuotaRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
quotaRepo = &fakes.FakeQuotaRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
})
runCommand := func() bool {
cmd := NewListQuotas(ui, testconfig.NewRepositoryWithDefaults(), quotaRepo)
return testcmd.RunCommand(cmd, []string{}, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).ToNot(HavePassedRequirements())
})
})
Context("when quotas exist", func() {
BeforeEach(func() {
quotaRepo.FindAllReturns([]models.QuotaFields{
models.QuotaFields{
Name: "quota-name",
MemoryLimit: 1024,
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
starter = &testcmd.FakeApplicationStarter{}
stopper = &testcmd.FakeApplicationStopper{}
config = testconfig.NewRepositoryWithDefaults()
app = models.Application{}
app.Name = "my-app"
app.Guid = "my-app-guid"
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewRestart(ui, config, starter, stopper), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails with usage when an app name is not given", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
requirementsFactory.Application = app
requirementsFactory.TargetedSpaceSuccess = true
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
restarter = &testcmd.FakeApplicationRestarter{}
appRepo = &testApplication.FakeApplicationRepository{}
ui = new(testterm.FakeUI)
config = testconfig.NewRepositoryWithDefaults()
cmd = NewScale(ui, config, restarter, appRepo)
})
Describe("requirements", func() {
It("requires the user to be logged in with a targed space", func() {
args := []string{"-m", "1G", "my-app"}
requirementsFactory.LoginSuccess = false
requirementsFactory.TargetedSpaceSuccess = true
testcmd.RunCommand(cmd, args, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
requirementsFactory.LoginSuccess = true
requirementsFactory.TargetedSpaceSuccess = false
testcmd.RunCommand(cmd, args, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("requires an app to be specified", func() {
testcmd.RunCommand(cmd, []string{"-m", "1G"}, requirementsFactory)
Expect(ui.FailedWithUsage).To(BeTrue())
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
space2 = models.Space{}
space2.Guid = "some-space-guid"
space2.Name = "some-space"
orgRepo.ListOrgsReturns([]models.Organization{org1, org2}, nil)
spaceRepo.Spaces = []models.Space{space1, space2}
})
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"}
l := NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
testcmd.RunCommand(l, Flags, nil)
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"))
routeRepo *testapi.FakeRouteRepository
domainRepo *testapi.FakeDomainRepository
requirementsFactory *testreq.FakeReqFactory
config core_config.ReadWriter
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
routeRepo = &testapi.FakeRouteRepository{}
domainRepo = &testapi.FakeDomainRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
config = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewCheckRoute(ui, config, routeRepo, domainRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
runCommand("foobar.example.com", "bar.example.com")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when no org is targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand("foobar.example.com", "bar.example.com")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
configRepo core_config.ReadWriter
routeRepo *testapi.FakeRouteRepository
requirementsFactory *testreq.FakeReqFactory
routeCreator *testcmd.FakeRouteCreator
)
BeforeEach(func() {
ui = new(testterm.FakeUI)
configRepo = testconfig.NewRepositoryWithDefaults()
routeRepo = new(testapi.FakeRouteRepository)
routeCreator = &testcmd.FakeRouteCreator{}
requirementsFactory = new(testreq.FakeReqFactory)
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewMapRoute(ui, configRepo, routeRepo, routeCreator), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not invoked with exactly two args", func() {
runCommand("whoops-all-crunchberries")
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
runCommand("whatever", "shuttup")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
Context("when the user is logged in", func() {
var _ = Describe("zone command", func() {
var (
ui *testterm.FakeUI
configRepo core_config.Reader
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewShowZone(ui, configRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
runCommand("whoops")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails with usage when not provided exactly one arg", func() {
requirementsFactory.LoginSuccess = true
runCommand("too", "much")
Expect(ui.FailedWithUsage).To(BeTrue())
})
})
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
configRepo core_config.ReadWriter
appRepo *testApplication.FakeApplicationRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
appRepo = &testApplication.FakeApplicationRepository{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewRenameApp(ui, configRepo, appRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails with usage when not invoked with an old name and a new name", func() {
requirementsFactory.LoginSuccess = true
runCommand("foo")
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
runCommand("my-app", "my-new-app")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
configRepo core_config.ReadWriter
userRepo *testapi.FakeUserRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
userRepo = &testapi.FakeUserRepository{}
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewOrgUsers(ui, configRepo, userRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails with usage when invoked without an org name", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
runCommand("say-hello-to-my-little-org")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
requirementsFactory *testreq.FakeReqFactory
spaceRepo *testapi.FakeSpaceRepository
userRepo *testapi.FakeUserRepository
config core_config.ReadWriter
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
spaceRepo = &testapi.FakeSpaceRepository{}
userRepo = &testapi.FakeUserRepository{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewSpaceUsers(ui, config, spaceRepo, userRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
runCommand("my-org", "my-space")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("succeeds when logged in", func() {
requirementsFactory.LoginSuccess = true
runCommand("some-org", "whatever-space")
Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
Expect("some-org").To(Equal(requirementsFactory.OrganizationName))
var (
ui *testterm.FakeUI
configRepo core_config.ReadWriter
requirementsFactory *testreq.FakeReqFactory
appFilesRepo *testappfiles.FakeAppFilesRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
appFilesRepo = &testappfiles.FakeAppFilesRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewFiles(ui, configRepo, appFilesRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.TargetedSpaceSuccess = true
runCommand("my-app", "/foo")
})
It("fails when a space is not targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand("my-app", "/foo")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails with usage when not provided an app name", func() {
func runCurlWithInputs(deps curlDependencies, args []string) {
cmd := NewCurl(deps.ui, deps.config, deps.curlRepo)
testcmd.RunCommand(cmd, args, deps.requirementsFactory)
}
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
configRepo core_config.ReadWriter
serviceBrokerRepo *testapi.FakeServiceBrokerRepo
)
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
serviceBrokerRepo = &testapi.FakeServiceBrokerRepo{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewUpdateServiceBroker(ui, configRepo, serviceBrokerRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails with usage when invoked without exactly four args", func() {
requirementsFactory.LoginSuccess = true
runCommand("arg1", "arg2", "arg3")
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails when not logged in", func() {
runCommand("heeeeeeey", "yooouuuuuuu", "guuuuuuuuys", "ヾ(＠*ー⌒ー*@)ノ")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
ui *testterm.FakeUI
app models.Application
appRepo *testApplication.FakeApplicationRepository
requirementsFactory *testreq.FakeReqFactory
config core_config.ReadWriter
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
appRepo = &testApplication.FakeApplicationRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewStop(ui, config, appRepo), args, requirementsFactory)
}
It("fails requirements when not logged in", func() {
runCommand("some-app-name")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
Context("when logged in and an app exists", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
app = models.Application{}
app.Name = "my-app"
app.Guid = "my-app-guid"
app.State = "started"
configRepo core_config.ReadWriter
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
app = models.Application{}
app.Name = "my-app"
app.Guid = "my-app-guid"
appRepo = &testApplication.FakeApplicationRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewUnsetEnv(ui, configRepo, appRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.TargetedSpaceSuccess = true
requirementsFactory.Application = app
runCommand("foo", "bar")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when a space is not targeted", func() {
requirementsFactory.LoginSuccess = true
requirementsFactory.Application = app
runCommand("foo", "bar")
. "github.com/nttlabs/cli/testhelpers/matchers"
)
var _ = Describe("bind-service command", func() {
var (
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
requirementsFactory = &testreq.FakeReqFactory{}
})
It("fails requirements when not logged in", func() {
cmd := NewBindService(&testterm.FakeUI{}, testconfig.NewRepository(), &testapi.FakeServiceBindingRepo{})
testcmd.RunCommand(cmd, []string{"service", "app"}, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
Context("when logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
})
It("binds a service instance to an app", func() {
app := models.Application{}
app.Name = "my-app"
app.Guid = "my-app-guid"
serviceInstance := models.ServiceInstance{}
serviceInstance.Name = "my-service"
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
configRepo core_config.ReadWriter
spaceRepo *testapi.FakeSpaceRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
spaceRepo = &testapi.FakeSpaceRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
configRepo = testconfig.NewRepositoryWithDefaults()
})
runCommand := func(args ...string) {
testcmd.RunCommand(NewListSpaces(ui, configRepo, spaceRepo), args, requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when an org is not targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
BeforeEach(func() {
ui = &testterm.FakeUI{}
app = models.Application{}
app.Name = "my-app"
appRepo = &testApplication.FakeApplicationRepository{}
appRepo.ReadReturns.App = app
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
})
runCommand := func(args ...string) {
cmd := NewEnv(ui, configRepo, appRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("Requirements", func() {
It("fails when the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
runCommand("my-app")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
It("fails with usage when no app name is given", func() {
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
func callSpaces(args []string, requirementsFactory *testreq.FakeReqFactory, config core_config.Reader, spaceRepo spaces.SpaceRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewListSpaces(ui, config, spaceRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}