From 018a501221bcb6931c36499e575339d4a3f8408a Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sat, 2 Apr 2016 23:28:13 +0200 Subject: [PATCH 1/6] feat(test): Add test for HandleHTTP for HEAD request --- request_test.go | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/request_test.go b/request_test.go index e1e60da..2cf3273 100644 --- a/request_test.go +++ b/request_test.go @@ -5,7 +5,9 @@ import ( "encoding/json" "encoding/xml" "errors" + "fmt" "github.com/nbio/st" + "gopkg.in/vinci-proxy/utils.v0" "io" "io/ioutil" "net/http" @@ -338,3 +340,28 @@ func TestReaderWithStringReaderAsParameter(t *testing.T) { body, _ := ioutil.ReadAll(req.Body) st.Expect(t, string(body), "Hello") } + +func TestRequest(t *testing.T) { + intercepted := false + modifierFunc := func(m *RequestModifier) { + intercepted = true + } + interceptor := Request(modifierFunc) + interceptor.Modifier(&RequestModifier{}) + st.Expect(t, intercepted, true) +} + +func TestHandleHTTPHEADRequest(t *testing.T) { + modifierFunc := func(m *RequestModifier) { + m.Header.Set("foo", "bar") + } + w := utils.NewWriterStub() + req := &http.Request{Method: "HEAD", Header: make(http.Header)} + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, "Hi") + st.Expect(t, r.Header.Get("foo"), "") + }) + interceptor := Request(modifierFunc) + interceptor.HandleHTTP(w, req, handler) + st.Expect(t, string(w.Body), "Hi") +} From 672ab39ec620fd561ed8a41e5c37aa62d8a2463f Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sat, 2 Apr 2016 23:29:24 +0200 Subject: [PATCH 2/6] feat(test): Add test for HandleHTTP for OPTIONS request --- request_test.go | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/request_test.go b/request_test.go index 2cf3273..1df9a80 100644 --- a/request_test.go +++ b/request_test.go @@ -365,3 +365,18 @@ func TestHandleHTTPHEADRequest(t *testing.T) { interceptor.HandleHTTP(w, req, handler) st.Expect(t, string(w.Body), "Hi") } + +func TestHandleHTTPOPTIONSRequest(t *testing.T) { + modifierFunc := func(m *RequestModifier) { + m.Header.Set("foo", "bar") + } + w := utils.NewWriterStub() + req := &http.Request{Method: "OPTIONS", Header: make(http.Header)} + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, "Hi") + st.Expect(t, r.Header.Get("foo"), "") + }) + interceptor := Request(modifierFunc) + interceptor.HandleHTTP(w, req, handler) + st.Expect(t, string(w.Body), "Hi") +} From 1153dbbe99d33c71d4f1f32ef6227044e5837457 Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sat, 2 Apr 2016 23:47:43 +0200 Subject: [PATCH 3/6] feat(test): Add test for HandleHTTP --- request_test.go | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-) diff --git a/request_test.go b/request_test.go index 1df9a80..7f34414 100644 --- a/request_test.go +++ b/request_test.go @@ -352,31 +352,46 @@ func TestRequest(t *testing.T) { } func TestHandleHTTPHEADRequest(t *testing.T) { - modifierFunc := func(m *RequestModifier) { - m.Header.Set("foo", "bar") - } - w := utils.NewWriterStub() - req := &http.Request{Method: "HEAD", Header: make(http.Header)} handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hi") st.Expect(t, r.Header.Get("foo"), "") }) - interceptor := Request(modifierFunc) + interceptor := Request(func(m *RequestModifier) { + m.Header.Set("foo", "bar") + }) + w := utils.NewWriterStub() + req := &http.Request{Method: "HEAD", Header: make(http.Header)} interceptor.HandleHTTP(w, req, handler) st.Expect(t, string(w.Body), "Hi") } func TestHandleHTTPOPTIONSRequest(t *testing.T) { - modifierFunc := func(m *RequestModifier) { + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, "Hi") + st.Expect(t, r.Header.Get("foo"), "") + }) + interceptor := Request(func(m *RequestModifier) { m.Header.Set("foo", "bar") - } + }) w := utils.NewWriterStub() req := &http.Request{Method: "OPTIONS", Header: make(http.Header)} + interceptor.HandleHTTP(w, req, handler) + st.Expect(t, string(w.Body), "Hi") +} + +func TestHandleHTTP(t *testing.T) { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hi") - st.Expect(t, r.Header.Get("foo"), "") + st.Expect(t, r.Header.Get("foo"), "bar") + requestBody, _ := ioutil.ReadAll(r.Body) + st.Expect(t, string(requestBody), "Hello") }) - interceptor := Request(modifierFunc) + interceptor := Request(func(m *RequestModifier) { + m.Header.Set("foo", "bar") + m.String("Hello") + }) + w := utils.NewWriterStub() + req := &http.Request{Method: "POST", Header: make(http.Header)} interceptor.HandleHTTP(w, req, handler) st.Expect(t, string(w.Body), "Hi") } From 076ed32489654f894043756f19f7ff4655204ac8 Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sun, 3 Apr 2016 00:54:42 +0200 Subject: [PATCH 4/6] refactor(test): Refactor HandleHTTP tests --- request_test.go | 49 ++++++++++++++++++++----------------------------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/request_test.go b/request_test.go index 7f34414..d756b6d 100644 --- a/request_test.go +++ b/request_test.go @@ -5,7 +5,6 @@ import ( "encoding/json" "encoding/xml" "errors" - "fmt" "github.com/nbio/st" "gopkg.in/vinci-proxy/utils.v0" "io" @@ -352,46 +351,38 @@ func TestRequest(t *testing.T) { } func TestHandleHTTPHEADRequest(t *testing.T) { - handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - fmt.Fprint(w, "Hi") - st.Expect(t, r.Header.Get("foo"), "") - }) - interceptor := Request(func(m *RequestModifier) { - m.Header.Set("foo", "bar") - }) - w := utils.NewWriterStub() - req := &http.Request{Method: "HEAD", Header: make(http.Header)} - interceptor.HandleHTTP(w, req, handler) - st.Expect(t, string(w.Body), "Hi") + testHandleHttpNotIntercepted(t, "HEAD") } func TestHandleHTTPOPTIONSRequest(t *testing.T) { - handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - fmt.Fprint(w, "Hi") - st.Expect(t, r.Header.Get("foo"), "") - }) + testHandleHttpNotIntercepted(t, "OPTIONS") +} + +func testHandleHttpNotIntercepted(t *testing.T, method string) { interceptor := Request(func(m *RequestModifier) { m.Header.Set("foo", "bar") }) - w := utils.NewWriterStub() - req := &http.Request{Method: "OPTIONS", Header: make(http.Header)} - interceptor.HandleHTTP(w, req, handler) - st.Expect(t, string(w.Body), "Hi") + stubbedWriter := utils.NewWriterStub() + req := &http.Request{Method: method, Header: make(http.Header)} + handler := http.HandlerFunc(func(writer http.ResponseWriter, r *http.Request) { + st.Expect(t, writer, stubbedWriter) + st.Expect(t, r.Header.Get("foo"), "") + }) + interceptor.HandleHTTP(stubbedWriter, req, handler) } func TestHandleHTTP(t *testing.T) { - handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - fmt.Fprint(w, "Hi") - st.Expect(t, r.Header.Get("foo"), "bar") - requestBody, _ := ioutil.ReadAll(r.Body) - st.Expect(t, string(requestBody), "Hello") - }) interceptor := Request(func(m *RequestModifier) { m.Header.Set("foo", "bar") m.String("Hello") }) - w := utils.NewWriterStub() + stubbedWriter := utils.NewWriterStub() req := &http.Request{Method: "POST", Header: make(http.Header)} - interceptor.HandleHTTP(w, req, handler) - st.Expect(t, string(w.Body), "Hi") + handler := http.HandlerFunc(func(writer http.ResponseWriter, r *http.Request) { + st.Expect(t, writer, stubbedWriter) + st.Expect(t, r.Header.Get("foo"), "bar") + requestBody, _ := ioutil.ReadAll(r.Body) + st.Expect(t, string(requestBody), "Hello") + }) + interceptor.HandleHTTP(stubbedWriter, req, handler) } From 1e1f7b49ffca987b19a58cbdeb4f3a07843c2536 Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sun, 3 Apr 2016 01:15:41 +0200 Subject: [PATCH 5/6] fix(lint): Fix lint for HandleHTTP test --- request_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/request_test.go b/request_test.go index d756b6d..ad5c26d 100644 --- a/request_test.go +++ b/request_test.go @@ -351,14 +351,14 @@ func TestRequest(t *testing.T) { } func TestHandleHTTPHEADRequest(t *testing.T) { - testHandleHttpNotIntercepted(t, "HEAD") + testHandleHTTPNotIntercepted(t, "HEAD") } func TestHandleHTTPOPTIONSRequest(t *testing.T) { - testHandleHttpNotIntercepted(t, "OPTIONS") + testHandleHTTPNotIntercepted(t, "OPTIONS") } -func testHandleHttpNotIntercepted(t *testing.T, method string) { +func testHandleHTTPNotIntercepted(t *testing.T, method string) { interceptor := Request(func(m *RequestModifier) { m.Header.Set("foo", "bar") }) From 58123eb45c9bf9e7cda3d3004eab77b210b7d644 Mon Sep 17 00:00:00 2001 From: Yohan Robert Date: Sun, 3 Apr 2016 12:03:10 +0200 Subject: [PATCH 6/6] feat(request): Allow HEAD and OPTIONS request to be intercepted --- request.go | 5 ----- request_test.go | 21 --------------------- 2 files changed, 26 deletions(-) diff --git a/request.go b/request.go index e8cd04b..1d26628 100644 --- a/request.go +++ b/request.go @@ -182,11 +182,6 @@ func Request(h ReqModifierFunc) *RequestInterceptor { // HandleHTTP handles the middleware call chain, intercepting the request data if possible. // This methods implements the middleware layer compatible interface. func (s *RequestInterceptor) HandleHTTP(w http.ResponseWriter, r *http.Request, h http.Handler) { - if r.Method == "HEAD" || r.Method == "OPTIONS" { - h.ServeHTTP(w, r) - return - } - req := NewRequestModifier(r) s.Modifier(req) h.ServeHTTP(w, req.Request) diff --git a/request_test.go b/request_test.go index ad5c26d..cd3fed4 100644 --- a/request_test.go +++ b/request_test.go @@ -350,27 +350,6 @@ func TestRequest(t *testing.T) { st.Expect(t, intercepted, true) } -func TestHandleHTTPHEADRequest(t *testing.T) { - testHandleHTTPNotIntercepted(t, "HEAD") -} - -func TestHandleHTTPOPTIONSRequest(t *testing.T) { - testHandleHTTPNotIntercepted(t, "OPTIONS") -} - -func testHandleHTTPNotIntercepted(t *testing.T, method string) { - interceptor := Request(func(m *RequestModifier) { - m.Header.Set("foo", "bar") - }) - stubbedWriter := utils.NewWriterStub() - req := &http.Request{Method: method, Header: make(http.Header)} - handler := http.HandlerFunc(func(writer http.ResponseWriter, r *http.Request) { - st.Expect(t, writer, stubbedWriter) - st.Expect(t, r.Header.Get("foo"), "") - }) - interceptor.HandleHTTP(stubbedWriter, req, handler) -} - func TestHandleHTTP(t *testing.T) { interceptor := Request(func(m *RequestModifier) { m.Header.Set("foo", "bar")