Пример #1
0
		It("asks the user if they would like to proceed", func() {
			ui.Inputs = []string{"n"}
			cmd.Execute(flagContext)
			Eventually(func() []string { return ui.Prompts }).Should(ContainSubstrings(
				[]string{"Really delete the route"},
			))
		})

		Context("when the response is to proceed", func() {
			BeforeEach(func() {
				ui.Inputs = []string{"y"}
			})

			It("tries to find the route", func() {
				cmd.Execute(flagContext)
				Eventually(routeRepo.FindCallCount()).Should(Equal(1))
				host, domain, path, port := routeRepo.FindArgsForCall(0)
				Expect(host).To(Equal(""))
				Expect(path).To(Equal(""))
				Expect(port).To(Equal(0))
				Expect(domain).To(Equal(fakeDomain))
			})

			Context("when a path is passed", func() {
				BeforeEach(func() {
					err := flagContext.Parse("domain-name", "-f", "--path", "the-path")
					Expect(err).NotTo(HaveOccurred())
					cmd.Requirements(factory, flagContext)
				})

				It("tries to find the route with the path", func() {
Пример #2
0
		var runCLIErr error

		BeforeEach(func() {
			err := flagContext.Parse("domain-name", "service-instance")
			Expect(err).NotTo(HaveOccurred())
			cmd.Requirements(factory, flagContext)
			ui.Inputs = []string{"n"}
		})

		JustBeforeEach(func() {
			runCLIErr = cmd.Execute(flagContext)
		})

		It("tries to find the route", func() {
			Expect(runCLIErr).NotTo(HaveOccurred())
			Expect(routeRepo.FindCallCount()).To(Equal(1))
			host, domain, path, port := routeRepo.FindArgsForCall(0)
			Expect(host).To(Equal(""))
			Expect(domain).To(Equal(fakeDomain))
			Expect(path).To(Equal(""))
			Expect(port).To(Equal(0))
		})

		Context("when given a hostname", func() {
			BeforeEach(func() {
				flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
				err := flagContext.Parse("domain-name", "service-instance", "-n", "the-hostname")
				Expect(err).NotTo(HaveOccurred())
				ui.Inputs = []string{"n"}
			})
Пример #3
0
						}
						return models.DomainFields{}, domainNotFoundError
					}

					fakeRouteRepository.FindReturns(models.Route{}, cferrors.NewModelNotFoundError("", ""))
				})

				Context("when the hostname is present in the original route", func() {
					BeforeEach(func() {
						routeName = "hostname.old-domain.com/path"
					})

					It("replace the domain from manifest", func() {
						Expect(findAndBindRouteErr).NotTo(HaveOccurred())

						Expect(fakeRouteRepository.FindCallCount()).To(Equal(1))

						Expect(fakeRouteRepository.CreateCallCount()).To(Equal(1))
						actualHost, actualDomain, actualPath, actualPort, actualUseRandomPort := fakeRouteRepository.CreateArgsForCall(0)
						Expect(actualHost).To(Equal("hostname"))
						Expect(actualDomain.Name).To(Equal("shared-domain.com"))
						Expect(actualPath).To(Equal("path"))
						Expect(actualPort).To(Equal(0))
						Expect(actualUseRandomPort).To(BeFalse())
					})
				})

				Context("when the hostname is provided as a flag", func() {
					BeforeEach(func() {
						routeName = "old-domain.com/path"
						appParamsFromContext = models.AppParams{