git.iko.soy/typeable/oauth2-proxy
on f435fa6 help sign in
typeable/oauth2-proxy/api/api_test.go
129 lines 3.7 kB history raw
1package api
3import (
4 "io/ioutil"
5 "net/http"
6 "net/http/httptest"
7 "strings"
8 "testing"
10 "github.com/bitly/go-simplejson"
12 "github.com/stretchr/testify/assert"
15func testBackend(responseCode int, payload string) *httptest.Server {
16 return httptest.NewServer(http.HandlerFunc(
17 func(w http.ResponseWriter, r *http.Request) {
18 w.WriteHeader(responseCode)
19 w.Write([]byte(payload))
20 }))
23func TestRequest(t *testing.T) {
24 backend := testBackend(200, "{\"foo\": \"bar\"}")
25 defer backend.Close()
27 req, _ := http.NewRequest("GET", backend.URL, nil)
28 response, err := Request(req)
29 assert.Equal(t, nil, err)
30 result, err := response.Get("foo").String()
31 assert.Equal(t, nil, err)
32 assert.Equal(t, "bar", result)
35func TestRequestFailure(t *testing.T) {
36 // Create a backend to generate a test URL, then close it to cause a
37 // connection error.
38 backend := testBackend(200, "{\"foo\": \"bar\"}")
39 backend.Close()
41 req, err := http.NewRequest("GET", backend.URL, nil)
42 assert.Equal(t, nil, err)
43 resp, err := Request(req)
44 assert.Equal(t, (*simplejson.Json)(nil), resp)
45 assert.NotEqual(t, nil, err)
46 if !strings.Contains(err.Error(), "refused") {
47 t.Error("expected error when a connection fails: ", err)
48 }
51func TestHttpErrorCode(t *testing.T) {
52 backend := testBackend(404, "{\"foo\": \"bar\"}")
53 defer backend.Close()
55 req, err := http.NewRequest("GET", backend.URL, nil)
56 assert.Equal(t, nil, err)
57 resp, err := Request(req)
58 assert.Equal(t, (*simplejson.Json)(nil), resp)
59 assert.NotEqual(t, nil, err)
62func TestJsonParsingError(t *testing.T) {
63 backend := testBackend(200, "not well-formed JSON")
64 defer backend.Close()
66 req, err := http.NewRequest("GET", backend.URL, nil)
67 assert.Equal(t, nil, err)
68 resp, err := Request(req)
69 assert.Equal(t, (*simplejson.Json)(nil), resp)
70 assert.NotEqual(t, nil, err)
73// Parsing a URL practically never fails, so we won't cover that test case.
74func TestRequestUnparsedResponseUsingAccessTokenParameter(t *testing.T) {
75 backend := httptest.NewServer(http.HandlerFunc(
76 func(w http.ResponseWriter, r *http.Request) {
77 token := r.FormValue("access_token")
78 if r.URL.Path == "/" && token == "my_token" {
79 w.WriteHeader(200)
80 w.Write([]byte("some payload"))
81 } else {
82 w.WriteHeader(403)
83 }
84 }))
85 defer backend.Close()
87 response, err := RequestUnparsedResponse(
88 backend.URL+"?access_token=my_token", nil)
89 assert.Equal(t, nil, err)
90 assert.Equal(t, 200, response.StatusCode)
91 body, err := ioutil.ReadAll(response.Body)
92 assert.Equal(t, nil, err)
93 response.Body.Close()
94 assert.Equal(t, "some payload", string(body))
97func TestRequestUnparsedResponseUsingAccessTokenParameterFailedResponse(t *testing.T) {
98 backend := testBackend(200, "some payload")
99 // Close the backend now to force a request failure.
100 backend.Close()
102 response, err := RequestUnparsedResponse(
103 backend.URL+"?access_token=my_token", nil)
104 assert.NotEqual(t, nil, err)
105 assert.Equal(t, (*http.Response)(nil), response)
108func TestRequestUnparsedResponseUsingHeaders(t *testing.T) {
109 backend := httptest.NewServer(http.HandlerFunc(
110 func(w http.ResponseWriter, r *http.Request) {
111 if r.URL.Path == "/" && r.Header["Auth"][0] == "my_token" {
112 w.WriteHeader(200)
113 w.Write([]byte("some payload"))
114 } else {
115 w.WriteHeader(403)
116 }
117 }))
118 defer backend.Close()
120 headers := make(http.Header)
121 headers.Set("Auth", "my_token")
122 response, err := RequestUnparsedResponse(backend.URL, headers)
123 assert.Equal(t, nil, err)
124 assert.Equal(t, 200, response.StatusCode)
125 body, err := ioutil.ReadAll(response.Body)
126 assert.Equal(t, nil, err)
127 response.Body.Close()
128 assert.Equal(t, "some payload", string(body))