record req/resps in fake data provider

Author: skudasov

framework/components/fake/fake.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/smartcontractkit/chainlink-testing-framework/framework"
-	"net/http"
 	"os"
 )
 
@@ -22,7 +21,7 @@ type Output struct {
 	BaseURLDocker string `toml:"base_url_docker"`
 }
 
-func FakeJSON(path string, response gin.H, statusCode int) error {
+func JSON(path string, response map[string]any, statusCode int) error {
 	if Service == nil {
 		return fmt.Errorf("mock service is not initialized, please set up NewFakeDataProvider in your tests")
 	}
@@ -32,23 +31,13 @@ func FakeJSON(path string, response gin.H, statusCode int) error {
 	return nil
 }
 
-func runMocks(in *Input) {
-	router := gin.Default()
-	router.GET("/mock1", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "This is a GET request response from the mock service.",
-		})
-	})
-	router.POST("/mock2", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "This is a POST request response from the mock service.",
-		})
-	})
-	_ = router.Run(fmt.Sprintf(":%d", in.Port))
-}
-
+// NewFakeDataProvider creates new fake data provider
 func NewFakeDataProvider(in *Input) (*Output, error) {
-	go runMocks(in)
+	Service = gin.Default()
+	Service.Use(recordMiddleware())
+	go func() {
+		_ = Service.Run(fmt.Sprintf(":%d", in.Port))
+	}()
 	out := &Output{
 		BaseURLHost: fmt.Sprintf("http://localhost:%d", in.Port),
 	}

framework/components/fake/record.go

@@ -0,0 +1,86 @@
+package fake
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io/ioutil"
+	"net/http"
+)
+
+var (
+	R = NewRecords()
+)
+
+// Record is a request and response data
+type Record struct {
+	Method  string      `json:"method"`
+	Path    string      `json:"path"`
+	Headers http.Header `json:"headers"`
+	ReqBody string      `json:"req_body"`
+	ResBody string      `json:"res_body"`
+	Status  int         `json:"status"`
+}
+
+type Records struct {
+	r map[string]*Record
+}
+
+func NewRecords() *Records {
+	return &Records{make(map[string]*Record)}
+}
+
+func (r *Records) Get(path string) (*Record, error) {
+	rec, ok := r.r[path]
+	if !ok {
+		return nil, fmt.Errorf("no record was found for path: %s", path)
+	}
+	return rec, nil
+}
+
+// CustomResponseWriter wraps gin.ResponseWriter to capture response data
+type CustomResponseWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+// Write captures response data
+func (w *CustomResponseWriter) Write(data []byte) (int, error) {
+	w.body.Write(data) // Capture response data
+	return w.ResponseWriter.Write(data)
+}
+
+// Middleware to record both requests and responses
+func recordMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Capture request data
+		var reqBodyBytes []byte
+		if c.Request.Body != nil {
+			reqBodyBytes, _ = ioutil.ReadAll(c.Request.Body)
+			c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(reqBodyBytes))
+		}
+		reqBody := string(reqBodyBytes)
+
+		// Create custom response writer
+		customWriter := &CustomResponseWriter{
+			ResponseWriter: c.Writer,
+			body:           bytes.NewBufferString(""),
+		}
+		c.Writer = customWriter
+
+		// Process request
+		c.Next()
+
+		// Capture response data
+		resBody := customWriter.body.String()
+		status := c.Writer.Status()
+		R.r[c.Request.URL.Path] = &Record{
+			Method:  c.Request.Method,
+			Path:    c.Request.URL.Path,
+			Headers: c.Request.Header,
+			ReqBody: reqBody,
+			ResBody: resBody,
+			Status:  status,
+		}
+	}
+}

framework/components/fake/record_test.go

@@ -0,0 +1,67 @@
+package fake_test
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/fake"
+	"github.com/stretchr/testify/require"
+	"net/http"
+	"testing"
+)
+
+func TestRecord(t *testing.T) {
+	cfg := &fake.Input{
+		Port: 9111,
+	}
+	out, err := fake.NewFakeDataProvider(cfg)
+	require.NoError(t, err)
+	r := resty.New().SetBaseURL(out.BaseURLHost)
+
+	t.Run("can mock a response with JSON", func(t *testing.T) {
+		apiPath := "/fake/api/1"
+		err = fake.JSON(apiPath, map[string]any{
+			"status": "ok",
+		}, 200)
+		require.NoError(t, err)
+		var respBody struct {
+			Status string `json:"status"`
+		}
+		resp, err := r.R().SetResult(&respBody).Get(apiPath)
+		require.NoError(t, err)
+		require.Equal(t, 200, resp.StatusCode())
+		require.Equal(t, "ok", respBody.Status)
+	})
+
+	t.Run("can record request/response and access it", func(t *testing.T) {
+		apiPath := "/fake/api/2"
+		err = fake.JSON(apiPath, map[string]any{
+			"status": "ok",
+		}, 200)
+		require.NoError(t, err)
+		reqBody := struct {
+			SomeData string `json:"some_data"`
+		}{
+			SomeData: "some_data",
+		}
+		var respBody struct {
+			Status string `json:"status"`
+		}
+		_, err := r.R().SetBody(reqBody).SetResult(&respBody).Post(apiPath)
+		require.NoError(t, err)
+
+		// get request and response
+		recordedData, err := fake.R.Get(apiPath)
+		require.Equal(t, &fake.Record{
+			Method: "POST",
+			Path:   apiPath,
+			Headers: http.Header{
+				"Accept-Encoding": []string{"gzip"},
+				"Content-Type":    []string{"application/json"},
+				"Content-Length":  []string{"25"},
+				"User-Agent":      []string{"go-resty/2.15.3 (https://github.com/go-resty/resty)"},
+			},
+			ReqBody: `{"some_data":"some_data"}`,
+			ResBody: `{"status":"ok"}`,
+			Status:  200,
+		}, recordedData)
+	})
+}