feat(tests): normalize dynamic result hashes in VCR cassettes

Add stateful hash normalization to vcrpy_utils so that server-computed
executionResult (40-hex:64-hex) and exportResult (40-hex) hashes are
replaced with deterministic placeholders (EXECUTION_RESULT_N,
EXPORT_RESULT_N) during cassette recording. This eliminates noisy diffs
when re-recording cassettes from different environments.

Normalization is applied to request URIs, request bodies, and response
bodies via the existing before_record_* callbacks.

risk: low

Author: tychtjan

packages/gooddata-fdw/tests/conftest.py

@@ -5,6 +5,7 @@
 import pytest
 import yaml
 from gooddata_fdw.environment import ColumnDefinition
+from tests_support.vcrpy_utils import configure_normalization
 
 
 def pytest_addoption(parser):
@@ -23,6 +24,7 @@ def test_config(request):
     with open(config_path) as f:
         config = yaml.safe_load(f)
 
+    configure_normalization(config)
     return config
 
 

packages/gooddata-pandas/tests/conftest.py

@@ -3,6 +3,7 @@
 
 import pytest
 import yaml
+from tests_support.vcrpy_utils import configure_normalization
 
 
 def pytest_addoption(parser):
@@ -21,4 +22,5 @@ def test_config(request):
     with open(config_path) as f:
         config = yaml.safe_load(f)
 
+    configure_normalization(config)
     return config

packages/tests-support/src/tests_support/vcrpy_utils.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import os
+import re
 import typing
 from typing import Any
 from urllib.parse import urlparse
@@ -42,6 +43,50 @@
 _normalization_replacements: list[tuple[str, str]] = []
 _normalization_configured: bool = False
 
