})
Context("when there are routes in different spaces", func() {
BeforeEach(func() {
routeRepo.ListAllRoutesStub = func(cb func(models.Route) bool) error {
space1 := models.SpaceFields{Name: "space-1"}
space2 := models.SpaceFields{Name: "space-2"}
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}
route.Space = space1
route.ServiceInstance = models.ServiceInstanceFields{
Name: "test-service",
GUID: "service-guid",
}
route2 := models.Route{}
route2.Host = "hostname-2"
route2.Path = "/foo"
route2.Domain = domain2
route2.Apps = []models.ApplicationFields{app1, app2}
route2.Space = space2
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"},
))
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"))
Expect(ui.Outputs).To(ContainSubstrings(
a.State = "stopped"
return a, nil
}
zipper.ZipReturns(nil)
zipper.GetZipSizeReturns(9001, nil)
actor.GatherFilesReturns(nil, true, 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 = "app-name"
route.Domain = domainRepo.ListDomainsForOrgDomains[0]
routeRepo.FindByHostAndDomainReturns.Route = route
})
It("notifies users about the error actor.GatherFiles() returns", func() {
actor.GatherFilesReturns([]resources.AppFileResource{}, false, errors.New("failed to get file mode"))
callPush("app-name")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"failed to get file mode"},
))
})
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()
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
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"},
[]string{"OK"},
