func (us UsersService) Create(username, email, token string) (User, error) {
resp, err := newNetworkClient(us.config).MakeRequest(network.Request{
Method: "POST",
Path: "/Users",
Authorization: network.NewTokenAuthorization(token),
Body: network.NewJSONRequestBody(documents.CreateUserRequest{
UserName: username,
Emails: []documents.Email{
{Value: email},
},
}),
AcceptableStatusCodes: []int{http.StatusCreated},
})
if err != nil {
return User{}, translateError(err)
}
var response documents.UserResponse
err = json.Unmarshal(resp.Body, &response)
if err != nil {
return User{}, MalformedResponseError{err}
}
return newUserFromResponse(us.config, response), nil
}
// Create will make a request to UAA to register a client with the given client resource and
// secret. A token with the "clients.write" scope is required.
func (cs ClientsService) Create(client Client, secret, token string) error {
_, err := newNetworkClient(cs.config).MakeRequest(network.Request{
Method: "POST",
Path: "/oauth/clients",
Authorization: network.NewTokenAuthorization(token),
Body: network.NewJSONRequestBody(client.toDocument(secret)),
AcceptableStatusCodes: []int{http.StatusCreated},
})
if err != nil {
return translateError(err)
}
return nil
}
func (us UsersService) SetPassword(id, password, token string) error {
_, err := newNetworkClient(us.config).MakeRequest(network.Request{
Method: "PUT",
Path: fmt.Sprintf("/Users/%s/password", id),
Authorization: network.NewTokenAuthorization(token),
Body: network.NewJSONRequestBody(documents.SetPasswordRequest{
Password: password,
}),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return translateError(err)
}
return nil
}
func (us UsersService) Update(user User, token string) (User, error) {
resp, err := newNetworkClient(us.config).MakeRequest(network.Request{
Method: "PUT",
Path: fmt.Sprintf("/Users/%s", user.ID),
Authorization: network.NewTokenAuthorization(token),
IfMatch: strconv.Itoa(user.Version),
Body: network.NewJSONRequestBody(newUpdateUserDocumentFromUser(user)),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return User{}, translateError(err)
}
var response documents.UserResponse
err = json.Unmarshal(resp.Body, &response)
if err != nil {
return User{}, MalformedResponseError{err}
}
return newUserFromResponse(us.config, response), nil
}
// Create will make a request to UAA to create a new group resource with the given
// DisplayName. A token with the "scim.write" scope is required.
func (gs GroupsService) Create(displayName, token string) (Group, error) {
resp, err := newNetworkClient(gs.config).MakeRequest(network.Request{
Method: "POST",
Path: "/Groups",
Authorization: network.NewTokenAuthorization(token),
Body: network.NewJSONRequestBody(documents.CreateGroupRequest{
DisplayName: displayName,
Schemas: schemas,
}),
AcceptableStatusCodes: []int{http.StatusCreated},
})
if err != nil {
return Group{}, translateError(err)
}
var response documents.GroupResponse
err = json.Unmarshal(resp.Body, &response)
if err != nil {
return Group{}, MalformedResponseError{err}
}
return newGroupFromResponse(gs.config, response), nil
}
"github.com/pivotal-cf-experimental/warrant/internal/network"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RequestBodyEncoder", func() {
Describe("JSONRequestBody", func() {
Describe("Encode", func() {
It("returns a JSON encoded representation of the given object with proper content type", func() {
var object struct {
Hello string `json:"hello"`
}
object.Hello = "goodbye"
body, contentType, err := network.NewJSONRequestBody(object).Encode()
Expect(err).NotTo(HaveOccurred())
Expect(ioutil.ReadAll(body)).To(MatchJSON(`{
"hello": "goodbye"
}`))
Expect(contentType).To(Equal("application/json"))
})
It("returns an error when the JSON cannot be encoded", func() {
_, _, err := network.NewJSONRequestBody(func() {}).Encode()
Expect(err).To(HaveOccurred())
})
})
})
Describe("FormRequestBody", func() {
AfterEach(func() {
fakeServer.Close()
})
Describe("makeRequest", func() {
It("can make requests", func() {
jsonBody := map[string]interface{}{
"hello": "goodbye",
}
resp, err := client.MakeRequest(network.Request{
Method: "GET",
Path: "/path",
Authorization: network.NewTokenAuthorization(token),
Body: network.NewJSONRequestBody(jsonBody),
AcceptableStatusCodes: []int{http.StatusOK},
})
Expect(err).NotTo(HaveOccurred())
Expect(resp.Code).To(Equal(http.StatusOK))
Expect(resp.Body).To(MatchJSON(`{
"body": "{\"hello\":\"goodbye\"}",
"headers": {
"Accept": ["application/json"],
"Accept-Encoding": ["gzip"],
"Authorization": ["Bearer TOKEN"],
"Content-Length": ["19"],
"Content-Type": ["application/json"],
"User-Agent": ["Go 1.1 package http"]
}
}`))