func (repo CloudControllerServiceRepository) CreateServiceInstance(name, planGUID string, params map[string]interface{}, tags []string) (err error) {
path := "/v2/service_instances?accepts_incomplete=true"
request := models.ServiceInstanceCreateRequest{
Name: name,
PlanGUID: planGUID,
SpaceGUID: repo.config.SpaceFields().GUID,
Params: params,
Tags: tags,
}
jsonBytes, err := json.Marshal(request)
if err != nil {
return err
}
err = repo.gateway.CreateResource(repo.config.APIEndpoint(), path, bytes.NewReader(jsonBytes))
if httpErr, ok := err.(errors.HTTPError); ok && httpErr.ErrorCode() == errors.ServiceInstanceNameTaken {
serviceInstance, findInstanceErr := repo.FindInstanceByName(name)
if findInstanceErr == nil && serviceInstance.ServicePlan.GUID == planGUID {
return errors.NewModelAlreadyExistsError("Service", name)
}
}
return
}
func (c CloudControllerServiceKeyRepository) CreateServiceKey(instanceGUID string, keyName string, params map[string]interface{}) error {
path := "/v2/service_keys"
request := models.ServiceKeyRequest{
Name: keyName,
ServiceInstanceGUID: instanceGUID,
Params: params,
}
jsonBytes, err := json.Marshal(request)
if err != nil {
return err
}
err = c.gateway.CreateResource(c.config.APIEndpoint(), path, bytes.NewReader(jsonBytes))
if httpErr, ok := err.(errors.HTTPError); ok {
switch httpErr.ErrorCode() {
case errors.ServiceKeyNameTaken:
return errors.NewModelAlreadyExistsError("Service key", keyName)
case errors.UnbindableService:
return errors.NewUnbindableServiceError()
default:
return errors.New(httpErr.Error())
}
}
return nil
}
func (repo CloudControllerUserRepository) Create(username, password string) (err error) {
uaaEndpoint, err := repo.getAuthEndpoint()
if err != nil {
return
}
path := "/Users"
body, err := json.Marshal(resources.NewUAAUserResource(username, password))
if err != nil {
return
}
createUserResponse := &resources.UAAUserFields{}
err = repo.uaaGateway.CreateResource(uaaEndpoint, path, bytes.NewReader(body), createUserResponse)
switch httpErr := err.(type) {
case nil:
case errors.HTTPError:
if httpErr.StatusCode() == http.StatusConflict {
err = errors.NewModelAlreadyExistsError("user", username)
return
}
return
default:
return
}
path = "/v2/users"
body, err = json.Marshal(resources.Metadata{
GUID: createUserResponse.ID,
})
if err != nil {
return
}
return repo.ccGateway.CreateResource(repo.config.APIEndpoint(), path, bytes.NewReader(body))
}
})
Describe("requirements are satisfied", func() {
It("create service key successfully", func() {
callCreateService([]string{"fake-service-instance", "fake-service-key"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service key", "fake-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
[]string{"OK"},
))
Expect(serviceKeyRepo.CreateServiceKeyMethod.InstanceGUID).To(Equal("fake-instance-guid"))
Expect(serviceKeyRepo.CreateServiceKeyMethod.KeyName).To(Equal("fake-service-key"))
})
It("create service key failed when the service key already exists", func() {
serviceKeyRepo.CreateServiceKeyMethod.Error = errors.NewModelAlreadyExistsError("Service key", "exist-service-key")
callCreateService([]string{"fake-service-instance", "exist-service-key"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service key", "exist-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
[]string{"OK"},
[]string{"Service key exist-service-key already exists"}))
})
It("create service key failed when the service is unbindable", func() {
serviceKeyRepo.CreateServiceKeyMethod.Error = errors.NewUnbindableServiceError()
callCreateService([]string{"fake-service-instance", "exist-service-key"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service key", "exist-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
))
Expect(ui.Outputs()).NotTo(ContainSubstrings([]string{"will incurr a cost"}))
})
It("warns the user when the service is not free", func() {
callCreateService([]string{"cleardb", "expensive", "my-expensive-cleardb-service"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service instance", "my-expensive-cleardb-service", "my-org", "my-space", "my-user"},
[]string{"OK"},
[]string{"Attention: The plan `expensive` of service `cleardb` is not free. The instance `my-expensive-cleardb-service` will incur a cost. Contact your administrator if you think this is in error."},
))
})
})
It("warns the user when the service already exists with the same service plan", func() {
serviceRepo.CreateServiceInstanceReturns(errors.NewModelAlreadyExistsError("Service", "my-cleardb-service"))
callCreateService([]string{"cleardb", "spark", "my-cleardb-service"})
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating service instance", "my-cleardb-service"},
[]string{"OK"},
[]string{"my-cleardb-service", "already exists"},
))
name, planGUID, _, _ := serviceRepo.CreateServiceInstanceArgsForCall(0)
Expect(name).To(Equal("my-cleardb-service"))
Expect(planGUID).To(Equal("cleardb-spark-guid"))
})
Context("When there are multiple services with the same label", func() {
runCommand("my-user", "my-password")
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Creating user", "my-user"},
[]string{"OK"},
[]string{"TIP"},
))
userName, password := userRepo.CreateArgsForCall(0)
Expect(userName).To(Equal("my-user"))
Expect(password).To(Equal("my-password"))
})
Context("when creating the user returns an error", func() {
It("prints a warning when the given user already exists", func() {
userRepo.CreateReturns(errors.NewModelAlreadyExistsError("User", "my-user"))
runCommand("my-user", "my-password")
Expect(ui.WarnOutputs).To(ContainSubstrings(
[]string{"already exists"},
))
Expect(ui.Outputs()).ToNot(ContainSubstrings([]string{"FAILED"}))
})
It("fails when any error other than alreadyExists is returned", func() {
userRepo.CreateReturns(errors.NewHTTPError(403, "403", "Forbidden"))
runCommand("my-user", "my-password")