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