Golang models.Route类代码示例

		Expect(deps.routeRepo.FindByHostAndDomainHost).To(Equal("tims-1st-crazy-app"))
		Expect(deps.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("TestPushingAppWhenItDoesNotExistButRouteExists", func() {
		deps := getPushDependencies()

		route := models.Route{}
		route.Guid = "my-route-guid"
		route.Host = "my-new-app"
		route.Domain = deps.domainRepo.ListSharedDomainsDomains[0]

		deps.routeRepo.FindByHostAndDomainRoute = route
		deps.appRepo.ReadNotFound = true

		ui := callPush([]string{"my-new-app"}, deps)

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

		Expect(*appRepo.CreatedAppParams().Name).To(Equal("Tim's 1st-Crazy__app!"))

		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"))

	It("TestMapRouteRequirements", func() {

		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{

			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"},
			})
		})

		Context("when the default route for the app already exists", func() {
			BeforeEach(func() {
				routeRepo.FindByHostAndDomainErr = false

				route := models.Route{}
				route.Guid = "my-route-guid"
				route.Host = "my-new-app"
				route.Domain = domainRepo.ListDomainsForOrgDomains[0]

				routeRepo.FindByHostAndDomainRoute = route
			})

			It("binds to existing routes", func() {
				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"))

		})

		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)

		It("does not fail with usage when provided with a domain", func() {
			ui = callDeleteRoute("y", []string{"example.com"}, reqFactory, routeRepo)
			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"},
			})

	})

	var callDeleteRoute = func(confirmation string, args []string) {
		ui.Inputs = []string{confirmation}
		testcmd.RunCommand(cmd, testcmd.NewContext("delete-route", args), reqFactory)
	}

	It("fails requirements when not logged in", func() {
		callDeleteRoute("y", []string{"-n", "my-host", "example.com"})
		Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
	})

	Context("when logged in successfully", func() {
		BeforeEach(func() {
			reqFactory.LoginSuccess = true
			route := models.Route{}
			route.Guid = "route-guid"
			route.Host = "my-host"
			route.Domain = models.DomainFields{
				Guid: "domain-guid",
				Name: "example.com",
			}
			routeRepo.FindByHostAndDomainRoute = route
		})

		It("passes requirements when logged in", func() {
			callDeleteRoute("y", []string{"-n", "my-host", "example.com"})
			Expect(testcmd.CommandDidPassRequirements).To(BeTrue())
		})

		It("fails with usage when given zero args", func() {

		It("fails when an org and space is not targeted", func() {
			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{

	Context("when not logged in", func() {
		BeforeEach(func() {
			requirementsFactory.LoginSuccess = false
		})

		It("does not pass requirements", func() {
			runCommand("-n", "my-host", "example.com")
			Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
		})
	})

	Context("when logged in successfully", func() {
		BeforeEach(func() {
			requirementsFactory.LoginSuccess = true
			route := models.Route{Guid: "route-guid"}
			route.Domain = models.DomainFields{
				Guid: "domain-guid",
				Name: "example.com",
			}
			routeRepo.FindByHostAndDomainRoute = route
		})

		It("fails with usage when given zero args", func() {
			runCommand()
			Expect(ui.FailedWithUsage).To(BeTrue())
		})

		It("does not fail with usage when provided with a domain", func() {
			runCommand("example.com")
			Expect(ui.FailedWithUsage).To(BeFalse())