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)
})
AfterEach(func() {
testServer.Close()
})
Describe("GetAllServiceOfferings", func() {
BeforeEach(func() {
setupTestServer(
testapi.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
Path: "/v2/services?inline-relations-depth=1",
},
}))
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Failed"},
})
})
})
})
Describe("updates to the config", func() {
var l Login
BeforeEach(func() {
Config.SetApiEndpoint("api.the-old-endpoint.com")
Config.SetAccessToken("the-old-access-token")
Config.SetRefreshToken("the-old-refresh-token")
l = NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
})
JustBeforeEach(func() {
testcmd.RunCommand(l, testcmd.NewContext("login", Flags), nil)
})
var ItShowsTheTarget = func() {
It("shows the target", func() {
Expect(ui.ShowConfigurationCalled).To(BeTrue())
})
}
var ItDoesntShowTheTarget = func() {
Expect(config.HasSpace()).To(BeFalse())
})
It("TestUpdateEndpointWhenUrlIsAlreadyTargeted", func() {
testServerFn = validApiInfoEndpoint
org := models.OrganizationFields{}
org.Name = "my-org"
org.Guid = "my-org-guid"
space := models.SpaceFields{}
space.Name = "my-space"
space.Guid = "my-space-guid"
config.SetApiEndpoint(testServer.URL)
config.SetAccessToken("some access token")
config.SetRefreshToken("some refresh token")
config.SetOrganizationFields(org)
config.SetSpaceFields(space)
repo.UpdateEndpoint(testServer.URL)
Expect(config.OrganizationFields()).To(Equal(org))
Expect(config.SpaceFields()).To(Equal(space))
Expect(config.AccessToken()).To(Equal("some access token"))
Expect(config.RefreshToken()).To(Equal("some refresh token"))
})
It("returns a failure response when the API request fails", func() {
testServerFn = func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotFound)
})
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"},
})
})
It("prompts the user to target an org when no org is targeted", func() {
sf := models.SpaceFields{}
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)
})
runCommand := func(args ...string) {
cmd := NewDeleteUser(ui, configRepo, userRepo)
testcmd.RunCommand(cmd, testcmd.NewContext("delete-user", args), requirementsFactory)
}
Describe("requirements", func() {
It("fails when not logged in", func() {
requirementsFactory.LoginSuccess = false
runCommand("my-user")
Expect(testcmd.CommandDidPassRequirements).To(BeFalse())
})
It("fails with usage when no arguments are given", func() {
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() {
fakeConsumer.RecentReturns.Err = errors.New("oops")
})
It("returns the error", func() {
_, err := logsRepo.RecentLogsFor("app-guid")
Expect(err).To(Equal(errors.New("oops")))
})
})
Expect(Config.OrganizationFields().Guid).To(BeEmpty())
Expect(Config.SpaceFields().Guid).To(BeEmpty())
Expect(Config.AccessToken()).To(Equal("my_access_token"))
Expect(Config.RefreshToken()).To(Equal("my_refresh_token"))
testassert.SliceContains(ui.Outputs, testassert.Lines{
{"Failed"},
})
})
})
Context("when the user is already logged in and the config is fully populated", func() {
BeforeEach(func() {
Config = testconfig.NewRepositoryWithDefaults()
Config.SetApiEndpoint("api.example.com")
Config.SetAccessToken("my_access_token")
Config.SetRefreshToken("my_refesh_token")
authRepo.Config = Config
})
Describe("and a new login fails to set api endpoint", func() {
BeforeEach(func() {
endpointRepo.UpdateEndpointError = errors.NewErrorWithMessage("API endpoint not found")
Flags = []string{"-a", "api.nonexistent.com"}
l := NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
testcmd.RunCommand(l, testcmd.NewContext("login", Flags), nil)
})
It("clears the entire config", func() {
Expect(Config.ApiEndpoint()).To(BeEmpty())
