localstack-snapshot 0.2.0__tar.gz → 0.3.1__tar.gz

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.2.0
+Version: 0.3.1
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 
@@ -222,6 +222,7 @@ Requires-Dist: black==23.10.0; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: coverage[toml]>=5.0.0; extra == "dev"
 Requires-Dist: ruff==0.1.0; extra == "dev"
+Dynamic: license-file
 
 Snapshot testing for pytest
 ===============================
@@ -233,10 +234,19 @@ This project is in a very early stage and will be both restructured and renamed.
 
 ## Quickstart
 
-to install the python and other developer requirements into a venv run:
+To install the python and other developer requirements into a venv run:
 
     make install
 
+### Configuration options
+
+There's a few env vars that can be used with this project:
+
+* `TEST_TARGET`: Set to `AWS_CLOUD` to use an externally-deployed instance when running tests.
+* `SNAPSHOT_LEGACY_REPORT`: By default set to `0`. Can be set to `1`. This enables the legacy reporting output style.
+* `SNAPSHOT_UDPATE`: By default set to `0`. Can be set to `1`. This enables updating the snapshot file rather than comparing with its contents.
+* `SNAPSHOT_RAW`: By default set to `0`. Can be set to `1`. This outputs an additional snapshot file which contains the untransformed values.
+
 ## Format code
 
 We use black and isort as code style tools.

localstack_snapshot-0.3.1/README.md

@@ -0,0 +1,35 @@
+Snapshot testing for pytest
+===============================
+
+Extracted snapshot testing lib for LocalStack.
+
+This project is in a very early stage and will be both restructured and renamed.
+
+
+## Quickstart
+
+To install the python and other developer requirements into a venv run:
+
+    make install
+
+### Configuration options
+
+There's a few env vars that can be used with this project:
+
+* `TEST_TARGET`: Set to `AWS_CLOUD` to use an externally-deployed instance when running tests.
+* `SNAPSHOT_LEGACY_REPORT`: By default set to `0`. Can be set to `1`. This enables the legacy reporting output style.
+* `SNAPSHOT_UDPATE`: By default set to `0`. Can be set to `1`. This enables updating the snapshot file rather than comparing with its contents.
+* `SNAPSHOT_RAW`: By default set to `0`. Can be set to `1`. This outputs an additional snapshot file which contains the untransformed values.
+
+## Format code
+
+We use black and isort as code style tools.
+To execute them, run:
+
+    make format
+
+## Build distribution
+
+To build a wheel and source distribution, simply run
+
+    make dist

localstack_snapshot-0.3.1/localstack_snapshot/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/localstack_snapshot/snapshots/prototype.py

@@ -25,6 +25,8 @@ from .transformer_utility import TransformerUtility
 SNAPSHOT_LOGGER = logging.getLogger(__name__)
 SNAPSHOT_LOGGER.setLevel(logging.DEBUG if os.environ.get("DEBUG_SNAPSHOT") else logging.WARNING)
 
+_SKIP_PLACEHOLDER_VALUE = "$__to_be_skipped__$"
+
 
 class SnapshotMatchResult:
     def __init__(self, a: dict, b: dict, key: str = ""):
@@ -218,7 +220,7 @@ class SnapshotSession:
         self.skip_verification_paths = skip_verification_paths or []
         if skip_verification_paths:
             SNAPSHOT_LOGGER.warning(
-                f"Snapshot verification disabled for paths: {skip_verification_paths}"
+                "Snapshot verification disabled for paths: %s", skip_verification_paths
             )
 
         if self.update:
@@ -272,6 +274,8 @@ class SnapshotSession:
                 self._transform_dict_to_parseable_values(v)
 
             if isinstance(v, str) and v.startswith("{"):
+                # Doesn't handle JSON arrays and nested JSON strings. See JsonStringTransformer.
+                # TODO for the major release consider having JSON parsing in one place only: either here or in JsonStringTransformer
                 try:
                     json_value = json.loads(v)
                     original[k] = json_value
