func TestEmptyServicesList(t *testing.T) {
serviceInstances := []cf.ServiceInstance{}
serviceSummaryRepo := &testapi.FakeServiceSummaryRepo{
GetSummariesInCurrentSpaceInstances: serviceInstances,
}
ui := &testterm.FakeUI{}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
space := cf.SpaceFields{}
space.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewListServices(ui, config, serviceSummaryRepo)
cmd.Run(testcmd.NewContext("services", []string{}))
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting services in org", "my-org", "my-space", "my-user"},
{"OK"},
{"No services found"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"name", "service", "plan", "bound apps"},
})
}
func TestListingSpaces(t *testing.T) {
spaceRepo := &testapi.FakeSpaceRepository{
Spaces: []cf.Space{
cf.Space{Name: "space1"}, cf.Space{Name: "space2"},
},
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true}
ui := callSpaces([]string{}, reqFactory, config, spaceRepo)
assert.Contains(t, ui.Outputs[0], "Getting spaces in org")
assert.Contains(t, ui.Outputs[0], "my-org")
assert.Contains(t, ui.Outputs[0], "my-user")
assert.Contains(t, ui.Outputs[1], "OK")
assert.Contains(t, ui.Outputs[3], "space1")
assert.Contains(t, ui.Outputs[4], "space2")
}
func deleteServiceBroker(t *testing.T, confirmation string, args []string) (ui *testterm.FakeUI, reqFactory *testreq.FakeReqFactory, repo *testapi.FakeServiceBrokerRepo) {
serviceBroker := cf.ServiceBroker{
Name: "service-broker-to-delete",
Guid: "service-broker-to-delete-guid",
}
reqFactory = &testreq.FakeReqFactory{LoginSuccess: true}
repo = &testapi.FakeServiceBrokerRepo{FindByNameServiceBroker: serviceBroker}
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
ctxt := testcmd.NewContext("delete-service-broker", args)
cmd := NewDeleteServiceBroker(ui, config, repo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callListQuotas(t *testing.T, reqFactory *testreq.FakeReqFactory, quotaRepo *testapi.FakeQuotaRepository) (fakeUI *testterm.FakeUI) {
fakeUI = &testterm.FakeUI{}
ctxt := testcmd.NewContext("quotas", []string{})
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
spaceFields := cf.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := cf.OrganizationFields{}
orgFields.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: spaceFields,
OrganizationFields: orgFields,
AccessToken: token,
}
cmd := organization.NewListQuotas(fakeUI, config, quotaRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func TestListAllPagesOfOrgs(t *testing.T) {
org1 := cf.Organization{}
org1.Name = "Organization-1"
org2 := cf.Organization{}
org2.Name = "Organization-2"
org3 := cf.Organization{}
org3.Name = "Organization-3"
orgRepo := &testapi.FakeOrgRepository{
Organizations: []cf.Organization{org1, org2, org3},
}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
tokenInfo := configuration.TokenInfo{Username: "******"}
accessToken, err := testconfig.CreateAccessTokenWithTokenInfo(tokenInfo)
assert.NoError(t, err)
config := &configuration.Configuration{AccessToken: accessToken}
ui := callListOrgs(config, reqFactory, orgRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting orgs as my-user"},
{"Organization-1"},
{"Organization-2"},
{"Organization-3"},
})
}
func callListRoutes(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, routeRepo *testapi.FakeRouteRepository) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("routes", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
space := cf.SpaceFields{}
space.Name = "my-space"
org := cf.OrganizationFields{}
org.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewListRoutes(ui, config, routeRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func deleteSpace(t *testing.T, confirmation string, args []string) (ui *testterm.FakeUI, spaceRepo *testapi.FakeSpaceRepository) {
space := cf.Space{Name: "space-to-delete", Guid: "space-to-delete-guid"}
reqFactory := &testreq.FakeReqFactory{}
spaceRepo = &testapi.FakeSpaceRepository{FindByNameSpace: space}
configRepo := &testconfig.FakeConfigRepository{}
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
ctxt := testcmd.NewContext("delete-space", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewDeleteSpace(ui, config, spaceRepo, configRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func deleteWithConfirmation(t *testing.T, confirmation string) (ui *testterm.FakeUI, userRepo *testapi.FakeUserRepository) {
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
userRepo = &testapi.FakeUserRepository{
FindByUsernameUser: cf.User{Username: "******", Guid: "my-found-user-guid"},
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewDeleteUser(ui, config, userRepo)
ctxt := testcmd.NewContext("delete-user", []string{"my-user"})
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func deleteApp(t *testing.T, confirmation string, args []string) (ui *testterm.FakeUI, reqFactory *testreq.FakeReqFactory, appRepo *testapi.FakeApplicationRepository) {
app := cf.Application{}
app.Name = "app-to-delete"
app.Guid = "app-to-delete-guid"
reqFactory = &testreq.FakeReqFactory{}
appRepo = &testapi.FakeApplicationRepository{ReadApp: app}
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
space := cf.SpaceFields{}
space.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
ctxt := testcmd.NewContext("delete", args)
cmd := NewDeleteApp(ui, config, appRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callDeleteServiceAuthToken(t *testing.T, args []string, inputs []string, reqFactory *testreq.FakeReqFactory, authTokenRepo *testapi.FakeAuthTokenRepo) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{
Inputs: inputs,
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
space := cf.SpaceFields{}
space.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewDeleteServiceAuthToken(ui, config, authTokenRepo)
ctxt := testcmd.NewContext("delete-service-auth-token", args)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callStacks(t *testing.T, stackRepo *testapi.FakeStackRepository) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("stacks", []string{})
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
space := cf.SpaceFields{}
space.Name = "my-space"
org := cf.OrganizationFields{}
org.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewStacks(ui, config, stackRepo)
testcmd.RunCommand(cmd, ctxt, nil)
return
}
func callDeleteDomain(t *testing.T, args []string, inputs []string, reqFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (ui *testterm.FakeUI) {
ctxt := testcmd.NewContext("delete-domain", args)
ui = &testterm.FakeUI{
Inputs: inputs,
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
spaceFields := cf.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := cf.OrganizationFields{}
orgFields.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: spaceFields,
OrganizationFields: orgFields,
AccessToken: token,
}
cmd := domain.NewDeleteDomain(ui, config, domainRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func deleteOrg(t *testing.T, confirmation string, args []string, orgRepo *testapi.FakeOrgRepository) (ui *testterm.FakeUI) {
reqFactory := &testreq.FakeReqFactory{}
configRepo := &testconfig.FakeConfigRepository{}
ui = &testterm.FakeUI{
Inputs: []string{confirmation},
}
ctxt := testcmd.NewContext("delete-org", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
spaceFields := cf.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := cf.OrganizationFields{}
orgFields.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: spaceFields,
OrganizationFields: orgFields,
AccessToken: token,
}
cmd := NewDeleteOrg(ui, config, orgRepo, configRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callRenameOrg(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, orgRepo *testapi.FakeOrgRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("rename-org", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
spaceFields := cf.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := cf.OrganizationFields{}
orgFields.Name = "my-org"
config := &configuration.Configuration{
SpaceFields: spaceFields,
OrganizationFields: orgFields,
AccessToken: token,
}
cmd := organization.NewRenameOrg(ui, config, orgRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callDomainMapper(t *testing.T, shouldMap bool, args []string, reqFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (ui *testterm.FakeUI) {
cmdName := "map-domain"
if !shouldMap {
cmdName = "unmap-domain"
}
ctxt := testcmd.NewContext(cmdName, args)
ui = &testterm.FakeUI{}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
orgFields := cf.OrganizationFields{}
orgFields.Name = "my-org"
spaceFields := cf.SpaceFields{}
spaceFields.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: spaceFields,
OrganizationFields: orgFields,
AccessToken: token,
}
cmd := domain.NewDomainMapper(ui, config, domainRepo, shouldMap)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func TestListingSpaces(t *testing.T) {
space := cf.Space{}
space.Name = "space1"
space2 := cf.Space{}
space2.Name = "space2"
space3 := cf.Space{}
space3.Name = "space3"
spaceRepo := &testapi.FakeSpaceRepository{
Spaces: []cf.Space{space, space2, space3},
}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
config := &configuration.Configuration{
OrganizationFields: org,
AccessToken: token,
}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true}
ui := callSpaces([]string{}, reqFactory, config, spaceRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting spaces in org", "my-org", "my-user"},
{"space1"},
{"space2"},
{"space3"},
})
}
func callPush(t *testing.T,
args []string,
starter ApplicationStarter,
stopper ApplicationStopper,
appRepo api.ApplicationRepository,
domainRepo api.DomainRepository,
routeRepo api.RouteRepository,
stackRepo api.StackRepository,
appBitsRepo *testapi.FakeApplicationBitsRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
ctxt := testcmd.NewContext("push", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewPush(fakeUI, config, starter, stopper, appRepo, domainRepo, routeRepo, stackRepo, appBitsRepo)
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func TestListAllPagesOfOrgs(t *testing.T) {
orgs := []cf.Organization{
cf.Organization{Name: "Organization-1"},
cf.Organization{Name: "Organization-2"},
cf.Organization{Name: "Organization-3"},
}
orgRepo := &testapi.FakeOrgRepository{
Organizations: orgs,
}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
tokenInfo := configuration.TokenInfo{Username: "******"}
accessToken, err := testconfig.CreateAccessTokenWithTokenInfo(tokenInfo)
assert.NoError(t, err)
config := &configuration.Configuration{AccessToken: accessToken}
ui := callListOrgs(config, reqFactory, orgRepo)
testassert.SliceContains(t, ui.Outputs, []string{
"Getting orgs as my-user",
"Organization-1",
"Organization-2",
"Organization-3",
})
}
func callRenameService(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI, serviceRepo *testapi.FakeServiceRepo) {
ui = &testterm.FakeUI{}
serviceRepo = &testapi.FakeServiceRepo{}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
space := cf.SpaceFields{}
space.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewRenameService(ui, config, serviceRepo)
ctxt := testcmd.NewContext("rename-service", args)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func TestServices(t *testing.T) {
plan := cf.ServicePlanFields{}
plan.Guid = "spark-guid"
plan.Name = "spark"
offering := cf.ServiceOfferingFields{}
offering.Label = "cleardb"
serviceInstance := cf.ServiceInstance{}
serviceInstance.Name = "my-service-1"
serviceInstance.ServicePlan = plan
serviceInstance.ApplicationNames = []string{"cli1", "cli2"}
serviceInstance.ServiceOffering = offering
plan2 := cf.ServicePlanFields{}
plan2.Guid = "spark-guid-2"
plan2.Name = "spark-2"
serviceInstance2 := cf.ServiceInstance{}
serviceInstance2.Name = "my-service-2"
serviceInstance2.ServicePlan = plan2
serviceInstance2.ApplicationNames = []string{"cli1"}
serviceInstance2.ServiceOffering = offering
serviceInstance3 := cf.ServiceInstance{}
serviceInstance3.Name = "my-service-provided-by-user"
serviceInstances := []cf.ServiceInstance{serviceInstance, serviceInstance2, serviceInstance3}
serviceSummaryRepo := &testapi.FakeServiceSummaryRepo{
GetSummariesInCurrentSpaceInstances: serviceInstances,
}
ui := &testterm.FakeUI{}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
space := cf.SpaceFields{}
space.Name = "my-space"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
cmd := NewListServices(ui, config, serviceSummaryRepo)
cmd.Run(testcmd.NewContext("services", []string{}))
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting services in org", "my-org", "my-space", "my-user"},
{"OK"},
{"my-service-1", "cleardb", "spark", "cli1, cli2"},
{"my-service-2", "cleardb", "spark-2", "cli1"},
{"my-service-provided-by-user", "user-provided"},
})
}
func startAppWithInstancesAndErrors(t *testing.T, app cf.Application, instances [][]cf.ApplicationInstance, errorCodes []string) (ui *testterm.FakeUI, appRepo *testapi.FakeApplicationRepository, reqFactory *testreq.FakeReqFactory) {
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
ApplicationStartTimeout: 2,
}
appRepo = &testapi.FakeApplicationRepository{
FindByNameApp: app,
GetInstancesResponses: instances,
GetInstancesErrorCodes: errorCodes,
}
currentTime := time.Now()
messageType := logmessage.LogMessage_ERR
sourceType := logmessage.LogMessage_DEA
logMessage1 := logmessage.LogMessage{
Message: []byte("Log Line 1"),
AppId: proto.String(app.Guid),
MessageType: &messageType,
SourceType: &sourceType,
Timestamp: proto.Int64(currentTime.UnixNano()),
}
logMessage2 := logmessage.LogMessage{
Message: []byte("Log Line 2"),
AppId: proto.String(app.Guid),
MessageType: &messageType,
SourceType: &sourceType,
Timestamp: proto.Int64(currentTime.UnixNano()),
}
logRepo := &testapi.FakeLogsRepository{
TailLogMessages: []logmessage.LogMessage{
logMessage1,
logMessage2,
},
}
args := []string{"my-app"}
reqFactory = &testreq.FakeReqFactory{Application: app}
ui = callStart(args, config, reqFactory, appRepo, logRepo)
return
}
func TestMarketplaceServices(t *testing.T) {
plan := cf.ServicePlanFields{}
plan.Name = "service-plan-a"
plan2 := cf.ServicePlanFields{}
plan2.Name = "service-plan-b"
plan3 := cf.ServicePlanFields{}
plan3.Name = "service-plan-c"
plan4 := cf.ServicePlanFields{}
plan4.Name = "service-plan-d"
offering := cf.ServiceOffering{}
offering.Label = "zzz-my-service-offering"
offering.Description = "service offering 1 description"
offering.Plans = []cf.ServicePlanFields{plan, plan2}
offering2 := cf.ServiceOffering{}
offering2.Label = "aaa-my-service-offering"
offering2.Description = "service offering 2 description"
offering2.Plans = []cf.ServicePlanFields{plan3, plan4}
serviceOfferings := []cf.ServiceOffering{offering, offering2}
serviceRepo := &testapi.FakeServiceRepo{ServiceOfferings: serviceOfferings}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
org.Guid = "my-org-guid"
space := cf.SpaceFields{}
space.Name = "my-space"
space.Guid = "my-space-guid"
config := &configuration.Configuration{
SpaceFields: space,
OrganizationFields: org,
AccessToken: token,
}
ui := callMarketplaceServices(t, config, serviceRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting services from marketplace in org", "my-org", "my-space", "my-user"},
{"OK"},
{"service", "plans", "description"},
{"aaa-my-service-offering", "service offering 2 description", "service-plan-c", "service-plan-d"},
{"zzz-my-service-offering", "service offering 1 description", "service-plan-a", "service-plan-b"},
})
}
func TestMarketplaceServices(t *testing.T) {
serviceOfferings := []cf.ServiceOffering{
cf.ServiceOffering{
Label: "my-service-offering-1",
Description: "service offering 1 description",
Plans: []cf.ServicePlan{
cf.ServicePlan{Name: "service-plan-a"},
cf.ServicePlan{Name: "service-plan-b"},
},
},
cf.ServiceOffering{
Label: "my-service-offering-2",
Description: "service offering 2 description",
Plans: []cf.ServicePlan{
cf.ServicePlan{Name: "service-plan-c"},
cf.ServicePlan{Name: "service-plan-d"},
},
},
}
serviceRepo := &testapi.FakeServiceRepo{ServiceOfferings: serviceOfferings}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space", Guid: "my-space-guid"},
Organization: cf.Organization{Name: "my-org", Guid: "my-org-guid"},
AccessToken: token,
}
ui := callMarketplaceServices(t, config, serviceRepo)
assert.Contains(t, ui.Outputs[0], "Getting services from marketplace in org")
assert.Contains(t, ui.Outputs[0], "my-org")
assert.Contains(t, ui.Outputs[0], "my-space")
assert.Contains(t, ui.Outputs[0], "my-user")
assert.Contains(t, ui.Outputs[1], "OK")
assert.Contains(t, ui.Outputs[4], "my-service-offering-1")
assert.Contains(t, ui.Outputs[4], "service offering 1 description")
assert.Contains(t, ui.Outputs[4], "service-plan-a, service-plan-b")
assert.Contains(t, ui.Outputs[5], "my-service-offering-2")
assert.Contains(t, ui.Outputs[5], "service offering 2 description")
assert.Contains(t, ui.Outputs[5], "service-plan-c, service-plan-d")
}
func callShowSpace(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, config *configuration.Configuration) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("space", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config.Organization = cf.Organization{Name: "my-org"}
config.AccessToken = token
cmd := NewShowSpace(ui, config)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callShareDomain(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
ctxt := testcmd.NewContext("share-domain", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
AccessToken: token,
}
cmd := NewShareDomain(fakeUI, config, domainRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func TestUpdatePassword(t *testing.T) {
req := testapi.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "PUT",
Path: "/Users/my-user-guid/password",
Matcher: testnet.RequestBodyMatcher(`{"password":"******","oldPassword":"******"}`),
Response: testnet.TestResponse{Status: http.StatusOK},
})
accessToken, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{UserGuid: "my-user-guid"})
assert.NoError(t, err)
passwordUpdateServer, handler, repo := createPasswordRepo(t, req, accessToken)
defer passwordUpdateServer.Close()
apiResponse := repo.UpdatePassword("old-password", "new-password")
assert.True(t, handler.AllRequestsCalled())
assert.False(t, apiResponse.IsNotSuccessful())
}
func callRenameSpace(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, spaceRepo *testapi.FakeSpaceRepository) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
ctxt := testcmd.NewContext("create-space", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewRenameSpace(ui, config, spaceRepo, testconfig.FakeConfigRepository{})
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callListDomains(t *testing.T, args []string, reqFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
ctxt := testcmd.NewContext("domains", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewListDomains(fakeUI, config, domainRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callUnsetSpaceRole(t *testing.T, args []string, spaceRepo *testapi.FakeSpaceRepository, userRepo *testapi.FakeUserRepository, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
ctxt := testcmd.NewContext("unset-space-role", args)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "my-space"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
cmd := NewUnsetSpaceRole(ui, config, spaceRepo, userRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
func callApps(t *testing.T, appSummaryRepo *testapi.FakeAppSummaryRepo, reqFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{}
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
config := &configuration.Configuration{
Space: cf.Space{Name: "development"},
Organization: cf.Organization{Name: "my-org"},
AccessToken: token,
}
ctxt := testcmd.NewContext("apps", []string{})
cmd := NewListApps(ui, config, appSummaryRepo)
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}