예제 #1
0
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",
예제 #2
0
					},
				}))

				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() {
예제 #3
0
			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)
예제 #4
0
파일: ui_test.go 프로젝트: normalnorman/cli
			})

			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{}
예제 #5
0
		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() {
예제 #6
0
파일: logs_test.go 프로젝트: nota-ja/cli
	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")))
			})
		})
예제 #7
0
			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())