@@ -304,7 +308,7 @@ class SnapshotSession:
             try:
                 replaced_tmp[key] = json.loads(dumped_value)
             except JSONDecodeError:
-                SNAPSHOT_LOGGER.error(f"could not decode json-string:\n{tmp}")
+                SNAPSHOT_LOGGER.error("could not decode json-string:\n%s", tmp)
                 return {}
 
         return replaced_tmp
@@ -363,6 +367,23 @@ class SnapshotSession:
 
             return full_path_nodes[::-1][1:]  # reverse the list and remove Root()/$
 
+        def _remove_placeholder(_tmp):
+            """Traverse the object and remove any values in a list that would be equal to the placeholder"""
+            if isinstance(_tmp, dict):
+                for k, v in _tmp.items():
+                    if isinstance(v, dict):
+                        _remove_placeholder(v)
+                    elif isinstance(v, list):
+                        _tmp[k] = _remove_placeholder(v)
+            elif isinstance(_tmp, list):
+                return [
+                    _remove_placeholder(item) for item in _tmp if item != _SKIP_PLACEHOLDER_VALUE
+                ]
+
+            return _tmp
+
+        has_placeholder = False
+
         for path in self.skip_verification_paths:
             matches = parse(path).find(tmp) or []
             for m in matches:
@@ -376,7 +397,24 @@ class SnapshotSession:
                             helper = helper.get(p, None)
                             if not helper:
                                 continue
+
                 if (
                     isinstance(helper, dict) and full_path[-1] in helper.keys()
                 ):  # might have been deleted already
                     del helper[full_path[-1]]
+                elif isinstance(helper, list):
+                    try:
+                        index = int(full_path[-1].lstrip("[").rstrip("]"))
+                        # we need to set a placeholder value as the skips are based on index
+                        # if we are to pop the values, the next skip index will have shifted and won't be correct
+                        helper[index] = _SKIP_PLACEHOLDER_VALUE
+                        has_placeholder = True
+                    except ValueError:
+                        SNAPSHOT_LOGGER.warning(
+                            "Snapshot skip path '%s' was not applied as it was invalid for that snapshot",
+                            path,
+                            exc_info=SNAPSHOT_LOGGER.isEnabledFor(logging.DEBUG),
+                        )
+
+        if has_placeholder:
+            _remove_placeholder(tmp)

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/localstack_snapshot/snapshots/report.py

@@ -1,4 +1,5 @@
 import logging
+import re
 
 from localstack_snapshot.snapshots import SnapshotMatchResult
 
@@ -29,6 +30,8 @@ _esctable = {
     "underlined": 4,
 }
 
