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
}
func (us UsersService) Find(query UsersQuery, token string) ([]User, error) {
requestPath := url.URL{
Path: "/Users",
RawQuery: url.Values{
"filter": []string{query.Filter},
}.Encode(),
}
resp, err := newNetworkClient(us.config).MakeRequest(network.Request{
Method: "GET",
Path: requestPath.String(),
Authorization: network.NewTokenAuthorization(token),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return []User{}, translateError(err)
}
var response documents.UserListResponse
err = json.Unmarshal(resp.Body, &response)
if err != nil {
return []User{}, MalformedResponseError{err}
}
var userList []User
for _, userResponse := range response.Resources {
userList = append(userList, newUserFromResponse(us.config, userResponse))
}
return userList, err
}
// Delete will make a request to UAA to delete the group resource with the matching id.
// A token with the "scim.write" scope is required.
func (gs GroupsService) Delete(id, token string) error {
_, err := newNetworkClient(gs.config).MakeRequest(network.Request{
Method: "DELETE",
Path: fmt.Sprintf("/Groups/%s", id),
Authorization: network.NewTokenAuthorization(token),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return translateError(err)
}
return 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
}
// Get will make a request to UAA to fetch the group resource with the matching id.
// A token with the "scim.read" scope is required.
func (gs GroupsService) Get(id, token string) (Group, error) {
resp, err := newNetworkClient(gs.config).MakeRequest(network.Request{
Method: "GET",
Path: fmt.Sprintf("/Groups/%s", id),
Authorization: network.NewTokenAuthorization(token),
AcceptableStatusCodes: []int{http.StatusOK},
})
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
}
// Get will make a request to UAA to fetch the client matching the given id.
// A token with the "clients.read" scope is required.
func (cs ClientsService) Get(id, token string) (Client, error) {
resp, err := newNetworkClient(cs.config).MakeRequest(network.Request{
Method: "GET",
Path: fmt.Sprintf("/oauth/clients/%s", id),
Authorization: network.NewTokenAuthorization(token),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return Client{}, translateError(err)
}
var document documents.ClientResponse
err = json.Unmarshal(resp.Body, &document)
if err != nil {
return Client{}, MalformedResponseError{err}
}
return newClientFromDocument(document), 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
}
// List wil make a request to UAA to list the groups that match the given Query.
// A token with the "scim.read" scope is required.
func (gs GroupsService) List(query Query, token string) ([]Group, error) {
resp, err := newNetworkClient(gs.config).MakeRequest(network.Request{
Method: "GET",
Path: "/Groups",
Authorization: network.NewTokenAuthorization(token),
AcceptableStatusCodes: []int{http.StatusOK},
})
if err != nil {
return []Group{}, translateError(err)
}
var response documents.GroupListResponse
err = json.Unmarshal(resp.Body, &response)
if err != nil {
return []Group{}, MalformedResponseError{err}
}
var groupList []Group
for _, groupResponse := range response.Resources {
groupList = append(groupList, newGroupFromResponse(gs.config, groupResponse))
}
return groupList, err
}
})
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"]
}
package network_test
import (
"github.com/pivotal-cf-experimental/warrant/internal/network"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RequestAuthorization", func() {
Describe("TokenAuthorization", func() {
It("returns a bearer token given a token value", func() {
auth := network.NewTokenAuthorization("TOKEN")
Expect(auth.Authorization()).To(Equal("Bearer TOKEN"))
})
})
Describe("BasicAuthorization", func() {
It("returns a basic auth header given a username and password", func() {
auth := network.NewBasicAuthorization("username", "password")
Expect(auth.Authorization()).To(Equal("Basic dXNlcm5hbWU6cGFzc3dvcmQ="))
})
})
})