func (repo *FakeBuildpackRepository) Create(name string, position *int, enabled *bool, locked *bool) (createdBuildpack models.Buildpack, apiErr error) { if repo.CreateBuildpackExists { return repo.CreateBuildpack, errors.NewHttpError(400, errors.BUILDPACK_EXISTS, "Buildpack already exists") } repo.CreateBuildpack = models.Buildpack{Name: name, Position: position, Enabled: enabled, Locked: locked} return repo.CreateBuildpack, repo.CreateApiResponse }
func (repo *FakeZoneRepository) Create(params models.ZoneParams) (apiErr error) { repo.CreateZoneParams = params if repo.CreateZoneExists { apiErr = errors.NewHttpError(400, errors.INVALID_REQUEST, "The request is invalid") return } return }
func (repo *FakeSpaceRepository) Create(name string, orgGuid string) (space models.Space, apiErr error) { if repo.CreateSpaceExists { apiErr = errors.NewHttpError(400, errors.SPACE_EXISTS, "Space already exists") return } repo.CreateSpaceName = name repo.CreateSpaceOrgGuid = orgGuid space = repo.CreateSpaceSpace return }
func (repo *FakeServiceBindingRepo) Create(instanceGuid, appGuid string) (apiErr error) { repo.CreateServiceInstanceGuid = instanceGuid repo.CreateApplicationGuid = appGuid if repo.CreateErrorCode != "" { apiErr = errors.NewHttpError(400, repo.CreateErrorCode, "Error binding service") } return }
func (repo *FakePasswordRepo) UpdatePassword(old string, new string) (apiErr error) { repo.UpdateOldPassword = old repo.UpdateNewPassword = new if repo.UpdateUnauthorized { apiErr = errors.NewHttpError(401, "unauthorized", "Authorization Failed") } return }
func (repo *FakeAppSummaryRepo) GetSummary(appGuid string) (summary models.Application, apiErr error) { repo.GetSummaryAppGuid = appGuid summary = repo.GetSummarySummary if repo.GetSummaryErrorCode != "" { apiErr = errors.NewHttpError(400, repo.GetSummaryErrorCode, "Error") } return }
func cloudControllerErrorHandler(statusCode int, body []byte) error { response := ccErrorResponse{} json.Unmarshal(body, &response) if response.Code == 1000 { // MAGICKAL NUMBERS AHOY return errors.NewInvalidTokenError(response.Description) } else { return errors.NewHttpError(statusCode, strconv.Itoa(response.Code), response.Description) } }
func (uaa UAAAuthenticationRepository) getAuthToken(data url.Values) error { type uaaErrorResponse struct { Code string `json:"error"` Description string `json:"error_description"` } type AuthenticationResponse struct { AccessToken string `json:"access_token"` TokenType string `json:"token_type"` RefreshToken string `json:"refresh_token"` Error uaaErrorResponse `json:"error"` } path := fmt.Sprintf("%s/oauth/token", uaa.config.AuthenticationEndpoint()) request, err := uaa.gateway.NewRequest("POST", path, "Basic "+base64.StdEncoding.EncodeToString([]byte("cf:")), strings.NewReader(data.Encode())) if err != nil { return errors.NewWithError(T("Failed to start oauth request"), err) } request.HttpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded") response := new(AuthenticationResponse) _, err = uaa.gateway.PerformRequestForJSONResponse(request, &response) switch err.(type) { case nil: case errors.HttpError: return err case *errors.InvalidTokenError: return errors.New(T("Authentication has expired. Please log back in to re-authenticate.\n\nTIP: Use `cf login -a <endpoint> -u <user> -o <org> -s <space>` to log back in and re-authenticate.")) default: return errors.NewWithError(T("auth request failed"), err) } // TODO: get the actual status code if response.Error.Code != "" { return errors.NewHttpError(0, response.Error.Code, response.Error.Description) } uaa.config.SetAccessToken(fmt.Sprintf("%s %s", response.TokenType, response.AccessToken)) uaa.config.SetRefreshToken(response.RefreshToken) return nil }
Expect(ui.FailedWithUsage).To(BeTrue()) }) }) Describe("when logged in", func() { BeforeEach(func() { requirementsFactory.LoginSuccess = true }) It("Sets the running environment variable group", func() { runCommand(`{"abc":"123", "def": "456"}`) Expect(ui.Outputs).To(ContainSubstrings( []string{"Setting the contents of the running environment variable group as my-user..."}, []string{"OK"}, )) Expect(environmentVariableGroupRepo.SetRunningArgsForCall(0)).To(Equal(`{"abc":"123", "def": "456"}`)) }) It("Fails with a reasonable message when invalid JSON is passed", func() { environmentVariableGroupRepo.SetRunningReturns(cf_errors.NewHttpError(400, cf_errors.PARSE_ERROR, "Request invalid due to parse error")) runCommand(`{"abc":"123", "invalid : "json"}`) Expect(ui.Outputs).To(ContainSubstrings( []string{"Setting the contents of the running environment variable group as my-user..."}, []string{"FAILED"}, []string{`Your JSON string syntax is invalid. Proper syntax is this: cf set-running-environment-variable-group '{"name":"value","name":"value"}'`}, )) }) }) })
It("creates the quota with paid service plans allowed", func() { runCommand("--allow-paid-service-plans", "my-for-profit-quota") Expect(quotaRepo.CreateArgsForCall(0).NonBasicServicesAllowed).To(BeTrue()) }) }) Context("when creating a quota returns an error", func() { It("alerts the user when creating the quota fails", func() { quotaRepo.CreateReturns(errors.New("WHOOP THERE IT IS")) runCommand("my-quota") Expect(ui.Outputs).To(ContainSubstrings( []string{"Creating space quota", "my-quota", "my-org"}, []string{"FAILED"}, )) }) It("warns the user when quota already exists", func() { quotaRepo.CreateReturns(errors.NewHttpError(400, "240002", "Quota Definition is taken: quota-sct")) runCommand("Banana") Expect(ui.Outputs).ToNot(ContainSubstrings( []string{"FAILED"}, )) Expect(ui.WarnOutputs).To(ContainSubstrings([]string{"already exists"})) }) }) }) })
Path: "/v2/service_instances", Matcher: testnet.RequestBodyMatcher(`{"name":"my-service","service_plan_guid":"different-plan-guid","space_guid":"my-space-guid","async":true}`), Response: testnet.TestResponse{ Status: http.StatusBadRequest, Body: `{"code":60002,"description":"The service instance name is taken: my-service"}`, }}), findServiceInstanceReq, serviceOfferingReq) }) It("fails if the plan is different", func() { err := repo.CreateServiceInstance("my-service", "different-plan-guid") Expect(testHandler).To(HaveAllRequestsCalled()) Expect(err).To(HaveOccurred()) Expect(err).To(BeAssignableToTypeOf(errors.NewHttpError(400, "", ""))) }) }) }) Describe("UpdateServiceInstance", func() { It("makes the right request", func() { setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{ Method: "PUT", Path: "/v2/service_instances/instance-guid", Matcher: testnet.RequestBodyMatcher(`{"service_plan_guid":"plan-guid"}`), Response: testnet.TestResponse{Status: http.StatusOK}, })) err := repo.UpdateServiceInstance("instance-guid", "plan-guid") Expect(testHandler).To(HaveAllRequestsCalled())
Context("some sort of awful terrible error that we were not prescient enough to anticipate", func() { BeforeEach(func() { securityGroupRepo.CreateReturns(errors.New("Wops I failed")) }) It("fails loudly", func() { Expect(ui.Outputs).To(ContainSubstrings( []string{"Creating security group", "my-group"}, []string{"FAILED"}, )) }) }) Context("when the group already exists", func() { BeforeEach(func() { securityGroupRepo.CreateReturns(errors.NewHttpError(400, "300005", "The security group is taken: my-group")) }) It("warns the user when group already exists", func() { Expect(ui.Outputs).ToNot(ContainSubstrings([]string{"FAILED"})) Expect(ui.WarnOutputs).To(ContainSubstrings([]string{"already exists"})) }) }) }) }) Context("when the file specified has invalid json", func() { BeforeEach(func() { tempFile.Write([]byte(`[{noquote: thiswontwork}]`)) })
package net import ( "encoding/json" "github.com/nttlabs/cli/cf/configuration/core_config" "github.com/nttlabs/cli/cf/errors" "github.com/nttlabs/cli/cf/terminal" ) type uaaErrorResponse struct { Code string `json:"error"` Description string `json:"error_description"` } var uaaErrorHandler = func(statusCode int, body []byte) error { response := uaaErrorResponse{} json.Unmarshal(body, &response) if response.Code == "invalid_token" { return errors.NewInvalidTokenError(response.Description) } else { return errors.NewHttpError(statusCode, response.Code, response.Description) } } func NewUAAGateway(config core_config.Reader, ui terminal.UI) Gateway { return newGateway(uaaErrorHandler, config, ui) }
[]string{"Binding service", "global-service", "app1", "my-org", "my-space", "my-user"}, []string{"OK"}, []string{"Creating", "app2"}, []string{"OK"}, []string{"Binding service", "app2-service", "app2", "my-org", "my-space", "my-user"}, []string{"OK"}, []string{"Binding service", "global-service", "app2", "my-org", "my-space", "my-user"}, []string{"OK"}, )) }) }) Context("when the app is already bound to the service", func() { BeforeEach(func() { appRepo.ReadReturns.App = maker.NewApp(maker.Overrides{}) serviceBinder.BindApplicationReturns.Error = errors.NewHttpError(500, "90003", "it don't work") }) It("gracefully continues", func() { callPush() Expect(len(serviceBinder.AppsToBind)).To(Equal(4)) Expect(ui.Outputs).ToNot(ContainSubstrings([]string{"FAILED"})) }) }) Context("when the service instance can't be found", func() { BeforeEach(func() { // routeRepo.FindByHostAndDomainReturns.Error = errors.new("can't find service instance") serviceRepo.FindInstanceByNameErr = true manifestRepo.ReadManifestReturns.Manifest = manifestWithServicesAndEnv() })
orgRepo.CreateReturns(nil) requirementsFactory.LoginSuccess = true }) It("creates an org", func() { runCommand("my-org") Expect(ui.Outputs).To(ContainSubstrings( []string{"Creating org", "my-org", "my-user"}, []string{"OK"}, )) Expect(orgRepo.CreateArgsForCall(0).Name).To(Equal("my-org")) }) It("fails and warns the user when the org already exists", func() { err := errors.NewHttpError(400, errors.ORG_EXISTS, "org already exists") orgRepo.CreateReturns(err) runCommand("my-org") Expect(ui.Outputs).To(ContainSubstrings( []string{"Creating org", "my-org"}, []string{"OK"}, []string{"my-org", "already exists"}, )) }) Context("when allowing a non-defualt quota", func() { var ( quota models.QuotaFields )
) getInstance := func(appGuid string) (instances []models.AppInstanceFields, apiErr error) { if len(defaultInstanceResponses) > 0 { instances = defaultInstanceResponses[0] if len(defaultInstanceResponses) > 1 { defaultInstanceResponses = defaultInstanceResponses[1:] } } if len(defaultInstanceErrorCodes) > 0 { errorCode := defaultInstanceErrorCodes[0] if len(defaultInstanceErrorCodes) > 1 { defaultInstanceErrorCodes = defaultInstanceErrorCodes[1:] } if errorCode != "" { apiErr = errors.NewHttpError(400, errorCode, "Error staging app") } } return } BeforeEach(func() { ui = new(testterm.FakeUI) requirementsFactory = &testreq.FakeReqFactory{} defaultAppForStart.Name = "my-app" defaultAppForStart.Guid = "my-app-guid" defaultAppForStart.InstanceCount = 2 domain := models.DomainFields{} domain.Name = "example.com"