engine_test.go

package engine_test

import (
	"context"
	"io"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/mockingio/engine"
	"github.com/mockingio/engine/mock"
	"github.com/mockingio/engine/persistent"
	"github.com/mockingio/engine/persistent/memory"
)

func TestEngine_Pause(t *testing.T) {
	eng := engine.New("mock-id", memory.New())
	eng.Pause()

	req := httptest.NewRequest(http.MethodPost, "/test", nil)
	w := httptest.NewRecorder()
	eng.Handler(w, req)
	res := w.Result()
	assert.Equal(t, http.StatusServiceUnavailable, res.StatusCode)
}

func TestEngine_PauseResume(t *testing.T) {
	mem := setupMock()
	req := httptest.NewRequest(http.MethodGet, "/hello", nil)
	eng := engine.New("mock-id", mem)

	eng.Pause()
	w := httptest.NewRecorder()
	eng.Handler(w, req)
	res := w.Result()
	assert.Equal(t, http.StatusServiceUnavailable, res.StatusCode)

	eng.Resume()
	w = httptest.NewRecorder()
	eng.Handler(w, req)
	res = w.Result()
	assert.Equal(t, http.StatusOK, res.StatusCode)
}

func TestEngine_Match(t *testing.T) {
	mem := setupMock()
	eng := engine.New("mock-id", mem)

	req := httptest.NewRequest(http.MethodGet, "/hello", nil)
	w := httptest.NewRecorder()
	eng.Handler(w, req)
	res := w.Result()
	defer func() {
		_ = res.Body.Close()
	}()

	bod, err := ioutil.ReadAll(res.Body)
	require.NoError(t, err)

	assert.Equal(t, "Hello World", string(bod))
	assert.Equal(t, http.StatusOK, res.StatusCode)
	assert.Equal(t, "text/plain", res.Header.Get("Content-Type"))
	assert.Equal(t, "test", res.Header.Get("X-Test"))
}

func TestEngine_Match_With_Delay_Response(t *testing.T) {
	mem := memory.New()
	_ = mem.SetMock(context.Background(), &mock.Mock{
		ID: "mock-id",
		Routes: []*mock.Route{
			{
				Method: "GET",
				Path:   "/hello",
				Responses: []mock.Response{
					{
						Status: 200,
						Delay:  50,
					},
				},
			},
		},
	})

	eng := engine.New("mock-id", mem)

	req := httptest.NewRequest(http.MethodGet, "/hello", nil)
	w := httptest.NewRecorder()

	timer := time.Now()
	eng.Handler(w, req)
	res := w.Result()
	defer func() {
		_ = res.Body.Close()
	}()

	assert.True(t, time.Since(timer) > 50*time.Millisecond)
	assert.Equal(t, http.StatusOK, res.StatusCode)
}

func TestEngine_NoResponses(t *testing.T) {
	mem := memory.New()
	_ = mem.SetMock(context.Background(), &mock.Mock{
		ID: "mock-id",
		Routes: []*mock.Route{
			{
				Method:    "GET",
				Path:      "/hello",
				Responses: []mock.Response{},
			},
		},
	})

	eng := engine.New("mock-id", mem)

	req := httptest.NewRequest(http.MethodGet, "/hello", nil)
	w := httptest.NewRecorder()
	eng.Handler(w, req)
	res := w.Result()
	defer func() {
		_ = res.Body.Close()
	}()

	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 TestEngine_CORS_Request(t *testing.T) {
	tests := []struct {
		name               string
		mok                *mock.Mock
		expectedStatusCode int
	}{
		{
			"Auto CORS option is disabled, and no matching response, expect default 404",
			&mock.Mock{
				ID: "mock-id",
			},
			http.StatusNotFound,
		}, {
			"Auto CORS option is enabled, and no matching response, expect 200 OK",
			&mock.Mock{
				ID:       "mock-id",
				AutoCORS: true,
			},
			http.StatusOK,
		},
		{
			"Auto CORS option is enabled, and has matching response, use the matched response",
			&mock.Mock{
				ID:       "mock-id",
				AutoCORS: true,
				Routes: []*mock.Route{
					{
						Method: "OPTIONS",
						Path:   "/hello",
						Responses: []mock.Response{
							{
								Status: 201,
							},
						},
					},
				},
			},
			http.StatusCreated,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mem := memory.New()
			_ = mem.SetMock(context.Background(), tt.mok)
			eng := engine.New("mock-id", mem)
			req := httptest.NewRequest(http.MethodOptions, "/hello", nil)
			w := httptest.NewRecorder()
			eng.Handler(w, req)
			res := w.Result()
			defer func() {
				_ = res.Body.Close()
			}()

			assert.Equal(t, tt.expectedStatusCode, res.StatusCode)
		})
	}
}

func TestEngine_MockNotFound(t *testing.T) {
	mem := memory.New()
	_ = mem.SetMock(context.Background(), &mock.Mock{
		ID: "mock-2",
	})
	eng := engine.New("mock-1", mem)
	req, _ := http.NewRequest(http.MethodGet, "/hello", nil)

	assert.Nil(t, eng.Match(req))
}

func setupMock() persistent.Persistent {
	mok := &mock.Mock{
		ID:       "mock-id",
		AutoCORS: true,
		Routes: []*mock.Route{
			{
				Method: "GET",
				Path:   "/hello",
				Responses: []mock.Response{
					{
						Status: 200,
						Body:   "Hello World",
						Headers: map[string]string{
							"Content-Type": "text/plain",
							"X-Test":       "test",
						},
					},
				},
			},
		},
	}
	mem := memory.New()
	_ = mem.SetMock(context.Background(), mok)

	return mem
}