Golang Route.Guid方法代碼示例

		})

		It("passes when confirmation is provided", func() {
			var ui *testterm.FakeUI
			domain := models.DomainFields{Name: "example.com"}
			domain2 := models.DomainFields{Name: "cookieclicker.co"}

			app1 := models.ApplicationFields{Name: "dora"}

			route := models.Route{}
			route.Host = "hostname-1"
			route.Domain = domain
			route.Apps = []models.ApplicationFields{app1}

			route2 := models.Route{}
			route2.Guid = "route2-guid"
			route2.Host = "hostname-2"
			route2.Domain = domain2

			routeRepo.Routes = []models.Route{route, route2}

			ui, _ = callDeleteOrphanedRoutes("y", []string{}, reqFactory, routeRepo)

			Expect(ui.Prompts).To(ContainSubstrings(
				[]string{"Really delete orphaned routes"},
			))

			Expect(ui.Outputs).To(ContainSubstrings(
				[]string{"Deleting route", "hostname-2.cookieclicker.co"},
				[]string{"OK"},
			))

			Expect(ui.Outputs).To(ContainSubstrings(
				[]string{"Creating route"},
				[]string{"OK"},
				[]string{"host.example.com", "already exists"},
			))

			Expect(routeRepo.CreateInSpaceHost).To(Equal("host"))
			Expect(routeRepo.CreateInSpaceDomainGuid).To(Equal("domain-guid"))
			Expect(routeRepo.CreateInSpaceSpaceGuid).To(Equal("my-space-guid"))
		})

		Describe("RouteCreator interface", func() {
			It("creates a route, given a domain and space", func() {
				createdRoute := models.Route{}
				createdRoute.Host = "my-host"
				createdRoute.Guid = "my-route-guid"
				routeRepo := &testapi.FakeRouteRepository{
					CreateInSpaceCreatedRoute: createdRoute,
				}

				cmd := NewCreateRoute(ui, config, routeRepo)
				route, apiErr := cmd.CreateRoute("my-host", requirementsFactory.Domain, requirementsFactory.Space.SpaceFields)

				Expect(apiErr).NotTo(HaveOccurred())
				Expect(route.Guid).To(Equal(createdRoute.Guid))
				Expect(ui.Outputs).To(ContainSubstrings(
					[]string{"Creating route", "my-host.example.com", "my-org", "my-space", "my-user"},
					[]string{"OK"},
				))

				Expect(routeRepo.CreateInSpaceHost).To(Equal("my-host"))

	})

	Describe("when pushing a new app", func() {
		BeforeEach(func() {
			appRepo.ReadReturns.Error = errors.NewModelNotFoundError("App", "the-app")

			zipper.ZipReturns(nil)
			zipper.GetZipSizeReturns(9001, nil)
			actor.GatherFilesReturns(nil, nil)
			actor.UploadAppReturns(nil)
		})

		Context("when the default route for the app already exists", func() {
			BeforeEach(func() {
				route := models.Route{}
				route.Guid = "my-route-guid"
				route.Host = "my-new-app"
				route.Domain = domainRepo.ListDomainsForOrgDomains[0]

				routeRepo.FindByHostAndDomainReturns.Route = route
			})

			It("binds to existing routes", func() {
				callPush("my-new-app")

				Expect(routeRepo.CreatedHost).To(BeEmpty())
				Expect(routeRepo.CreatedDomainGuid).To(BeEmpty())
				Expect(routeRepo.FindByHostAndDomainCalledWith.Host).To(Equal("my-new-app"))
				Expect(routeRepo.BoundAppGuid).To(Equal("my-new-app-guid"))
				Expect(routeRepo.BoundRouteGuid).To(Equal("my-route-guid"))

		domainRepo = &testapi.FakeDomainRepository{}
		sharedDomain := maker.NewSharedDomainFields(maker.Overrides{"name": "foo.cf-app.com", "guid": "foo-domain-guid"})
		domainRepo.ListDomainsForOrgDomains = []models.DomainFields{sharedDomain}

		//save original command dependences and restore later
		OriginalCommandStart = command_registry.Commands.FindCommand("start")
		OriginalCommandStop = command_registry.Commands.FindCommand("stop")
		OriginalCommandServiceBind = command_registry.Commands.FindCommand("bind-service")

		routeRepo = &testapi.FakeRouteRepository{}
		routeRepo.CreateStub = func(host string, domain models.DomainFields, path string) (models.Route, error) {
			// This never returns an error, which means it isn't tested.
			// This is copied from the old route repo fake.
			route := models.Route{}
			route.Guid = host + "-route-guid"
			route.Domain = domain
			route.Host = host
			route.Path = path

			return route, nil
		}
		stackRepo = &testStacks.FakeStackRepository{}
		serviceRepo = &testapi.FakeServiceRepository{}
		authRepo = &testapi.FakeAuthenticationRepository{}
		wordGenerator = new(testwords.FakeWordGenerator)
		wordGenerator.BabbleReturns("random-host")

		ui = new(testterm.FakeUI)
		configRepo = testconfig.NewRepositoryWithDefaults()

		It("passes requirements when logged in", func() {
			_, passed := callDeleteOrphanedRoutes("y", []string{}, reqFactory, routeRepo)
			Expect(passed).To(BeTrue())
		})

		It("passes when confirmation is provided", func() {
			var ui *testterm.FakeUI
			domain := models.DomainFields{Name: "example.com"}
			domain2 := models.DomainFields{Name: "cookieclicker.co"}

			app1 := models.ApplicationFields{Name: "dora"}

			routeRepo.ListRoutesStub = func(cb func(models.Route) bool) error {
				route := models.Route{}
				route.Guid = "route1-guid"
				route.Host = "hostname-1"
				route.Domain = domain
				route.Apps = []models.ApplicationFields{app1}

				route2 := models.Route{}
				route2.Guid = "route2-guid"
				route2.Host = "hostname-2"
				route2.Domain = domain2

				cb(route)
				cb(route2)

				return nil
			}

		routeRepo := &testapi.FakeRouteRepository{}
		requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true}

		callMapRoute([]string{"-n", "my-host", "my-app", "my-domain.com"}, requirementsFactory, routeRepo, &testcmd.FakeRouteCreator{})
		Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
		Expect(requirementsFactory.ApplicationName).To(Equal("my-app"))
		Expect(requirementsFactory.DomainName).To(Equal("my-domain.com"))
	})
	It("TestMapRouteWhenBinding", func() {

		domain := models.DomainFields{}
		domain.Guid = "my-domain-guid"
		domain.Name = "example.com"
		route := models.Route{}
		route.Guid = "my-route-guid"
		route.Host = "foo"
		route.Domain = domain

		app := models.Application{}
		app.Guid = "my-app-guid"
		app.Name = "my-app"

		routeRepo := &testapi.FakeRouteRepository{}
		requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true, Application: app, Domain: domain}
		routeCreator := &testcmd.FakeRouteCreator{ReservedRoute: route}

		ui := callMapRoute([]string{"-n", "my-host", "my-app", "my-domain.com"}, requirementsFactory, routeRepo, routeCreator)

		Expect(ui.Outputs).To(ContainSubstrings(
			[]string{"Adding route", "foo.example.com", "my-app", "my-org", "my-space", "my-user"},