generated_client_test.go

// Code generated by go-uaa/generator; DO NOT EDIT.

package uaa_test

import (
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"

	uaa "github.com/cloudfoundry-community/go-uaa"
	. "github.com/onsi/gomega"
	"github.com/sclevine/spec"
)

func testClient(t *testing.T, when spec.G, it spec.S) {
	var (
		s       *httptest.Server
		handler http.Handler
		called  int
		a       *uaa.API
	)

	it.Before(func() {
		RegisterTestingT(t)
		called = 0
		s = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
			called = called + 1
			Expect(handler).NotTo(BeNil())
			handler.ServeHTTP(w, req)
		}))
		var err error
		a, err = uaa.New(s.URL, uaa.WithNoAuthentication())
		Expect(err).NotTo(HaveOccurred())
	})

	it.After(func() {
		if s != nil {
			s.Close()
		}
	})

	when("GetClient()", func() {
		when("the client is returned from the server", func() {
			it.Before(func() {
				handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
					Expect(req.Header.Get("Accept")).To(Equal("application/json"))
					Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
					w.WriteHeader(http.StatusOK)
					w.Write([]byte(clientResponse))
				})
			})
			it("gets the client from the UAA by ID", func() {
				client, err := a.GetClient("00000000-0000-0000-0000-000000000001")
				Expect(err).NotTo(HaveOccurred())
				Expect(client.ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			})
		})

		when("the server errors", func() {
			it.Before(func() {
				handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
					Expect(req.Header.Get("Accept")).To(Equal("application/json"))
					Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
					w.WriteHeader(http.StatusInternalServerError)
				})
			})

			it("returns helpful error", func() {
				client, err := a.GetClient("00000000-0000-0000-0000-000000000001")
				Expect(err).To(HaveOccurred())
				Expect(client).To(BeNil())
				Expect(err.Error()).To(ContainSubstring("An error occurred while calling"))
			})
		})

		when("the server returns unparsable clients", func() {
			it.Before(func() {
				handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
					Expect(req.Header.Get("Accept")).To(Equal("application/json"))
					Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
					w.WriteHeader(http.StatusOK)
					w.Write([]byte("{unparsable-json-response}"))
				})
			})

			it("returns helpful error", func() {
				client, err := a.GetClient("00000000-0000-0000-0000-000000000001")
				Expect(err).To(HaveOccurred())
				Expect(client).To(BeNil())
				Expect(err.Error()).To(ContainSubstring("An unknown error occurred while parsing response from"))
				Expect(err.Error()).To(ContainSubstring("Response was {unparsable-json-response}"))
			})
		})
	})

	when("CreateClient()", func() {
		it("performs a POST with the client data and returns the created client", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.Header.Get("Content-Type")).To(Equal("application/json"))
				Expect(req.Method).To(Equal(http.MethodPost))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				defer req.Body.Close()
				body, _ := ioutil.ReadAll(req.Body)
				Expect(body).To(MatchJSON(testClientJSON))
				w.WriteHeader(http.StatusCreated)
				w.Write([]byte(clientResponse))
			})

			created, err := a.CreateClient(testClientValue)
			Expect(called).To(Equal(1))
			Expect(err).NotTo(HaveOccurred())
			Expect(created).NotTo(BeNil())
		})

		it("returns error when response cannot be parsed", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodPost))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte("{unparseable}"))
			})
			created, err := a.CreateClient(testClientValue)
			Expect(err).To(HaveOccurred())
			Expect(created).To(BeNil())
		})

		it("returns error when response is not 200 OK", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodPost))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				w.WriteHeader(http.StatusBadRequest)
			})
			created, err := a.CreateClient(testClientValue)
			Expect(err).To(HaveOccurred())
			Expect(created).To(BeNil())
		})
	})

	when("UpdateClient()", func() {
		it("performs a PUT with the client data and returns the updated client", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.Header.Get("Content-Type")).To(Equal("application/json"))
				Expect(req.Method).To(Equal(http.MethodPut))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				defer req.Body.Close()
				body, _ := ioutil.ReadAll(req.Body)
				Expect(body).To(MatchJSON(testClientJSON))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientResponse))
			})

			updated, err := a.UpdateClient(testClientValue)
			Expect(called).To(Equal(1))
			Expect(err).NotTo(HaveOccurred())
			Expect(updated).NotTo(BeNil())
		})

		it("returns error when response cannot be parsed", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodPut))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte("{unparseable}"))
			})
			updated, err := a.UpdateClient(testClientValue)
			Expect(err).To(HaveOccurred())
			Expect(updated).To(BeNil())
		})

		it("returns error when response is not 200 OK", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodPut))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				w.WriteHeader(http.StatusBadRequest)
			})
			updated, err := a.UpdateClient(testClientValue)
			Expect(err).To(HaveOccurred())
			Expect(updated).To(BeNil())
		})
	})

	when("DeleteClient()", func() {
		it("errors when the clientID is empty", func() {
			deleted, err := a.DeleteClient("")
			Expect(called).To(Equal(0))
			Expect(err).To(HaveOccurred())
			Expect(deleted).To(BeNil())
		})

		it("performs a DELETE for the client", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.Method).To(Equal(http.MethodDelete))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientResponse))
			})

			deleted, err := a.DeleteClient("00000000-0000-0000-0000-000000000001")
			Expect(called).To(Equal(1))
			Expect(err).NotTo(HaveOccurred())
			Expect(deleted).NotTo(BeNil())
		})

		it("returns error when response cannot be parsed", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodDelete))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte("{unparseable}"))
			})
			deleted, err := a.DeleteClient("00000000-0000-0000-0000-000000000001")
			Expect(err).To(HaveOccurred())
			Expect(deleted).To(BeNil())
		})

		it("returns error when response is not 200 OK", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Method).To(Equal(http.MethodDelete))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint + "/00000000-0000-0000-0000-000000000001"))
				w.WriteHeader(http.StatusBadRequest)
			})
			deleted, err := a.DeleteClient("00000000-0000-0000-0000-000000000001")
			Expect(err).To(HaveOccurred())
			Expect(deleted).To(BeNil())
		})
	})

	when("ListAllClients()", func() {
		it("can return multiple pages", func() {
			page1 := MultiPaginatedResponse(1, 1, 2, uaa.Client{ClientID: "test-client-1"})
			page2 := MultiPaginatedResponse(2, 1, 2, uaa.Client{ClientID: "test-client-2"})
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				w.WriteHeader(http.StatusOK)
				if called == 1 {
					Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
					Expect(req.URL.Query().Get("count")).To(Equal("100"))
					w.Write([]byte(page1))
				} else {
					Expect(req.URL.Query().Get("startIndex")).To(Equal("2"))
					Expect(req.URL.Query().Get("count")).To(Equal("1"))
					w.Write([]byte(page2))
				}
			})

			clients, err := a.ListAllClients("", "", "")
			Expect(err).NotTo(HaveOccurred())
			Expect(clients[0].ClientID).To(Equal("test-client-1"))
			Expect(clients[1].ClientID).To(Equal("test-client-2"))
			Expect(called).To(Equal(2))
		})

		it("returns an error when the endpoint doesn't respond", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				w.WriteHeader(http.StatusInternalServerError)
			})

			clients, err := a.ListAllClients("", "", "")
			Expect(err).To(HaveOccurred())
			Expect(clients).To(BeNil())
			Expect(called).To(Equal(1))
		})
	})

	when("ListClients()", func() {
		it("can accept a filter query to limit results", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal("id eq \"00000000-0000-0000-0000-000000000001\""))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientListResponse))
			})
			clientList, _, err := a.ListClients("id eq \"00000000-0000-0000-0000-000000000001\"", "", "", 1, 100)
			Expect(err).NotTo(HaveOccurred())
			Expect(clientList[0].ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			Expect(clientList[1].ClientID).To(Equal("00000000-0000-0000-0000-000000000002"))
		})

		it("does not include the filter param if no filter exists", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal(""))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientListResponse))
			})
			clientList, _, err := a.ListClients("", "", "", 1, 100)
			Expect(err).NotTo(HaveOccurred())
			Expect(clientList[0].ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			Expect(clientList[1].ClientID).To(Equal("00000000-0000-0000-0000-000000000002"))
		})

		it("can accept sortBy", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal(""))
				Expect(req.URL.Query().Get("sortBy")).To(Equal("testField"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientListResponse))
			})
			clientList, _, err := a.ListClients("", "testField", "", 1, 100)
			Expect(err).NotTo(HaveOccurred())
			Expect(clientList[0].ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			Expect(clientList[1].ClientID).To(Equal("00000000-0000-0000-0000-000000000002"))
		})

		it("can accept sort order ascending/descending", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal(""))
				Expect(req.URL.Query().Get("sortBy")).To(Equal(""))
				Expect(req.URL.Query().Get("sortOrder")).To(Equal("ascending"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientListResponse))
			})
			clientList, _, err := a.ListClients("", "", uaa.SortAscending, 1, 100)
			Expect(err).NotTo(HaveOccurred())
			Expect(clientList[0].ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			Expect(clientList[1].ClientID).To(Equal("00000000-0000-0000-0000-000000000002"))
		})

		it("uses a startIndex of 1 if 0 is supplied", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(clientListResponse))
			})
			clientList, _, err := a.ListClients("", "", "", 0, 0)
			Expect(err).NotTo(HaveOccurred())
			Expect(clientList[0].ClientID).To(Equal("00000000-0000-0000-0000-000000000001"))
			Expect(clientList[1].ClientID).To(Equal("00000000-0000-0000-0000-000000000002"))
		})

		it("returns an error when the endpoint doesn't respond", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal("id eq \"00000000-0000-0000-0000-000000000001\""))
				w.WriteHeader(http.StatusInternalServerError)
			})

			clientList, _, err := a.ListClients("id eq \"00000000-0000-0000-0000-000000000001\"", "", "", 1, 100)
			Expect(err).To(HaveOccurred())
			Expect(clientList).To(BeNil())
		})

		it("returns an error when response is unparseable", func() {
			handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				Expect(req.Header.Get("Accept")).To(Equal("application/json"))
				Expect(req.URL.Path).To(Equal(uaa.ClientsEndpoint))
				Expect(req.URL.Query().Get("count")).To(Equal("100"))
				Expect(req.URL.Query().Get("startIndex")).To(Equal("1"))
				Expect(req.URL.Query().Get("filter")).To(Equal("id eq \"00000000-0000-0000-0000-000000000001\""))
				w.WriteHeader(http.StatusOK)
				w.Write([]byte("{unparsable}"))
			})
			clientList, _, err := a.ListClients("id eq \"00000000-0000-0000-0000-000000000001\"", "", "", 1, 100)
			Expect(err).To(HaveOccurred())
			Expect(clientList).To(BeNil())
		})
	})
}