+_regular_json_path_chars_regex = re.compile("[a-zA-Z0-9_-]+")
+
 
 class PatchPath(str):
     """
@@ -52,7 +55,11 @@ def _format_json_path(path: list):
     json_str = "$.."
     for idx, elem in enumerate(path):
         if not isinstance(elem, int):
-            json_str += str(elem)
+            _elem = str(elem)
+            # we want to wrap in single quotes parts with special characters so that users can copy-paste them directly
+            if not _regular_json_path_chars_regex.fullmatch(_elem):
+                _elem = f"'{_elem}'"
+            json_str += _elem
         if idx < len(path) - 1 and not json_str.endswith(".."):
             json_str += "."
 

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/localstack_snapshot/snapshots/transformer.py

@@ -1,8 +1,10 @@
 import copy
+import json
 import logging
 import os
 import re
 from datetime import datetime
+from json import JSONDecodeError
 from re import Pattern
 from typing import Any, Callable, Optional, Protocol
 
@@ -100,8 +102,14 @@ class ResponseMetaDataTransformer:
             if k == "ResponseMetadata":
                 metadata = v
                 http_headers = metadata.get("HTTPHeaders")
+                if not isinstance(http_headers, dict):
+                    continue
+
                 # TODO "x-amz-bucket-region"
                 # TestS3.test_region_header_exists -> verifies bucket-region
+
+                # FIXME: proper value is `content-type` with no underscore in lowercase, but this will necessitate a
+                #  refresh of all snapshots
                 headers_to_collect = ["content_type"]
                 simplified_headers = {}
                 for h in headers_to_collect:
@@ -184,35 +192,36 @@ class RegexTransformer:
         return input_data
 
 
-class KeyValueBasedTransformer:
+class KeyValueBasedTransformerFunctionReplacement:
     def __init__(
         self,
         match_fn: Callable[[str, Any], Optional[str]],
-        replacement: str,
+        replacement_function: [Callable[[str, Any], str]],
         replace_reference: bool = True,
     ):
         self.match_fn = match_fn
-        self.replacement = replacement
+        self.replacement_function = replacement_function
         self.replace_reference = replace_reference
 
     def transform(self, input_data: dict, *, ctx: TransformContext) -> dict:
         for k, v in input_data.items():
             if (match_result := self.match_fn(k, v)) is not None:
+                replacement = self.replacement_function(k, v)
                 if self.replace_reference:
                     _register_serialized_reference_replacement(
-                        ctx, reference_value=match_result, replacement=self.replacement
+                        ctx, reference_value=match_result, replacement=replacement
                     )
                 else:
                     if isinstance(v, str):
                         SNAPSHOT_LOGGER.debug(
-                            f"Replacing value for key '{k}': Match result '{match_result:.200s}' with '{self.replacement}'. (Original value: {str(v)})"
+                            f"Replacing value for key '{k}': Match result '{match_result:.200s}' with '{replacement}'. (Original value: {str(v)})"
                         )
-                        input_data[k] = v.replace(match_result, self.replacement)
+                        input_data[k] = v.replace(match_result, replacement)
                     else:
                         SNAPSHOT_LOGGER.debug(
-                            f"Replacing value for key '{k}' with '{self.replacement}'. (Original value: {str(v)})"
+                            f"Replacing value for key '{k}' with '{replacement}'. (Original value: {str(v)})"
                         )
-                        input_data[k] = self.replacement
+                        input_data[k] = replacement
             elif isinstance(v, list) and len(v) > 0:
                 for i in range(0, len(v)):
                     if isinstance(v[i], dict):
@@ -223,6 +232,20 @@ class KeyValueBasedTransformer:
         return input_data
 
 
+class KeyValueBasedTransformer(KeyValueBasedTransformerFunctionReplacement):
+    def __init__(
+        self,
+        match_fn: Callable[[str, Any], Optional[str]],
+        replacement: str,
+        replace_reference: bool = True,
+    ):
+        super().__init__(
+            match_fn=match_fn,
+            replacement_function=lambda k, v: replacement,
+            replace_reference=replace_reference,
+        )
+
+
 class GenericTransformer:
     def __init__(self, fn: Callable[[dict, TransformContext], dict]):
         self.fn = fn
@@ -360,3 +383,78 @@ class TextTransformer:
             f"Registering text pattern '{self.text}' in snapshot with '{self.replacement}'"
         )
         return input_data
+
+
+class JsonStringTransformer:
+    """
+    Parses JSON string at the specified key.
+    Additionally, attempts to parse any JSON strings inside the parsed JSON
+
+    This transformer complements the default parsing of JSON strings in
+    localstack_snapshot.snapshots.prototype.SnapshotSession._transform_dict_to_parseable_values
+
+    Shortcomings of the default parser that this transformer addresses:
+    - parsing of nested JSON strings '{"a": "{\\"b\\":42}"}'
+    - parsing of JSON arrays at the specified key, e.g. '["a", "b"]'
+
+    Such parsing allows applying transformations further to the elements of the parsed JSON - timestamps, ARNs, etc.
+
+    Such parsing is not done by default because it's not a common use case.
+    Whether to parse a JSON string or not should be decided by the user on a case by case basis.
+    Limited general parsing that we already have is preserved for backwards compatibility.
+    """
+
+    key: str
+
+    def __init__(self, key: str):
+        self.key = key
+
+    def transform(self, input_data: dict, *, ctx: TransformContext = None) -> dict:
+        return self._transform_dict(input_data, ctx=ctx)
+
+    def _transform(self, input_data: Any, ctx: TransformContext = None) -> Any:
+        if isinstance(input_data, dict):
+            return self._transform_dict(input_data, ctx=ctx)
+        elif isinstance(input_data, list):
+            return self._transform_list(input_data, ctx=ctx)
+        return input_data
+
+    def _transform_dict(self, input_data: dict, ctx: TransformContext = None) -> dict:
+        for k, v in input_data.items():
+            if k == self.key and isinstance(v, str) and v.strip().startswith(("{", "[")):
+                try:
+                    SNAPSHOT_LOGGER.debug(f"Replacing string value of {k} with parsed JSON")
+                    json_value = json.loads(v)
+                    input_data[k] = self._transform_nested(json_value)
+                except JSONDecodeError:
+                    SNAPSHOT_LOGGER.exception(
+                        f'Value mapped to "{k}" key is not a valid JSON string and won\'t be transformed. Value: {v}'
+                    )
+            else:
+                input_data[k] = self._transform(v, ctx=ctx)
+        return input_data
+
+    def _transform_list(self, input_data: list, ctx: TransformContext = None) -> list:
+        return [self._transform(item, ctx=ctx) for item in input_data]
+
+    def _transform_nested(self, input_data: Any) -> Any:
+        """
+        Separate method from the main `_transform_dict` one because
+        it checks every string while the main one attempts to load at specified key only.
+        This one is implicit, best-effort attempt,
+        while the main one is explicit about at which key transform should happen
+        """
+        if isinstance(input_data, list):
+            input_data = [self._transform_nested(item) for item in input_data]
+        if isinstance(input_data, dict):
+            for k, v in input_data.items():
+                input_data[k] = self._transform_nested(v)
+        if isinstance(input_data, str) and input_data.strip().startswith(("{", "[")):
+            try:
+                json_value = json.loads(input_data)
+                input_data = self._transform_nested(json_value)
+            except JSONDecodeError:
+                SNAPSHOT_LOGGER.debug(
+                    f"The value is not a valid JSON string and won't be transformed. The value: {input_data}"
+                )
+        return input_data

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/localstack_snapshot/snapshots/transformer_utility.py

@@ -1,10 +1,13 @@
 from re import Pattern
-from typing import Optional
+from typing import Any, Callable, Optional
 
 from localstack_snapshot.snapshots.transformer import (
     JsonpathTransformer,
+    JsonStringTransformer,
     KeyValueBasedTransformer,
+    KeyValueBasedTransformerFunctionReplacement,
     RegexTransformer,
+    SortingTransformer,
     TextTransformer,
 )
 
@@ -38,6 +41,33 @@ class TransformerUtility:
             replace_reference=reference_replacement,
         )
 
+    @staticmethod
+    def key_value_replacement_function(
+        key: str,
+        replacement_function: Callable[[str, Any], str] = None,
+        reference_replacement: bool = True,
+    ):
+        """Creates a new KeyValueBasedTransformer. If the key matches, the value will be replaced.
+
+        :param key: the name of the key which should be replaced
+        :param replacement_function: The function calculating the replacement. Will be passed the key and value of the replaced pair.
+        By default it is the key-name in lowercase, separated with hyphen
+        :param reference_replacement: if False, only the original value for this key will be replaced.
+        If True all references of this value will be replaced (using a regex pattern), for the entire test case.
+        In this case, the replaced value will be nummerated as well.
+        Default: True
+
+        :return: KeyValueBasedTransformer
+        """
+        replacement_function = replacement_function or (
+            lambda x, y: _replace_camel_string_with_hyphen(key)
+        )
+        return KeyValueBasedTransformerFunctionReplacement(
+            lambda k, v: v if k == key and (v is not None and v != "") else None,
+            replacement_function=replacement_function,
+            replace_reference=reference_replacement,
+        )
+
     @staticmethod
     def jsonpath(jsonpath: str, value_replacement: str, reference_replacement: bool = True):
         """Creates a new JsonpathTransformer. If the jsonpath matches, the value will be replaced.
