func createServiceRepoWithConfig(reqs []testnet.TestRequest, config configuration.ReadWriter) (testServer *httptest.Server, handler *testnet.TestHandler, repo ServiceRepository) {
testServer, handler = testnet.NewServer(reqs)
config.SetApiEndpoint(testServer.URL)
gateway := net.NewCloudControllerGateway(config)
repo = NewCloudControllerServiceRepository(config, gateway)
return
}
func NewRepositoryLocator(config configuration.ReadWriter, gatewaysByName map[string]net.Gateway) (loc RepositoryLocator) {
strategy := strategy.NewEndpointStrategy(config.ApiVersion())
authGateway := gatewaysByName["auth"]
cloudControllerGateway := gatewaysByName["cloud-controller"]
uaaGateway := gatewaysByName["uaa"]
loc.authRepo = NewUAAAuthenticationRepository(authGateway, config)
// ensure gateway refreshers are set before passing them by value to repositories
cloudControllerGateway.SetTokenRefresher(loc.authRepo)
uaaGateway.SetTokenRefresher(loc.authRepo)
loc.appBitsRepo = NewCloudControllerApplicationBitsRepository(config, cloudControllerGateway, app_files.ApplicationZipper{})
loc.appEventsRepo = NewCloudControllerAppEventsRepository(config, cloudControllerGateway, strategy)
loc.appFilesRepo = NewCloudControllerAppFilesRepository(config, cloudControllerGateway)
loc.appRepo = NewCloudControllerApplicationRepository(config, cloudControllerGateway)
loc.appSummaryRepo = NewCloudControllerAppSummaryRepository(config, cloudControllerGateway)
loc.appInstancesRepo = NewCloudControllerAppInstancesRepository(config, cloudControllerGateway)
loc.authTokenRepo = NewCloudControllerServiceAuthTokenRepository(config, cloudControllerGateway)
loc.curlRepo = NewCloudControllerCurlRepository(config, cloudControllerGateway)
loc.domainRepo = NewCloudControllerDomainRepository(config, cloudControllerGateway, strategy)
loc.endpointRepo = NewEndpointRepository(config, cloudControllerGateway)
loc.logsRepo = NewLoggregatorLogsRepository(config)
loc.organizationRepo = NewCloudControllerOrganizationRepository(config, cloudControllerGateway)
loc.passwordRepo = NewCloudControllerPasswordRepository(config, uaaGateway)
loc.quotaRepo = NewCloudControllerQuotaRepository(config, cloudControllerGateway)
loc.routeRepo = NewCloudControllerRouteRepository(config, cloudControllerGateway, loc.domainRepo)
loc.stackRepo = NewCloudControllerStackRepository(config, cloudControllerGateway)
loc.serviceRepo = NewCloudControllerServiceRepository(config, cloudControllerGateway)
loc.serviceBindingRepo = NewCloudControllerServiceBindingRepository(config, cloudControllerGateway)
loc.serviceBrokerRepo = NewCloudControllerServiceBrokerRepository(config, cloudControllerGateway)
loc.serviceSummaryRepo = NewCloudControllerServiceSummaryRepository(config, cloudControllerGateway)
loc.spaceRepo = NewCloudControllerSpaceRepository(config, cloudControllerGateway)
loc.userProvidedServiceInstanceRepo = NewCCUserProvidedServiceInstanceRepository(config, cloudControllerGateway)
loc.userRepo = NewCloudControllerUserRepository(config, uaaGateway, cloudControllerGateway)
loc.buildpackRepo = NewCloudControllerBuildpackRepository(config, cloudControllerGateway)
loc.buildpackBitsRepo = NewCloudControllerBuildpackBitsRepository(config, cloudControllerGateway, app_files.ApplicationZipper{})
return
}
"cf/errors"
"cf/models"
"cf/net"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testapi "testhelpers/api"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("Buildpacks repo", func() {
var (
ts *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
repo BuildpackRepository
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
gateway := net.NewCloudControllerGateway(config)
repo = NewCloudControllerBuildpackRepository(config, gateway)
})
AfterEach(func() {
ts.Close()
})
var setupTestServer = func(requests ...testnet.TestRequest) {
ts, handler = testnet.NewServer(requests)
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("rename-space command", func() {
var (
ui *testterm.FakeUI
configRepo configuration.ReadWriter
reqFactory *testreq.FakeReqFactory
spaceRepo *testapi.FakeSpaceRepository
)
BeforeEach(func() {
ui = new(testterm.FakeUI)
configRepo = testconfig.NewRepositoryWithDefaults()
reqFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedOrgSuccess: true}
spaceRepo = &testapi.FakeSpaceRepository{}
})
var callRenameSpace = func(args []string) {
cmd := NewRenameSpace(ui, configRepo, spaceRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("create-space", args), reqFactory)
}
import (
"cf/configuration"
"cf/errors"
"cf/models"
. "cf/requirements"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testconfig "testhelpers/configuration"
testterm "testhelpers/terminal"
)
var _ = Describe("Testing with ginkgo", func() {
var config configuration.ReadWriter
var ui *testterm.FakeUI
BeforeEach(func() {
ui = new(testterm.FakeUI)
config = testconfig.NewRepository()
config.SetOrganizationFields(models.OrganizationFields{Guid: "the-org-guid"})
})
It("succeeds when the domain is found", func() {
domain := models.DomainFields{Name: "example.com", Guid: "domain-guid"}
domainRepo := &testapi.FakeDomainRepository{FindByNameInOrgDomain: domain}
domainReq := NewDomainRequirement("example.com", ui, config, domainRepo)
success := domainReq.Execute()
Expect(success).To(BeTrue())
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("target command", func() {
var (
orgRepo *testapi.FakeOrgRepository
spaceRepo *testapi.FakeSpaceRepository
config configuration.ReadWriter
reqFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
orgRepo, spaceRepo, config, reqFactory = getTargetDependencies()
})
It("fails with usage when called without -o or -s", func() {
ui := callTarget([]string{"bad-foo"}, reqFactory, config, orgRepo, spaceRepo)
Expect(ui.FailedWithUsage).To(BeTrue())
})
It("fails requirements when targeting a space or org", func() {
callTarget([]string{"-o", "some-crazy-org-im-not-in"}, reqFactory, config, orgRepo, spaceRepo)
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
ui.ShowConfiguration(config)
})
testassert.SliceDoesNotContain(output, testassert.Lines{
{"API endpoint:"},
})
testassert.SliceContains(output, testassert.Lines{
{"Not logged in", "Use", "log in"},
})
})
})
Context("when an api endpoint is set and the user logged in", func() {
var config configuration.ReadWriter
BeforeEach(func() {
accessToken := configuration.TokenInfo{
UserGuid: "my-user-guid",
Username: "******",
Email: "my-user-email",
}
config = testconfig.NewRepositoryWithAccessToken(accessToken)
config.SetApiEndpoint("https://test.example.org")
config.SetApiVersion("☃☃☃")
})
Describe("tells the user what is set in the config", func() {
var output []string
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("delete-org command", func() {
var (
config configuration.ReadWriter
ui *testterm.FakeUI
requirementsFactory *testreq.FakeReqFactory
orgRepo *testapi.FakeOrgRepository
)
BeforeEach(func() {
ui = &testterm.FakeUI{
Inputs: []string{"y"},
}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
org := models.Organization{}
org.Name = "org-to-delete"
org.Guid = "org-to-delete-guid"
orgRepo = &testapi.FakeOrgRepository{Organizations: []models.Organization{org}}
})
. "cf/api"
"cf/configuration"
"cf/errors"
"code.google.com/p/gogoprotobuf/proto"
"github.com/cloudfoundry/loggregatorlib/logmessage"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testconfig "testhelpers/configuration"
"time"
)
var _ = Describe("loggregator logs repository", func() {
var (
fakeConsumer *testapi.FakeLoggregatorConsumer
logsRepo *LoggregatorLogsRepository
configRepo configuration.ReadWriter
)
BeforeEach(func() {
fakeConsumer = testapi.NewFakeLoggregatorConsumer()
configRepo = testconfig.NewRepositoryWithDefaults()
configRepo.SetLoggregatorEndpoint("loggregator-server.test.com")
configRepo.SetAccessToken("the-access-token")
repo := NewLoggregatorLogsRepository(configRepo, fakeConsumer)
logsRepo = &repo
})
Describe("RecentLogsFor", func() {
Context("when an error occurs", func() {
BeforeEach(func() {
"fmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
"net/url"
testapi "testhelpers/api"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("User Repository", func() {
var (
ccServer *httptest.Server
ccHandler *testnet.TestHandler
uaaServer *httptest.Server
uaaHandler *testnet.TestHandler
repo UserRepository
config configuration.ReadWriter
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
ccGateway := net.NewCloudControllerGateway(config)
uaaGateway := net.NewUAAGateway(config)
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway)
})
AfterEach(func() {
if uaaServer != nil {
uaaServer.Close()
}
testterm "testhelpers/terminal"
)
func callApi(args []string, config configuration.Reader, endpointRepo *testapi.FakeEndpointRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewApi(ui, config, endpointRepo)
ctxt := testcmd.NewContext("api", args)
reqFactory := &testreq.FakeReqFactory{}
testcmd.RunCommand(cmd, ctxt, reqFactory)
return
}
var _ = Describe("api command", func() {
var (
config configuration.ReadWriter
endpointRepo *testapi.FakeEndpointRepo
)
BeforeEach(func() {
config = testconfig.NewRepository()
endpointRepo = &testapi.FakeEndpointRepo{Config: config}
})
Context("when the user does not provide an endpoint", func() {
Context("when the endpoint is set", func() {
It("prints out the api endpoint", func() {
config.SetApiEndpoint("https://api.run.pivotal.io")
config.SetApiVersion("2.0")
ui := callApi([]string{}, config, endpointRepo)
"cf/configuration"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("auth command", func() {
var (
ui *testterm.FakeUI
cmd Authenticate
config configuration.ReadWriter
repo *testapi.FakeAuthenticationRepository
reqFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
reqFactory = &testreq.FakeReqFactory{}
repo = &testapi.FakeAuthenticationRepository{
Config: config,
AccessToken: "my-access-token",
RefreshToken: "my-refresh-token",
}
cmd = NewAuthenticate(ui, config, repo)
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"strconv"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testterm "testhelpers/terminal"
)
var _ = Describe("Login Command", func() {
var (
Flags []string
Config configuration.ReadWriter
ui *testterm.FakeUI
authRepo *testapi.FakeAuthenticationRepository
endpointRepo *testapi.FakeEndpointRepo
orgRepo *testapi.FakeOrgRepository
spaceRepo *testapi.FakeSpaceRepository
)
BeforeEach(func() {
Flags = []string{}
Config = testconfig.NewRepository()
ui = &testterm.FakeUI{}
authRepo = &testapi.FakeAuthenticationRepository{
AccessToken: "my_access_token",
RefreshToken: "my_refresh_token",
Config: Config,
}
endpointRepo = &testapi.FakeEndpointRepo{Config: Config}
"cf/configuration"
"cf/net"
"encoding/base64"
"fmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("AuthenticationRepository", func() {
var (
gateway net.Gateway
ts *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
)
BeforeEach(func() {
gateway = net.NewUAAGateway()
})
AfterEach(func() {
ts.Close()
})
It("logs in", func() {
ts, handler, config = setupAuthDependencies(successfulLoginRequest)
auth := NewUAAAuthenticationRepository(gateway, config)
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
"testhelpers/maker"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("delete-space command", func() {
var (
ui *testterm.FakeUI
space models.Space
config configuration.ReadWriter
spaceRepo *testapi.FakeSpaceRepository
requirementsFactory *testreq.FakeReqFactory
)
runCommand := func(args ...string) {
ctxt := testcmd.NewContext("delete-space", args)
cmd := NewDeleteSpace(ui, config, spaceRepo)
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
spaceRepo = &testapi.FakeSpaceRepository{}
config = testconfig.NewRepositoryWithDefaults()
"cf/errors"
"cf/net"
"encoding/base64"
"fmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("AuthenticationRepository", func() {
var (
gateway net.Gateway
testServer *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
gateway = net.NewUAAGateway(config)
})
AfterEach(func() {
testServer.Close()
})
It("logs in", func() {
testServer, handler, config = setupAuthDependencies(successfulLoginRequest)
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("Marketplace Services", func() {
var ui *testterm.FakeUI
var reqFactory *testreq.FakeReqFactory
var config configuration.ReadWriter
var serviceRepo *testapi.FakeServiceRepo
var fakeServiceOfferings []models.ServiceOffering
BeforeEach(func() {
serviceRepo = &testapi.FakeServiceRepo{}
ui = &testterm.FakeUI{}
reqFactory = &testreq.FakeReqFactory{ApiEndpointSuccess: true}
fakeServiceOfferings = []models.ServiceOffering{
models.ServiceOffering{
Plans: []models.ServicePlanFields{
models.ServicePlanFields{Name: "service-plan-a"},
models.ServicePlanFields{Name: "service-plan-b"},
},
ServiceOfferingFields: models.ServiceOfferingFields{
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("delete-user command", func() {
var (
ui *testterm.FakeUI
configRepo configuration.ReadWriter
userRepo *testapi.FakeUserRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{Inputs: []string{"y"}}
userRepo = &testapi.FakeUserRepository{}
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true}
configRepo = testconfig.NewRepositoryWithDefaults()
token, err := testconfig.EncodeAccessToken(configuration.TokenInfo{
UserGuid: "admin-user-guid",
Username: "******",
})
Expect(err).ToNot(HaveOccurred())
configRepo.SetAccessToken(token)
"support": "http://support.cloudfoundry.com",
"version": 2,
"description": "Cloud Foundry sponsored by Pivotal",
"authorization_endpoint": "https://login.example.com",
"api_version": "42.0.0"
}`)
}
var invalidJsonResponseApiEndpoint = func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, `Foo`)
}
var _ = Describe("Endpoints Repository", func() {
var (
config configuration.ReadWriter
testServer *httptest.Server
repo EndpointRepository
testServerFn func(w http.ResponseWriter, r *http.Request)
)
BeforeEach(func() {
config = testconfig.NewRepository()
testServer = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
testServerFn(w, r)
}))
repo = NewEndpointRepository(config, net.NewCloudControllerGateway())
})
AfterEach(func() {
testServer.Close()
})
config := testconfig.NewRepository()
config.SetAuthorizationEndpoint(authServer.URL)
config.SetApiEndpoint(apiServer.URL)
config.SetAccessToken("bearer initial-access-token")
config.SetRefreshToken("initial-refresh-token")
authGateway := NewUAAGateway()
authenticator := api.NewUAAAuthenticationRepository(authGateway, config)
return config, authenticator
}
var _ = Describe("Testing with ginkgo", func() {
var ccGateway Gateway
var uaaGateway Gateway
var config configuration.ReadWriter
var authRepo api.AuthenticationRepository
BeforeEach(func() {
ccGateway = NewCloudControllerGateway()
uaaGateway = NewUAAGateway()
})
It("TestNewRequest", func() {
request, apiResponse := ccGateway.NewRequest("GET", "https://example.com/v2/apps", "BEARER my-access-token", nil)
Expect(apiResponse.IsSuccessful()).To(BeTrue())
Expect(request.HttpReq.Header.Get("Authorization")).To(Equal("BEARER my-access-token"))
Expect(request.HttpReq.Header.Get("accept")).To(Equal("application/json"))
Expect(request.HttpReq.Header.Get("User-Agent")).To(Equal("go-cli " + cf.Version + " / " + runtime.GOOS))
})
"fmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
"net/url"
testapi "testhelpers/api"
testconfig "testhelpers/configuration"
"testhelpers/maker"
testnet "testhelpers/net"
)
var _ = Describe("Services Repo", func() {
var (
testServer *httptest.Server
testHandler *testnet.TestHandler
configRepo configuration.ReadWriter
repo ServiceRepository
)
setupTestServer := func(reqs ...testnet.TestRequest) {
testServer, testHandler = testnet.NewServer(reqs)
configRepo.SetApiEndpoint(testServer.URL)
}
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
configRepo.SetAccessToken("BEARER my_access_token")
gateway := net.NewCloudControllerGateway(configRepo)
repo = NewCloudControllerServiceRepository(configRepo, gateway)
})
"cf/configuration"
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("rename-org command", func() {
var (
requirementsFactory *testreq.FakeReqFactory
orgRepo *testapi.FakeOrgRepository
ui *testterm.FakeUI
configRepo configuration.ReadWriter
)
BeforeEach(func() {
requirementsFactory = &testreq.FakeReqFactory{}
orgRepo = &testapi.FakeOrgRepository{}
ui = new(testterm.FakeUI)
configRepo = testconfig.NewRepositoryWithDefaults()
})
var callRenameOrg = func(args []string) {
cmd := organization.NewRenameOrg(ui, configRepo, orgRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("rename-org", args), requirementsFactory)
}
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"strconv"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testterm "testhelpers/terminal"
)
var _ = Describe("Login Command", func() {
var (
Flags []string
Config configuration.ReadWriter
ui *testterm.FakeUI
authRepo *testapi.FakeAuthenticationRepository
endpointRepo *testapi.FakeEndpointRepo
orgRepo *testapi.FakeOrgRepository
spaceRepo *testapi.FakeSpaceRepository
)
BeforeEach(func() {
Flags = []string{}
Config = testconfig.NewRepository()
ui = &testterm.FakeUI{}
authRepo = &testapi.FakeAuthenticationRepository{
AccessToken: "my_access_token",
RefreshToken: "my_refresh_token",
Config: Config,
}
endpointRepo = &testapi.FakeEndpointRepo{}
"cf/configuration"
"cf/models"
"cf/net"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
testtime "testhelpers/time"
)
var _ = Describe("App Events Repo", func() {
var (
server *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
repo AppEventsRepository
)
BeforeEach(func() {
config = testconfig.NewRepository()
config.SetAccessToken("BEARER my_access_token")
config.SetApiVersion("2.2.0")
})
JustBeforeEach(func() {
strategy := strategy.NewEndpointStrategy(config.ApiVersion())
gateway := net.NewCloudControllerGateway(config)
repo = NewCloudControllerAppEventsRepository(config, gateway, strategy)
})
"io/ioutil"
"net/http"
"net/http/httptest"
"net/url"
"os"
"runtime"
"strings"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
"time"
)
var _ = Describe("Gateway", func() {
var (
ccGateway Gateway
uaaGateway Gateway
config configuration.ReadWriter
authRepo api.AuthenticationRepository
)
BeforeEach(func() {
config = testconfig.NewRepository()
ccGateway = NewCloudControllerGateway(config)
uaaGateway = NewUAAGateway(config)
})
It("TestNewRequest", func() {
request, apiErr := ccGateway.NewRequest("GET", "https://example.com/v2/apps", "BEARER my-access-token", nil)
Expect(apiErr).NotTo(HaveOccurred())
Expect(request.HttpReq.Header.Get("Authorization")).To(Equal("BEARER my-access-token"))
Expect(request.HttpReq.Header.Get("accept")).To(Equal("application/json"))
"cf/errors"
"cf/models"
"cf/net"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testapi "testhelpers/api"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("Testing with ginkgo", func() {
var (
testServer *httptest.Server
testHandler *testnet.TestHandler
configRepo configuration.ReadWriter
repo CloudControllerServiceBindingRepository
)
setupTestServer := func(reqs ...testnet.TestRequest) {
testServer, testHandler = testnet.NewServer(reqs)
configRepo.SetApiEndpoint(testServer.URL)
}
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
gateway := net.NewCloudControllerGateway(configRepo)
repo = NewCloudControllerServiceBindingRepository(configRepo, gateway)
})
testterm "testhelpers/terminal"
)
func callApi(args []string, config configuration.ReadWriter, endpointRepo *testapi.FakeEndpointRepo) (ui *testterm.FakeUI) {
ui = new(testterm.FakeUI)
cmd := NewApi(ui, config, endpointRepo)
ctxt := testcmd.NewContext("api", args)
requirementsFactory := &testreq.FakeReqFactory{}
testcmd.RunCommand(cmd, ctxt, requirementsFactory)
return
}
var _ = Describe("api command", func() {
var (
config configuration.ReadWriter
endpointRepo *testapi.FakeEndpointRepo
)
BeforeEach(func() {
config = testconfig.NewRepository()
endpointRepo = &testapi.FakeEndpointRepo{}
})
Context("when the api endpoint's ssl certificate is invalid", func() {
It("warns the user and prints out a tip", func() {
endpointRepo.UpdateEndpointError = errors.NewInvalidSSLCert("https://buttontomatoes.org", "why? no. go away")
ui := callApi([]string{"https://buttontomatoes.org"}, config, endpointRepo)
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"FAILED"},
{"SSL cert", "https://buttontomatoes.org"},
"crypto/tls"
"github.com/cloudfoundry/loggregatorlib/logmessage"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http/httptest"
"strings"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
"time"
)
var _ = Describe("loggregator logs repository", func() {
var (
logChan chan *logmessage.Message
testServer *httptest.Server
requestHandler *requestHandlerWithExpectedPath
logsRepo *LoggregatorLogsRepository
configRepo configuration.ReadWriter
messagesToSend [][]byte
)
BeforeEach(func() {
startTime := time.Now()
messagesToSend = [][]byte{
marshalledLogMessageWithTime("My message 1", startTime.UnixNano()),
marshalledLogMessageWithTime("My message 2", startTime.UnixNano()),
marshalledLogMessageWithTime("My message 3", startTime.UnixNano()),
}
logChan = make(chan *logmessage.Message, 1000)
requestHandler = new(requestHandlerWithExpectedPath)
requestHandler.handlerFunc = func(conn *websocket.Conn) {
"cf/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
testapi "testhelpers/api"
testassert "testhelpers/assert"
testcmd "testhelpers/commands"
testconfig "testhelpers/configuration"
testreq "testhelpers/requirements"
testterm "testhelpers/terminal"
)
var _ = Describe("auth command", func() {
var (
ui *testterm.FakeUI
cmd Authenticate
config configuration.ReadWriter
repo *testapi.FakeAuthenticationRepository
requirementsFactory *testreq.FakeReqFactory
)
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
repo = &testapi.FakeAuthenticationRepository{
Config: config,
AccessToken: "my-access-token",
RefreshToken: "my-refresh-token",
}
cmd = NewAuthenticate(ui, config, repo)
})
It("prompts the user to login", func() {
output := captureOutput(func() {
ui := NewUI((os.Stdin))
ui.ShowConfiguration(config)
})
testassert.SliceContains(output, testassert.Lines{
{"Not logged in", "Use", "log in"},
})
})
})
Context("when an api endpoint is set and the user logged in", func() {
var config configuration.ReadWriter
BeforeEach(func() {
config = testconfig.NewRepository()
config.SetApiEndpoint("https://test.example.org")
config.SetAccessToken("some-access-token")
})
It("prompts the user to target an org and space when no org or space is targeted", func() {
output := captureOutput(func() {
ui := NewUI(os.Stdin)
ui.ShowConfiguration(config)
})
testassert.SliceContains(output, testassert.Lines{
{"No", "org", "space", "targeted", "-o ORG", "-s SPACE"},