func TestSecurityGroupSpaces(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
RunSpecs(t, "SecurityGroupSpaces Suite")
}
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 TestEnvironmentVariableGroups(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
RunSpecs(t, "EnvironmentVariableGroups Suite")
}
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 TestCopyApplicationSource(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
RunSpecs(t, "CopyApplicationSource Suite")
}
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 TestStaging(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
RunSpecs(t, "Staging Suite")
}
func createServiceBrokerRepo(requests ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceBrokerRepository) {
ts, handler = testnet.NewServer(requests)
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCloudControllerServiceBrokerRepository(configRepo, gateway)
return
}
func createUserProvidedServiceInstanceRepo(req testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo UserProvidedServiceInstanceRepository) {
ts, handler = testnet.NewServer([]testnet.TestRequest{req})
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCCUserProvidedServiceInstanceRepository(configRepo, gateway)
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 createPasswordRepo(req testnet.TestRequest) (passwordServer *httptest.Server, handler *testnet.TestHandler, repo PasswordRepository) {
passwordServer, handler = testnet.NewServer([]testnet.TestRequest{req})
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetUaaEndpoint(passwordServer.URL)
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCloudControllerPasswordRepository(configRepo, gateway)
return
}
func createOrganizationRepo(reqs ...testnet.TestRequest) (testserver *httptest.Server, handler *testnet.TestHandler, repo OrganizationRepository) {
testserver, handler = testnet.NewServer(reqs)
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(testserver.URL)
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCloudControllerOrganizationRepository(configRepo, gateway)
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 TestApp(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "fixtures", "plugins"), "test_1")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "fixtures", "plugins"), "test_2")
RunSpecs(t, "App Suite")
}
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 createAppInstancesRepo(requests []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo AppInstancesRepository) {
ts, handler = testnet.NewServer(requests)
space := models.SpaceFields{}
space.Guid = "my-space-guid"
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCloudControllerAppInstancesRepository(configRepo, gateway)
return
}
func TestPlugin(t *testing.T) {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config)
RegisterFailHandler(Fail)
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "test_with_help")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "test_with_push")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "test_with_push_short_name")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "test_1")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "test_2")
plugin_builder.BuildTestBinary(filepath.Join("..", "..", "..", "fixtures", "plugins"), "empty_plugin")
RunSpecs(t, "Plugin Suite")
}
var _ = Describe("enable-feature-flag command", func() {
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
flagRepo *fakeflag.FakeFeatureFlagRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
flagRepo = &fakeflag.FakeFeatureFlagRepository{}
})
runCommand := func(args ...string) bool {
cmd := NewEnableFeatureFlag(ui, testconfig.NewRepositoryWithDefaults(), flagRepo)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
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.FailedWithUsage).To(BeTrue())
})
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("update-space-quota command", func() {
var (
ui *testterm.FakeUI
quotaRepo *fakes.FakeSpaceQuotaRepository
requirementsFactory *testreq.FakeReqFactory
quota models.SpaceQuota
quotaPaidService models.SpaceQuota
)
runCommand := func(args ...string) bool {
cmd := NewUpdateSpaceQuota(ui, configuration.NewRepositoryWithDefaults(), quotaRepo)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
quotaRepo = &fakes.FakeSpaceQuotaRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
Describe("requirements", func() {
It("fails when the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
requirementsFactory.TargetedOrgSuccess = true
Expect(runCommand("my-quota", "-m", "50G")).NotTo(HavePassedRequirements())
})
var (
cmd *SetQuota
ui *testterm.FakeUI
quotaRepo *fakes.FakeQuotaRepository
requirementsFactory *testreq.FakeReqFactory
)
runCommand := func(args ...string) {
testcmd.RunCommand(cmd, args, requirementsFactory)
}
BeforeEach(func() {
ui = new(testterm.FakeUI)
quotaRepo = &fakes.FakeQuotaRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
cmd = NewSetQuota(ui, testconfig.NewRepositoryWithDefaults(), quotaRepo)
})
It("fails with usage when provided too many or two few args", func() {
runCommand("org")
Expect(ui.FailedWithUsage).To(BeTrue())
runCommand("org", "quota", "extra-stuff")
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails requirements when not logged in", func() {
runCommand("my-org", "my-quota")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
var _ = Describe("set-running-environment-variable-group command", func() {
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
environmentVariableGroupRepo *test_environmentVariableGroups.FakeEnvironmentVariableGroupsRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
environmentVariableGroupRepo = &test_environmentVariableGroups.FakeEnvironmentVariableGroupsRepository{}
})
runCommand := func(args ...string) bool {
cmd := NewSetRunningEnvironmentVariableGroup(ui, testconfig.NewRepositoryWithDefaults(), environmentVariableGroupRepo)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).ToNot(HavePassedRequirements())
})
It("fails with usage when it does not receive any arguments", func() {
requirementsFactory.LoginSuccess = true
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
})
})
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",
var _ = Describe("quota", func() {
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
quotaRepo *fakes.FakeQuotaRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{}
quotaRepo = &fakes.FakeQuotaRepository{}
})
runCommand := func(args ...string) {
cmd := NewShowQuota(ui, testconfig.NewRepositoryWithDefaults(), quotaRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
}
Context("When not logged in", func() {
It("fails requirements", func() {
runCommand("quota-name")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
Context("When logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
})
var _ = Describe("delete-quota command", func() {
var (
ui *testterm.FakeUI
quotaRepo *fakes.FakeQuotaRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
quotaRepo = &fakes.FakeQuotaRepository{}
requirementsFactory = &testreq.FakeReqFactory{}
})
runCommand := func(args ...string) {
cmd := NewDeleteQuota(ui, configuration.NewRepositoryWithDefaults(), quotaRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
}
Context("when the user is not logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = false
})
It("fails requirements", func() {
runCommand("my-quota")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
var (
ui *testterm.FakeUI
actor *testactor.FakeServicePlanActor
requirementsFactory *testreq.FakeReqFactory
tokenRefresher *testapi.FakeAuthenticationRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
actor = &testactor.FakeServicePlanActor{}
requirementsFactory = &testreq.FakeReqFactory{}
tokenRefresher = &testapi.FakeAuthenticationRepository{}
})
runCommand := func(args []string) bool {
cmd := NewEnableServiceAccess(ui, configuration.NewRepositoryWithDefaults(), actor, tokenRefresher)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
runCommand([]string{"foo"})
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails with usage when it does not recieve any arguments", func() {
requirementsFactory.LoginSuccess = true
runCommand(nil)
Expect(ui.FailedWithUsage).To(BeTrue())
})
})
ui *testterm.FakeUI
app models.Application
appRepo *testApplication.FakeApplicationRepository
configRepo core_config.ReadWriter
requirementsFactory *testreq.FakeReqFactory
)
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())
})
})
actor *testactor.FakeServiceActor
requirementsFactory *testreq.FakeReqFactory
serviceBroker1 models.ServiceBroker
serviceBroker2 models.ServiceBroker
tokenRefresher *testapi.FakeAuthenticationRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
actor = &testactor.FakeServiceActor{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
tokenRefresher = &testapi.FakeAuthenticationRepository{}
})
runCommand := func(args ...string) bool {
cmd := NewServiceAccess(ui, testconfig.NewRepositoryWithDefaults(), actor, tokenRefresher)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).ToNot(HavePassedRequirements())
})
})
Describe("when logged in", func() {
BeforeEach(func() {
serviceBroker1 = models.ServiceBroker{
Guid: "broker1",
Name: "brokername1",
var (
ui *testterm.FakeUI
spaceRepo *fakes.FakeSpaceRepository
quotaRepo *quotafakes.FakeSpaceQuotaRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
spaceRepo = &fakes.FakeSpaceRepository{}
quotaRepo = "afakes.FakeSpaceQuotaRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
})
runCommand := func(args ...string) bool {
cmd := NewSetSpaceQuota(ui, testconfig.NewRepositoryWithDefaults(), spaceRepo, quotaRepo)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("space", "space-quota")).ToNot(HavePassedRequirements())
})
It("requires the user to target an org", func() {
requirementsFactory.TargetedOrgSuccess = false
Expect(runCommand("space", "space-quota")).ToNot(HavePassedRequirements())
})
It("fails with usage if the user does not provide a quota and space", func() {
var _ = Describe("feature-flags command", func() {
var (
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
flagRepo *fakeflag.FakeFeatureFlagRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
flagRepo = &fakeflag.FakeFeatureFlagRepository{}
})
runCommand := func(args ...string) bool {
cmd := NewListFeatureFlags(ui, testconfig.NewRepositoryWithDefaults(), flagRepo)
return testcmd.RunCommand(cmd, args, requirementsFactory)
}
Describe("requirements", func() {
It("requires the user to be logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand()).ToNot(HavePassedRequirements())
})
})
Describe("when logged in", func() {
BeforeEach(func() {
flags := []models.FeatureFlag{
models.FeatureFlag{
Name: "user_org_creation",