+# --- Dynamic hash normalization ---
+# executionResult: 40-hex ":" 64-hex (body uses ":", URI uses "%3A")
+_EXEC_HASH_BODY_RE = re.compile(r"[0-9a-f]{40}:[0-9a-f]{64}")
+_EXEC_HASH_URI_RE = re.compile(r"[0-9a-f]{40}%3[Aa][0-9a-f]{64}")
+
+# exportResult: 40-hex, anchored to /export/tabular/ in URIs
+# or preceded by "exportResult" context in bodies
+_EXPORT_HASH_URI_RE = re.compile(r"(?<=/export/tabular/)[0-9a-f]{40}(?![0-9a-f])")
+_EXPORT_HASH_BODY_RE = re.compile(
+    r'(?<=exportResult": ")[0-9a-f]{40}(?![0-9a-f])'  # JSON: "exportResult": "hash"
+    r"|"
+    r"(?<=exportResult: )[0-9a-f]{40}(?![0-9a-f])"  # YAML: exportResult: hash
+)
+
+
+class _HashNormalizer:
+    """Maps server-computed hex hashes to deterministic placeholders.
+
+    Assigns stable placeholders (EXECUTION_RESULT_0, EXPORT_RESULT_0, etc.)
+    to dynamic hashes that differ between environments and re-recordings.
+    The same hash always maps to the same placeholder within a session.
+    """
+
+    def __init__(self) -> None:
+        self._exec_map: dict[str, str] = {}
+        self._export_map: dict[str, str] = {}
+        self._exec_counter: int = 0
+        self._export_counter: int = 0
+
+    def normalize_exec(self, full_hash: str) -> str:
+        if full_hash not in self._exec_map:
+            self._exec_map[full_hash] = f"EXECUTION_RESULT_{self._exec_counter}"
+            self._exec_counter += 1
+        return self._exec_map[full_hash]
+
+    def normalize_export(self, hex_hash: str) -> str:
+        if hex_hash not in self._export_map:
+            self._export_map[hex_hash] = f"EXPORT_RESULT_{self._export_counter}"
+            self._export_counter += 1
+        return self._export_map[hex_hash]
+
+
+_hash_normalizer = _HashNormalizer()
+
 
 def configure_normalization(test_config: dict[str, Any]) -> None:
     """Build normalization replacements from the active test environment config.
@@ -117,6 +162,26 @@ def _apply_replacements(text: str) -> str:
     return text
 
 
+def _normalize_hashes_in_text(text: str) -> str:
+    """Replace executionResult/exportResult hashes with deterministic placeholders."""
+    text = _EXEC_HASH_BODY_RE.sub(lambda m: _hash_normalizer.normalize_exec(m.group(0)), text)
+    text = _EXPORT_HASH_BODY_RE.sub(lambda m: _hash_normalizer.normalize_export(m.group(0)), text)
+    return text
+
+
+def _normalize_hashes_in_uri(uri: str) -> str:
+    """Replace executionResult/exportResult hashes in a request URI."""
+
+    def _replace_exec_uri(m: re.Match) -> str:
+        # Convert URL-encoded %3A to plain colon for consistent mapping
+        plain = m.group(0).replace("%3A", ":").replace("%3a", ":")
+        return _hash_normalizer.normalize_exec(plain)
+
+    uri = _EXEC_HASH_URI_RE.sub(_replace_exec_uri, uri)
+    uri = _EXPORT_HASH_URI_RE.sub(lambda m: _hash_normalizer.normalize_export(m.group(0)), uri)
+    return uri
+
+
 def _normalize_body(body: str | None) -> str:
     """Strip environment-specific fields from a JSON request body for matching."""
     if not body:
@@ -217,10 +282,9 @@ def serialize(self, cassette_dict: dict[str, Any]) -> str:
 
 
 def _normalize_uri(uri: str) -> str:
-    """Rewrite a request URI to use the canonical host."""
-    if not _normalization_replacements:
-        return uri
-    return _apply_replacements(uri)
+    """Rewrite a request URI to use the canonical host and normalize dynamic hashes."""
+    uri = _apply_replacements(uri) if _normalization_replacements else uri
+    return _normalize_hashes_in_uri(uri)
 
 
 def custom_before_request(request, headers_str: str = HEADERS_STR):
@@ -233,12 +297,18 @@ def custom_before_request(request, headers_str: str = HEADERS_STR):
     # Normalize URI to canonical host
     request.uri = _normalize_uri(request.uri)
 
-    # Normalize environment-specific values in request body
-    if _normalization_replacements and request.body:
+    # Normalize environment-specific values and dynamic hashes in request body
+    if request.body:
         if isinstance(request.body, bytes):
-            request.body = _apply_replacements(request.body.decode("utf-8", errors="replace")).encode("utf-8")
+            decoded = request.body.decode("utf-8", errors="replace")
+            if _normalization_replacements:
+                decoded = _apply_replacements(decoded)
+            decoded = _normalize_hashes_in_text(decoded)
+            request.body = decoded.encode("utf-8")
         elif isinstance(request.body, str):
-            request.body = _apply_replacements(request.body)
+            if _normalization_replacements:
+                request.body = _apply_replacements(request.body)
+            request.body = _normalize_hashes_in_text(request.body)
 
     if hasattr(request, headers_str):
         request.headers = {header: request.headers[header] for header in sorted(request.headers)}
@@ -277,16 +347,21 @@ def custom_before_response(
             unified_headers[header] = value
         response[headers_str] = unified_headers
 
-    # Normalize environment-specific values in response body
-    if _normalization_replacements:
-        body = response.get("body")
-        if body is not None:
-            body_string = body.get("string")
-            if body_string:
-                if isinstance(body_string, bytes):
-                    body["string"] = _apply_replacements(body_string.decode("utf-8", errors="replace")).encode("utf-8")
-                elif isinstance(body_string, str):
-                    body["string"] = _apply_replacements(body_string)
+    # Normalize response body: environment-specific values and dynamic hashes
+    body = response.get("body")
+    if body is not None:
+        body_string = body.get("string")
+        if body_string:
+            if isinstance(body_string, bytes):
+                decoded = body_string.decode("utf-8", errors="replace")
+                if _normalization_replacements:
+                    decoded = _apply_replacements(decoded)
+                decoded = _normalize_hashes_in_text(decoded)
+                body["string"] = decoded.encode("utf-8")
+            elif isinstance(body_string, str):
+                if _normalization_replacements:
+                    body_string = _apply_replacements(body_string)
+                body["string"] = _normalize_hashes_in_text(body_string)
 
     return response