func createUsersRepo(t *testing.T, ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewTLSServer(t, ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewTLSServer(t, uaaReqs)
uaaTarget = uaa.URL
}
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ccTarget,
Organization: cf.Organization{Guid: "some-org-guid"},
}
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{GetEndpointEndpoints: map[cf.EndpointType]string{
cf.UaaEndpointKey: uaaTarget,
}}
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway, endpointRepo)
return
}
func createUsersRepo(t *testing.T, ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewTLSServer(t, ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewTLSServer(t, uaaReqs)
uaaTarget = uaa.URL
}
org := cf.OrganizationFields{}
org.Guid = "some-org-guid"
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ccTarget,
OrganizationFields: org,
}
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.Endpoint = uaaTarget
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway, endpointRepo)
return
}
func TestListEventsWithNoEvents(t *testing.T) {
emptyEventsRequest := testnet.TestRequest{
Method: "GET",
Path: "/v2/apps/my-app-guid/events",
Response: testnet.TestResponse{
Status: http.StatusOK,
Body: `{"resources": []}`},
}
listEventsServer, handler := testnet.NewTLSServer(t, []testnet.TestRequest{emptyEventsRequest})
defer listEventsServer.Close()
config := &configuration.Configuration{
Target: listEventsServer.URL,
AccessToken: "BEARER my_access_token",
}
repo := NewCloudControllerAppEventsRepository(config, net.NewCloudControllerGateway())
eventChan, apiErr := repo.ListEvents("my-app-guid")
_, ok := <-eventChan
_, open := <-apiErr
assert.False(t, ok)
assert.False(t, open)
assert.True(t, handler.AllRequestsCalled())
}
func setupAuthDependencies(request testnet.TestRequest) (*httptest.Server, *testnet.TestHandler, configuration.ReadWriter) {
ts, handler := testnet.NewTLSServer([]testnet.TestRequest{request})
config := testconfig.NewRepository()
config.SetAuthorizationEndpoint(ts.URL)
return ts, handler, config
}
func TestCurlWithCustomHeaders(t *testing.T) {
req := testapi.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "POST",
Path: "/v2/endpoint",
Matcher: func(t *testing.T, req *http.Request) {
assert.Equal(t, req.Header.Get("content-type"), "ascii/cats")
assert.Equal(t, req.Header.Get("x-something-else"), "5")
},
Response: testnet.TestResponse{
Status: http.StatusOK,
Body: jsonResponse},
})
ts, handler := testnet.NewTLSServer(t, []testnet.TestRequest{req})
defer ts.Close()
deps := newCurlDependencies()
deps.config.Target = ts.URL
headers := "content-type: ascii/cats\nx-something-else:5"
repo := NewCloudControllerCurlRepository(deps.config, deps.gateway)
_, _, apiResponse := repo.Request("POST", "/v2/endpoint", headers, "")
println(apiResponse.Message)
assert.True(t, handler.AllRequestsCalled())
assert.True(t, apiResponse.IsSuccessful())
}
func testUploadApp(t *testing.T, dir string, requests []testnet.TestRequest) (app cf.Application, apiResponse net.ApiResponse) {
ts, handler := testnet.NewTLSServer(t, requests)
defer ts.Close()
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
}
gateway := net.NewCloudControllerGateway()
gateway.PollingThrottle = time.Duration(0)
zipper := cf.ApplicationZipper{}
repo := NewCloudControllerApplicationBitsRepository(config, gateway, zipper)
var reportedFileCount, reportedUploadSize uint64
apiResponse = repo.UploadApp("my-cool-app-guid", dir, func(uploadSize, fileCount uint64) {
reportedUploadSize = uploadSize
reportedFileCount = fileCount
})
assert.Equal(t, reportedFileCount, uint64(len(expectedApplicationContent)))
assert.Equal(t, reportedUploadSize, uint64(759))
assert.True(t, handler.AllRequestsCalled())
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 createUserProvidedServiceInstanceRepo(req testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo UserProvidedServiceInstanceRepository) {
ts, handler = testnet.NewTLSServer([]testnet.TestRequest{req})
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCCUserProvidedServiceInstanceRepository(configRepo, gateway)
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 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 setupAuthDependencies(request testnet.TestRequest) (deps authDependencies) {
deps.ts, deps.handler = testnet.NewTLSServer([]testnet.TestRequest{request})
deps.config = testconfig.NewRepository()
deps.config.SetAuthorizationEndpoint(deps.ts.URL)
deps.gateway = net.NewUAAGateway()
return
}
func createAppInstancesRepo(requests []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo AppInstancesRepository) {
ts, handler = testnet.NewTLSServer(requests)
space := models.SpaceFields{}
space.Guid = "my-space-guid"
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerAppInstancesRepository(configRepo, gateway)
return
}
func createServiceRepoWithConfig(reqs []testnet.TestRequest, config configuration.ReadWriter) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceRepository) {
if len(reqs) > 0 {
ts, handler = testnet.NewTLSServer(reqs)
config.SetApiEndpoint(ts.URL)
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerServiceRepository(config, gateway)
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 createServiceRepoWithConfig(t *testing.T, reqs []testnet.TestRequest, config *configuration.Configuration) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceRepository) {
if len(reqs) > 0 {
ts, handler = testnet.NewTLSServer(t, reqs)
config.Target = ts.URL
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerServiceRepository(config, gateway)
return
}
func createOrgPaginator(t *testing.T, reqs ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, p *paginator.OrganizationPaginator) {
ts, handler = testnet.NewTLSServer(t, reqs)
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
}
gateway := net.NewCloudControllerGateway()
p = paginator.NewOrganizationPaginator(config, gateway)
return
}
func createQuotaRepo(t *testing.T, req testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo QuotaRepository) {
ts, handler = testnet.NewTLSServer(t, []testnet.TestRequest{req})
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerQuotaRepository(config, gateway)
return
}
func createRoutesRepo(requests ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo CloudControllerRouteRepository, domainRepo *testapi.FakeDomainRepository) {
ts, handler = testnet.NewTLSServer(requests)
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
gateway := net.NewCloudControllerGateway()
domainRepo = &testapi.FakeDomainRepository{}
repo = NewCloudControllerRouteRepository(configRepo, gateway, domainRepo)
return
}
func createServiceBrokerRepo(t *testing.T, requests ...testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceBrokerRepository) {
ts, handler = testnet.NewTLSServer(t, requests)
config := &configuration.Configuration{
Target: ts.URL,
AccessToken: "BEARER my_access_token",
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerServiceBrokerRepository(config, gateway)
return
}
func createAppRepo(t *testing.T, requests []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo ApplicationRepository) {
ts, handler = testnet.NewTLSServer(t, requests)
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
Space: cf.Space{Name: "my-space", Guid: "my-space-guid"},
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerApplicationRepository(config, gateway)
return
}
func setupEventTest(requests []testnet.TestRequest) (deps eventTestDependencies) {
deps.server, deps.handler = testnet.NewTLSServer(requests)
configRepo := testconfig.NewRepository()
configRepo.SetApiEndpoint(deps.server.URL)
configRepo.SetAccessToken("BEARER my_access_token")
deps.config = configRepo
deps.gateway = net.NewCloudControllerGateway()
return
}
func createServiceSummaryRepo(t *testing.T, req testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo ServiceSummaryRepository) {
ts, handler = testnet.NewTLSServer(t, []testnet.TestRequest{req})
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
Space: cf.Space{Guid: "my-space-guid"},
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerServiceSummaryRepository(config, gateway)
return
}
func createPasswordRepo(t *testing.T, req testnet.TestRequest, accessToken string) (passwordServer *httptest.Server, handler *testnet.TestHandler, repo PasswordRepository) {
passwordServer, handler = testnet.NewTLSServer(t, []testnet.TestRequest{req})
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.Endpoint = passwordServer.URL
config := &configuration.Configuration{
AccessToken: accessToken,
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerPasswordRepository(config, gateway, endpointRepo)
return
}
func createDomainRepo(t *testing.T, reqs []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo DomainRepository) {
ts, handler = testnet.NewTLSServer(t, reqs)
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
Space: cf.Space{Guid: "my-space-guid"},
Organization: cf.Organization{Guid: "my-org-guid"},
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerDomainRepository(config, gateway)
return
}
func createAppInstancesRepo(t *testing.T, requests []testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo AppInstancesRepository) {
ts, handler = testnet.NewTLSServer(t, requests)
space := cf.SpaceFields{}
space.Guid = "my-space-guid"
config := &configuration.Configuration{
SpaceFields: space,
AccessToken: "BEARER my_access_token",
Target: ts.URL,
}
gateway := net.NewCloudControllerGateway()
repo = NewCloudControllerAppInstancesRepository(config, gateway)
return
}
func TestListFiles(t *testing.T) {
expectedResponse := "file 1\n file 2\n file 3"
listFilesEndpoint := func(writer http.ResponseWriter, request *http.Request) {
methodMatches := request.Method == "GET"
pathMatches := request.URL.Path == "/some/path"
if !methodMatches || !pathMatches {
fmt.Printf("One of the matchers did not match. Method [%t] Path [%t]",
methodMatches, pathMatches)
writer.WriteHeader(http.StatusInternalServerError)
return
}
writer.WriteHeader(http.StatusOK)
fmt.Fprint(writer, expectedResponse)
}
listFilesServer := httptest.NewTLSServer(http.HandlerFunc(listFilesEndpoint))
defer listFilesServer.Close()
req := testapi.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
Path: "/v2/apps/my-app-guid/instances/0/files/some/path",
Response: testnet.TestResponse{
Status: http.StatusTemporaryRedirect,
Header: http.Header{
"Location": {fmt.Sprintf("%s/some/path", listFilesServer.URL)},
},
},
})
listFilesRedirectServer, handler := testnet.NewTLSServer(t, []testnet.TestRequest{req})
defer listFilesRedirectServer.Close()
config := &configuration.Configuration{
Target: listFilesRedirectServer.URL,
AccessToken: "BEARER my_access_token",
}
gateway := net.NewCloudControllerGateway()
repo := NewCloudControllerAppFilesRepository(config, gateway)
list, err := repo.ListFiles(cf.Application{Guid: "my-app-guid"}, "some/path")
assert.True(t, handler.AllRequestsCalled())
assert.False(t, err.IsNotSuccessful())
assert.Equal(t, list, expectedResponse)
}
func createRoutesRepo(t *testing.T, request testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, repo CloudControllerRouteRepository, domainRepo *testapi.FakeDomainRepository) {
ts, handler = testnet.NewTLSServer(t, []testnet.TestRequest{request})
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ts.URL,
Space: cf.Space{Guid: "my-space-guid"},
}
gateway := net.NewCloudControllerGateway()
domainRepo = &testapi.FakeDomainRepository{}
repo = NewCloudControllerRouteRepository(config, gateway, domainRepo)
return
}
func setupAuthWithEndpoint(t *testing.T, request testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, auth UAAAuthenticationRepository) {
ts, handler = testnet.NewTLSServer(t, []testnet.TestRequest{request})
configRepo := testconfig.FakeConfigRepository{}
configRepo.Delete()
config, err := configRepo.Get()
assert.NoError(t, err)
config.AuthorizationEndpoint = ts.URL
config.AccessToken = ""
gateway := net.NewUAAGateway()
auth = NewUAAAuthenticationRepository(gateway, configRepo)
return
}
func createUsersRepo(ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewTLSServer(ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewTLSServer(uaaReqs)
uaaTarget = uaa.URL
}
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ccTarget)
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.Endpoint = uaaTarget
repo = NewCloudControllerUserRepository(configRepo, uaaGateway, ccGateway, endpointRepo)
return
}