Move api to pkg/requests

pkg/requests/requests.go

@@ -0,0 +1,64 @@
+package requests
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/bitly/go-simplejson"
+	"github.com/pusher/oauth2_proxy/logger"
+)
+
+// Request parses the request body into a simplejson.Json object
+func Request(req *http.Request) (*simplejson.Json, error) {
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		logger.Printf("%s %s %s", req.Method, req.URL, err)
+		return nil, err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	resp.Body.Close()
+	logger.Printf("%d %s %s %s", resp.StatusCode, req.Method, req.URL, body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("got %d %s", resp.StatusCode, body)
+	}
+	data, err := simplejson.NewJson(body)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// RequestJSON parses the request body into the given interface
+func RequestJSON(req *http.Request, v interface{}) error {
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		logger.Printf("%s %s %s", req.Method, req.URL, err)
+		return err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	resp.Body.Close()
+	logger.Printf("%d %s %s %s", resp.StatusCode, req.Method, req.URL, body)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("got %d %s", resp.StatusCode, body)
+	}
+	return json.Unmarshal(body, v)
+}
+
+// RequestUnparsedResponse performs a GET and returns the raw response object
+func RequestUnparsedResponse(url string, header http.Header) (resp *http.Response, err error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header = header
+
+	return http.DefaultClient.Do(req)
+}

pkg/requests/requests_test.go

@@ -0,0 +1,129 @@
+package requests
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/bitly/go-simplejson"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func testBackend(responseCode int, payload string) *httptest.Server {
+	return httptest.NewServer(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(responseCode)
+			w.Write([]byte(payload))
+		}))
+}
+
+func TestRequest(t *testing.T) {
+	backend := testBackend(200, "{\"foo\": \"bar\"}")
+	defer backend.Close()
+
+	req, _ := http.NewRequest("GET", backend.URL, nil)
+	response, err := Request(req)
+	assert.Equal(t, nil, err)
+	result, err := response.Get("foo").String()
+	assert.Equal(t, nil, err)
+	assert.Equal(t, "bar", result)
+}
+
+func TestRequestFailure(t *testing.T) {
+	// Create a backend to generate a test URL, then close it to cause a
+	// connection error.
+	backend := testBackend(200, "{\"foo\": \"bar\"}")
+	backend.Close()
+
+	req, err := http.NewRequest("GET", backend.URL, nil)
+	assert.Equal(t, nil, err)
+	resp, err := Request(req)
+	assert.Equal(t, (*simplejson.Json)(nil), resp)
+	assert.NotEqual(t, nil, err)
+	if !strings.Contains(err.Error(), "refused") {
+		t.Error("expected error when a connection fails: ", err)
+	}
+}
+
+func TestHttpErrorCode(t *testing.T) {
+	backend := testBackend(404, "{\"foo\": \"bar\"}")
+	defer backend.Close()
+
+	req, err := http.NewRequest("GET", backend.URL, nil)
+	assert.Equal(t, nil, err)
+	resp, err := Request(req)
+	assert.Equal(t, (*simplejson.Json)(nil), resp)
+	assert.NotEqual(t, nil, err)
+}
+
+func TestJsonParsingError(t *testing.T) {
+	backend := testBackend(200, "not well-formed JSON")
+	defer backend.Close()
+
+	req, err := http.NewRequest("GET", backend.URL, nil)
+	assert.Equal(t, nil, err)
+	resp, err := Request(req)
+	assert.Equal(t, (*simplejson.Json)(nil), resp)
+	assert.NotEqual(t, nil, err)
+}
+
+// Parsing a URL practically never fails, so we won't cover that test case.
+func TestRequestUnparsedResponseUsingAccessTokenParameter(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			token := r.FormValue("access_token")
+			if r.URL.Path == "/" && token == "my_token" {
+				w.WriteHeader(200)
+				w.Write([]byte("some payload"))
+			} else {
+				w.WriteHeader(403)
+			}
+		}))
+	defer backend.Close()
+
+	response, err := RequestUnparsedResponse(
+		backend.URL+"?access_token=my_token", nil)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, 200, response.StatusCode)
+	body, err := ioutil.ReadAll(response.Body)
+	assert.Equal(t, nil, err)
+	response.Body.Close()
+	assert.Equal(t, "some payload", string(body))
+}
+
+func TestRequestUnparsedResponseUsingAccessTokenParameterFailedResponse(t *testing.T) {
+	backend := testBackend(200, "some payload")
+	// Close the backend now to force a request failure.
+	backend.Close()
+
+	response, err := RequestUnparsedResponse(
+		backend.URL+"?access_token=my_token", nil)
+	assert.NotEqual(t, nil, err)
+	assert.Equal(t, (*http.Response)(nil), response)
+}
+
+func TestRequestUnparsedResponseUsingHeaders(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/" && r.Header["Auth"][0] == "my_token" {
+				w.WriteHeader(200)
+				w.Write([]byte("some payload"))
+			} else {
+				w.WriteHeader(403)
+			}
+		}))
+	defer backend.Close()
+
+	headers := make(http.Header)
+	headers.Set("Auth", "my_token")
+	response, err := RequestUnparsedResponse(backend.URL, headers)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, 200, response.StatusCode)
+	body, err := ioutil.ReadAll(response.Body)
+	assert.Equal(t, nil, err)
+	response.Body.Close()
+	assert.Equal(t, "some payload", string(body))
+}