Method ExactBodyMatch

pkg/agent/proxy/integrations/http/match.go:610–713

ExactBodyMatch performs exact body matching with noise awareness. First pass: fast string equality. Second pass: noise-aware comparison that skips obfuscated fields identified by Mock.Noise patterns. Three body shapes are handled in the second pass: 1. A mock body that is itself entirely a noise val

(body []byte, schemaMatched []*models.Mock)

//     produce byte-identical request bodies at replay.
//  3. JSON — field-by-field comparison via JSONBodyMatchScore.
func (h *HTTP) ExactBodyMatch(body []byte, schemaMatched []*models.Mock) (bool, *models.Mock) {
	// Log all mock names in a single line for better readability
	mockNames := make([]string, len(schemaMatched))
	for i, mock := range schemaMatched {
		mockNames[i] = mock.Name
	}
	h.Logger.Debug("mocks under consideration for exact body match", zap.Strings("mock names", mockNames), zap.String("req body", string(body)))

	// First pass: exact string match (fastest path)
	for _, mock := range schemaMatched {
		if mock.Spec.HTTPReq.Body == string(body) {
			h.Logger.Debug("http mock matched",
				zap.String("mock", mock.Name),
				zap.Float64("match_percentage", 100.0),
				zap.String("match_type", "exact_body"))
			return true, mock
		}
	}

	// Second pass: noise-aware match for mocks with obfuscated values.
	// Pre-compute request-side properties once so we don't re-derive them per
	// candidate mock: JSON unmarshaling for the JSON-noise path, and the
	// form-encoded heuristic (which itself runs url.ParseQuery) for the
	// form-body path.
	reqBodyStr := string(body)
	isReqJSON := pkg.IsJSON(body)
	var reqData interface{}
	if isReqJSON {
		if err := json.Unmarshal(body, &reqData); err != nil {
			isReqJSON = false
		}
	}
	reqIsForm := !isReqJSON && looksLikeFormEncoded(reqBodyStr)

	for _, mock := range schemaMatched {
		nc := util.NewNoiseChecker(mock.Noise)
		if nc == nil {
			continue // no noise patterns → already checked in first pass
		}

		mockBody := mock.Spec.HTTPReq.Body

		// If the entire body is a single noisy value, auto-match
		// (schema match already filtered by URL, method, headers)
		if nc.IsNoisy(mockBody) {
			h.Logger.Debug("http mock matched",
				zap.String("mock", mock.Name),
				zap.Float64("match_percentage", 100.0),
				zap.Int("noisy_fields_skipped", 1),
				zap.String("match_type", "exact_body_fully_noisy"))
			return true, mock
		}

		// Form-encoded noise-aware comparison. Each "key=value" segment is
		// tested against the mock's noise patterns; a match wildcards that
		// segment. The remaining keys must be the same set on both sides
		// and each non-wildcarded value(s) must be byte-equal.
		if reqIsForm && looksLikeFormEncoded(mockBody) {