Merge pull request #4 from mockingio/feat/support-proxy

Feat/support proxy

Author: tuongaz

engine.go

@@ -1,9 +1,12 @@
 package engine
 
 import (
+	"context"
+	"io"
 	"net/http"
 	"time"
 
+	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 
 	"github.com/mockingio/engine/matcher"
@@ -15,6 +18,7 @@ type Engine struct {
 	mockID   string
 	isPaused bool
 	db       persistent.Persistent
+	mock     *mock.Mock
 }
 
 func New(mockID string, db persistent.Persistent) *Engine {
@@ -34,12 +38,13 @@ func (eng *Engine) Pause() {
 
 func (eng *Engine) Match(req *http.Request) *mock.Response {
 	ctx := req.Context()
-	mok, err := eng.db.GetMock(ctx, eng.mockID)
-	if err != nil {
-		log.WithError(err).Error("loading mock")
+	if err := eng.reloadMock(ctx); err != nil {
+		log.WithError(err).Error("reload mock")
 		return nil
 	}
 
+	mok := eng.getMock()
+
 	sessionID, err := eng.db.GetActiveSession(ctx, eng.mockID)
 	if err != nil {
 		log.WithError(err).WithField("config_id", eng.mockID).Error("get active session")
@@ -79,8 +84,13 @@ func (eng *Engine) Handler(w http.ResponseWriter, r *http.Request) {
 
 	response := eng.Match(r)
 	if response == nil {
-		// TODO: no matched? What will be the response?
-		w.WriteHeader(http.StatusNotFound)
+		mok := eng.getMock()
+		if mok.ProxyEnabled() {
+			eng.handleProxy(w, r)
+			return
+		}
+
+		eng.noMatchHandler(w)
 		return
 	}
 
@@ -91,3 +101,73 @@ func (eng *Engine) Handler(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(response.Status)
 	_, _ = w.Write([]byte(response.Body))
 }
+
+func (eng *Engine) noMatchHandler(w http.ResponseWriter) {
+	w.WriteHeader(http.StatusNotFound)
+}
+
+func (eng *Engine) handleProxy(w http.ResponseWriter, r *http.Request) {
+	proxy := eng.getMock().Proxy
+
+	req, err := copyProxyRequest(r, proxy)
+	if err != nil {
+		log.WithError(err).Error("copy request")
+		eng.noMatchHandler(w)
+		return
+	}
+
+	res, err := (&http.Client{}).Do(req)
+	if err != nil {
+		log.WithError(err).Error("make proxy request")
+		eng.noMatchHandler(w)
+		return
+	}
+	defer func() { _ = res.Body.Close() }()
+
+	writeProxyResponse(res, w, proxy)
+}
+
+func (eng *Engine) getMock() *mock.Mock {
+	return eng.mock
+}
+
+func (eng *Engine) reloadMock(ctx context.Context) error {
+	mok, err := eng.db.GetMock(ctx, eng.mockID)
+	if err != nil {
+		return errors.Wrap(err, "get mock from DB")
+	}
+
+	if mok == nil {
+		return errors.New("mock not found")
+	}
+
+	eng.mock = mok
+
+	return nil
+}
+
+func copyProxyRequest(r *http.Request, proxy *mock.Proxy) (*http.Request, error) {
+	req, err := http.NewRequest(r.Method, proxy.Host+r.URL.Path, r.Body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header = r.Header
+
+	for k, v := range proxy.RequestHeaders {
+		req.Header.Add(k, v)
+	}
+
+	return req, nil
+}
+
+func writeProxyResponse(res *http.Response, w http.ResponseWriter, proxy *mock.Proxy) {
+	for k, v := range res.Header {
+		w.Header().Add(k, v[0])
+	}
+	for k, v := range proxy.ResponseHeaders {
+		w.Header().Add(k, v)
+	}
+
+	w.WriteHeader(res.StatusCode)
+	_, _ = io.Copy(w, res.Body)
+}

engine_test.go

@@ -2,6 +2,7 @@ package engine_test
 
 import (
 	"context"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
@@ -127,6 +128,52 @@ func TestEngine_NoResponses(t *testing.T) {
 	assert.Equal(t, http.StatusNotFound, res.StatusCode)
 }
 
+func TestEngine_ProxyHandler(t *testing.T) {
+	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/hello" {
+			t.Errorf("request path is %s, not /hello", r.URL.Path)
+		}
+
+		if r.Header.Get("X-Request") != "from request" {
+			t.Error("header is not append to the request")
+		}
+
+		w.Header().Set("Content-Type", "html/text")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("From Proxy"))
+	}))
+
+	mok := &mock.Mock{
+		ID: "mock-id",
+		Proxy: &mock.Proxy{
+			Enabled: true,
+			Host:    proxyServer.URL,
+			RequestHeaders: map[string]string{
+				"X-Request": "from request",
+			},
+			ResponseHeaders: map[string]string{
+				"X-Response": "from response",
+			},
+		},
+	}
+	mem := memory.New()
+	_ = mem.SetMock(context.Background(), mok)
+	eng := engine.New("mock-id", mem)
+
+	w := httptest.NewRecorder()
+	eng.Handler(w, httptest.NewRequest(http.MethodGet, "/hello", nil))
+	res := w.Result()
+	body, _ := io.ReadAll(res.Body)
+	defer func() {
+		_ = res.Body.Close()
+	}()
+
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+	assert.Equal(t, "From Proxy", string(body))
+	assert.Equal(t, "html/text", res.Header.Get("Content-Type"))
+	assert.Equal(t, "from response", res.Header.Get("X-Response"))
+}
+
 func setupMock() persistent.Persistent {
 	mok := &mock.Mock{
 		ID: "mock-id",

matcher/route.go

@@ -2,6 +2,7 @@ package matcher
 
 import (
 	"math/rand"
+	"net/http"
 	"strings"
 	"time"
 
@@ -28,8 +29,12 @@ func NewRouteMatcher(route *cfg.Route, req Context, db persistent.Persistent) *R
 
 func (r *RouteMatcher) Match() (*cfg.Response, error) {
 	httpRequest := r.req.HTTPRequest
+	method := r.route.Method
+	if r.route.Method == "" {
+		method = http.MethodGet
+	}
 
-	if !strings.EqualFold(r.route.Method, httpRequest.Method) {
+	if !strings.EqualFold(method, httpRequest.Method) {
 		return nil, nil
 	}
 

mock/fixtures/mock.golden.yml

@@ -51,3 +51,10 @@ routes:
   description: ""
   responses:
   - status: 201
+proxy:
+  enabled: true
+  host: https://google.com
+  request_headers:
+    X-Forward: "123"
+  response_headers:
+    X-Response: "123"

mock/fixtures/mock.yml

@@ -1,4 +1,11 @@
 name: Hello World
+proxy:
+  enabled: true
+  host: https://google.com
+  request_headers:
+    X-Forward: 123
+  response_headers:
+    X-Response: 123
 routes:
   - method: GET
     path: /hello/world

mock/mock.go

@@ -16,6 +16,7 @@ type Mock struct {
 	Name    string   `yaml:"name,omitempty" json:"name,omitempty"`
 	Port    string   `yaml:"port,omitempty" json:"port,omitempty"`
 	Routes  []*Route `yaml:"routes,omitempty" json:"routes,omitempty"`
+	Proxy   *Proxy   `yaml:"proxy,omitempty" json:"proxy,omitempty"`
 	options mockOptions
 }
 
@@ -55,6 +56,17 @@ func FromYaml(text string, opts ...Option) (*Mock, error) {
 	return m, nil
 }
 
+func (c Mock) Validate() error {
+	return validation.ValidateStruct(
+		&c,
+		validation.Field(&c.Routes, validation.Required),
+	)
+}
+
+func (c Mock) ProxyEnabled() bool {
+	return c.Proxy != nil && c.Proxy.Enabled
+}
+
 func defaultValues(m *Mock) {
 	for _, r := range m.Routes {
 		if r.Method == "" {
@@ -95,13 +107,6 @@ func addIDs(m *Mock) {
 	}
 }
 
-func (c Mock) Validate() error {
-	return validation.ValidateStruct(
-		&c,
-		validation.Field(&c.Routes, validation.Required),
-	)
-}
-
 func newID() string {
 	return uuid.NewString()
 }

mock/mock_test.go

@@ -2,10 +2,11 @@ package mock_test
 
 import (
 	_ "embed"
-	"gopkg.in/yaml.v2"
 	"path/filepath"
 	"testing"
 
+	"gopkg.in/yaml.v2"
+
 	. "github.com/mockingio/engine/mock"
 	"github.com/mockingio/engine/test"
 	"github.com/stretchr/testify/assert"
@@ -46,14 +47,24 @@ func TestConfig(t *testing.T) {
 	})
 
 	t.Run("error loading config from YAML file", func(t *testing.T) {
-		cfg, err := FromFile("")
+		mock, err := FromFile("")
 		assert.Error(t, err)
-		assert.Nil(t, cfg)
+		assert.Nil(t, mock)
 	})
 
 	t.Run("error loading mock from empty yaml", func(t *testing.T) {
-		cfg, err := FromYaml("")
+		mock, err := FromYaml("")
 		assert.Error(t, err)
-		assert.Nil(t, cfg)
+		assert.Nil(t, mock)
+	})
+
+	t.Run("proxy is enabled", func(t *testing.T) {
+		mock := &Mock{
+			Proxy: &Proxy{
+				Enabled: true,
+			},
+		}
+		assert.False(t, New().ProxyEnabled())
+		assert.True(t, mock.ProxyEnabled())
 	})
 }

mock/proxy.go

@@ -0,0 +1,8 @@
+package mock
+
+type Proxy struct {
+	Enabled         bool              `yaml:"enabled,omitempty" json:"enabled,omitempty"`
+	Host            string            `yaml:"host,omitempty" json:"host,omitempty"`
+	RequestHeaders  map[string]string `yaml:"request_headers,omitempty" json:"request_headers,omitempty"`
+	ResponseHeaders map[string]string `yaml:"response_headers,omitempty" json:"response_headers,omitempty"`
+}