func callShowOrg(args []string, requirementsFactory *testreq.FakeReqFactory) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
token := core_config.TokenInfo{Username: "******"}
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo := testconfig.NewRepositoryWithAccessToken(token)
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
return
}
func callListDomains(args []string, requirementsFactory *testreq.FakeReqFactory, domainRepo *testapi.FakeDomainRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "******"})
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
cmd := domain.NewListDomains(fakeUI, configRepo, domainRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
func callDeleteSharedDomain(args []string, inputs []string, deps deleteSharedDomainDependencies) (ui *testterm.FakeUI) {
ui = &testterm.FakeUI{
Inputs: inputs,
}
configRepo := testconfig.NewRepositoryWithAccessToken(configuration.TokenInfo{Username: "******"})
spaceFields := models.SpaceFields{}
spaceFields.Name = "my-space"
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
configRepo.SetSpaceFields(spaceFields)
configRepo.SetOrganizationFields(orgFields)
cmd := domain.NewDeleteSharedDomain(ui, configRepo, deps.domainRepo)
testcmd.RunCommand(cmd, args, deps.requirementsFactory)
return
}
func callCreateOrg(args []string, requirementsFactory *testreq.FakeReqFactory, orgRepo *testapi.FakeOrgRepository) (fakeUI *testterm.FakeUI) {
fakeUI = new(testterm.FakeUI)
space := models.SpaceFields{}
space.Name = "my-space"
organization := models.OrganizationFields{}
organization.Name = "my-org"
token := configuration.TokenInfo{Username: "******"}
config := testconfig.NewRepositoryWithAccessToken(token)
config.SetSpaceFields(space)
config.SetOrganizationFields(organization)
cmd := NewCreateOrg(fakeUI, config, orgRepo)
testcmd.RunCommand(cmd, args, requirementsFactory)
return
}
It("fails when not logged in", func() {
requirementsFactory.TargetedOrgSuccess = true
runCommand("some-space")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails when an org is not targeted", func() {
requirementsFactory.LoginSuccess = true
runCommand("some-space")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
})
Context("when logged in and an org is targeted", func() {
BeforeEach(func() {
org := models.OrganizationFields{}
org.Name = "my-org"
app := models.ApplicationFields{}
app.Name = "app1"
app.Guid = "app1-guid"
apps := []models.ApplicationFields{app}
domain := models.DomainFields{}
domain.Name = "domain1"
domain.Guid = "domain1-guid"
domains := []models.DomainFields{domain}
serviceInstance := models.ServiceInstanceFields{}
serviceInstance.Name = "service1"
serviceInstance.Guid = "service1-guid"
package commands_test
import (
"github.com/cloudfoundry/cli/cf/commands"
"github.com/cloudfoundry/cli/cf/configuration"
"github.com/cloudfoundry/cli/cf/models"
testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("logout command", func() {
var config configuration.Repository
BeforeEach(func() {
org := models.OrganizationFields{}
org.Name = "MyOrg"
space := models.SpaceFields{}
space.Name = "MySpace"
config = testconfig.NewRepository()
config.SetAccessToken("MyAccessToken")
config.SetOrganizationFields(org)
config.SetSpaceFields(space)
ui := new(testterm.FakeUI)
l := commands.NewLogout(ui, config)
l.Run(nil)
})
requirementsFactory.LoginSuccess = true
})
Context("when deleting the currently targeted org", func() {
It("untargets the deleted org", func() {
config.SetOrganizationFields(org.OrganizationFields)
runCommand("org-to-delete")
Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{}))
Expect(config.SpaceFields()).To(Equal(models.SpaceFields{}))
})
})
Context("when deleting an org that is not targeted", func() {
BeforeEach(func() {
otherOrgFields := models.OrganizationFields{}
otherOrgFields.Guid = "some-other-org-guid"
otherOrgFields.Name = "some-other-org"
config.SetOrganizationFields(otherOrgFields)
spaceFields := models.SpaceFields{}
spaceFields.Name = "some-other-space"
config.SetSpaceFields(spaceFields)
})
It("deletes the org with the given name", func() {
runCommand("org-to-delete")
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete the org org-to-delete"}))
Expect(ui.Outputs).To(ContainSubstrings(
It("prompts the user to target an org when no org is targeted", func() {
sf := models.SpaceFields{}
sf.GUID = "guid"
sf.Name = "name"
output := io_helpers.CaptureOutput(func() {
ui := NewUI(os.Stdin, os.Stdout, NewTeePrinter(os.Stdout), fakeLogger)
ui.ShowConfiguration(config)
})
Expect(output).To(ContainSubstrings([]string{"No", "org", "targeted", "-o ORG"}))
})
It("prompts the user to target a space when no space is targeted", func() {
of := models.OrganizationFields{}
of.GUID = "of-guid"
of.Name = "of-name"
output := io_helpers.CaptureOutput(func() {
ui := NewUI(os.Stdin, os.Stdout, NewTeePrinter(os.Stdout), fakeLogger)
ui.ShowConfiguration(config)
})
Expect(output).To(ContainSubstrings([]string{"No", "space", "targeted", "-s SPACE"}))
})
})
Describe("failing", func() {
It("panics with a specific string", func() {
io_helpers.CaptureOutput(func() {
testServer = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
testServerFn(w, r)
}))
gateway = net.NewCloudControllerGateway((config), time.Now, &testterm.FakeUI{})
gateway.SetTrustedCerts(testServer.TLS.Certificates)
repo = NewEndpointRepository(config, gateway)
})
AfterEach(func() {
testServer.Close()
})
Describe("updating the endpoints", func() {
Context("when the API request is successful", func() {
var (
org models.OrganizationFields
space models.SpaceFields
)
BeforeEach(func() {
org.Name = "my-org"
org.Guid = "my-org-guid"
space.Name = "my-space"
space.Guid = "my-space-guid"
config.SetOrganizationFields(org)
config.SetSpaceFields(space)
testServerFn = validApiInfoEndpoint
})
It("stores the data from the /info api in the config", func() {
repo.UpdateEndpoint(testServer.URL)
It("prompts the user to target an org when no org is targeted", func() {
sf := models.SpaceFields{}
sf.Guid = "guid"
sf.Name = "name"
output := io_helpers.CaptureOutput(func() {
ui := NewUI(os.Stdin, NewTeePrinter())
ui.ShowConfiguration(config)
})
Expect(output).To(ContainSubstrings([]string{"No", "org", "targeted", "-o ORG"}))
})
It("prompts the user to target a space when no space is targeted", func() {
of := models.OrganizationFields{}
of.Guid = "of-guid"
of.Name = "of-name"
output := io_helpers.CaptureOutput(func() {
ui := NewUI(os.Stdin, NewTeePrinter())
ui.ShowConfiguration(config)
})
Expect(output).To(ContainSubstrings([]string{"No", "space", "targeted", "-s SPACE"}))
})
})
Describe("failing", func() {
It("panics with a specific string", func() {
io_helpers.CaptureOutput(func() {
testServer = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
testServerFn(w, r)
}))
gateway = cloudcontrollergateway.NewTestCloudControllerGateway(coreConfig)
gateway.SetTrustedCerts(testServer.TLS.Certificates)
repo = NewEndpointRepository(gateway)
})
AfterEach(func() {
testServer.Close()
})
Describe("updating the endpoints", func() {
Context("when the API request is successful", func() {
var (
org models.OrganizationFields
space models.SpaceFields
)
BeforeEach(func() {
org.Name = "my-org"
org.GUID = "my-org-guid"
space.Name = "my-space"
space.GUID = "my-space-guid"
coreConfig.SetOrganizationFields(org)
coreConfig.SetSpaceFields(space)
testServerFn = validAPIInfoEndpoint
})
It("returns the configuration info from /info", func() {
config, endpoint, err := repo.GetCCInfo(testServer.URL)
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))
Expect(apiErr).NotTo(HaveOccurred())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Creating route", "my-host.example.com", "my-org", "my-space", "my-user"},
[]string{"OK"},
))
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: false}
callListDomains([]string{}, requirementsFactory, domainRepo)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("TestListDomainsFailsWithUsage", func() {
requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true}
domainRepo := &testapi.FakeDomainRepository{}
ui := callListDomains([]string{"foo"}, requirementsFactory, domainRepo)
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("lists domains", func() {
orgFields := models.OrganizationFields{}
orgFields.Name = "my-org"
orgFields.Guid = "my-org-guid"
requirementsFactory := &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true, OrganizationFields: orgFields}
domainRepo := &testapi.FakeDomainRepository{
ListDomainsForOrgDomains: []models.DomainFields{
models.DomainFields{
Shared: false,
Name: "Private-domain1",
},
models.DomainFields{
Shared: true,
Name: "The-shared-domain",
},