Exemplo n.º 1
0
		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"},
			{"Binding", "my-new-app.foo.cf-app.com"},
Exemplo n.º 2
0
		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"))

		testassert.SliceContains(ui.Outputs, testassert.Lines{
			{"Using", "my-new-app.foo.cf-app.com"},
			{"Binding", "my-new-app.foo.cf-app.com"},
Exemplo n.º 3
0
				{"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"))

				testassert.SliceContains(ui.Outputs, testassert.Lines{
					{"Using", "my-new-app.foo.cf-app.com"},
Exemplo n.º 4
0
		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"},
		})
Exemplo n.º 5
0
		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() {
			callDeleteRoute("y", []string{})
			Expect(ui.FailedWithUsage).To(BeTrue())
		})

		It("does not fail with usage when provided with a domain", func() {
Exemplo n.º 6
0
			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"},
				{"host", "domain", "apps"},