)
updateCommandDependency := func(pluginCall bool) {
deps.UI = ui
deps.Config = configRepo
deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo)
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("env").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
app = models.Application{}
app.Name = "my-app"
appRepo = new(applicationsfakes.FakeApplicationRepository)
appRepo.ReadReturns(app, nil)
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("env", args, requirementsFactory, updateCommandDependency, false)
}
Describe("Requirements", func() {
It("fails when the user is not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("my-app")).To(BeFalse())
})
It("fails if a space is not targeted", func() {
appName = "fake-app-name"
appRepo = new(applicationsfakes.FakeApplicationRepository)
req = requirements.NewDiegoApplicationRequirement(appName, appRepo)
})
Describe("GetApplication", func() {
It("returns an empty application", func() {
Expect(req.GetApplication()).To(Equal(models.Application{}))
})
Context("when the requirement has been executed", func() {
BeforeEach(func() {
app := models.Application{}
app.Diego = true
app.GUID = "fake-app-guid"
appRepo.ReadReturns(app, nil)
Expect(req.Execute()).ToNot(HaveOccurred())
})
It("returns the application", func() {
Expect(req.GetApplication().GUID).To(Equal("fake-app-guid"))
})
})
})
Describe("Execute", func() {
Context("when the returned application is a DEA application", func() {
BeforeEach(func() {
app := models.Application{}
app.Diego = false
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ApplicationRequirement", func() {
var appRepo *applicationsfakes.FakeApplicationRepository
BeforeEach(func() {
appRepo = new(applicationsfakes.FakeApplicationRepository)
})
It("succeeds when an app with the given name exists", func() {
app := models.Application{}
app.Name = "my-app"
app.GUID = "my-app-guid"
appRepo.ReadReturns(app, nil)
appReq := NewApplicationRequirement("foo", appRepo)
err := appReq.Execute()
Expect(err).NotTo(HaveOccurred())
Expect(appRepo.ReadArgsForCall(0)).To(Equal("foo"))
Expect(appReq.GetApplication()).To(Equal(app))
})
It("fails when an app with the given name cannot be found", func() {
appError := errors.NewModelNotFoundError("app", "foo")
appRepo.ReadReturns(models.Application{}, appError)
err := NewApplicationRequirement("foo", appRepo).Execute()
updateCommandDependency(logRepoWithTimeout)
cmd := commandregistry.Commands.FindCommand("start").(*Start)
cmd.LogServerConnectionTimeout = 100 * time.Millisecond
cmd.StagingTimeout = 100 * time.Millisecond
cmd.StartupTimeout = 200 * time.Millisecond
cmd.PingerThrottle = 10 * time.Millisecond
commandregistry.Register(cmd)
testcmd.RunCLICommandWithoutDependency("start", args, requirementsFactory)
return
}
startAppWithInstancesAndErrors := func(app models.Application, requirementsFactory *testreq.FakeReqFactory) (*testterm.FakeUI, *applicationsfakes.FakeApplicationRepository, *appinstancesfakes.FakeAppInstancesRepository) {
appRepo.UpdateReturns(app, nil)
appRepo.ReadReturns(app, nil)
appRepo.GetAppReturns(app, nil)
appInstancesRepo.GetInstancesStub = getInstance
args := []string{"my-app"}
requirementsFactory.Application = app
callStart(args)
return ui, appRepo, appInstancesRepo
}
It("fails requirements when not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(callStart([]string{"some-app-name"})).To(BeFalse())
})
[]string{"Removing env variable", "DATABASE_URL", "my-app", "my-org", "my-space", "my-user"},
[]string{"OK"},
))
Expect(requirementsFactory.ApplicationName).To(Equal("my-app"))
appGUID, params := appRepo.UpdateArgsForCall(0)
Expect(appGUID).To(Equal("my-app-guid"))
Expect(*params.EnvironmentVars).To(Equal(map[string]interface{}{
"foo": "bar",
}))
})
Context("when updating the app fails", func() {
BeforeEach(func() {
appRepo.UpdateReturns(models.Application{}, errors.New("Error updating app."))
appRepo.ReadReturns(app, nil)
})
It("fails and alerts the user", func() {
runCommand("does-not-exist", "DATABASE_URL")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Removing env variable"},
[]string{"FAILED"},
[]string{"Error updating app."},
))
})
})
It("tells the user if the specified env var was not set", func() {
runCommand("my-app", "CANT_STOP_WONT_STOP_UNSETTIN_THIS_ENV")
})
})
Describe("when retrieving the app token succeeds", func() {
var (
sourceApp, targetApp models.Application
)
BeforeEach(func() {
sourceApp = models.Application{
ApplicationFields: models.ApplicationFields{
Name: "source-app",
GUID: "source-app-guid",
},
}
appRepo.ReadReturns(sourceApp, nil)
targetApp = models.Application{
ApplicationFields: models.ApplicationFields{
Name: "target-app",
GUID: "target-app-guid",
},
}
appRepo.ReadFromSpaceReturns(targetApp, nil)
})
Describe("when no parameters are passed", func() {
It("obtains both the source and target application from the same space", func() {
runCommand("source-app", "target-app")
targetAppName, spaceGUID := appRepo.ReadFromSpaceArgsForCall(0)
Context("when logged in", func() {
BeforeEach(func() {
requirementsFactory.LoginSuccess = true
requirementsFactory.TargetedSpaceSuccess = true
})
It("fails with usage when not provided exactly one arg", func() {
runCommand()
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "argument"},
))
})
Context("When provided an app that exists", func() {
BeforeEach(func() {
appRepo.ReadReturns(app, nil)
})
It("deletes an app when the user confirms", func() {
ui.Inputs = []string{"y"}
runCommand("app-to-delete")
Expect(appRepo.ReadArgsForCall(0)).To(Equal("app-to-delete"))
Expect(appRepo.DeleteArgsForCall(0)).To(Equal("app-to-delete-guid"))
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete the app app-to-delete"}))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting", "app-to-delete", "my-org", "my-space", "my-user"},
[]string{"OK"},