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