Golang Route.Host方法代碼示例

		Expect(routeRepo.FindByHostAndDomainHost).To(Equal("tims-1st-crazy-app"))
		Expect(routeRepo.CreatedHost).To(Equal("tims-1st-crazy-app"))

		testassert.SliceContains(ui.Outputs, testassert.Lines{
			{"Creating", "tims-1st-crazy-app.foo.cf-app.com"},
			{"Binding", "tims-1st-crazy-app.foo.cf-app.com"},
		})
		testassert.SliceDoesNotContain(ui.Outputs, testassert.Lines{
			{"FAILED"},
		})
	})

	It("binds to existing routes when pushing an app", func() {
		route := models.Route{}
		route.Guid = "my-route-guid"
		route.Host = "my-new-app"
		route.Domain = domainRepo.ListSharedDomainsDomains[0]

		routeRepo.FindByHostAndDomainRoute = route
		appRepo.ReadNotFound = true

		callPush("my-new-app")

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

		testassert.SliceContains(ui.Outputs, testassert.Lines{
			{"Using", "my-new-app.foo.cf-app.com"},

		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)

		testassert.SliceContains(ui.Outputs, testassert.Lines{
			{"Adding route", "foo.example.com", "my-app", "my-org", "my-space", "my-user"},
			{"OK"},

			Expect(ui.FailedWithUsage).To(BeFalse())
		})

		It("does not fail with usage when provided a hostname", func() {
			ui = callDeleteRoute("y", []string{"-n", "my-host", "example.com"}, reqFactory, routeRepo)
			Expect(ui.FailedWithUsage).To(BeFalse())
		})

		It("TestDeleteRouteWithConfirmation", func() {
			domain := models.DomainFields{}
			domain.Guid = "domain-guid"
			domain.Name = "example.com"

			route := models.Route{}
			route.Guid = "route-guid"
			route.Host = "my-host"
			route.Domain = domain
			routeRepo.FindByHostAndDomainRoute = route

			ui := callDeleteRoute("y", []string{"-n", "my-host", "example.com"}, reqFactory, routeRepo)

			testassert.SliceContains(ui.Prompts, testassert.Lines{
				{"Really delete", "my-host"},
			})

			testassert.SliceContains(ui.Outputs, testassert.Lines{
				{"Deleting route", "my-host.example.com"},
				{"OK"},
			})
			Expect(routeRepo.DeleteRouteGuid).To(Equal("route-guid"))
		})

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

	It("TestRouteCreator", func() {
		space := models.SpaceFields{}
		space.Guid = "my-space-guid"
		space.Name = "my-space"
		domain := models.DomainFields{}
		domain.Guid = "domain-guid"
		domain.Name = "example.com"

		createdRoute := models.Route{}
		createdRoute.Host = "my-host"
		createdRoute.Guid = "my-route-guid"
		routeRepo := &testapi.FakeRouteRepository{
			CreateInSpaceCreatedRoute: createdRoute,
		}

		ui := new(testterm.FakeUI)
		configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "my-user"})
		orgFields := models.OrganizationFields{}
		orgFields.Name = "my-org"
		configRepo.SetOrganizationFields(orgFields)

		cmd := NewCreateRoute(ui, configRepo, routeRepo)
		route, apiErr := cmd.CreateRoute("my-host", domain, space)

		Expect(route.Guid).To(Equal(createdRoute.Guid))

			requirementsFactory.TargetedSpaceSuccess = false
			runCommand()
			Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
		})
	})

	Context("when there are routes", func() {
		BeforeEach(func() {
			domain := models.DomainFields{Name: "example.com"}
			domain2 := models.DomainFields{Name: "cookieclicker.co"}

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

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

			route2 := models.Route{}
			route2.Host = "hostname-2"
			route2.Domain = domain2
			route2.Apps = []models.ApplicationFields{app1, app2}
			routeRepo.Routes = []models.Route{route, route2}
		})

		It("lists routes", func() {
			runCommand()

			testassert.SliceContains(ui.Outputs, testassert.Lines{
				{"Getting routes", "my-user"},