requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
Expect(runCommand()).To(BeFalse())
})
})
Context("when logged in, targeting a space, and an app name is provided", func() {
BeforeEach(func() {
requirementsFactory.NewApplicationRequirementReturns(applicationReq)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
stopper.ApplicationStopReturns(app, nil)
})
It("restarts the given app", func() {
runCommand("my-app")
application, orgName, spaceName := stopper.ApplicationStopArgsForCall(0)
Expect(application).To(Equal(app))
Expect(orgName).To(Equal(config.OrganizationFields().Name))
Expect(spaceName).To(Equal(config.SpaceFields().Name))
application, orgName, spaceName = starter.ApplicationStartArgsForCall(0)
Expect(application).To(Equal(app))
Expect(orgName).To(Equal(config.OrganizationFields().Name))
Expect(spaceName).To(Equal(config.SpaceFields().Name))
})
})
})
It("gets the UAA endpoint and saves it to the config file", func() {
requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Passing{})
testcmd.RunCLICommand("auth", []string{"*****@*****.**", "password"}, requirementsFactory, updateCommandDependency, false, ui)
Expect(authRepo.GetLoginPromptsAndSaveUAAServerURLCallCount()).To(Equal(1))
})
Describe("when authentication fails", func() {
BeforeEach(func() {
authRepo.AuthenticateReturns(errors.New("Error authenticating."))
testcmd.RunCLICommand("auth", []string{"username", "password"}, requirementsFactory, updateCommandDependency, false, ui)
})
It("does not prompt the user when provided username and password", func() {
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{config.APIEndpoint()},
[]string{"Authenticating..."},
[]string{"FAILED"},
[]string{"Error authenticating"},
))
})
It("clears the user's session", func() {
Expect(config.AccessToken()).To(BeEmpty())
Expect(config.RefreshToken()).To(BeEmpty())
Expect(config.SpaceFields()).To(Equal(models.SpaceFields{}))
Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{}))
})
})
})
})
runCommand("my-app")
Expect(ui.Outputs()).To(ContainSubstrings([]string{"my-app", "is already stopped"}))
Expect(appRepo.UpdateCallCount()).To(BeZero())
})
})
Describe(".ApplicationStop()", func() {
It("returns the updated app model from ApplicationStop()", func() {
expectedStoppedApp := app
expectedStoppedApp.State = "stopped"
appRepo.UpdateReturns(expectedStoppedApp, nil)
updateCommandDependency(false)
stopper := commandregistry.Commands.FindCommand("stop").(*application.Stop)
actualStoppedApp, err := stopper.ApplicationStop(app, config.OrganizationFields().Name, config.SpaceFields().Name)
Expect(err).NotTo(HaveOccurred())
Expect(expectedStoppedApp).To(Equal(actualStoppedApp))
})
Context("When the app is already stopped", func() {
BeforeEach(func() {
app.State = "stopped"
})
It("returns the app without updating it", func() {
stopper := commandregistry.Commands.FindCommand("stop").(*application.Stop)
updatedApp, err := stopper.ApplicationStop(app, config.OrganizationFields().Name, config.SpaceFields().Name)
Expect(err).NotTo(HaveOccurred())
})
It("fails requirements when targeting a space or org", func() {
Expect(callTarget([]string{"-o", "some-crazy-org-im-not-in"})).To(BeFalse())
Expect(callTarget([]string{"-s", "i-love-space"})).To(BeFalse())
})
})
Context("when the user is logged in", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
})
var expectOrgToBeCleared = func() {
Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{}))
}
var expectSpaceToBeCleared = func() {
Expect(config.SpaceFields()).To(Equal(models.SpaceFields{}))
}
Context("there are no errors", func() {
BeforeEach(func() {
org := models.Organization{}
org.Name = "my-organization"
org.GUID = "my-organization-guid"
orgRepo.ListOrgsReturns([]models.Organization{org}, nil)
orgRepo.FindByNameReturns(org, nil)
config.SetOrganizationFields(models.OrganizationFields{Name: org.Name, GUID: org.GUID})
config.SetUaaEndpoint("http://uaa.the-endpoint")
Expect(config.UaaEndpoint()).To(Equal("http://uaa.the-endpoint"))
config.SetAccessToken("the-token")
Expect(config.AccessToken()).To(Equal("the-token"))
config.SetSSHOAuthClient("oauth-client-id")
Expect(config.SSHOAuthClient()).To(Equal("oauth-client-id"))
config.SetRefreshToken("the-token")
Expect(config.RefreshToken()).To(Equal("the-token"))
organization := models.OrganizationFields{Name: "the-org"}
config.SetOrganizationFields(organization)
Expect(config.OrganizationFields()).To(Equal(organization))
space := models.SpaceFields{Name: "the-space"}
config.SetSpaceFields(space)
Expect(config.SpaceFields()).To(Equal(space))
config.SetSSLDisabled(false)
Expect(config.IsSSLDisabled()).To(BeFalse())
config.SetLocale("en_US")
Expect(config.Locale()).To(Equal("en_US"))
config.SetPluginRepo(models.PluginRepo{Name: "repo", URL: "nowhere.com"})
Expect(config.PluginRepos()[0].Name).To(Equal("repo"))
Expect(config.PluginRepos()[0].URL).To(Equal("nowhere.com"))
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
Context("when logged in", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
})
Context("when deleting the currently targeted org", func() {
It("untargets the deleted org", func() {
config.SetOrganizationFields(org.OrganizationFields)
runCommand("org-to-delete")
Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{}))
Expect(config.SpaceFields()).To(Equal(models.SpaceFields{}))
})
})
Context("when deleting an org that is not targeted", func() {
BeforeEach(func() {
otherOrgFields := models.OrganizationFields{}
otherOrgFields.GUID = "some-other-org-guid"
otherOrgFields.Name = "some-other-org"
config.SetOrganizationFields(otherOrgFields)
spaceFields := models.SpaceFields{}
spaceFields.Name = "some-other-space"
config.SetSpaceFields(spaceFields)
})
orgRepo.FindByNameReturns(org2, nil)
OUT_OF_RANGE_CHOICE := "3"
ui.Inputs = []string{"api.example.com", "*****@*****.**", "password", OUT_OF_RANGE_CHOICE, "2", OUT_OF_RANGE_CHOICE, "1"}
testcmd.RunCLICommand("login", Flags, nil, updateCommandDependency, false, ui)
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Select an org"},
[]string{"1. some-org"},
[]string{"2. my-new-org"},
[]string{"Select a space"},
[]string{"1. my-space"},
[]string{"2. some-space"},
))
Expect(Config.OrganizationFields().GUID).To(Equal("my-new-org-guid"))
Expect(Config.SpaceFields().GUID).To(Equal("my-space-guid"))
Expect(Config.AccessToken()).To(Equal("my_access_token"))
Expect(Config.RefreshToken()).To(Equal("my_refresh_token"))
Expect(Config.APIEndpoint()).To(Equal("api.example.com"))
Expect(Config.APIVersion()).To(Equal("some-version"))
Expect(Config.AuthenticationEndpoint()).To(Equal("auth/endpoint"))
Expect(Config.SSHOAuthClient()).To(Equal("some-client"))
Expect(Config.MinCLIVersion()).To(Equal("1.0.0"))
Expect(Config.MinRecommendedCLIVersion()).To(Equal("1.0.0"))
Expect(Config.LoggregatorEndpoint()).To(Equal("loggregator/endpoint"))
Expect(Config.DopplerEndpoint()).To(Equal("doppler/endpoint"))
Expect(Config.RoutingAPIEndpoint()).To(Equal("routing/endpoint"))
Expect(endpointRepo.GetCCInfoCallCount()).To(Equal(1))
BeforeEach(func() {
org := models.Organization{}
org.Name = "the-old-org-name"
org.GUID = "the-old-org-guid"
orgReq := new(requirementsfakes.FakeOrganizationRequirement)
orgReq.GetOrganizationReturns(org)
requirementsFactory.NewOrganizationRequirementReturns(orgReq)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
})
It("passes requirements", func() {
Expect(callRenameOrg([]string{"the-old-org-name", "the-new-org-name"})).To(BeTrue())
})
It("renames an organization", func() {
targetedOrgName := configRepo.OrganizationFields().Name
callRenameOrg([]string{"the-old-org-name", "the-new-org-name"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Renaming org", "the-old-org-name", "the-new-org-name", "my-user"},
[]string{"OK"},
))
guid, name := orgRepo.RenameArgsForCall(0)
Expect(guid).To(Equal("the-old-org-guid"))
Expect(name).To(Equal("the-new-org-name"))
Expect(configRepo.OrganizationFields().Name).To(Equal(targetedOrgName))
})
Describe("when the organization is currently targeted", func() {
It("updates the name of the org in the config", func() {