func deleteWithConfirmation(confirmation string) (ui *testterm.FakeUI, userRepo *testapi.FakeUserRepository) {
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
user2 := models.UserFields{}
user2.Username = "******"
user2.Guid = "my-found-user-guid"
userRepo = &testapi.FakeUserRepository{
FindByUsernameUserFields: user2,
}
configRepo := testconfig.NewRepositoryWithDefaults()
accessToken, err := testconfig.EncodeAccessToken(configuration.TokenInfo{
Username: "******",
})
Expect(err).NotTo(HaveOccurred())
configRepo.SetAccessToken(accessToken)
cmd := NewDeleteUser(ui, configRepo, userRepo)
ctxt := testcmd.NewContext("delete-user", []string{"my-user"})
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func setupTestServerAndLogsRepo(messages ...[]byte) (testServer *httptest.Server, requestHandler *requestHandlerWithExpectedPath, logsRepo *LoggregatorLogsRepository) {
requestHandler = new(requestHandlerWithExpectedPath)
requestHandler.handlerFunc = func(conn *websocket.Conn) {
request := conn.Request()
requestHandler.lastPath = request.URL.Path
Expect(request.URL.RawQuery).To(Equal("app=my-app-guid"))
Expect(request.Method).To(Equal("GET"))
Expect(request.Header.Get("Authorization")).To(ContainSubstring("BEARER my_access_token"))
for _, msg := range messages {
conn.Write(msg)
}
time.Sleep(time.Duration(50) * time.Millisecond)
conn.Close()
}
testServer = httptest.NewTLSServer(websocket.Handler(requestHandler.handlerFunc))
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint("https://localhost")
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.LoggregatorEndpointReturns.Endpoint = strings.Replace(testServer.URL, "https", "wss", 1)
repo := NewLoggregatorLogsRepository(configRepo, endpointRepo)
logsRepo = &repo
return
}
func testUploadApp(dir string, requests []testnet.TestRequest) (app models.Application, apiResponse net.ApiResponse) {
ts, handler := testnet.NewTLSServer(requests)
defer ts.Close()
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
gateway.PollingThrottle = time.Duration(0)
zipper := cf.ApplicationZipper{}
repo := NewCloudControllerApplicationBitsRepository(configRepo, gateway, zipper)
var (
reportedPath string
reportedFileCount, reportedUploadSize uint64
)
apiResponse = repo.UploadApp("my-cool-app-guid", dir, func(path string, uploadSize, fileCount uint64) {
reportedPath = path
reportedUploadSize = uploadSize
reportedFileCount = fileCount
})
Expect(reportedPath).To(Equal(dir))
Expect(reportedFileCount).To(Equal(uint64(len(expectedApplicationContent))))
Expect(reportedUploadSize).To(Equal(uint64(759)))
Expect(handler.AllRequestsCalled()).To(BeTrue())
return
}
func callRenameSpace(args []string, reqFactory *testreq.FakeReqFactory, spaceRepo *testapi.FakeSpaceRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("create-space", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewRenameSpace(ui, configRepo, spaceRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func createServiceAuthTokenRepo(request testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceAuthTokenRepository) {
ts, handler = testnet.NewTLSServer([]testnet.TestRequest{request})
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerServiceAuthTokenRepository(configRepo, gateway)
return
}
func createBuildpackRepo(requests ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo BuildpackRepository) {
ts, handler = testnet.NewTLSServer(requests)
config := testconfig.NewRepositoryWithDefaults()
config.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerBuildpackRepository(config, 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)
repo = NewCCUserProvidedServiceInstanceRepository(configRepo, gateway)
return
}
func createSpacesRepo(reqs ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo SpaceRepository) {
ts, handler = testnet.NewServer(reqs)
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway(configRepo)
repo = NewCloudControllerSpaceRepository(configRepo, gateway)
return
}
func createAppSummaryRepo(requests []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo AppSummaryRepository) {
ts, handler = testnet.NewTLSServer(requests)
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerAppSummaryRepository(configRepo, gateway)
return
}
func callCreateServiceBroker(args []string, requirementsFactory *testreq.FakeReqFactory, serviceBrokerRepo *testapi.FakeServiceBrokerRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("create-service-broker", args)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewCreateServiceBroker(ui, config, serviceBrokerRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
func callSetEnv(args []string, reqFactory *testreq.FakeReqFactory, appRepo api.ApplicationRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("set-env", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewSetEnv(ui, configRepo, appRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callRenameOrg(args []string, reqFactory *testreq.FakeReqFactory, orgRepo *testapi.FakeOrgRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("rename-org", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := organization.NewRenameOrg(ui, configRepo, orgRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callScale(args []string, deps scaleDependencies) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("scale", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewScale(ui, configRepo, deps.restarter, deps.appRepo)
testcmd.RunCommand(cmd, ctxt, deps.reqFactory)
return
}
func createDomainRepo(reqs []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo DomainRepository) {
ts, handler = testnet.NewServer(reqs)
config := testconfig.NewRepositoryWithDefaults()
config.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerDomainRepository(config, gateway)
return
}
func callLogs(args []string, requirementsFactory *testreq.FakeReqFactory, logsRepo *testapi.FakeLogsRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("logs", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewLogs(ui, configRepo, logsRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
func callEvents(args []string, reqFactory *testreq.FakeReqFactory, eventsRepo *testapi.FakeAppEventsRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("events", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewEvents(ui, configRepo, eventsRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callRename(args []string, reqFactory *testreq.FakeReqFactory, appRepo *testapi.FakeApplicationRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("rename", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewRenameApp(ui, configRepo, appRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
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)
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)
repo = NewCloudControllerOrganizationRepository(configRepo, gateway)
return
}
func callUnmapRoute(args []string, reqFactory *testreq.FakeReqFactory, routeRepo *testapi.FakeRouteRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
var ctxt *cli.Context = testcmd.NewContext("unmap-route", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewUnmapRoute(ui, configRepo, routeRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callListServiceBrokers(args []string, serviceBrokerRepo *testapi.FakeServiceBrokerRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
config := testconfig.NewRepositoryWithDefaults()
ctxt := testcmd.NewContext("service-brokers", args)
cmd := NewListServiceBrokers(ui, config, serviceBrokerRepo)
testcmd.RunCommand(cmd, ctxt, &testreq.FakeReqFactory{})
return
}
func callApps(appSummaryRepo *testapi.FakeAppSummaryRepo, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
configRepo := testconfig.NewRepositoryWithDefaults()
ctxt := testcmd.NewContext("apps", []string{})
cmd := NewListApps(ui, configRepo, appSummaryRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callCreateSpace(args []string, requirementsFactory *testreq.FakeReqFactory, spaceRepo *testapi.FakeSpaceRepository, orgRepo *testapi.FakeOrgRepository, userRepo *testapi.FakeUserRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("create-space", args)
configRepo := testconfig.NewRepositoryWithDefaults()
spaceRoleSetter := user.NewSetSpaceRole(ui, configRepo, spaceRepo, userRepo)
cmd := NewCreateSpace(ui, configRepo, spaceRoleSetter, spaceRepo, orgRepo, userRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
func createPasswordRepo(req testnet.TestRequest) (passwordServer *httptest.Server, handler *testnet.TestHandler, repo PasswordRepository) {
passwordServer, handler = testnet.NewTLSServer([]testnet.TestRequest{req})
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.Endpoint = passwordServer.URL
configRepo := testconfig.NewRepositoryWithDefaults()
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerPasswordRepository(configRepo, gateway, endpointRepo)
return
}
func callShowSpace(args []string, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("space", args)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewShowSpace(ui, config)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callUnsetSpaceRole(args []string, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("unset-space-role", args)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUnsetSpaceRole(ui, config, spaceRepo, userRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
func callSsh(args []string, reqFactory *testreq.FakeReqFactory, appSshRepo *testapi.FakeAppSshRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("ssh", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewSsh(ui, configRepo, appSshRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callUpdateUserProvidedService(args []string, reqFactory *testreq.FakeReqFactory, userProvidedServiceInstanceRepo api.UserProvidedServiceInstanceRepository) (fakeUI *testterm.FakeUI) {
fakeUI = &testterm.FakeUI{}
ctxt := testcmd.NewContext("update-user-provided-service", args)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewUpdateUserProvidedService(fakeUI, config, userProvidedServiceInstanceRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callBindService(args []string, requirementsFactory *testreq.FakeReqFactory, serviceBindingRepo api.ServiceBindingRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
ctxt := testcmd.NewContext("bind-service", args)
config := testconfig.NewRepositoryWithDefaults()
cmd := NewBindService(fakeUI, config, serviceBindingRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
func callEnv(args []string, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("env", args)
configRepo := testconfig.NewRepositoryWithDefaults()
cmd := NewEnv(ui, configRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}