Merge branch 'master' into fix/update-github-actions-sha-latest

Author: ilijabojanovic

gateway/mw_mock_response.go

@@ -9,7 +9,9 @@ import (
 	"net/http"
 	"sort"
 	"strconv"
+	"time"
 
+	"github.com/TykTechnologies/tyk-pump/analytics"
 	"github.com/TykTechnologies/tyk/apidef/oas"
 	"github.com/TykTechnologies/tyk/common/option"
 	"github.com/TykTechnologies/tyk/header"
@@ -21,14 +23,22 @@ var _ TykMiddleware = (*mockResponseMiddleware)(nil)
 
 type mockResponseMiddleware struct {
 	*BaseMiddleware
+	hitRecorder hitRecorder
 }
 
 func newMockResponseMiddleware(base *BaseMiddleware, opts ...option.Option[mockResponseMiddleware]) TykMiddleware {
 	return option.New(opts).Build(mockResponseMiddleware{
 		BaseMiddleware: base,
+		hitRecorder:    &realHitRecorder{successHandler: &SuccessHandler{base.Copy()}},
 	})
 }
 
+func withHitRecorder(h hitRecorder) option.Option[mockResponseMiddleware] {
+	return func(m *mockResponseMiddleware) {
+		m.hitRecorder = h
+	}
+}
+
 func (m *mockResponseMiddleware) Name() string {
 	return "MockResponseMiddleware"
 }
@@ -61,11 +71,13 @@ func (m *mockResponseMiddleware) forward(res *http.Response, rw http.ResponseWri
 }
 
 func (m *mockResponseMiddleware) ProcessRequest(rw http.ResponseWriter, r *http.Request, _ interface{}) (error, int) {
+	start := time.Now()
+
 	if !m.Spec.hasActiveMock() {
 		return nil, http.StatusOK
 	}
 
-	res, err := m.mockResponse(r)
+	res, requestOverwritten, err := m.mockResponse(r)
 
 	if err != nil {
 		return fmt.Errorf("failed to mock response: %w", err), http.StatusInternalServerError
@@ -86,10 +98,16 @@ func (m *mockResponseMiddleware) ProcessRequest(rw http.ResponseWriter, r *http.
 		return fmt.Errorf("failed to forward response: %w", err), http.StatusInternalServerError
 	}
 
+	m.hitRecorder.hit(rw, requestOverwritten, res, start)
+
 	return nil, middleware.StatusRespond
 }
 
-func (m *mockResponseMiddleware) mockResponse(r *http.Request) (*http.Response, error) {
+func (m *mockResponseMiddleware) mockResponse(r *http.Request) (
+	res *http.Response,
+	internal *http.Request,
+	err error,
+) {
 	// Use FindSpecMatchesStatus to check if this path should be mocked
 	// This ensures the standard regex-based path matching is used, respecting gateway configurations
 	versionInfo, _ := m.Spec.Version(r)
@@ -99,21 +117,23 @@ func (m *mockResponseMiddleware) mockResponse(r *http.Request) (*http.Response,
 
 	if !found || urlSpec == nil {
 		// No mock response configured for this path
-		return nil, nil
+		return nil, nil, nil
 	}
 
 	mockResponse := urlSpec.OASMockResponseMeta
 	if mockResponse == nil || !mockResponse.Enabled {
-		return nil, nil
+		return nil, nil, nil
 	}
 
-	res := &http.Response{Header: http.Header{}}
+	res = &http.Response{Header: http.Header{}}
+
+	internal = r.Clone(r.Context())
+	internal.URL.Path = urlSpec.OASPath
 
 	var code int
 	var contentType string
 	var body []byte
 	var headers []oas.Header
-	var err error
 
 	if mockResponse.FromOASExamples != nil && mockResponse.FromOASExamples.Enabled {
 		// Find the route using the OAS path from URLSpec, not the actual request path.
@@ -122,13 +142,12 @@ func (m *mockResponseMiddleware) mockResponse(r *http.Request) (*http.Response,
 		route, _, routeErr := m.Spec.findRouteForOASPath(urlSpec.OASPath, urlSpec.OASMethod, strippedPath, r.URL.Path)
 		if routeErr != nil || route == nil {
 			log.Tracef("URL spec matched for mock response but route not found for OAS path %s: %v", urlSpec.OASPath, routeErr)
-			return nil, nil
+			return nil, nil, nil
 		}
 		code, contentType, body, headers, err = mockFromOAS(r, route.Operation, mockResponse.FromOASExamples)
 		res.StatusCode = code
 		if err != nil {
-			err = fmt.Errorf("mock: %w", err)
-			return res, err
+			return res, internal, fmt.Errorf("mock: %w", err)
 		}
 	} else {
 		code, body, headers = mockFromConfig(mockResponse)
@@ -143,12 +162,15 @@ func (m *mockResponseMiddleware) mockResponse(r *http.Request) (*http.Response,
 	}
 
 	res.StatusCode = code
+	res.Body = nopCloser{ReadSeeker: bytes.NewReader(body)}
 
-	res.Body = io.NopCloser(bytes.NewBuffer(body))
+	if m.Gw.GetConfig().CloseConnections {
+		res.Header.Set(header.Connection, "close")
+	}
 
 	m.Spec.sendRateLimitHeaders(ctxGetSession(r), res)
 
-	return res, nil
+	return res, internal, nil
 }
 
 func mockFromConfig(tykMockRespOp *oas.MockResponse) (int, []byte, []oas.Header) {
@@ -268,3 +290,23 @@ func mockFromOAS(r *http.Request, operation *openapi3.Operation, fromOASExamples
 
 	return code, contentType, body, headers, err
 }
+
+type hitRecorder interface {
+	hit(rw http.ResponseWriter, r *http.Request, res *http.Response, start time.Time)
+}
+
+type realHitRecorder struct {
+	successHandler *SuccessHandler
+}
+
+func (s *realHitRecorder) hit(rw http.ResponseWriter, r *http.Request, res *http.Response, start time.Time) {
+	if s.successHandler.Spec.DoNotTrack {
+		return
+	}
+
+	ms := DurationToMillisecond(time.Since(start))
+	latency := analytics.Latency{Total: int64(ms), Upstream: 0, Gateway: int64(ms)}
+	s.successHandler.RecordHit(r, latency, res.StatusCode, res, true)
+	s.successHandler.RecordAccessLog(r, res, latency)
+	s.successHandler.Base().RecordMetrics(rw, r, res.StatusCode, latency, res)
+}

gateway/mw_mock_response_test.go

@@ -2,10 +2,14 @@ package gateway
 
 import (
 	"context"
+	"io"
 	"net/http"
+	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -142,6 +146,85 @@ func TestMockResponse(t *testing.T) {
 			_, _ = g.Run(t, test.TestCase{Path: "/listen-path/get", BodyMatch: "mock: there is no example response for the content type: application/xml"})
 		})
 	})
+
+	t.Run("ProcessRequest", func(t *testing.T) {
+		t.Run("calls hit recorder for oas API", func(t *testing.T) {
+			spec := BuildOASAPI(func(oasDef *oas.OAS) {
+				opId := uuid.New()
+
+				headers := oas.Headers{}
+				headers.Add("Content-Type", "application/json")
+
+				tykExt := oasDef.GetTykExtension()
+				tykExt.Info.ID = "test"
+				tykExt.Info.Name = "test"
+				tykExt.Server.ListenPath.Value = "/test"
+				tykExt.Middleware = &oas.Middleware{}
+				tykExt.Middleware.Operations = oas.Operations{}
+				tykExt.Middleware.Operations[opId] = &oas.Operation{
+					MockResponse: &oas.MockResponse{
+						Enabled: true,
+						Code:    http.StatusCreated,
+						Body:    `{"mocked":true}`,
+						Headers: headers,
+					},
+				}
+
+				desc := "hello world"
+				responses := openapi3.NewResponses()
+				responses.Delete("default")
+				responses.Set("200", &openapi3.ResponseRef{
+					Value: &openapi3.Response{
+						Description: &desc,
+						Content: openapi3.Content{
+							"application/json": &openapi3.MediaType{},
+						},
+					},
+				})
+
+				oasDef.Paths = openapi3.NewPaths()
+				oasDef.Paths.Set("/mock", &openapi3.PathItem{
+					Get: &openapi3.Operation{
+						OperationID: opId,
+						Responses:   responses,
+					},
+				})
+			})[0]
+
+			apiSpec := g.Gw.LoadAPI(spec)[0]
+
+			_, _ = g.Run(t, test.TestCase{
+				Path:   "/test/mock",
+				Method: http.MethodGet,
+				Code:   http.StatusCreated,
+			})
+
+			logger := logrus.New()
+			logger.SetOutput(io.Discard)
+			entry := logrus.NewEntry(logger)
+
+			mockRecorder := &mockHitRecorder{}
+
+			baseMid := NewBaseMiddleware(g.Gw, apiSpec, nil, entry)
+			mockMw := newMockResponseMiddleware(baseMid, withHitRecorder(mockRecorder))
+
+			rw := httptest.NewRecorder()
+			r := httptest.NewRequest(http.MethodGet, "/test/mock", nil)
+
+			err, _ := mockMw.ProcessRequest(rw, r, nil)
+			assert.NoError(t, err)
+			require.Len(t, mockRecorder.calls, 1, "expected to be called once")
+
+			req := mockRecorder.calls[0].req
+			res := mockRecorder.calls[0].res
+
+			// is needed downstack during writing the log
+			assert.Equal(t, "/mock", req.URL.Path, "req is overwritten to local api endpoint")
+
+			// is needed downstack; body is being read at least twice: during writing log and during proxying to the real response
+			assert.IsType(t, nopCloser{}, res.Body, "response body is wrapped by nopCloser")
+		})
+	})
 }
 
 func Test_mockFromConfig(t *testing.T) {
@@ -665,3 +748,23 @@ func TestMockResponseWithInternalRedirect(t *testing.T) {
 		})
 	})
 }
+
+var _ hitRecorder = new(mockHitRecorder)
+
+type (
+	mockHitRecorder struct {
+		calls []mockHitRecorderCall
+	}
+
+	mockHitRecorderCall struct {
+		req *http.Request
+		res *http.Response
+	}
+)
+
+func (h *mockHitRecorder) hit(_ http.ResponseWriter, req *http.Request, res *http.Response, _ time.Time) {
+	h.calls = append(h.calls, mockHitRecorderCall{
+		req: req,
+		res: res,
+	})
+}