Golang Domain.Shared方法代碼示例

func TestListDomains(t *testing.T) {
	orgFields := cf.OrganizationFields{}
	orgFields.Name = "my-org"
	orgFields.Guid = "my-org-guid"

	reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true, OrganizationFields: orgFields}
	domain1 := cf.Domain{}
	domain1.Shared = true
	domain1.Name = "Domain1"

	domain2 := cf.Domain{}
	domain2.Shared = false
	domain2.Name = "Domain2"

	domain3 := cf.Domain{}
	domain3.Shared = false
	domain3.Name = "Domain3"

	domainRepo := &testapi.FakeDomainRepository{
		ListSharedDomainsDomains: []cf.Domain{domain1},
		ListDomainsForOrgDomains: []cf.Domain{domain2, domain3},
	}
	ui := callListDomains(t, []string{}, reqFactory, domainRepo)

	assert.Equal(t, domainRepo.ListDomainsForOrgDomainsGuid, "my-org-guid")

	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Getting domains in org", "my-org", "my-user"},
		{"name", "status"},
		{"Domain1", "shared"},
		{"Domain2", "owned"},
		{"Domain3", "owned"},
	})
}

func (repo CloudControllerDomainRepository) findAllWithPath(path string) (domains []cf.Domain, apiResponse net.ApiResponse) {
	domainResources := new(PaginatedDomainResources)
	apiResponse = repo.gateway.GetResource(path, repo.config.AccessToken, domainResources)
	if apiResponse.IsNotSuccessful() {
		return
	}

	for _, r := range domainResources.Resources {
		domain := cf.Domain{
			Name: r.Entity.Name,
			Guid: r.Metadata.Guid,
		}
		domain.Shared = r.Entity.OwningOrganizationGuid == ""

		for _, space := range r.Entity.Spaces {
			domain.Spaces = append(domain.Spaces, cf.Space{
				Name: space.Entity.Name,
				Guid: space.Metadata.Guid,
			})
		}
		domains = append(domains, domain)
	}

	return
}

func TestPushingAppWhenItAlreadyExistsWithoutARouteCreatesADefaultDomain(t *testing.T) {
	deps := getPushDependencies()

	sharedDomain := cf.Domain{}
	sharedDomain.Name = "foo.cf-app.com"
	sharedDomain.Shared = true
	sharedDomain.Guid = "foo-domain-guid"

	deps.routeRepo.FindByHostAndDomainErr = true
	deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{sharedDomain}
	deps.appRepo.ReadApp = maker.NewApp(maker.Overrides{"name": "existing-app", "guid": "existing-app-guid"})
	deps.appRepo.UpdateAppResult = deps.appRepo.ReadApp

	ui := callPush(t, []string{"-t", "111", "existing-app"}, deps)
	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Creating route", "existing-app.foo.cf-app.com"},
		{"OK"},
		{"Binding", "existing-app.foo.cf-app.com"},
		{"OK"},
		{"Uploading"},
		{"OK"},
	})

	assert.Equal(t, deps.routeRepo.FindByHostAndDomainDomain, "foo.cf-app.com")
	assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "existing-app")

	assert.Equal(t, deps.routeRepo.CreatedHost, "existing-app")
	assert.Equal(t, deps.routeRepo.CreatedDomainGuid, "foo-domain-guid")

	assert.Equal(t, deps.routeRepo.BoundAppGuid, "existing-app-guid")
	assert.Equal(t, deps.routeRepo.BoundRouteGuid, "existing-app-route-guid")
}

