Merge branch 'master' into server-side-caching

component/http/route.go

@@ -18,6 +18,26 @@ type Route struct {
 	middlewares []MiddlewareFunc
 }
 
+// Path returns route path value.
+func (r Route) Path() string {
+	return r.path
+}
+
+// Method returns route method value (GET/POST/...).
+func (r Route) Method() string {
+	return r.method
+}
+
+// Middlewares returns route middlewares.
+func (r Route) Middlewares() []MiddlewareFunc {
+	return r.middlewares
+}
+
+// Handler returns route handler function.
+func (r Route) Handler() http.HandlerFunc {
+	return r.handler
+}
+
 // RouteBuilder for building a route.
 type RouteBuilder struct {
 	method            string

component/http/route_test.go

@@ -2,11 +2,15 @@ package http
 
 import (
 	"context"
+	"encoding/json"
+	"io/ioutil"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	"github.com/beatlabs/patron/component/http/auth"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type MockAuthenticator struct {
@@ -299,3 +303,40 @@ func TestRoutesBuilder_Build(t *testing.T) {
 		})
 	}
 }
+
+func TestRoute_Getters(t *testing.T) {
+	type testResponse struct {
+		Value string
+	}
+
+	path := "/foo"
+	expectedResponse := testResponse{"foo"}
+	r, err := NewRouteBuilder(path, testingHandlerMock(expectedResponse)).WithTrace().MethodPost().Build()
+	require.NoError(t, err)
+
+	assert.Equal(t, path, r.Path())
+	assert.Equal(t, http.MethodPost, r.Method())
+	assert.Len(t, r.Middlewares(), 1)
+
+	// the only way to test do we get the same handler that we provided initially, is to run it explicitly,
+	// since all we have in Route itself is a wrapper function
+	req, err := http.NewRequest(http.MethodPost, path, nil)
+	require.NoError(t, err)
+	wr := httptest.NewRecorder()
+
+	r.Handler().ServeHTTP(wr, req)
+	br, err := ioutil.ReadAll(wr.Body)
+	require.NoError(t, err)
+
+	gotResponse := testResponse{}
+	err = json.Unmarshal(br, &gotResponse)
+	require.NoError(t, err)
+
+	assert.Equal(t, expectedResponse, gotResponse)
+}
+
+func testingHandlerMock(expected interface{}) ProcessorFunc {
+	return func(_ context.Context, _ *Request) (*Response, error) {
+		return NewResponse(expected), nil
+	}
+}