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"
