BeforeEach(func() {
appName = "fake-app-name"
appRepo = new(applicationsfakes.FakeRepository)
req = requirements.NewDEAApplicationRequirement(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.GUID = "fake-app-guid"
appRepo.ReadReturns(app, nil)
req.Execute()
})
It("returns the application", func() {
Expect(req.GetApplication().GUID).To(Equal("fake-app-guid"))
})
})
})
Describe("Execute", func() {
Context("when the returned application is a Diego application", func() {
BeforeEach(func() {
app := models.Application{}
app.Diego = true
Expect(runCommand("some-app-name")).To(BeFalse())
})
Context("when logged in and an app exists", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
app = models.Application{}
app.Name = "my-app"
app.GUID = "my-app-guid"
app.State = "started"
})
JustBeforeEach(func() {
appRepo.ReadReturns(app, nil)
applicationReq := new(requirementsfakes.FakeApplicationRequirement)
applicationReq.GetApplicationReturns(app)
requirementsFactory.NewApplicationRequirementReturns(applicationReq)
})
It("fails with usage when the app name is not given", func() {
runCommand()
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires an argument"},
))
})
It("stops the app with the given name", func() {
runCommand("my-app")
})
})
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)
logRepoWithTimeout := new(logsfakes.FakeLogsRepositoryWithTimeout)
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)
return testcmd.RunCLICommandWithoutDependency("start", args, requirementsFactory, ui)
}
startAppWithInstancesAndErrors := func(app models.Application, requirementsFactory *requirementsfakes.FakeFactory) (*testterm.FakeUI, *applicationsfakes.FakeRepository, *appinstancesfakes.FakeAppInstancesRepository) {
appRepo.UpdateReturns(app, nil)
appRepo.ReadReturns(app, nil)
appRepo.GetAppReturns(app, nil)
appInstancesRepo.GetInstancesStub = getInstance
args := []string{"my-app"}
applicationReq := new(requirementsfakes.FakeApplicationRequirement)
applicationReq.GetApplicationReturns(app)
requirementsFactory.NewApplicationRequirementReturns(applicationReq)
callStart(args)
return ui, appRepo, appInstancesRepo
}
It("fails requirements when not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
)
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.FakeRepository)
appRepo.ReadReturns(app, nil)
configRepo = testconfig.NewRepositoryWithDefaults()
requirementsFactory = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("env", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("Requirements", func() {
It("fails when the user is not logged in", func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
Expect(runCommand("my-app")).To(BeFalse())
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ApplicationRequirement", func() {
var appRepo *applicationsfakes.FakeRepository
BeforeEach(func() {
appRepo = new(applicationsfakes.FakeRepository)
})
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()
It("fails with usage when not provided exactly one arg", func() {
requirementsFactory.NewUsageRequirementReturns(requirements.Failing{})
Expect(runCommand()).To(BeFalse())
})
Context("when passing requirements", func() {
BeforeEach(func() {
requirementsFactory.NewUsageRequirementReturns(requirements.Passing{})
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{})
})
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"},
