func TestMapRouteWhenBinding(t *testing.T) {
domain := cf.Domain{}
domain.Guid = "my-domain-guid"
domain.Name = "example.com"
route := cf.Route{}
route.Guid = "my-route-guid"
route.Host = "foo"
route.Domain = domain.DomainFields
app := cf.Application{}
app.Guid = "my-app-guid"
app.Name = "my-app"
routeRepo := &testapi.FakeRouteRepository{}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, Application: app, Domain: domain}
routeCreator := &testcmd.FakeRouteCreator{ReservedRoute: route}
ui := callMapRoute(t, []string{"-n", "my-host", "my-app", "my-domain.com"}, reqFactory, routeRepo, routeCreator)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Adding route", "foo.example.com", "my-app", "my-org", "my-space", "my-user"},
{"OK"},
})
assert.Equal(t, routeRepo.BoundRouteGuid, "my-route-guid")
assert.Equal(t, routeRepo.BoundAppGuid, "my-app-guid")
}
func TestPushingAppWhenItDoesNotExistButRouteExists(t *testing.T) {
deps := getPushDependencies()
domain := cf.Domain{}
domain.Name = "foo.cf-app.com"
domain.Guid = "foo-domain-guid"
domain.Shared = true
route := cf.Route{}
route.Guid = "my-route-guid"
route.Host = "my-new-app"
route.Domain = domain.DomainFields
deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{domain}
deps.routeRepo.FindByHostAndDomainRoute = route
deps.appRepo.ReadNotFound = true
ui := callPush(t, []string{"my-new-app"}, deps)
assert.Empty(t, deps.routeRepo.CreatedHost)
assert.Empty(t, deps.routeRepo.CreatedDomainGuid)
assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "my-new-app")
assert.Equal(t, deps.routeRepo.BoundAppGuid, "my-new-app-guid")
assert.Equal(t, deps.routeRepo.BoundRouteGuid, "my-route-guid")
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Using", "my-new-app.foo.cf-app.com"},
{"Binding", "my-new-app.foo.cf-app.com"},
{"OK"},
})
}
func TestDeleteRouteWithConfirmation(t *testing.T) {
domain := cf.DomainFields{}
domain.Guid = "domain-guid"
domain.Name = "example.com"
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
route := cf.Route{}
route.Guid = "route-guid"
route.Host = "my-host"
route.Domain = domain
routeRepo := &testapi.FakeRouteRepository{
FindByHostAndDomainRoute: route,
}
ui := callDeleteRoute(t, "y", []string{"-n", "my-host", "example.com"}, reqFactory, routeRepo)
testassert.SliceContains(t, ui.Prompts, testassert.Lines{
{"Really delete", "my-host"},
})
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Deleting route", "my-host.example.com"},
{"OK"},
})
assert.Equal(t, routeRepo.DeleteRouteGuid, "route-guid")
}
func TestMapRouteWhenRouteNotReserved(t *testing.T) {
domain := cf.DomainFields{}
domain.Name = "my-domain.com"
route := cf.Route{}
route.Guid = "my-app-guid"
route.Host = "my-host"
route.Domain = domain
app := cf.Application{}
app.Guid = "my-app-guid"
app.Name = "my-app"
routeRepo := &testapi.FakeRouteRepository{}
reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, Application: app}
routeCreator := &testcmd.FakeRouteCreator{ReservedRoute: route}
callMapRoute(t, []string{"-n", "my-host", "my-app", "my-domain.com"}, reqFactory, routeRepo, routeCreator)
assert.Equal(t, routeCreator.ReservedRoute, route)
}
func TestRouteCreator(t *testing.T) {
space := cf.SpaceFields{}
space.Guid = "my-space-guid"
space.Name = "my-space"
domain := cf.DomainFields{}
domain.Guid = "domain-guid"
domain.Name = "example.com"
createdRoute := cf.Route{}
createdRoute.Host = "my-host"
createdRoute.Guid = "my-route-guid"
routeRepo := &testapi.FakeRouteRepository{
CreateInSpaceCreatedRoute: createdRoute,
}
ui := new(testterm.FakeUI)
token, err := testconfig.CreateAccessTokenWithTokenInfo(configuration.TokenInfo{
Username: "******",
})
assert.NoError(t, err)
org := cf.OrganizationFields{}
org.Name = "my-org"
config := &configuration.Configuration{
OrganizationFields: org,
AccessToken: token,
}
cmd := NewCreateRoute(ui, config, routeRepo)
route, apiResponse := cmd.CreateRoute("my-host", domain, space)
assert.Equal(t, route.Guid, createdRoute.Guid)
assert.True(t, apiResponse.IsSuccessful())
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating route", "my-host.example.com", "my-org", "my-space", "my-user"},
{"OK"},
})
assert.Equal(t, routeRepo.CreateInSpaceHost, "my-host")
assert.Equal(t, routeRepo.CreateInSpaceDomainGuid, "domain-guid")
assert.Equal(t, routeRepo.CreateInSpaceSpaceGuid, "my-space-guid")
}
func TestCreateRouteIsIdempotent(t *testing.T) {
space := cf.SpaceFields{}
space.Guid = "my-space-guid"
space.Name = "my-space"
domain := cf.DomainFields{}
domain.Guid = "domain-guid"
domain.Name = "example.com"
reqFactory := &testreq.FakeReqFactory{
LoginSuccess: true,
TargetedOrgSuccess: true,
Domain: cf.Domain{DomainFields: domain},
Space: cf.Space{SpaceFields: space},
}
route := cf.Route{}
route.Guid = "my-route-guid"
route.Host = "host"
route.Domain = domain
route.Space = space
routeRepo := &testapi.FakeRouteRepository{
CreateInSpaceErr: true,
FindByHostAndDomainRoute: route,
}
ui := callCreateRoute(t, []string{"-n", "host", "my-space", "example.com"}, reqFactory, routeRepo)
testassert.SliceContains(t, ui.Outputs, testassert.Lines{
{"Creating route"},
{"OK"},
{"host.example.com", "already exists"},
})
assert.Equal(t, routeRepo.CreateInSpaceHost, "host")
assert.Equal(t, routeRepo.CreateInSpaceDomainGuid, "domain-guid")
assert.Equal(t, routeRepo.CreateInSpaceSpaceGuid, "my-space-guid")
}
