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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.2.0
+Version: 0.3.0
 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.0/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.0/localstack_snapshot/__init__.py

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

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

@@ -272,6 +272,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

{localstack_snapshot-0.2.0 → localstack_snapshot-0.3.0}/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
 
@@ -184,35 +186,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 +226,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 +377,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.0}/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.0}/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.0
 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.0}/pyproject.toml

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

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

@@ -4,6 +4,7 @@ import json
 import pytest
 
 from localstack_snapshot.snapshots.transformer import (
+    JsonStringTransformer,
     SortingTransformer,
     TimestampTransformer,
     TransformContext,
@@ -50,6 +51,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 +312,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):

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"