ui = new(testterm.FakeUI) }) Context("when an org with the given name exists", func() { It("succeeds", func() { org := models.Organization{} org.Name = "my-org-name" org.Guid = "my-org-guid" orgRepo := &test_org.FakeOrganizationRepository{} orgReq := NewOrganizationRequirement("my-org-name", ui, orgRepo) orgRepo.ListOrgsReturns([]models.Organization{org}, nil) orgRepo.FindByNameReturns(org, nil) Expect(orgReq.Execute()).To(BeTrue()) Expect(orgRepo.FindByNameArgsForCall(0)).To(Equal("my-org-name")) Expect(orgReq.GetOrganization()).To(Equal(org)) }) }) It("fails when the org with the given name does not exist", func() { orgRepo := &test_org.FakeOrganizationRepository{} orgRepo.FindByNameReturns(models.Organization{}, errors.New("not found")) testassert.AssertPanic(testterm.QuietPanic, func() { NewOrganizationRequirement("foo", ui, orgRepo).Execute() }) }) })
) BeforeEach(func() { ui = new(testterm.FakeUI) }) Context("when a space with the given name exists", func() { It("succeeds", func() { space := models.Space{} space.Name = "awesome-sauce-space" space.Guid = "my-space-guid" spaceRepo := &testapi.FakeSpaceRepository{Spaces: []models.Space{space}} spaceReq := NewSpaceRequirement("awesome-sauce-space", ui, spaceRepo) Expect(spaceReq.Execute()).To(BeTrue()) Expect(spaceRepo.FindByNameName).To(Equal("awesome-sauce-space")) Expect(spaceReq.GetSpace()).To(Equal(space)) }) }) Context("when a space with the given name does not exist", func() { It("fails", func() { spaceRepo := &testapi.FakeSpaceRepository{FindByNameNotFound: true} testassert.AssertPanic(testterm.QuietPanic, func() { NewSpaceRequirement("foo", ui, spaceRepo).Execute() }) }) }) })
It("succeeds when the domain is found", func() { domain := models.DomainFields{Name: "example.com", Guid: "domain-guid"} domainRepo := &testapi.FakeDomainRepository{FindByNameInOrgDomain: domain} domainReq := NewDomainRequirement("example.com", ui, config, domainRepo) success := domainReq.Execute() Expect(success).To(BeTrue()) Expect(domainRepo.FindByNameInOrgName).To(Equal("example.com")) Expect(domainRepo.FindByNameInOrgGuid).To(Equal("the-org-guid")) Expect(domainReq.GetDomain()).To(Equal(domain)) }) It("fails when the domain is not found", func() { domainRepo := &testapi.FakeDomainRepository{FindByNameInOrgApiResponse: errors.NewModelNotFoundError("Domain", "")} domainReq := NewDomainRequirement("example.com", ui, config, domainRepo) testassert.AssertPanic(testterm.QuietPanic, func() { domainReq.Execute() }) }) It("fails when an error occurs fetching the domain", func() { domainRepo := &testapi.FakeDomainRepository{FindByNameInOrgApiResponse: errors.NewWithError("", errors.New(""))} domainReq := NewDomainRequirement("example.com", ui, config, domainRepo) testassert.AssertPanic(testterm.QuietPanic, func() { domainReq.Execute() }) }) })
var _ = Describe("ApplicationRequirement", func() { var ui *testterm.FakeUI var appRepo *testApplication.FakeApplicationRepository BeforeEach(func() { ui = new(testterm.FakeUI) appRepo = &testApplication.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 = app appReq := NewApplicationRequirement("foo", ui, appRepo) Expect(appReq.Execute()).To(BeTrue()) Expect(appRepo.ReadArgs.Name).To(Equal("foo")) Expect(appReq.GetApplication()).To(Equal(app)) }) It("fails when an app with the given name cannot be found", func() { appRepo.ReadReturns.Error = errors.NewModelNotFoundError("app", "foo") testassert.AssertPanic(testterm.QuietPanic, func() { NewApplicationRequirement("foo", ui, appRepo).Execute() }) }) })
) BeforeEach(func() { ui = new(testterm.FakeUI) }) Context("when a service instance with the given name can be found", func() { It("succeeds", func() { instance := models.ServiceInstance{} instance.Name = "my-service" instance.Guid = "my-service-guid" repo := &testapi.FakeServiceRepo{FindInstanceByNameServiceInstance: instance} req := NewServiceInstanceRequirement("my-service", ui, repo) Expect(req.Execute()).To(BeTrue()) Expect(repo.FindInstanceByNameName).To(Equal("my-service")) Expect(req.GetServiceInstance()).To(Equal(instance)) }) }) Context("when a service instance with the given name can't be found", func() { It("fails", func() { repo := &testapi.FakeServiceRepo{FindInstanceByNameNotFound: true} testassert.AssertPanic(testterm.QuietPanic, func() { NewServiceInstanceRequirement("foo", ui, repo).Execute() }) }) }) })
) BeforeEach(func() { ui = new(testterm.FakeUI) config = testconfig.NewRepositoryWithDefaults() }) Context("when the user has an org targeted", func() { It("succeeds", func() { req := NewTargetedOrgRequirement(ui, config) success := req.Execute() Expect(success).To(BeTrue()) }) }) Context("when the user does not have an org targeted", func() { It("fails", func() { config.SetOrganizationFields(models.OrganizationFields{}) testassert.AssertPanic(testterm.QuietPanic, func() { NewTargetedOrgRequirement(ui, config).Execute() }) Expect(ui.Outputs).To(ContainSubstrings( []string{"FAILED"}, []string{"No org targeted"}, )) }) }) })
var ( ui *testterm.FakeUI ) BeforeEach(func() { ui = new(testterm.FakeUI) }) Context("when a zone with the given name exists", func() { It("succeeds", func() { zone := models.Zone{} zone.Name = "my-zone-name" zone.Guid = "my-zone-guid" zoneRepo := &testapi.FakeZoneRepository{Zones: []models.Zone{zone}} zoneReq := NewZoneRequirement("my-zone-name", "my-org-guid", ui, zoneRepo) Expect(zoneReq.Execute()).To(BeTrue()) Expect(zoneRepo.FindByNameName).To(Equal("my-zone-name")) Expect(zoneReq.GetZone()).To(Equal(zone)) }) }) It("fails when the zone with the given name does not exist", func() { zoneRepo := &testapi.FakeZoneRepository{FindByNameNotFound: true} testassert.AssertPanic(testterm.QuietPanic, func() { NewZoneRequirement("foo", "my-org-guid", ui, zoneRepo).Execute() }) }) })
of.Name = "of-name" output := io_helpers.CaptureOutput(func() { ui := NewUI(os.Stdin, NewTeePrinter()) ui.ShowConfiguration(config) }) Expect(output).To(ContainSubstrings([]string{"No", "space", "targeted", "-s SPACE"})) }) }) Describe("failing", func() { It("panics with a specific string", func() { io_helpers.CaptureOutput(func() { testassert.AssertPanic(QuietPanic, func() { NewUI(os.Stdin, NewTeePrinter()).Failed("uh oh") }) }) }) It("does not use 'T' func to translate when it is not initialized", func() { t := i18n.T i18n.T = nil io_helpers.CaptureOutput(func() { testassert.AssertPanic(QuietPanic, func() { NewUI(os.Stdin, NewTeePrinter()).Failed("uh oh") }) }) i18n.T = t
) var _ = Describe("BuildpackRequirement", func() { var ( ui *testterm.FakeUI ) BeforeEach(func() { ui = new(testterm.FakeUI) }) It("succeeds when a buildpack with the given name exists", func() { buildpack := models.Buildpack{Name: "my-buildpack"} buildpackRepo := &testapi.FakeBuildpackRepository{FindByNameBuildpack: buildpack} buildpackReq := NewBuildpackRequirement("my-buildpack", ui, buildpackRepo) Expect(buildpackReq.Execute()).To(BeTrue()) Expect(buildpackRepo.FindByNameName).To(Equal("my-buildpack")) Expect(buildpackReq.GetBuildpack()).To(Equal(buildpack)) }) It("fails when the buildpack cannot be found", func() { buildpackRepo := &testapi.FakeBuildpackRepository{FindByNameNotFound: true} testassert.AssertPanic(testterm.QuietPanic, func() { NewBuildpackRequirement("foo", ui, buildpackRepo).Execute() }) }) })