@@ -81,3 +111,27 @@ class TransformerUtility:
         :return: TextTransformer
         """
         return TextTransformer(text, replacement)
+
+    @staticmethod
+    def json_string(key: str) -> JsonStringTransformer:
+        """Creates a new JsonStringTransformer. If there is a valid JSON text string at specified key
+        it will be loaded as a regular object or array.
+
+        :param key: key at which JSON string is expected
+
+        :return: JsonStringTransformer
+        """
+        return JsonStringTransformer(key)
+
+    @staticmethod
+    def sorting(key: str, sorting_fn: Optional[Callable[[...], Any]]) -> SortingTransformer:
+        """Creates a new SortingTransformer.
+
+        Sorts a list at `key` with the given `sorting_fn` (argument for `sorted(list, key=sorting_fn)`)
+
+        :param key: key at which the list to sort is expected
+        :param sorting_fn: sorting function
+
+        :return: SortingTransformer
+        """
+        return SortingTransformer(key, sorting_fn)

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/localstack_snapshot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.2.0
+Version: 0.3.1
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 
@@ -222,6 +222,7 @@ Requires-Dist: black==23.10.0; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: coverage[toml]>=5.0.0; extra == "dev"
 Requires-Dist: ruff==0.1.0; extra == "dev"
+Dynamic: license-file
 
 Snapshot testing for pytest
 ===============================
@@ -233,10 +234,19 @@ This project is in a very early stage and will be both restructured and renamed.
 
 ## Quickstart
 
-to install the python and other developer requirements into a venv run:
+To install the python and other developer requirements into a venv run:
 
     make install
 
+### Configuration options
+
+There's a few env vars that can be used with this project:
+
+* `TEST_TARGET`: Set to `AWS_CLOUD` to use an externally-deployed instance when running tests.
+* `SNAPSHOT_LEGACY_REPORT`: By default set to `0`. Can be set to `1`. This enables the legacy reporting output style.
+* `SNAPSHOT_UDPATE`: By default set to `0`. Can be set to `1`. This enables updating the snapshot file rather than comparing with its contents.
+* `SNAPSHOT_RAW`: By default set to `0`. Can be set to `1`. This outputs an additional snapshot file which contains the untransformed values.
+
 ## Format code
 
 We use black and isort as code style tools.

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/pyproject.toml

@@ -7,7 +7,7 @@ name = "localstack-snapshot"
 authors = [
     { name = "LocalStack Contributors", email = "info@localstack.cloud" }
 ]
-version = "0.2.0"
+version = "0.3.1"
 description = "Extracted snapshot testing lib for LocalStack"
 dependencies = [
     "jsonpath-ng>1.6",

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/tests/test_snapshots.py

@@ -191,6 +191,137 @@ class TestSnapshotManager:
         sm.match("key1", [{"key2": "value1"}, "value2", 3])
         sm._assert_all()
 
+    def test_list_as_last_node_in_skip_verification_path(self):
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"aaa": ["item1", "item2", "item3"]}}
+        sm.match(
+            "key_a",
+            {"aaa": ["item1", "different-value"]},
+        )
+
+        with pytest.raises(Exception) as ctx:  # asserts it fail without skipping
+            sm._assert_all()
+        ctx.match("Parity snapshot failed")
+
+        skip_path = ["$..aaa[1]", "$..aaa[2]"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        skip_path = ["$..aaa.1", "$..aaa.2"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+    def test_list_as_last_node_in_skip_verification_path_complex(self):
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {
+            "key_a": {
+                "aaa": [
+                    {"aab": ["aac", "aad"]},
+                    {"aab": ["aac", "aad"]},
+                    {"aab": ["aac", "aad"]},
+                ]
+            }
+        }
+        sm.match(
+            "key_a",
+            {
+                "aaa": [
+                    {"aab": ["aac", "bad-value"], "bbb": "value"},
+                    {"aab": ["aac", "aad", "bad-value"]},
+                    {"aab": ["bad-value", "aad"]},
+                ]
+            },
+        )
+
+        with pytest.raises(Exception) as ctx:  # asserts it fail without skipping
+            sm._assert_all()
+        ctx.match("Parity snapshot failed")
+
+        skip_path = [
+            "$..aaa[0].aab[1]",
+            "$..aaa[0].bbb",
+            "$..aaa[1].aab[2]",
+            "$..aaa[2].aab[0]",
+        ]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        skip_path = [
+            "$..aaa.0..aab.1",
+            "$..aaa.0..bbb",
+            "$..aaa.1..aab.2",
+            "$..aaa.2..aab.0",
+        ]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+    def test_list_as_mid_node_in_skip_verification_path(self):
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"aaa": [{"aab": "value1"}, {"aab": "value2"}]}}
+        sm.match(
+            "key_a",
+            {"aaa": [{"aab": "value1"}, {"aab": "bad-value"}]},
+        )
+
+        with pytest.raises(Exception) as ctx:  # asserts it fail without skipping
+            sm._assert_all()
+        ctx.match("Parity snapshot failed")
+
+        skip_path = ["$..aaa[1].aab"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        skip_path = ["$..aaa.1.aab"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+    def test_list_as_last_node_in_skip_verification_path_nested(self):
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {
+            "key_a": {
+                "aaa": [
+                    "bbb",
+                    "ccc",
+                    [
+                        "ddd",
+                        "eee",
+                        [
+                            "fff",
+                            "ggg",
+                        ],
+                    ],
+                ]
+            }
+        }
+        sm.match(
+            "key_a",
+            {
+                "aaa": [
+                    "bbb",
+                    "ccc",
+                    [
+                        "bad-value",
+                        "eee",
+                        [
+                            "fff",
+                            "ggg",
+                        ],
+                    ],
+                ]
+            },
+        )
+
+        with pytest.raises(Exception) as ctx:  # asserts it fail without skipping
+            sm._assert_all()
+        ctx.match("Parity snapshot failed")
+
+        skip_path = ["$..aaa[2][0]"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        skip_path = ["$..aaa.2[0]"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        # these 2 will actually skip almost everything, as they will match every first element of any list inside `aaa`
+        skip_path = ["$..aaa..[0]"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
+        skip_path = ["$..aaa..0"]
+        sm._assert_all(skip_verification_paths=skip_path)
+
 
 def test_json_diff_format():
     path = ["Records", 1]
@@ -209,6 +340,14 @@ def test_json_diff_format():
     assert _format_json_path(path) == '"$.."'
     path = [1, 1, 0, "SomeKey"]
     assert _format_json_path(path) == '"$..SomeKey"'
+    path = ["Some:Key"]
+    assert _format_json_path(path) == "\"$..'Some:Key'\""
+    path = ["Some.Key"]
+    assert _format_json_path(path) == "\"$..'Some.Key'\""
+    path = ["Some-Key"]
+    assert _format_json_path(path) == '"$..Some-Key"'
+    path = ["Some0Key"]
+    assert _format_json_path(path) == '"$..Some0Key"'
 
 
 def test_sorting_transformer():

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.1}/tests/test_transformer.py

@@ -4,6 +4,8 @@ import json
 import pytest
 
 from localstack_snapshot.snapshots.transformer import (
+    JsonStringTransformer,
+    ResponseMetaDataTransformer,
     SortingTransformer,
     TimestampTransformer,
     TransformContext,
@@ -50,6 +52,81 @@ class TestTransformer:
 
         assert json.loads(tmp) == expected_key_value_reference
 
+    def test_key_value_replacement_custom_function(self):
+        input = {
+            "hello": "12characters",
+            "hello2": "again",
+            "path": {
+                "to": {
+                    "anotherkey": "hi",
+                    "twelvesymbol": {"hello": "twelvesymbol"},
+                    "fifteen_symbols": {"hello": "fifteen_symbols"},
+                }
+            },
+        }
+
+        key_value = TransformerUtility.key_value_replacement_function(
+            "hello",
+            replacement_function=lambda k, v: f"placeholder({len(v)})",
+            reference_replacement=False,
+        )
+
+        expected_key_value = {
+            "hello": "placeholder(12)",
+            "hello2": "again",
+            "path": {
+                "to": {
+                    "anotherkey": "hi",
+                    "twelvesymbol": {"hello": "placeholder(12)"},
+                    "fifteen_symbols": {"hello": "placeholder(15)"},
+                }
+            },
+        }
+
+        ctx = TransformContext()
+        assert key_value.transform(input, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_key_value_replacement_custom_function_reference_replacement(self):
+        input = {
+            "hello": "12characters",
+            "hello2": "again",
+            "path": {
+                "to": {
+                    "anotherkey": "hi",
+                    "twelvesymbol": {"hello": "twelvesymbol"},
+                    "fifteen_symbols": {"hello": "fifteen_symbols"},
+                }
+            },
+        }
+
+        key_value = TransformerUtility.key_value_replacement_function(
+            "hello",
+            replacement_function=lambda k, v: f"placeholder({len(v)})",
+            reference_replacement=True,
+        )
+        # replacement counters are per replacement key, so it will start from 1 again.
+        expected_key_value_reference = {
+            "hello": "<placeholder(12):1>",
+            "hello2": "again",
+            "path": {
+                "to": {
+                    "anotherkey": "hi",
+                    "<placeholder(12):2>": {"hello": "<placeholder(12):2>"},
+                    "<placeholder(15):1>": {"hello": "<placeholder(15):1>"},
+                }
+            },
+        }
+        ctx = TransformContext()
+        assert key_value.transform(input, ctx=ctx) == input
+        assert len(ctx.serialized_replacements) == 3
+
+        tmp = json.dumps(input, default=str)
+        for sr in ctx.serialized_replacements:
+            tmp = sr(tmp)
+
+        assert json.loads(tmp) == expected_key_value_reference
+
     def test_key_value_replacement_with_falsy_value(self):
         input = {
             "hello": "world",
@@ -236,6 +313,57 @@ class TestTransformer:
             output = sr(output)
         assert json.loads(output) == expected
 
+    @pytest.mark.parametrize(
+        "input_value,transformed_value",
+        [
+            pytest.param('{"a": "b"}', {"a": "b"}, id="simple_json_object"),
+            pytest.param('{\n  "a": "b"\n}', {"a": "b"}, id="formatted_json_object"),
+            pytest.param('\n  {"a": "b"}', {"a": "b"}, id="json_with_whitespaces"),
+            pytest.param('{"a": 42}malformed', '{"a": 42}malformed', id="malformed_json"),
+            pytest.param('["a", "b"]', ["a", "b"], id="simple_json_list"),
+            pytest.param('{"a": "{\\"b\\":42}"}', {"a": {"b": 42}}, id="nested_json_object"),
+            pytest.param(
+                '{"a": "\\n  {\\n  \\"b\\":42}"}',
+                {"a": {"b": 42}},
+                id="nested_formatted_json_object_with_whitespaces",
+            ),
+            pytest.param(
+                '{"a": "[{\\"b\\":\\"c\\"}]"}', {"a": [{"b": "c"}]}, id="nested_json_list"
+            ),
+            pytest.param(
+                '{"a": "{\\"b\\":42malformed}"}',
+                {"a": '{"b":42malformed}'},
+                id="malformed_nested_json",
+            ),
+            pytest.param("[]", [], id="empty_list"),
+            pytest.param("{}", {}, id="empty_object"),
+            pytest.param("", "", id="empty_string"),
+        ],
+    )
+    def test_json_string(self, input_value, transformed_value):
+        key = "key"
+        input_data = {key: input_value}
+        expected = {key: transformed_value}
+
+        transformer = JsonStringTransformer(key)
+
+        ctx = TransformContext()
+        output = transformer.transform(input_data, ctx=ctx)
+
+        assert output == expected
+
+    def test_json_string_in_a_nested_key(self):
+        key = "nested-key-in-an-object-hidden-inside-a-list"
+        input_data = {"top-level-key": [{key: '{"a": "b"}'}]}
+        expected = {"top-level-key": [{key: {"a": "b"}}]}
+
+        transformer = JsonStringTransformer(key)
+
+        ctx = TransformContext()
+        output = transformer.transform(input_data, ctx=ctx)
+
+        assert output == expected
+
 
 class TestTimestampTransformer:
     def test_generic_timestamp_transformer(self):
@@ -278,3 +406,81 @@ class TestTimestampTransformer:
         ctx = TransformContext()
         output = transformer.transform(input, ctx=ctx)
         assert output == expected
+
+
+class TestResponseMetaDataTransformer:
+    def test_with_headers(self):
+        input_data = {"ResponseMetadata": {"HTTPHeaders": {"header1": "value1"}}}
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"HTTPHeaders": {}}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_with_headers_and_status_code(self):
+        input_data = {
+            "ResponseMetadata": {"HTTPHeaders": {"header1": "value1"}, "HTTPStatusCode": 500}
+        }
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"HTTPHeaders": {}, "HTTPStatusCode": 500}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_with_status_code_only(self):
+        input_data = {"ResponseMetadata": {"HTTPStatusCode": 500, "RandomData": "random"}}
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"HTTPStatusCode": 500, "RandomData": "random"}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_with_empty_response_metadata(self):
+        input_data = {"ResponseMetadata": {"NotHeaders": "data"}}
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"NotHeaders": "data"}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_with_headers_wrong_type(self):
+        input_data = {"ResponseMetadata": {"HTTPHeaders": "data"}}
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"HTTPHeaders": "data"}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []
+
+    def test_headers_filtering(self):
+        input_data = {
+            "ResponseMetadata": {"HTTPHeaders": {"content_type": "value1", "header1": "value1"}}
+        }
+
+        metadata_transformer = ResponseMetaDataTransformer()
+
+        expected_key_value = {"ResponseMetadata": {"HTTPHeaders": {"content_type": "value1"}}}
+
+        copied = copy.deepcopy(input_data)
+        ctx = TransformContext()
+        assert metadata_transformer.transform(copied, ctx=ctx) == expected_key_value
+        assert ctx.serialized_replacements == []

localstack_snapshot-0.2.0/README.md

@@ -1,26 +0,0 @@
-Snapshot testing for pytest
-===============================
-
-Extracted snapshot testing lib for LocalStack.
-
-This project is in a very early stage and will be both restructured and renamed.
-
-
-## Quickstart
-
-to install the python and other developer requirements into a venv run:
-
-    make install
-
-## Format code
-
-We use black and isort as code style tools.
-To execute them, run:
-
-    make format
-
-## Build distribution
-
-To build a wheel and source distribution, simply run
-
-    make dist

localstack_snapshot-0.2.0/localstack_snapshot/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"