application models.Application deps commandregistry.Dependency ) BeforeEach(func() { ui = &testterm.FakeUI{} appInstancesRepo = new(appinstancesfakes.FakeAppInstancesRepository) config = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{}) application = models.Application{} application.Name = "my-app" application.GUID = "my-app-guid" application.InstanceCount = 1 applicationReq := new(requirementsfakes.FakeApplicationRequirement) applicationReq.GetApplicationReturns(application) requirementsFactory.NewApplicationRequirementReturns(applicationReq) }) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = config deps.RepoLocator = deps.RepoLocator.SetAppInstancesRepository(appInstancesRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("restart-app-instance").SetDependency(deps, pluginCall)) } runCommand := func(args ...string) bool { return testcmd.RunCLICommand("restart-app-instance", args, requirementsFactory, updateCommandDependency, false, ui)
}) }) Describe("ssh", func() { var ( currentApp models.Application ) BeforeEach(func() { requirementsFactory.NewLoginRequirementReturns(requirements.Passing{}) requirementsFactory.NewTargetedSpaceRequirementReturns(requirements.Passing{}) currentApp = models.Application{} currentApp.Name = "my-app" currentApp.State = "started" currentApp.GUID = "my-app-guid" currentApp.EnableSSH = true currentApp.Diego = true applicationReq := new(requirementsfakes.FakeApplicationRequirement) applicationReq.GetApplicationReturns(currentApp) requirementsFactory.NewApplicationRequirementReturns(applicationReq) }) Describe("Error getting required info to run ssh", func() { var ( testServer *httptest.Server handler *testnet.TestHandler ) AfterEach(func() {
{ Host: "app1", Domain: models.DomainFields{ Name: "example.com", }, }} app2Routes := []models.RouteSummary{ { Host: "app2", Domain: models.DomainFields{Name: "cfapps.io"}, }} app := models.Application{} app.Name = "Application-1" app.GUID = "Application-1-guid" app.State = "started" app.RunningInstances = 1 app.InstanceCount = 1 app.Memory = 512 app.DiskQuota = 1024 app.Routes = app1Routes app.AppPorts = []int{8080, 9090} app2 := models.Application{} app2.Name = "Application-2" app2.GUID = "Application-2-guid" app2.State = "started" app2.RunningInstances = 1 app2.InstanceCount = 2 app2.Memory = 256
requirementsFactory *testreq.FakeReqFactory deps commandregistry.Dependency ) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("set-env").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} app = models.Application{} app.Name = "my-app" app.GUID = "my-app-guid" appRepo = new(applicationsfakes.FakeApplicationRepository) requirementsFactory = &testreq.FakeReqFactory{} configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("set-env", args, requirementsFactory, updateCommandDependency, false) } Describe("requirements", func() { It("fails when login is not successful", func() { requirementsFactory.Application = app requirementsFactory.TargetedSpaceSuccess = true Expect(runCommand("hey", "gabba", "gabba")).To(BeFalse())
cmd = &commands.CreateAppManifest{} cmd.SetDependency(deps, false) flagContext = flags.NewFlagContext(cmd.MetaData().Flags) factory = new(requirementsfakes.FakeFactory) loginRequirement = &passingRequirement{Name: "login-requirement"} factory.NewLoginRequirementReturns(loginRequirement) targetedSpaceRequirement = &passingRequirement{Name: "targeted-space-requirement"} factory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement) applicationRequirement = new(requirementsfakes.FakeApplicationRequirement) application := models.Application{} application.GUID = "app-guid" applicationRequirement.GetApplicationReturns(application) factory.NewApplicationRequirementReturns(applicationRequirement) }) Describe("Requirements", func() { Context("when not provided exactly one arg", func() { BeforeEach(func() { flagContext.Parse("app-name", "extra-arg") }) It("fails with usage", func() { Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic()) Expect(ui.Outputs()).To(ContainSubstrings( []string{"FAILED"}, []string{"Incorrect Usage. Requires APP_NAME as argument"},
cmd = &route.MapRoute{} cmd.SetDependency(deps, false) flagContext = flags.NewFlagContext(cmd.MetaData().Flags) factory = new(requirementsfakes.FakeFactory) loginRequirement = &passingRequirement{Name: "login-requirement"} factory.NewLoginRequirementReturns(loginRequirement) applicationRequirement = new(requirementsfakes.FakeApplicationRequirement) factory.NewApplicationRequirementReturns(applicationRequirement) fakeApplication := models.Application{} fakeApplication.GUID = "fake-app-guid" applicationRequirement.GetApplicationReturns(fakeApplication) domainRequirement = new(requirementsfakes.FakeDomainRequirement) factory.NewDomainRequirementReturns(domainRequirement) fakeDomain = models.DomainFields{ GUID: "fake-domain-guid", Name: "fake-domain-name", } domainRequirement.GetDomainReturns(fakeDomain) minAPIVersionRequirement = &passingRequirement{Name: "min-api-version-requirement"} factory.NewMinAPIVersionRequirementReturns(minAPIVersionRequirement) diegoApplicationRequirement = new(requirementsfakes.FakeDiegoApplicationRequirement)
It("fails with usage when the app cannot be found", func() { appRepo.ReadReturns(models.Application{}, errors.NewModelNotFoundError("app", "hocus-pocus")) runCommand("hocus-pocus") Expect(ui.Outputs).To(ContainSubstrings( []string{"FAILED"}, []string{"not found"}, )) }) Context("when the app has at least one env var", func() { BeforeEach(func() { app = models.Application{} app.Name = "my-app" app.GUID = "the-app-guid" appRepo.ReadReturns(app, nil) appRepo.ReadEnvReturns(&models.Environment{ Environment: map[string]interface{}{ "my-key": "my-value", "my-key2": "my-value2", "first-key": 0, "first-bool": false, }, System: map[string]interface{}{ "VCAP_SERVICES": map[string]interface{}{ "pump-yer-brakes": "drive-slow", }, }, Application: map[string]interface{}{
BeforeEach(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{}
}, "entity": { "name": "my-cool-app" } }`), ), ) }) It("returns the application", func() { createdApp, err := repo.Create(appParams) Expect(err).NotTo(HaveOccurred()) app := models.Application{} app.Name = "my-cool-app" app.GUID = "my-cool-app-guid" Expect(createdApp).To(Equal(app)) }) }) Context("when the create fails", func() { BeforeEach(func() { h := ccServer.GetHandler(0) ccServer.SetHandler(0, ghttp.CombineHandlers( h, ghttp.RespondWith(http.StatusInternalServerError, ""), ), ) })
requirementsFactory *requirementsfakes.FakeFactory deps commandregistry.Dependency ) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.Config = configRepo deps.RepoLocator = deps.RepoLocator.SetApplicationRepository(appRepo) deps.RepoLocator = deps.RepoLocator.SetRouteRepository(routeRepo) commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("delete").SetDependency(deps, pluginCall)) } BeforeEach(func() { app = models.Application{} app.Name = "app-to-delete" app.GUID = "app-to-delete-guid" ui = &testterm.FakeUI{} appRepo = new(applicationsfakes.FakeRepository) routeRepo = new(apifakes.FakeRouteRepository) requirementsFactory = new(requirementsfakes.FakeFactory) configRepo = testconfig.NewRepositoryWithDefaults() }) runCommand := func(args ...string) bool { return testcmd.RunCLICommand("delete", args, requirementsFactory, updateCommandDependency, false, ui) } It("fails requirements when not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"})
flagContext = flags.NewFlagContext(cmd.MetaData().Flags) factory = new(requirementsfakes.FakeFactory) loginRequirement = &passingRequirement{Name: "login-requirement"} factory.NewLoginRequirementReturns(loginRequirement) targetedSpaceRequirement = &passingRequirement{} factory.NewTargetedSpaceRequirementReturns(targetedSpaceRequirement) deaApplicationRequirement = new(requirementsfakes.FakeDEAApplicationRequirement) factory.NewDEAApplicationRequirementReturns(deaApplicationRequirement) app := models.Application{} app.InstanceCount = 1 app.GUID = "app-guid" app.Name = "app-name" deaApplicationRequirement.GetApplicationReturns(app) }) Describe("Requirements", func() { Context("when not provided one or two args", func() { BeforeEach(func() { flagContext.Parse("app-name", "the-path", "extra-arg") }) It("fails with usage", func() { Expect(func() { cmd.Requirements(factory, flagContext) }).To(Panic()) Expect(ui.Outputs).To(ContainSubstrings( []string{"FAILED"}, []string{"Incorrect Usage. Requires an argument"},
Describe("InteractiveSession", func() { var opts *options.SSHOptions var sessionError error var interactiveSessionInvoker func(secureShell sshCmd.SecureShell) BeforeEach(func() { sshEndpoint = "ssh.example.com:22" opts = &options.SSHOptions{ AppName: "app-name", Index: 2, } currentApp.State = "STARTED" currentApp.Diego = true currentApp.GUID = "app-guid" token = "bearer token" interactiveSessionInvoker = func(secureShell sshCmd.SecureShell) { sessionError = secureShell.InteractiveSession() } }) JustBeforeEach(func() { connectErr := secureShell.Connect(opts) Expect(connectErr).NotTo(HaveOccurred()) interactiveSessionInvoker(secureShell) }) It("dials the correct endpoint as the correct user", func() { Expect(fakeSecureDialer.DialCallCount()).To(Equal(1))
return testcmd.RunCLICommand("bind-service", args, requirementsFactory, updateCommandDependency, false) } It("fails requirements when not logged in", func() { Expect(callBindService([]string{"service", "app"})).To(BeFalse()) }) Context("when logged in", func() { BeforeEach(func() { requirementsFactory.LoginSuccess = true }) It("binds a service instance to an app", func() { app := models.Application{} app.Name = "my-app" app.GUID = "my-app-guid" serviceInstance := models.ServiceInstance{} serviceInstance.Name = "my-service" serviceInstance.GUID = "my-service-guid" requirementsFactory.Application = app requirementsFactory.ServiceInstance = serviceInstance callBindService([]string{"my-app", "my-service"}) Expect(requirementsFactory.ApplicationName).To(Equal("my-app")) Expect(requirementsFactory.ServiceInstanceName).To(Equal("my-service")) Expect(ui.Outputs).To(ContainSubstrings( []string{"Binding service", "my-service", "my-app", "my-org", "my-space", "my-user"}, []string{"OK"}, []string{"TIP", "my-app"}, ))