testServer.Close()
})
Context("error when getting SSH info from /v2/info", func() {
BeforeEach(func() {
getRequest := apifakes.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
Path: "/v2/info",
Response: testnet.TestResponse{
Status: http.StatusNotFound,
Body: `{}`,
},
})
testServer, handler = testnet.NewServer([]testnet.TestRequest{getRequest})
configRepo.SetAPIEndpoint(testServer.URL)
ccGateway = net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{}, new(tracefakes.FakePrinter), "")
deps.Gateways["cloud-controller"] = ccGateway
})
It("notifies users", func() {
runCommand("my-app")
Expect(handler).To(HaveAllRequestsCalled())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Error getting SSH info", "404"},
))
})
})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Incorrect Usage", "Requires", "arguments"},
))
})
It("fails if the user has not set an api endpoint", func() {
requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Failing{Message: "no api set"})
Expect(testcmd.RunCLICommand("auth", []string{"username", "password"}, requirementsFactory, updateCommandDependency, false, ui)).To(BeFalse())
})
})
Context("when an api endpoint is targeted", func() {
BeforeEach(func() {
requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Passing{})
config.SetAPIEndpoint("foo.example.org/authenticate")
})
It("authenticates successfully", func() {
requirementsFactory.NewAPIEndpointRequirementReturns(requirements.Passing{})
testcmd.RunCLICommand("auth", []string{"*****@*****.**", "password"}, requirementsFactory, updateCommandDependency, false, ui)
Expect(ui.FailedWithUsage).To(BeFalse())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"foo.example.org/authenticate"},
[]string{"OK"},
))
Expect(authRepo.AuthenticateArgsForCall(0)).To(Equal(map[string]string{
"username": "******",
"password": "******",
Describe("List routes", func() {
It("lists routes in the current space", func() {
ts, handler = testnet.NewServer([]testnet.TestRequest{
apifakes.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
Path: "/v2/spaces/the-space-guid/routes?inline-relations-depth=1",
Response: firstPageRoutesResponse,
}),
apifakes.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
Path: "/v2/spaces/the-space-guid/routes?inline-relations-depth=1&page=2",
Response: secondPageRoutesResponse,
}),
})
configRepo.SetAPIEndpoint(ts.URL)
routes := []models.Route{}
apiErr := repo.ListRoutes(func(route models.Route) bool {
routes = append(routes, route)
return true
})
Expect(len(routes)).To(Equal(2))
Expect(routes[0].GUID).To(Equal("route-1-guid"))
Expect(routes[0].Path).To(Equal(""))
Expect(routes[0].ServiceInstance.GUID).To(Equal("service-guid"))
Expect(routes[0].ServiceInstance.Name).To(Equal("test-service"))
Expect(routes[1].GUID).To(Equal("route-2-guid"))
Expect(routes[1].Path).To(Equal("/path-2"))
Expect(handler).To(HaveAllRequestsCalled())
It("is threadsafe", func() {
performSaveCh := make(chan struct{})
beginSaveCh := make(chan struct{})
finishSaveCh := make(chan struct{})
finishReadCh := make(chan struct{})
persistor.SaveStub = func(configuration.DataInterface) error {
close(beginSaveCh)
<-performSaveCh
close(finishSaveCh)
return nil
}
go func() {
config.SetAPIEndpoint("foo")
}()
<-beginSaveCh
go func() {
config.APIEndpoint()
close(finishReadCh)
}()
Consistently(finishSaveCh).ShouldNot(BeClosed())
Consistently(finishReadCh).ShouldNot(BeClosed())
performSaveCh <- struct{}{}
Eventually(finishReadCh).Should(BeClosed())
Expect(result).To(Equal("doppler-endpoint-sample"))
})
})
Context(".ApiEndpoint, .ApiVersion and .HasAPIEndpoint", func() {
BeforeEach(func() {
rpcService, err = NewRpcService(nil, nil, config, api.RepositoryLocator{}, nil, nil, nil, rpc.DefaultServer)
err := rpcService.Start()
Expect(err).ToNot(HaveOccurred())
pingCli(rpcService.Port())
})
It("returns the ApiEndpoint(), ApiVersion() and HasAPIEndpoint() setting in config", func() {
config.SetAPIVersion("v1.1.1")
config.SetAPIEndpoint("www.fake-domain.com")
client, err = rpc.Dial("tcp", "127.0.0.1:"+rpcService.Port())
Expect(err).ToNot(HaveOccurred())
var result string
err = client.Call("CliRpcCmd.ApiEndpoint", "", &result)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("www.fake-domain.com"))
err = client.Call("CliRpcCmd.ApiVersion", "", &result)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("v1.1.1"))
var exists bool
err = client.Call("CliRpcCmd.HasAPIEndpoint", "", &exists)
Expect(Config.RefreshToken()).To(Equal("my_refresh_token"))
Expect(endpointRepo.GetCCInfoCallCount()).To(Equal(1))
Expect(endpointRepo.GetCCInfoArgsForCall(0)).To(Equal("api.example.com"))
Expect(authRepo.AuthenticateCallCount()).To(Equal(1))
Expect(authRepo.AuthenticateArgsForCall(0)).To(Equal(map[string]string{
"username": "******",
"password": "******",
}))
Expect(ui.ShowConfigurationCalled).To(BeTrue())
})
It("doesn't ask the user for the API url if they have it in their config", func() {
orgRepo.FindByNameReturns(org, nil)
Config.SetAPIEndpoint("http://api.example.com")
Flags = []string{"-o", "my-new-org", "-s", "my-space"}
ui.Inputs = []string{"*****@*****.**", "password"}
testcmd.RunCLICommand("login", Flags, nil, updateCommandDependency, false, ui)
Expect(Config.APIEndpoint()).To(Equal("http://api.example.com"))
Expect(Config.OrganizationFields().GUID).To(Equal("my-new-org-guid"))
Expect(Config.SpaceFields().GUID).To(Equal("my-space-guid"))
Expect(Config.AccessToken()).To(Equal("my_access_token"))
Expect(Config.RefreshToken()).To(Equal("my_refresh_token"))
Expect(endpointRepo.GetCCInfoCallCount()).To(Equal(1))
Expect(endpointRepo.GetCCInfoArgsForCall(0)).To(Equal("http://api.example.com"))
Expect(ui.ShowConfigurationCalled).To(BeTrue())
authRepo *authenticationfakes.FakeRepository
endpointRepo *coreconfigfakes.FakeEndpointRepository
cmd commandregistry.Command
deps commandregistry.Dependency
factory *requirementsfakes.FakeFactory
flagContext flags.FlagContext
endpointRequirement requirements.Requirement
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
configRepo.SetAPIEndpoint("fake-api-endpoint")
endpointRepo = new(coreconfigfakes.FakeEndpointRepository)
repoLocator := deps.RepoLocator.SetEndpointRepository(endpointRepo)
authRepo = new(authenticationfakes.FakeRepository)
repoLocator = repoLocator.SetAuthenticationRepository(authRepo)
deps = commandregistry.Dependency{
UI: ui,
Config: configRepo,
RepoLocator: repoLocator,
}
cmd = &commands.OneTimeSSHCode{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
. "code.cloudfoundry.org/cli/cf/requirements"
testconfig "code.cloudfoundry.org/cli/testhelpers/configuration"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("APIEndpointRequirement", func() {
var (
config coreconfig.Repository
)
BeforeEach(func() {
config = testconfig.NewRepository()
})
It("succeeds when given a config with an API endpoint", func() {
config.SetAPIEndpoint("api.example.com")
req := NewAPIEndpointRequirement(config)
err := req.Execute()
Expect(err).NotTo(HaveOccurred())
})
It("fails when given a config without an API endpoint", func() {
req := NewAPIEndpointRequirement(config)
err := req.Execute()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("No API endpoint set"))
})
})
Context("when the api endpoint's ssl certificate is invalid", func() {
It("warns the user and prints out a tip", func() {
endpointRepo.GetCCInfoReturns(nil, "", errors.NewInvalidSSLCert("https://buttontomatoes.org", "why? no. go away"))
callApi([]string{"https://buttontomatoes.org"})
Expect(runCLIErr).To(HaveOccurred())
Expect(runCLIErr.Error()).To(ContainSubstring("Invalid SSL Cert for https://buttontomatoes.org"))
Expect(runCLIErr.Error()).To(ContainSubstring("TIP"))
Expect(runCLIErr.Error()).To(ContainSubstring("--skip-ssl-validation"))
})
})
Context("when the user does not provide an endpoint", func() {
Context("when the endpoint is set in the config", func() {
BeforeEach(func() {
config.SetAPIEndpoint("https://api.run.pivotal.io")
config.SetAPIVersion("2.0")
config.SetSSLDisabled(true)
})
It("prints out the api endpoint and appropriately sets the config", func() {
callApi([]string{})
Expect(ui.Outputs()).To(ContainSubstrings([]string{"https://api.run.pivotal.io", "2.0"}))
Expect(config.IsSSLDisabled()).To(BeTrue())
})
Context("when the --unset flag is passed", func() {
It("unsets the APIEndpoint", func() {
callApi([]string{"--unset"})