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

{localstack-snapshot-0.1.1 → localstack_snapshot-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.1.1
+Version: 0.3.0
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 
@@ -217,12 +217,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jsonpath-ng>1.6
 Requires-Dist: deepdiff
-Requires-Dist: botocore
 Provides-Extra: dev
 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
 ===============================
@@ -234,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.1.1 → localstack_snapshot-0.3.0}/localstack_snapshot/snapshots/prototype.py

@@ -1,3 +1,4 @@
+import io
 import json
 import logging
 import os
@@ -7,7 +8,6 @@ from pathlib import Path
 from re import Pattern
 from typing import Dict, List, Optional
 
-from botocore.response import StreamingBody
 from deepdiff import DeepDiff
 from jsonpath_ng import DatumInContext
 from jsonpath_ng.ext import parse
@@ -164,6 +164,23 @@ class SnapshotSession:
     def _update(self, key: str, obj_state: dict) -> None:
         self.observed_state[key] = obj_state
 
+    def match_object(self, key: str, obj: object) -> None:
+        def _convert_object_to_dict(obj_):
+            if isinstance(obj_, dict):
+                for key in list(obj_.keys()):
+                    if key.startswith("_"):
+                        del obj_[key]
+                    else:
+                        obj_[key] = _convert_object_to_dict(obj_[key])
+            elif isinstance(obj_, list):
+                for idx, val in enumerate(obj_):
+                    obj_[idx] = _convert_object_to_dict(val)
+            elif hasattr(obj_, "__dict__"):
+                return _convert_object_to_dict(obj_.__dict__)
+            return obj_
+
+        return self.match(key, _convert_object_to_dict(obj))
+
     def match(self, key: str, obj: dict) -> None:
         if key in self.called_keys:
             raise Exception(
@@ -243,11 +260,10 @@ class SnapshotSession:
     def _transform_dict_to_parseable_values(self, original):
         """recursively goes through dict and tries to resolve values to strings (& parse them as json if possible)"""
         for k, v in original.items():
-            if isinstance(v, StreamingBody):
+            if isinstance(v, io.IOBase):
                 # update v for json parsing below
-                original[k] = v = v.read().decode(
-                    "utf-8"
-                )  # TODO: patch boto client so this doesn't break any further read() calls
+                # TODO: patch boto client so this doesn't break any further read() calls
+                original[k] = v = v.read().decode("utf-8")
             if isinstance(v, list) and v:
                 for item in v:
                     if isinstance(item, dict):
@@ -256,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.1.1 → 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
 
@@ -16,6 +18,10 @@ SNAPSHOT_LOGGER.setLevel(logging.DEBUG if os.environ.get("DEBUG_SNAPSHOT") else
 GlobalReplacementFn = Callable[[str], str]
 
 
+class TransformerException(Exception):
+    pass
+
+
 class TransformContext:
     _cache: dict
     replacements: list[GlobalReplacementFn]
@@ -43,6 +49,19 @@ class TransformContext:
 def _register_serialized_reference_replacement(
     transform_context: TransformContext, *, reference_value: str, replacement: str
 ):
+    # Provide a better error message for the TypeError if the reference value is not iterable (e.g., float)
+    # Example: `TypeError: argument of type 'float' is not iterable`
+    # Using a list would throw an AttributeError because `.replace` is not applicable.
+    # The snapshot library currently only supports strings for reference replacements
+    if not isinstance(reference_value, str):
+        message = (
+            f"The reference value {reference_value} of type {type(reference_value)} is not a string."
+            f" Consider using `reference_replacement=False` in your transformer"
+            f" for the replacement {replacement} because reference replacements are only supported for strings."
+        )
+        SNAPSHOT_LOGGER.error(message)
+        raise TransformerException(message)
+
     if '"' in reference_value:
         reference_value = reference_value.replace('"', '\\"')
 
@@ -167,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):
@@ -206,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
@@ -327,3 +361,94 @@ class TimestampTransformer:
 
     def _transform_list(self, input_data: list, ctx: TransformContext = None) -> list:
         return [self._transform(e, ctx=ctx) for e in input_data]
+
+
+class TextTransformer:
+    def __init__(self, text: str, replacement: str):
+        self.text = text
+        self.replacement = replacement
+
+    def transform(self, input_data: dict, *, ctx: TransformContext) -> dict:
+        def replace_val(s):
+            return s.replace(self.text, self.replacement)
+
+        ctx.register_serialized_replacement(replace_val)
+        SNAPSHOT_LOGGER.debug(
+            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.3.0/localstack_snapshot/snapshots/transformer_utility.py

@@ -0,0 +1,137 @@
+from re import Pattern
+from typing import Any, Callable, Optional
+
+from localstack_snapshot.snapshots.transformer import (
+    JsonpathTransformer,
+    JsonStringTransformer,
+    KeyValueBasedTransformer,
+    KeyValueBasedTransformerFunctionReplacement,
+    RegexTransformer,
+    SortingTransformer,
+    TextTransformer,
+)
+
+
+def _replace_camel_string_with_hyphen(input_string: str):
+    return "".join(["-" + char.lower() if char.isupper() else char for char in input_string]).strip(
+        "-"
+    )
+
+
+class TransformerUtility:
+    @staticmethod
+    def key_value(
+        key: str, value_replacement: Optional[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 value_replacement: the value which will replace the original value.
+        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
+        """
+        return KeyValueBasedTransformer(
+            lambda k, v: v if k == key and (v is not None and v != "") else None,
+            replacement=value_replacement or _replace_camel_string_with_hyphen(key),
+            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.
+
+        :param jsonpath: the jsonpath that should be matched
+        :param value_replacement: the value which will replace the original value.
+        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: JsonpathTransformer
+        """
+        return JsonpathTransformer(
+            jsonpath=jsonpath,
+            replacement=value_replacement,
+            replace_reference=reference_replacement,
+        )
+
+    @staticmethod
+    def regex(regex: str | Pattern[str], replacement: str):
+        """Creates a new RegexTransformer. All matches in the string-converted dict will be replaced.
+
+        :param regex: the regex that should be matched
+        :param replacement: the value which will replace the original value.
+
+        :return: RegexTransformer
+        """
+        return RegexTransformer(regex, replacement)
+
+    @staticmethod
+    def text(text: str, replacement: str):
+        """Creates a new TextTransformer. All occurrences in the string-converted dict will be replaced.
+
+        Useful if the text contains special characters that would confuse the RegexTransformer, like '+' or '('.
+
+        :param text: the text that should be replaced
+        :param replacement: the value which will replace the original value.
+
+        :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.1.1 → localstack_snapshot-0.3.0}/localstack_snapshot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.1.1
+Version: 0.3.0
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 
@@ -217,12 +217,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jsonpath-ng>1.6
 Requires-Dist: deepdiff
-Requires-Dist: botocore
 Provides-Extra: dev
 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
 ===============================
@@ -234,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.1.1 → localstack_snapshot-0.3.0}/localstack_snapshot.egg-info/requires.txt

@@ -1,6 +1,5 @@
 jsonpath-ng>1.6
 deepdiff
-botocore
 
 [dev]
 black==23.10.0

{localstack-snapshot-0.1.1 → localstack_snapshot-0.3.0}/pyproject.toml

@@ -7,12 +7,11 @@ name = "localstack-snapshot"
 authors = [
     { name = "LocalStack Contributors", email = "info@localstack.cloud" }
 ]
-version = "0.1.1"
+version = "0.3.0"
 description = "Extracted snapshot testing lib for LocalStack"
 dependencies = [
     "jsonpath-ng>1.6",
     "deepdiff",
-    "botocore",
 ]
 requires-python = ">=3.10"
 license = {file = "LICENSE"}

{localstack-snapshot-0.1.1 → localstack_snapshot-0.3.0}/tests/test_snapshots.py

@@ -1,3 +1,5 @@
+import io
+
 import pytest
 
 from localstack_snapshot.snapshots import SnapshotSession
@@ -20,6 +22,12 @@ class TestSnapshotManager:
             sm._assert_all()
         ctx.match("Parity snapshot failed")
 
+    def test_diff_with_io_stream(self):
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"a": "data"}}
+        sm.match("key_a", {"a": io.BytesIO(b"data")})
+        sm._assert_all()
+
     def test_multiple_assertmatch_with_same_key_fail(self):
         sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
         sm.recorded_state = {"key_a": {"a": 3}}
@@ -37,6 +45,48 @@ class TestSnapshotManager:
         sm.match("key_a", {"aaa": "something", "bbb": "something hello"})
         sm._assert_all()
 
+    def test_match_object_nochange(self):
+        class CustomObject:
+            def __init__(self, name, nested=False):
+                self.name = name
+                if nested:
+                    self.nested = CustomObject(f"nested{name}")
+                    self.listed = [CustomObject(f"listed{name}"), "otherobj"]
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {
+            "key_a": {
+                "name": "myname",
+                "nested": {"name": "nestedmyname"},
+                "listed": [{"name": "listedmyname"}, "otherobj"],
+            }
+        }
+        sm.match_object("key_a", CustomObject(name="myname", nested=True))
+        sm._assert_all()
+
+    def test_match_object_ignore_private_values(self):
+        class CustomObject:
+            def __init__(self, name):
+                self.name = name
+                self._internal = "n/a"
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"name": "myname"}}
+        sm.match_object("key_a", CustomObject(name="myname"))
+        sm._assert_all()
+
+    def test_match_object_change(self):
+        class CustomObject:
+            def __init__(self, name):
+                self.name = name
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"name": "myname"}}
+        sm.match_object("key_a", CustomObject(name="diffname"))
+        with pytest.raises(Exception) as ctx:
+            sm._assert_all()
+        ctx.match("Parity snapshot failed")
+
     # def test_context_replacement_no_change(self):
     #     sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
     #     sm.add_transformer(TransformerUtility.key_value("name"))

{localstack-snapshot-0.1.1 → 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",
@@ -211,6 +287,82 @@ class TestTransformer:
         output = transformer.transform(input, ctx=ctx)
         assert output == expected
 
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "a+b",
+            "question?",
+            "amount: $4.00",
+            "emoji: ^^",
+            "sentence.",
+            "others (like so)",
+            "special {char}",
+        ],
+    )
+    def test_text(self, value):
+        input = {"key": f"some {value} with more text"}
+
+        expected = {"key": "some <value> with more text"}
+
+        transformer = TransformerUtility.text(value, "<value>")
+
+        ctx = TransformContext()
+        output = transformer.transform(json.dumps(input), ctx=ctx)
+        for sr in ctx.serialized_replacements:
+            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.1.1/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.1.1/localstack_snapshot/__init__.py

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

localstack-snapshot-0.1.1/localstack_snapshot/snapshots/transformer_utility.py

@@ -1,69 +0,0 @@
-from re import Pattern
-from typing import Optional
-
-from localstack_snapshot.snapshots.transformer import (
-    JsonpathTransformer,
-    KeyValueBasedTransformer,
-    RegexTransformer,
-)
-
-
-def _replace_camel_string_with_hyphen(input_string: str):
-    return "".join(["-" + char.lower() if char.isupper() else char for char in input_string]).strip(
-        "-"
-    )
-
-
-class TransformerUtility:
-    @staticmethod
-    def key_value(
-        key: str, value_replacement: Optional[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 value_replacement: the value which will replace the original value.
-        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
-        """
-        return KeyValueBasedTransformer(
-            lambda k, v: v if k == key and (v is not None and v != "") else None,
-            replacement=value_replacement or _replace_camel_string_with_hyphen(key),
-            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.
-
-        :param jsonpath: the jsonpath that should be matched
-        :param value_replacement: the value which will replace the original value.
-        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: JsonpathTransformer
-        """
-        return JsonpathTransformer(
-            jsonpath=jsonpath,
-            replacement=value_replacement,
-            replace_reference=reference_replacement,
-        )
-
-    @staticmethod
-    def regex(regex: str | Pattern[str], replacement: str):
-        """Creates a new RegexTransformer. All matches in the string-converted dict will be replaced.
-
-        :param regex: the regex that should be matched
-        :param replacement: the value which will replace the original value.
-
-        :return: RegexTransformer
-        """
-        return RegexTransformer(regex, replacement)