Treat callback like response

pkg/match/request.go

@@ -64,9 +64,9 @@ func (mm Request) matchKeyAndValues(reqMap mock.Values, mockMap mock.Values) boo
 					return false
 				}
 			} else {
-			  log.Debugf("value %v doesn't appear in mock", key)
+				log.Debugf("value %v doesn't appear in mock", key)
 
-			  return false
+				return false
 			}
 		}
 	}

pkg/mock/definition.go

@@ -3,10 +3,13 @@ package mock
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/jmartin82/mmock/v3/internal/config/logger"
 	"reflect"
 	"time"
 )
 
+var log = logger.Log
+
 type Values map[string][]string
 
 type Cookies map[string]string
@@ -28,10 +31,35 @@ type Request struct {
 	Body string `json:"body"`
 }
 
+type ReplacementRequiredPayload interface {
+	GetHeaders() HttpHeaders
+	GetBody() string
+}
+
+type ReplacementRequired struct {
+}
+
+func (rr Response) GetHeaders() HttpHeaders {
+	return rr.HttpHeaders
+}
+
+func (rr Response) GetBody() string {
+	return rr.Body
+}
+
+func (rr Callback) GetHeaders() HttpHeaders {
+	return rr.HttpHeaders
+}
+
+func (rr Callback) GetBody() string {
+	return rr.Body
+}
+
 type Response struct {
 	StatusCode int `json:"statusCode"`
 	HttpHeaders
 	Body string `json:"body"`
+	*ReplacementRequired
 }
 
 type Callback struct {
@@ -41,6 +69,7 @@ type Callback struct {
 	HttpHeaders
 	Body    string `json:"body"`
 	Timeout Delay  `json:"timeout"`
+	*ReplacementRequired
 }
 
 type Scenario struct {

pkg/vars/evaluator.go

@@ -27,49 +27,58 @@ func (fp ResponseMessageEvaluator) Eval(req *mock.Request, m *mock.Definition) {
 	streamFiller := fp.FillerFactory.CreateStreamFiller()
 
 	//replace stream holders for their content
-	fp.walkAndFill(m, streamFiller.Fill(fp.walkAndGet(m.Response)))
+	m.Response.HttpHeaders, m.Response.Body = fp.walkAndFill(m.Response, streamFiller.Fill(fp.walkAndGet(m.Response)))
+	m.Callback.HttpHeaders, m.Callback.Body = fp.walkAndFill(m.Callback, streamFiller.Fill(fp.walkAndGet(m.Callback)))
 
 	//extract holders
 	holders := fp.walkAndGet(m.Response)
-	fp.extractVars(m.Callback.Body, &holders)
+	holders = append(holders, fp.walkAndGet(m.Callback)...)
 
 	//fill holders
 	vars := requestFiller.Fill(holders)
 	fp.mergeVars(vars, fakeFiller.Fill(holders))
-	fp.walkAndFill(m, vars)
-}
 
-func (fp ResponseMessageEvaluator) walkAndGet(res mock.Response) []string {
+	m.Response.HttpHeaders, m.Response.Body = fp.walkAndFill(m.Response, vars)
+	m.Callback.HttpHeaders, m.Callback.Body = fp.walkAndFill(m.Callback, vars)
+}
 
+func (fp ResponseMessageEvaluator) walkAndGet(res mock.ReplacementRequiredPayload) []string {
 	vars := []string{}
-	for _, header := range res.Headers {
+	for _, header := range res.GetHeaders().Headers {
 		for _, value := range header {
 			fp.extractVars(value, &vars)
 		}
 
 	}
-	for _, value := range res.Cookies {
+
+	for _, value := range res.GetHeaders().Cookies {
 		fp.extractVars(value, &vars)
 	}
 
-	fp.extractVars(res.Body, &vars)
+	fp.extractVars(res.GetBody(), &vars)
+
 	return vars
 }
 
-func (fp ResponseMessageEvaluator) walkAndFill(m *mock.Definition, vars map[string][]string) {
-	res := &m.Response
-	for header, values := range res.Headers {
+func (fp ResponseMessageEvaluator) walkAndFill(res mock.ReplacementRequiredPayload, vars map[string][]string) (mock.HttpHeaders, string) {
+	headers := res.GetHeaders().Headers
+	cookies := res.GetHeaders().Cookies
+	body := res.GetBody()
+
+	for header, values := range headers {
 		for i, value := range values {
-			res.Headers[header][i] = fp.replaceVars(value, vars)
+			headers[header][i] = fp.replaceVars(value, vars)
 		}
 
 	}
-	for cookie, value := range res.Cookies {
-		res.Cookies[cookie] = fp.replaceVars(value, vars)
+
+	for cookie, value := range cookies {
+		cookies[cookie] = fp.replaceVars(value, vars)
 	}
 
-	res.Body = fp.replaceVars(res.Body, vars)
-	m.Callback.Body = fp.replaceVars(m.Callback.Body, vars)
+	newBody := fp.replaceVars(body, vars)
+
+	return mock.HttpHeaders{Headers: headers, Cookies: cookies}, newBody
 }
 
 func (fp ResponseMessageEvaluator) replaceVars(input string, vars map[string][]string) string {

pkg/vars/evaluator_test.go

@@ -184,10 +184,10 @@ func (ddf DummyDataFaker) Hex(n int) string {
 	return strings.Repeat("0", n)
 }
 
-func getProcessor() ResponseMessageEvaluator {
+func getProcessor() *ResponseMessageEvaluator {
 	dfp := NewDummyDataFaker("AleixMG")
 	ff := NewFillerFactory(dfp)
-	return ResponseMessageEvaluator{FillerFactory: ff}
+	return &ResponseMessageEvaluator{FillerFactory: ff}
 }
 
 func TestReplaceTags(t *testing.T) {
@@ -203,34 +203,60 @@ func TestReplaceTags(t *testing.T) {
 	req.Cookies = cookie
 
 	res := mock.Response{}
+	cb := mock.Callback{}
+
 	res.Body = "Request Body {{request.body}}. Query {{request.query.param1}}. Cookie: {{request.cookie.cookie1}}. Random: {{fake.UserName}}"
+	cb.Body = "Callback Body {{request.body}}. Query {{request.query.param1}}. Cookie: {{request.cookie.cookie1}}. Random: {{fake.UserName}}"
+
+	cookie = make(mock.Cookies)
+	cookie["cookie1"] = "valCookie"
+	cookie["cookie2"] = "{{fake.UserName}}"
+
+	val = make(mock.Values)
+	val["header1"] = []string{"valHeader"}
+	val["header2"] = []string{"valHeader", "{{request.query.param1}}"}
+
+	res.HttpHeaders = mock.HttpHeaders{Headers: val, Cookies: cookie}
 
 	cookie = make(mock.Cookies)
 	cookie["cookie1"] = "valCookie"
 	cookie["cookie2"] = "{{fake.UserName}}"
-	res.Cookies = cookie
 
 	val = make(mock.Values)
 	val["header1"] = []string{"valHeader"}
 	val["header2"] = []string{"valHeader", "{{request.query.param1}}"}
 
-	res.Headers = val
+	cb.HttpHeaders = mock.HttpHeaders{Headers: val, Cookies: cookie}
+
+	mock := mock.Definition{Request: req, Response: res, Callback: cb}
 
-	mock := mock.Definition{Request: req, Response: res}
 	varsProcessor := getProcessor()
 	varsProcessor.Eval(&req, &mock)
 
 	if mock.Response.Body != "Request Body hi!. Query valParam. Cookie: valCookie. Random: AleixMG" {
 		t.Error("Replaced tags in body not match", res.Body)
 	}
 
-	if mock.Response.Cookies["cookie2"] != "AleixMG" {
-		t.Error("Replaced tags in cookie match", mock.Response.Cookies["cookie2"])
+	if mock.Response.HttpHeaders.Cookies["cookie2"] != "AleixMG" {
+		t.Error("Replaced tags in cookie match", mock.Response.HttpHeaders.Cookies["cookie2"])
 	}
 
-	if mock.Response.Headers["header2"][1] != "valParam" {
-		t.Error("Replaced tags in headers match", mock.Response.Headers["header2"][1])
+	if mock.Response.HttpHeaders.Headers["header2"][1] != "valParam" {
+		t.Error("Replaced tags in headers match", mock.Response.HttpHeaders.Headers["header2"][1])
 	}
+
+	if mock.Callback.Body != "Callback Body hi!. Query valParam. Cookie: valCookie. Random: AleixMG" {
+		t.Error("Replaced tags in body not match", cb.Body)
+	}
+
+	if mock.Callback.HttpHeaders.Cookies["cookie2"] != "AleixMG" {
+		t.Error("Replaced tags in Callback cookie match", mock.Callback.HttpHeaders.Cookies["cookie2"])
+	}
+
+	if mock.Callback.HttpHeaders.Headers["header2"][1] != "valParam" {
+		t.Error("Replaced tags in Callback headers match", mock.Callback.HttpHeaders.Headers["header2"][1])
+	}
+
 }
 
 func TestReplaceUndefinedFakeTag(t *testing.T) {