git.iko.soy/typeable/oauth2-proxy
on master help sign in
Remove old requests code
commit028a0ed62e8c039caf5fae8a642468bb42b7eff7 authorJoel Speed <joel.speed@hotmail.co.uk> dateSat 4 Jul 2020, 06:29 (6 years ago) parent5314245
2 files changed−210
compare with master
unifiedsplit
pkg/requests/requests.go−74 pkg/requests/requests_test.go−136
pkg/requests/requests.godeleted−74
@@ -1,74 +0,0 @@
1−package requests
2−
3−import (
4− "context"
5− "encoding/json"
6− "fmt"
7− "io/ioutil"
8− "net/http"
9−
10− "github.com/bitly/go-simplejson"
11− "github.com/oauth2-proxy/oauth2-proxy/pkg/logger"
12−)
13−
14−// Request parses the request body into a simplejson.Json object
15−func Request(req *http.Request) (*simplejson.Json, error) {
16− resp, err := http.DefaultClient.Do(req)
17− if err != nil {
18− logger.Printf("%s %s %s", req.Method, req.URL, err)
19− return nil, err
20− }
21− body, err := ioutil.ReadAll(resp.Body)
22− if body != nil {
23− defer resp.Body.Close()
24− }
25−
26− logger.Printf("%d %s %s %s", resp.StatusCode, req.Method, req.URL, body)
27−
28− if err != nil {
29− return nil, fmt.Errorf("problem reading http request body: %w", err)
30− }
31−
32− if resp.StatusCode != 200 {
33− return nil, fmt.Errorf("got %d %s", resp.StatusCode, body)
34− }
35−
36− data, err := simplejson.NewJson(body)
37− if err != nil {
38− return nil, fmt.Errorf("error unmarshalling json: %w", err)
39− }
40− return data, nil
41−}
42−
43−// RequestJSON parses the request body into the given interface
44−func RequestJSON(req *http.Request, v interface{}) error {
45− resp, err := http.DefaultClient.Do(req)
46− if err != nil {
47− logger.Printf("%s %s %s", req.Method, req.URL, err)
48− return err
49− }
50− body, err := ioutil.ReadAll(resp.Body)
51− if body != nil {
52− defer resp.Body.Close()
53− }
54−
55− logger.Printf("%d %s %s %s", resp.StatusCode, req.Method, req.URL, body)
56− if err != nil {
57− return fmt.Errorf("error reading body from http response: %w", err)
58− }
59− if resp.StatusCode != 200 {
60− return fmt.Errorf("got %d %s", resp.StatusCode, body)
61− }
62− return json.Unmarshal(body, v)
63−}
64−
65−// RequestUnparsedResponse performs a GET and returns the raw response object
66−func RequestUnparsedResponse(ctx context.Context, url string, header http.Header) (resp *http.Response, err error) {
67− req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
68− if err != nil {
69− return nil, fmt.Errorf("error performing get request: %w", err)
70− }
71− req.Header = header
72−
73− return http.DefaultClient.Do(req)
74−}
pkg/requests/requests_test.godeleted−136
@@ -1,136 +0,0 @@
1−package requests
2−
3−import (
4− "context"
5− "io/ioutil"
6− "net/http"
7− "net/http/httptest"
8− "strings"
9− "testing"
10−
11− "github.com/bitly/go-simplejson"
12− "github.com/stretchr/testify/assert"
13− "github.com/stretchr/testify/require"
14−)
15−
16−func testBackend(t *testing.T, responseCode int, payload string) *httptest.Server {
17− return httptest.NewServer(http.HandlerFunc(
18− func(w http.ResponseWriter, r *http.Request) {
19− w.WriteHeader(responseCode)
20− _, err := w.Write([]byte(payload))
21− require.NoError(t, err)
22− }))
23−}
24−
25−func TestRequest(t *testing.T) {
26− backend := testBackend(t, 200, "{\"foo\": \"bar\"}")
27− defer backend.Close()
28−
29− req, _ := http.NewRequest("GET", backend.URL, nil)
30− response, err := Request(req)
31− assert.Equal(t, nil, err)
32− result, err := response.Get("foo").String()
33− assert.Equal(t, nil, err)
34− assert.Equal(t, "bar", result)
35−}
36−
37−func TestRequestFailure(t *testing.T) {
38− // Create a backend to generate a test URL, then close it to cause a
39− // connection error.
40− backend := testBackend(t, 200, "{\"foo\": \"bar\"}")
41− backend.Close()
42−
43− req, err := http.NewRequest("GET", backend.URL, nil)
44− assert.Equal(t, nil, err)
45− resp, err := Request(req)
46− assert.Equal(t, (*simplejson.Json)(nil), resp)
47− assert.NotEqual(t, nil, err)
48− if !strings.Contains(err.Error(), "refused") {
49− t.Error("expected error when a connection fails: ", err)
50− }
51−}
52−
53−func TestHttpErrorCode(t *testing.T) {
54− backend := testBackend(t, 404, "{\"foo\": \"bar\"}")
55− defer backend.Close()
56−
57− req, err := http.NewRequest("GET", backend.URL, nil)
58− assert.Equal(t, nil, err)
59− resp, err := Request(req)
60− assert.Equal(t, (*simplejson.Json)(nil), resp)
61− assert.NotEqual(t, nil, err)
62−}
63−
64−func TestJsonParsingError(t *testing.T) {
65− backend := testBackend(t, 200, "not well-formed JSON")
66− defer backend.Close()
67−
68− req, err := http.NewRequest("GET", backend.URL, nil)
69− assert.Equal(t, nil, err)
70− resp, err := Request(req)
71− assert.Equal(t, (*simplejson.Json)(nil), resp)
72− assert.NotEqual(t, nil, err)
73−}
74−
75−// Parsing a URL practically never fails, so we won't cover that test case.
76−func TestRequestUnparsedResponseUsingAccessTokenParameter(t *testing.T) {
77− backend := httptest.NewServer(http.HandlerFunc(
78− func(w http.ResponseWriter, r *http.Request) {
79− token := r.FormValue("access_token")
80− if r.URL.Path == "/" && token == "my_token" {
81− w.WriteHeader(200)
82− _, err := w.Write([]byte("some payload"))
83− require.NoError(t, err)
84− } else {
85− w.WriteHeader(403)
86− }
87− }))
88− defer backend.Close()
89−
90− response, err := RequestUnparsedResponse(
91− context.Background(), backend.URL+"?access_token=my_token", nil)
92− assert.Equal(t, nil, err)
93− defer response.Body.Close()
94−
95− assert.Equal(t, 200, response.StatusCode)
96− body, err := ioutil.ReadAll(response.Body)
97− assert.Equal(t, nil, err)
98− assert.Equal(t, "some payload", string(body))
99−}
100−
101−func TestRequestUnparsedResponseUsingAccessTokenParameterFailedResponse(t *testing.T) {
102− backend := testBackend(t, 200, "some payload")
103− // Close the backend now to force a request failure.
104− backend.Close()
105−
106− response, err := RequestUnparsedResponse(
107− context.Background(), backend.URL+"?access_token=my_token", nil)
108− assert.NotEqual(t, nil, err)
109− assert.Equal(t, (*http.Response)(nil), response)
110−}
111−
112−func TestRequestUnparsedResponseUsingHeaders(t *testing.T) {
113− backend := httptest.NewServer(http.HandlerFunc(
114− func(w http.ResponseWriter, r *http.Request) {
115− if r.URL.Path == "/" && r.Header["Auth"][0] == "my_token" {
116− w.WriteHeader(200)
117− _, err := w.Write([]byte("some payload"))
118− require.NoError(t, err)
119− } else {
120− w.WriteHeader(403)
121− }
122− }))
123− defer backend.Close()
124−
125− headers := make(http.Header)
126− headers.Set("Auth", "my_token")
127− response, err := RequestUnparsedResponse(context.Background(), backend.URL, headers)
128− assert.Equal(t, nil, err)
129− defer response.Body.Close()
130−
131− assert.Equal(t, 200, response.StatusCode)
132− body, err := ioutil.ReadAll(response.Body)
133− assert.Equal(t, nil, err)
134−
135− assert.Equal(t, "some payload", string(body))
136−}