func TestPushingAppWhenItAlreadyExistsAndHostIsSpecified(t *testing.T) {
	deps := getPushDependencies()

	domain := cf.Domain{}
	domain.Name = "example.com"
	domain.Guid = "domain-guid"
	domain.Shared = true

	existingRoute := cf.RouteSummary{}
	existingRoute.Host = "existing-app"
	existingRoute.Domain = domain.DomainFields

	existingApp := cf.Application{}
	existingApp.Name = "existing-app"
	existingApp.Guid = "existing-app-guid"
	existingApp.Routes = []cf.RouteSummary{existingRoute}

	deps.appRepo.ReadApp = existingApp
	deps.appRepo.UpdateAppResult = existingApp
	deps.routeRepo.FindByHostAndDomainNotFound = true
	deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{domain}

	ui := callPush(t, []string{"-n", "new-host", "existing-app"}, deps)

	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Creating route", "new-host.example.com"},
		{"OK"},
		{"Binding", "new-host.example.com"},
	})

	assert.Equal(t, deps.routeRepo.FindByHostAndDomainDomain, "example.com")
	assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "new-host")
	assert.Equal(t, deps.routeRepo.CreatedHost, "new-host")
	assert.Equal(t, deps.routeRepo.CreatedDomainGuid, "domain-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 TestPushingAppWhenItDoesNotExist(t *testing.T) {
	deps := getPushDependencies()

	domain := cf.Domain{}
	domain.Guid = "not-the-right-guid"
	domain.Name = "not shared domain"
	domain.OwningOrganizationGuid = "my-org-guid"

	sharedDomain := cf.Domain{}
	sharedDomain.Name = "foo.cf-app.com"
	sharedDomain.Shared = true
	sharedDomain.Guid = "foo-domain-guid"
	appRepo := deps.appRepo
	domainRepo := deps.domainRepo
	routeRepo := deps.routeRepo
	appBitsRepo := deps.appBitsRepo
	stopper := deps.stopper
	starter := deps.starter

	domainRepo.ListDomainsForOrgDomains = []cf.Domain{domain, sharedDomain}
	routeRepo.FindByHostAndDomainErr = true

	appRepo.ReadNotFound = true

	ui := callPush(t, []string{"-t", "111", "my-new-app"}, deps)
	assert.Equal(t, appRepo.CreatedAppParams().Get("name").(string), "my-new-app")
	assert.Equal(t, appRepo.CreatedAppParams().Get("space_guid").(string), "my-space-guid")

	assert.Equal(t, routeRepo.FindByHostAndDomainHost, "my-new-app")
	assert.Equal(t, routeRepo.CreatedHost, "my-new-app")
	assert.Equal(t, routeRepo.CreatedDomainGuid, "foo-domain-guid")
	assert.Equal(t, routeRepo.BoundAppGuid, "my-new-app-guid")
	assert.Equal(t, routeRepo.BoundRouteGuid, "my-new-app-route-guid")

	assert.Equal(t, appBitsRepo.UploadedAppGuid, "my-new-app-guid")

	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Creating app", "my-new-app", "my-org", "my-space"},
		{"OK"},
		{"Creating", "my-new-app.foo.cf-app.com"},
		{"OK"},
		{"Binding", "my-new-app.foo.cf-app.com"},
		{"OK"},
		{"Uploading my-new-app"},
		{"OK"},
	})

	assert.Equal(t, stopper.AppToStop.Guid, "")
	assert.Equal(t, starter.AppToStart.Guid, "my-new-app-guid")
	assert.Equal(t, starter.AppToStart.Name, "my-new-app")
	assert.Equal(t, starter.Timeout, 111)
}

func TestPushingAppWithNoHostname(t *testing.T) {
	deps := getPushDependencies()
	domain := cf.Domain{}
	domain.Name = "bar.cf-app.com"
	domain.Guid = "bar-domain-guid"
	domain.Shared = true

	deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{domain}
	deps.routeRepo.FindByHostAndDomainErr = true
	deps.appRepo.ReadNotFound = true

	callPush(t, []string{
		"--no-hostname",
		"my-new-app",
	}, deps)

	assert.Equal(t, deps.appRepo.CreatedAppParams().Get("name").(string), "my-new-app")
	assert.Equal(t, deps.routeRepo.CreatedHost, "")
	assert.Equal(t, deps.routeRepo.CreatedDomainGuid, "bar-domain-guid")
}

func TestDeleteDomainForceFlagSkipsConfirmation(t *testing.T) {
	reqFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true}

	domain := cf.Domain{}
	domain.Name = "foo.com"
	domain.Guid = "foo-guid"
	domain.Shared = true
	domainRepo := &testapi.FakeDomainRepository{
		FindByNameInOrgDomain: domain,
	}
	ui := callDeleteDomain(t, []string{"-f", "foo.com"}, []string{}, reqFactory, domainRepo)

	assert.Equal(t, domainRepo.DeleteDomainGuid, "foo-guid")

	assert.Equal(t, len(ui.Prompts), 0)
	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Deleting domain", "foo.com"},
		{"OK"},
	})
}

func TestPushingAppWithACrazyName(t *testing.T) {
	deps := getPushDependencies()

	sharedDomain := cf.Domain{}
	sharedDomain.Name = "foo.cf-app.com"
	sharedDomain.Shared = true
	sharedDomain.Guid = "foo-domain-guid"

	deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{sharedDomain}
	deps.routeRepo.FindByHostAndDomainErr = true

	deps.appRepo.ReadNotFound = true

	ui := callPush(t, []string{"-t", "111", "Tim's 1st-Crazy__app!"}, deps)
	assert.Equal(t, deps.appRepo.CreatedAppParams().Get("name"), "Tim's 1st-Crazy__app!")

	assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "tims-1st-crazy-app")
	assert.Equal(t, deps.routeRepo.CreatedHost, "tims-1st-crazy-app")

	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Creating", "tims-1st-crazy-app.foo.cf-app.com"},
		{"Binding", "tims-1st-crazy-app.foo.cf-app.com"},
	})
}