func TestLoggingInWithTooManyOrgsDoesNotShowOrgList(t *testing.T) {
c := LoginTestContext{
Inputs: []string{"api.example.com", "*****@*****.**", "password", "my-org-1", "my-space"},
}
callLogin(t, &c, func(c *LoginTestContext) {
for i := 0; i < 60; i++ {
id := strconv.Itoa(i)
org := cf.Organization{}
org.Guid = "my-org-guid-" + id
org.Name = "my-org-" + id
c.orgRepo.Organizations = append(c.orgRepo.Organizations, org)
}
c.orgRepo.FindByNameOrganization = c.orgRepo.Organizations[1]
space1 := cf.Space{}
space1.Guid = "my-space-guid"
space1.Name = "my-space"
space2 := cf.Space{}
space2.Guid = "some-space-guid"
space2.Name = "some-space"
c.spaceRepo.Spaces = []cf.Space{space1, space2}
})
savedConfig := testconfig.SavedConfiguration
testassert.SliceDoesNotContain(t, c.ui.Outputs, testassert.Lines{
{"my-org-2"},
})
assert.Equal(t, c.orgRepo.FindByNameName, "my-org-1")
assert.Equal(t, savedConfig.OrganizationFields.Guid, "my-org-guid-1")
}
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 TestGetRequestWithMultipleHeaderFlags(t *testing.T) {
deps := newCurlDependencies()
runCurlWithInputs(deps, []string{"-H", "Content-Type:cat", "-H", "Content-Length:12", "/foo"})
assert.Equal(t, deps.curlRepo.Header, "Content-Type:cat\nContent-Length:12")
testassert.SliceDoesNotContain(t, deps.ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestRequestWithMethodFlag(t *testing.T) {
deps := newCurlDependencies()
runCurlWithInputs(deps, []string{"-X", "post", "/foo"})
assert.Equal(t, deps.curlRepo.Method, "post")
testassert.SliceDoesNotContain(t, deps.ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestGetRequestWithDataFlag(t *testing.T) {
deps := newCurlDependencies()
runCurlWithInputs(deps, []string{"-d", "body content to upload", "/foo"})
assert.Equal(t, deps.curlRepo.Body, "body content to upload")
testassert.SliceDoesNotContain(t, deps.ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestPushingWithDefaultManifestNotFound(t *testing.T) {
deps := getPushDependencies()
deps.appRepo.ReadNotFound = true
deps.manifestRepo.ReadManifestManifest = singleAppManifest()
deps.manifestRepo.ReadManifestErrors = manifest.ManifestErrors{syscall.ENOENT}
ui := callPush(t, []string{"--no-route", "app-name"}, deps)
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestPushingWithNoManifestFlag(t *testing.T) {
deps := getPushDependencies()
deps.appRepo.ReadNotFound = true
ui := callPush(t, []string{"--no-route", "--no-manifest", "app-name"}, deps)
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"FAILED"},
{"hacker-manifesto"},
})
assert.Equal(t, deps.manifestRepo.ReadManifestPath, "")
assert.Equal(t, deps.appRepo.CreatedAppParams().Get("name").(string), "app-name")
}
func TestCreateBuildpackWithPosition(t *testing.T) {
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
repo, bitsRepo := getRepositories()
ui := callCreateBuildpack([]string{"my-buildpack", "my.war", "5"}, reqFactory, repo, bitsRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating buildpack", "my-buildpack"},
{"OK"},
{"Uploading buildpack", "my-buildpack"},
{"OK"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestGetRequestWithIncludeFlag(t *testing.T) {
deps := newCurlDependencies()
deps.curlRepo.ResponseHeader = "Content-Size:1024"
deps.curlRepo.ResponseBody = "response for get"
runCurlWithInputs(deps, []string{"-i", "/foo"})
testassert.SliceContains(t, deps.ui.Outputs, testassert.Lines{
{"Content-Size:1024"},
{"response for get"},
})
testassert.SliceDoesNotContain(t, deps.ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestCreateBuildpackWhenItAlreadyExists(t *testing.T) {
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
repo, bitsRepo := getRepositories()
repo.CreateBuildpackExists = true
ui := callCreateBuildpack([]string{"my-buildpack", "my.war", "5"}, reqFactory, repo, bitsRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating buildpack", "my-buildpack"},
{"OK"},
{"my-buildpack", "already exists"},
{"tip", "update-buildpack"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestRequestWithNoFlags(t *testing.T) {
deps := newCurlDependencies()
deps.curlRepo.ResponseHeader = "Content-Size:1024"
deps.curlRepo.ResponseBody = "response for get"
runCurlWithInputs(deps, []string{"/foo"})
assert.Equal(t, deps.curlRepo.Method, "GET")
assert.Equal(t, deps.curlRepo.Path, "/foo")
testassert.SliceContains(t, deps.ui.Outputs, testassert.Lines{
{"response for get"},
})
testassert.SliceDoesNotContain(t, deps.ui.Outputs, testassert.Lines{
{"FAILED"},
{"Content-Size:1024"},
})
}
func TestMarketplaceServicesWhenNotLoggedIn(t *testing.T) {
serviceOfferings := []cf.ServiceOffering{}
serviceRepo := &testapi.FakeServiceRepo{ServiceOfferings: serviceOfferings}
config := &configuration.Configuration{}
ui := callMarketplaceServices(t, config, serviceRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Getting services from marketplace..."},
{"OK"},
{"No service offerings found"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"service", "plans", "description"},
})
}
func TestCreateBuildpackEnabled(t *testing.T) {
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
repo, bitsRepo := getRepositories()
ui := callCreateBuildpack([]string{"--enable", "my-buildpack", "my.war", "5"}, reqFactory, repo, bitsRepo)
assert.NotNil(t, repo.CreateBuildpack.Enabled)
assert.Equal(t, *repo.CreateBuildpack.Enabled, true)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"creating buildpack", "my-buildpack"},
{"OK"},
{"uploading buildpack", "my-buildpack"},
{"OK"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"FAILED"},
})
}
func TestCreateSpaceWhenItAlreadyExists(t *testing.T) {
resetSpaceDefaults()
defaultSpaceRepo.CreateSpaceExists = true
ui := callCreateSpace(t, []string{"my-space"}, defaultReqFactory, defaultSpaceRepo, defaultOrgRepo, defaultUserRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating space", "my-space"},
{"OK"},
{"my-space", "already exists"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"Assigning", "my-user", "my-space", cf.SpaceRoleToUserInput[cf.SPACE_MANAGER]},
})
assert.Equal(t, defaultSpaceRepo.CreateSpaceName, "")
assert.Equal(t, defaultSpaceRepo.CreateSpaceOrgGuid, "")
assert.Equal(t, defaultUserRepo.SetSpaceRoleUserGuid, "")
assert.Equal(t, defaultUserRepo.SetSpaceRoleSpaceGuid, "")
}
func TestPushingAppWhenItAlreadyExistsAndNoHostFlagIsPresent(t *testing.T) {
deps := getPushDependencies()
domain := cf.Domain{}
domain.Name = "example.com"
domain.Guid = "domain-guid"
domain.Shared = true
existingRoute := cf.RouteSummary{}
existingRoute.Host = "existing-app"
existingRoute.Domain = domain.DomainFields
existingApp := cf.Application{}
existingApp.Name = "existing-app"
existingApp.Guid = "existing-app-guid"
existingApp.Routes = []cf.RouteSummary{existingRoute}
deps.appRepo.ReadApp = existingApp
deps.appRepo.UpdateAppResult = existingApp
deps.routeRepo.FindByHostAndDomainNotFound = true
deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{domain}
ui := callPush(t, []string{"--no-hostname", "existing-app"}, deps)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating route", "example.com"},
{"OK"},
{"Binding", "example.com"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"existing-app.example.com"},
})
assert.Equal(t, deps.routeRepo.FindByHostAndDomainDomain, "example.com")
assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "")
assert.Equal(t, deps.routeRepo.CreatedHost, "")
assert.Equal(t, deps.routeRepo.CreatedDomainGuid, "domain-guid")
}
func TestStartApplicationOnlyShowsCurrentStagingLogs(t *testing.T) {
t.Parallel()
displayApp := &testcmd.FakeAppDisplayer{}
reqFactory := &testreq.FakeReqFactory{Application: defaultAppForStart}
appRepo := &testapi.FakeApplicationRepository{
ReadApp: defaultAppForStart,
UpdateAppResult: defaultAppForStart,
}
appInstancesRepo := &testapi.FakeAppInstancesRepo{
GetInstancesResponses: defaultInstanceReponses,
GetInstancesErrorCodes: defaultInstanceErrorCodes,
}
currentTime := time.Now()
wrongSourceName := "DEA"
correctSourceName := "STG"
logRepo := &testapi.FakeLogsRepository{
TailLogMessages: []*logmessage.Message{
NewLogMessage("Log Line 1", defaultAppForStart.Guid, wrongSourceName, currentTime),
NewLogMessage("Log Line 2", defaultAppForStart.Guid, correctSourceName, currentTime),
NewLogMessage("Log Line 3", defaultAppForStart.Guid, correctSourceName, currentTime),
NewLogMessage("Log Line 4", defaultAppForStart.Guid, wrongSourceName, currentTime),
},
}
ui := callStart([]string{"my-app"}, &configuration.Configuration{}, reqFactory, displayApp, appRepo, appInstancesRepo, logRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Log Line 2"},
{"Log Line 3"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"Log Line 1"},
{"Log Line 4"},
})
}
func TestStartApplicationWhenStartTimesOut(t *testing.T) {
t.Parallel()
displayApp := &testcmd.FakeAppDisplayer{}
appInstance := cf.AppInstanceFields{}
appInstance.State = cf.InstanceStarting
appInstance2 := cf.AppInstanceFields{}
appInstance2.State = cf.InstanceStarting
appInstance3 := cf.AppInstanceFields{}
appInstance3.State = cf.InstanceStarting
appInstance4 := cf.AppInstanceFields{}
appInstance4.State = cf.InstanceDown
appInstance5 := cf.AppInstanceFields{}
appInstance5.State = cf.InstanceDown
appInstance6 := cf.AppInstanceFields{}
appInstance6.State = cf.InstanceDown
instances := [][]cf.AppInstanceFields{
[]cf.AppInstanceFields{appInstance, appInstance2},
[]cf.AppInstanceFields{appInstance3, appInstance4},
[]cf.AppInstanceFields{appInstance5, appInstance6},
}
errorCodes := []string{"500", "500", "500"}
ui, _, _, _ := startAppWithInstancesAndErrors(t, displayApp, defaultAppForStart, instances, errorCodes, 0)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Starting", "my-app"},
{"OK"},
{"FAILED"},
{"Start app timeout"},
})
testassert.SliceDoesNotContain(t, ui.Outputs, testassert.Lines{
{"instances running"},
})
}
func init() {
Describe("migrating service instances from v1 to v2", func() {
var (
ui *testterm.FakeUI
serviceRepo *testapi.FakeServiceRepo
cmd *MigrateServiceInstances
requirementsFactory *testreq.FakeReqFactory
context *cli.Context
args []string
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
config := testconfig.NewRepository()
serviceRepo = &testapi.FakeServiceRepo{}
cmd = NewMigrateServiceInstances(ui, config, serviceRepo)
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: false}
args = []string{}
})
Describe("requirements", func() {
It("requires you to be logged in", func() {
context = testcmd.NewContext("migrate-service-instances", args)
testcmd.RunCommand(cmd, context, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("requires five arguments to run", func() {
requirementsFactory.LoginSuccess = true
args = []string{"one", "two", "three"}
context = testcmd.NewContext("migrate-service-instances", args)
testcmd.RunCommand(cmd, context, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("passes requirements if user is logged in and provided five args to run", func() {
requirementsFactory.LoginSuccess = true
args = []string{"one", "two", "three", "four", "five"}
ui.Inputs = append(ui.Inputs, "no")
context = testcmd.NewContext("migrate-service-instances", args)
testcmd.RunCommand(cmd, context, requirementsFactory)
Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
})
})
Describe("migrating service instances", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
args = []string{"v1-service-name", "v1-provider-name", "v1-plan-name", "v2-service-name", "v2-plan-name"}
context = testcmd.NewContext("migrate-service-instances", args)
serviceRepo.ServiceInstanceCountForServicePlan = 1
})
It("displays the warning and the prompt including info about the instances and plan to migrate", func() {
ui.Inputs = []string{""}
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
testassert.SliceContains(ui.Prompts, testassert.Lines{
{"Really migrate", "1 service instance",
"from plan", "v1-service-name", "v1-provider-name", "v1-plan-name",
"to", "v2-service-name", "v2-plan-name"},
})
})
Context("when the user confirms", func() {
BeforeEach(func() {
ui.Inputs = []string{"yes"}
})
Context("when the v1 and v2 service instances exists", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResultGuids = []string{"v1-guid", "v2-guid"}
serviceRepo.MigrateServicePlanFromV1ToV2ReturnedCount = 1
})
It("makes a request to migrate the v1 service instance", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
Expect(serviceRepo.V1GuidToMigrate).To(Equal("v1-guid"))
Expect(serviceRepo.V2GuidToMigrate).To(Equal("v2-guid"))
})
It("finds the v1 service plan by its name, provider and service label", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
expectedV1 := api.ServicePlanDescription{
ServicePlanName: "v1-plan-name",
ServiceProvider: "v1-provider-name",
ServiceName: "v1-service-name",
}
Expect(serviceRepo.FindServicePlanByDescriptionArguments[0]).To(Equal(expectedV1))
})
It("finds the v2 service plan by its name and service label", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
expectedV2 := api.ServicePlanDescription{
ServicePlanName: "v2-plan-name",
ServiceName: "v2-service-name",
}
Expect(serviceRepo.FindServicePlanByDescriptionArguments[1]).To(Equal(expectedV2))
})
It("notifies the user that the migration was successful", func() {
serviceRepo.ServiceInstanceCountForServicePlan = 2
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Attempting to migrate", "2", "service instances"},
{"1", "service instance", "migrated"},
{"OK"},
})
})
})
Context("when finding the v1 plan fails", func() {
Context("because the plan does not exist", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResponses = []net.ApiResponse{net.NewNotFoundApiResponse("not used")}
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"Plan", "v1-service-name", "v1-provider-name", "v1-plan-name", "cannot be found"},
})
})
It("does not display the warning", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
})
})
Context("because there was an http error", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResponses = []net.ApiResponse{net.NewApiResponseWithMessage("uh oh")}
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"uh oh"},
})
})
It("does not display the warning", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
})
})
})
Context("when finding the v2 plan fails", func() {
Context("because the plan does not exist", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResponses = []net.ApiResponse{net.NewSuccessfulApiResponse(), net.NewNotFoundApiResponse("not used")}
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"Plan", "v2-service-name", "v2-plan-name", "cannot be found"},
})
})
It("does not display the warning", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
})
})
Context("because there was an http error", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResponses = []net.ApiResponse{net.NewSuccessfulApiResponse(), net.NewApiResponseWithMessage("uh oh")}
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"uh oh"},
})
})
It("does not display the warning", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
})
})
})
Context("when migrating the plans fails", func() {
BeforeEach(func() {
serviceRepo.MigrateServicePlanFromV1ToV2Response = net.NewApiResponseWithMessage("ruh roh")
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"ruh roh"},
})
})
})
Context("when there are no instances to migrate", func() {
BeforeEach(func() {
serviceRepo.FindServicePlanByDescriptionResultGuids = []string{"v1-guid", "v2-guid"}
serviceRepo.ServiceInstanceCountForServicePlan = 0
})
It("returns a meaningful error", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"no service instances to migrate"},
})
})
It("does not show the user the warning", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"WARNING:", "this operation is to replace a service broker"},
})
})
})
Context("when it cannot fetch the number of instances", func() {
BeforeEach(func() {
serviceRepo.ServiceInstanceCountApiResponse = net.NewApiResponseWithMessage("service instance fetch is very bad")
})
It("notifies the user of the failure", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"service instance fetch is very bad"},
})
})
})
})
Context("when the user does not confirm", func() {
BeforeEach(func() {
ui.Inputs = append(ui.Inputs, "no")
})
It("does not continue the migration", func() {
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{{"Migrating"}})
Expect(serviceRepo.MigrateServicePlanFromV1ToV2Called).To(BeFalse())
})
})
})
})
}
ui := callCreateSpace([]string{"-o", "cool-organization", "my-space"}, defaultReqFactory, defaultSpaceRepo, defaultOrgRepo, defaultUserRepo)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"error"},
})
Expect(defaultSpaceRepo.CreateSpaceName).To(Equal(""))
})
It("TestCreateSpaceWhenItAlreadyExists", func() {
resetSpaceDefaults()
defaultSpaceRepo.CreateSpaceExists = true
ui := callCreateSpace([]string{"my-space"}, defaultReqFactory, defaultSpaceRepo, defaultOrgRepo, defaultUserRepo)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Creating space", "my-space"},
{"OK"},
{"my-space", "already exists"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"Assigning", "my-user", "my-space", models.SpaceRoleToUserInput[models.SPACE_MANAGER]},
})
Expect(defaultSpaceRepo.CreateSpaceName).To(Equal(""))
Expect(defaultSpaceRepo.CreateSpaceOrgGuid).To(Equal(""))
Expect(defaultUserRepo.SetSpaceRoleUserGuid).To(Equal(""))
Expect(defaultUserRepo.SetSpaceRoleSpaceGuid).To(Equal(""))
})
})
It("indicates when a service doesn't exist", func() {
deps := setupDependencies()
deps.serviceRepo.FindServiceOfferingByLabelAndProviderApiResponse = cferrors.NewModelNotFoundError("Service Offering", "")
deps.ui.Inputs = []string{"yes"}
testcmd.RunCommand(
NewPurgeServiceOffering(deps.ui, deps.config, deps.serviceRepo),
testcmd.NewContext("purge-service-offering", []string{"-p", "the-provider", "the-service-name"}),
deps.reqFactory,
)
testassert.SliceContains(deps.ui.Outputs, testassert.Lines{{"Service offering", "does not exist"}})
testassert.SliceDoesNotContain(deps.ui.Outputs, testassert.Lines{{"Warning"}})
testassert.SliceDoesNotContain(deps.ui.Outputs, testassert.Lines{{"Ok"}})
Expect(deps.serviceRepo.PurgeServiceOfferingCalled).To(Equal(false))
})
})
type commandDependencies struct {
ui *testterm.FakeUI
config configuration.ReadWriter
serviceRepo *testapi.FakeServiceRepo
reqFactory *testreq.FakeReqFactory
}
func setupDependencies() (obj commandDependencies) {
obj.ui = &testterm.FakeUI{}
It("creates and uploads buildpacks", func() {
context := testcmd.NewContext("create-buildpack", []string{"my-buildpack", "my.war", "5"})
testcmd.RunCommand(cmd, context, requirementsFactory)
Expect(repo.CreateBuildpack.Enabled).To(BeNil())
Expect(ui.FailedWithUsage).To(BeFalse())
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Creating buildpack", "my-buildpack"},
{"OK"},
{"Uploading buildpack", "my-buildpack"},
{"OK"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"FAILED"},
})
})
It("warns the user when the buildpack already exists", func() {
repo.CreateBuildpackExists = true
context := testcmd.NewContext("create-buildpack", []string{"my-buildpack", "my.war", "5"})
testcmd.RunCommand(cmd, context, requirementsFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Creating buildpack", "my-buildpack"},
{"OK"},
{"my-buildpack", "already exists"},
{"tip", "update-buildpack"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
TailLogMessages: []*logmessage.Message{
NewLogMessage("Log Line 1", defaultAppForStart.Guid, wrongSourceName, currentTime),
NewLogMessage("Log Line 2", defaultAppForStart.Guid, correctSourceName, currentTime),
NewLogMessage("Log Line 3", defaultAppForStart.Guid, correctSourceName, currentTime),
NewLogMessage("Log Line 4", defaultAppForStart.Guid, wrongSourceName, currentTime),
},
}
ui := callStart([]string{"my-app"}, testconfig.NewRepository(), reqFactory, displayApp, appRepo, appInstancesRepo, logRepo)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Log Line 2"},
{"Log Line 3"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"Log Line 1"},
{"Log Line 4"},
})
})
It("TestStartApplicationWhenAppHasNoURL", func() {
displayApp := &testcmd.FakeAppDisplayer{}
app := defaultAppForStart
app.Routes = []models.RouteSummary{}
appInstance := models.AppInstanceFields{}
appInstance.State = models.InstanceRunning
instances := [][]models.AppInstanceFields{
[]models.AppInstanceFields{appInstance},
[]models.AppInstanceFields{appInstance},
}
errorCodes := []string{""}
It("strips special characters when creating a default route", func() {
routeRepo.FindByHostAndDomainErr = true
appRepo.ReadNotFound = true
callPush("-t", "111", "Tim's 1st-Crazy__app!")
Expect(*appRepo.CreatedAppParams().Name).To(Equal("Tim's 1st-Crazy__app!"))
Expect(routeRepo.FindByHostAndDomainHost).To(Equal("tims-1st-crazy-app"))
Expect(routeRepo.CreatedHost).To(Equal("tims-1st-crazy-app"))
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Creating", "tims-1st-crazy-app.foo.cf-app.com"},
{"Binding", "tims-1st-crazy-app.foo.cf-app.com"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"FAILED"},
})
})
It("binds to existing routes when pushing an app", func() {
route := models.Route{}
route.Guid = "my-route-guid"
route.Host = "my-new-app"
route.Domain = domainRepo.ListSharedDomainsDomains[0]
routeRepo.FindByHostAndDomainRoute = route
appRepo.ReadNotFound = true
callPush("my-new-app")
Expect(routeRepo.CreatedHost).To(BeEmpty())
space2 := models.Space{}
space2.Guid = "some-space-guid"
space2.Name = "some-space"
spaceRepo.Spaces = []models.Space{space1, space2}
})
It("doesn't display a list of orgs (the user must type the name)", func() {
ui.Inputs = []string{"api.example.com", "*****@*****.**", "password", "my-org-1", "my-space"}
l := NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
testcmd.RunCommand(l, testcmd.NewContext("login", Flags), nil)
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"my-org-2"},
})
Expect(orgRepo.FindByNameName).To(Equal("my-org-1"))
Expect(Config.OrganizationFields().Guid).To(Equal("my-org-guid-1"))
})
})
Describe("when there is only a single org and space", func() {
It("does not ask the user to select an org/space", func() {
ui.Inputs = []string{"http://api.example.com", "*****@*****.**", "password"}
l := NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
testcmd.RunCommand(l, testcmd.NewContext("login", Flags), nil)
Expect(Config.OrganizationFields().Guid).To(Equal("my-new-org-guid"))
Expect(Config.SpaceFields().Guid).To(Equal("my-space-guid"))
testcmd.RunCommand(cmd, testcmd.NewContext("services", []string{}), reqFactory)
testassert.SliceContains(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"},
})
})
It("lists no services when none are found", func() {
serviceInstances := []models.ServiceInstance{}
serviceSummaryRepo := &testapi.FakeServiceSummaryRepo{
GetSummariesInCurrentSpaceInstances: serviceInstances,
}
cmd := NewListServices(ui, configRepo, serviceSummaryRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("services", []string{}), reqFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Getting services in org", "my-org", "my-space", "my-user"},
{"OK"},
{"No services found"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"name", "service", "plan", "bound apps"},
})
})
})
runCurlWithInputs(deps, []string{"/foo"})
Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
})
It("makes a get request given an endpoint", func() {
deps.curlRepo.ResponseHeader = "Content-Size:1024"
deps.curlRepo.ResponseBody = "response for get"
runCurlWithInputs(deps, []string{"/foo"})
Expect(deps.curlRepo.Method).To(Equal("GET"))
Expect(deps.curlRepo.Path).To(Equal("/foo"))
testassert.SliceContains(deps.ui.Outputs, testassert.Lines{
{"response for get"},
})
testassert.SliceDoesNotContain(deps.ui.Outputs, testassert.Lines{
{"FAILED"},
{"Content-Size:1024"},
})
})
It("makes a post request given -X", func() {
runCurlWithInputs(deps, []string{"-X", "post", "/foo"})
Expect(deps.curlRepo.Method).To(Equal("post"))
testassert.SliceDoesNotContain(deps.ui.Outputs, testassert.Lines{
{"FAILED"},
})
})
It("sends headers given -H", func() {
runCurlWithInputs(deps, []string{"-H", "Content-Type:cat", "/foo"})
Context("when user is not logged in", func() {
var config configuration.Reader
BeforeEach(func() {
config = testconfig.NewRepository()
})
It("prompts the user to login", func() {
output := captureOutput(func() {
ui := NewUI((os.Stdin))
ui.ShowConfiguration(config)
})
testassert.SliceDoesNotContain(output, testassert.Lines{
{"API endpoint:"},
})
testassert.SliceContains(output, testassert.Lines{
{"Not logged in", "Use", "log in"},
})
})
})
Context("when an api endpoint is set and the user logged in", func() {
var config configuration.ReadWriter
BeforeEach(func() {
accessToken := configuration.TokenInfo{
UserGuid: "my-user-guid",
c.orgRepo.FindByNameOrganization = c.orgRepo.Organizations[1]
space1 := models.Space{}
space1.Guid = "my-space-guid"
space1.Name = "my-space"
space2 := models.Space{}
space2.Guid = "some-space-guid"
space2.Name = "some-space"
c.spaceRepo.Spaces = []models.Space{space1, space2}
callLogin(c)
testassert.SliceDoesNotContain(c.ui.Outputs, testassert.Lines{
{"my-org-2"},
})
Expect(c.orgRepo.FindByNameName).To(Equal("my-org-1"))
Expect(c.Config.OrganizationFields().Guid).To(Equal("my-org-guid-1"))
})
It("TestSuccessfullyLoggingInWithFlags", func() {
c := setUpLoginTestContext()
c.Flags = []string{"-a", "api.example.com", "-u", "*****@*****.**", "-p", "password", "-o", "my-org", "-s", "my-space"}
callLogin(c)
Expect(c.Config.ApiEndpoint()).To(Equal("api.example.com"))
Expect(c.Config.OrganizationFields().Guid).To(Equal("my-org-guid"))
Expect(c.Config.SpaceFields().Guid).To(Equal("my-space-guid"))
serviceRepo.GetAllServiceOfferingsReturns.ServiceOfferings = fakeServiceOfferings
cmd := NewMarketplaceServices(ui, config, serviceRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("marketplace", []string{}), reqFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Getting all services from marketplace"},
{"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"},
})
})
It("does not display a table if no service offerings exist", func() {
serviceRepo := &testapi.FakeServiceRepo{}
serviceRepo.GetAllServiceOfferingsReturns.ServiceOfferings = []models.ServiceOffering{}
cmd := NewMarketplaceServices(ui, config, serviceRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("marketplace", []string{}), reqFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"No service offerings found"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"service", "plans", "description"},
})
})
})
})
})
Context("when no flags are specified", func() {
It("prints a description of the app's limits", func() {
testcmd.RunCommand(cmd, testcmd.NewContext("scale", []string{"my-app"}), reqFactory)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Showing", "my-app", "my-org", "my-space", "my-user"},
{"OK"},
{"memory", "256M"},
{"disk", "1G"},
{"instances", "42"},
})
testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
{"Scaling", "my-app", "my-org", "my-space", "my-user"},
})
})
})
Context("when the user does not confirm 'yes'", func() {
It("does not restart the app", func() {
ui.Inputs = []string{"whatever"}
testcmd.RunCommand(cmd, testcmd.NewContext("scale", []string{"-i", "5", "-m", "512M", "-k", "2G", "my-app"}), reqFactory)
Expect(restarter.AppToRestart.Guid).To(Equal(""))
})
})
Context("when the user provides the -f flag", func() {
It("does not prompt the user", func() {