Ejemplo n.º 1
0
				testassert.SliceContains(ui.Outputs, testassert.Lines{
					{"Setting api endpoint to", "example.com"},
					{"OK"},
				})
			})
		})

		Context("when the ssl certificate is invalid", func() {
			BeforeEach(func() {
				endpointRepo.UpdateEndpointError = errors.NewInvalidSSLCert("https://example.com", "it don't work")
			})

			It("fails and gives the user a helpful message about skipping", func() {
				ui := callApi([]string{"https://example.com"}, config, endpointRepo)

				Expect(config.ApiEndpoint()).To(Equal(""))
				testassert.SliceContains(ui.Outputs, testassert.Lines{
					{"Invalid SSL Cert", "https://example.com"},
					{"TIP"},
				})
			})
		})

		Describe("unencrypted http endpoints", func() {
			It("warns the user", func() {
				ui = callApi([]string{"http://example.com"}, config, endpointRepo)
				testassert.SliceContains(ui.Outputs, testassert.Lines{
					{"Warning"},
				})
			})
		})
Ejemplo n.º 2
0
		It("gets the UAA endpoint and saves it to the config file", func() {
			requirementsFactory.ApiEndpointSuccess = true
			testcmd.RunCommand(cmd, testcmd.NewContext("auth", []string{"*****@*****.**", "password"}), requirementsFactory)
			Expect(repo.GetLoginPromptsWasCalled).To(BeTrue())
		})

		Describe("when authentication fails", func() {
			BeforeEach(func() {
				repo.AuthError = true
				testcmd.RunCommand(cmd, testcmd.NewContext("auth", []string{"username", "password"}), requirementsFactory)
			})

			It("does not prompt the user when provided username and password", func() {
				testassert.SliceContains(ui.Outputs, testassert.Lines{
					{config.ApiEndpoint()},
					{"Authenticating..."},
					{"FAILED"},
					{"Error authenticating"},
				})
			})

			It("clears the user's session", func() {
				Expect(config.AccessToken()).To(BeEmpty())
				Expect(config.RefreshToken()).To(BeEmpty())
				Expect(config.SpaceFields()).To(Equal(models.SpaceFields{}))
				Expect(config.OrganizationFields()).To(Equal(models.OrganizationFields{}))
			})
		})
	})
})
Ejemplo n.º 3
0
			ccGateway.SetTrustedCerts(apiServer.TLS.Certificates)
		})

		AfterEach(func() {
			apiServer.Close()
			authServer.Close()
		})

		It("returns the last response if the job completes before the timeout", func() {
			go func() {
				time.Sleep(25 * time.Millisecond)
				jobStatus = "finished"
			}()

			request, _ := ccGateway.NewRequest("GET", config.ApiEndpoint()+"/v2/foo", config.AccessToken(), nil)
			_, apiErr := ccGateway.PerformPollingRequestForJSONResponse(request, new(struct{}), 500*time.Millisecond)
			Expect(apiErr).NotTo(HaveOccurred())
		})

		It("returns an error if jobs takes longer than the timeout", func() {
			request, _ := ccGateway.NewRequest("GET", config.ApiEndpoint()+"/v2/foo", config.AccessToken(), nil)
			_, apiErr := ccGateway.PerformPollingRequestForJSONResponse(request, new(struct{}), 10*time.Millisecond)
			Expect(apiErr).To(HaveOccurred())
			Expect(apiErr.Error()).To(ContainSubstring("timed out"))
		})
	})

	Describe("when uploading a file", func() {
		var (
			err          error
Ejemplo n.º 4
0
					},
				}))

				Expect(ui.ShowConfigurationCalled).To(BeTrue())
			})

			It("doesn't ask the user for the API url if they have it in their config", func() {
				Config.SetApiEndpoint("http://api.example.com")

				Flags = []string{"-o", "my-new-org", "-s", "my-space"}
				ui.Inputs = []string{"*****@*****.**", "password"}

				l := NewLogin(ui, Config, authRepo, endpointRepo, orgRepo, spaceRepo)
				testcmd.RunCommand(l, testcmd.NewContext("login", Flags), nil)

				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.UpdateEndpointReceived).To(Equal("http://api.example.com"))
				Expect(ui.ShowConfigurationCalled).To(BeTrue())
			})
		})

		Describe("when there are too many orgs to show", func() {
			BeforeEach(func() {
				for i := 0; i < 60; i++ {
					id := strconv.Itoa(i)
					org := models.Organization{}
Ejemplo n.º 5
0
			org.Name = "my-org"
			org.Guid = "my-org-guid"

			space := models.SpaceFields{}
			space.Name = "my-space"
			space.Guid = "my-space-guid"

			config.SetOrganizationFields(org)
			config.SetSpaceFields(space)

			repo.UpdateEndpoint(testServer.URL)

			Expect(config.AccessToken()).To(Equal(""))
			Expect(config.AuthorizationEndpoint()).To(Equal("https://login.example.com"))
			Expect(config.LoggregatorEndpoint()).To(Equal("wss://loggregator.foo.example.org:4443"))
			Expect(config.ApiEndpoint()).To(Equal(testServer.URL))
			Expect(config.ApiVersion()).To(Equal("42.0.0"))
			Expect(config.HasOrganization()).To(BeFalse())
			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"
Ejemplo n.º 6
0
			ccGateway.SetTokenRefresher(authRepo)
			ccGateway.PollingThrottle = 3 * time.Millisecond
		})

		AfterEach(func() {
			apiServer.Close()
			authServer.Close()
		})

		It("returns the last response if the job completes before the timeout", func() {
			go func() {
				time.Sleep(25 * time.Millisecond)
				jobStatus = "finished"
			}()

			request, _ := ccGateway.NewRequest("GET", config.ApiEndpoint()+"/v2/foo", config.AccessToken(), nil)
			_, apiResponse := ccGateway.PerformPollingRequestForJSONResponse(request, new(struct{}), 500*time.Millisecond)
			Expect(apiResponse.IsSuccessful()).To(BeTrue())
		})

		It("returns an error if jobs takes longer than the timeout", func() {
			request, _ := ccGateway.NewRequest("GET", config.ApiEndpoint()+"/v2/foo", config.AccessToken(), nil)
			_, apiResponse := ccGateway.PerformPollingRequestForJSONResponse(request, new(struct{}), 10*time.Millisecond)
			Expect(apiResponse.IsSuccessful()).To(BeFalse())
			Expect(apiResponse.Message).To(ContainSubstring("timed out"))
		})
	})

	Describe("when uploading a file", func() {
		var err error
		var request *Request
Ejemplo n.º 7
0
		org.Name = "my-org"
		org.Guid = "my-org-guid"

		space := models.SpaceFields{}
		space.Name = "my-space"
		space.Guid = "my-space-guid"

		config.SetOrganizationFields(org)
		config.SetSpaceFields(space)

		repo.UpdateEndpoint(ts.URL)

		Expect(config.AccessToken()).To(Equal(""))
		Expect(config.AuthorizationEndpoint()).To(Equal("https://login.example.com"))
		Expect(config.LoggregatorEndpoint()).To(Equal("wss://loggregator.foo.example.org:4443"))
		Expect(config.ApiEndpoint()).To(Equal(ts.URL))
		Expect(config.ApiVersion()).To(Equal("42.0.0"))
		Expect(config.HasOrganization()).To(BeFalse())
		Expect(config.HasSpace()).To(BeFalse())
	})

	It("TestUpdateEndpointWhenUrlIsAlreadyTargeted", func() {
		ts, repo := createEndpointRepoForUpdate(config, validApiInfoEndpoint)
		defer ts.Close()

		org := models.OrganizationFields{}
		org.Name = "my-org"
		org.Guid = "my-org-guid"

		space := models.SpaceFields{}
		space.Name = "my-space"