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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.3.0
+Version: 0.3.2
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 

localstack_snapshot-0.3.2/localstack_snapshot/__init__.py

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

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

@@ -2,7 +2,9 @@ import io
 import json
 import logging
 import os
+from collections.abc import Iterator
 from datetime import datetime, timezone
+from enum import Enum
 from json import JSONDecodeError
 from pathlib import Path
 from re import Pattern
@@ -25,6 +27,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 = ""):
@@ -167,16 +171,27 @@ class SnapshotSession:
     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)
+                # Serialize the values of the dictionary, while skipping any private keys (starting with '_')
+                return {
+                    key_: _convert_object_to_dict(obj_[key_])
+                    for key_ in obj_
+                    if not key_.startswith("_")
+                }
+            elif isinstance(obj_, (list, Iterator)):
+                return [_convert_object_to_dict(val) for val in obj_]
+            elif isinstance(obj_, Enum):
+                return obj_.value
             elif hasattr(obj_, "__dict__"):
-                return _convert_object_to_dict(obj_.__dict__)
+                # This is an object - let's try to convert it to a dictionary
+                # A  naive approach would be to use the '__dict__' object directly, but that only lists the attributes
+                # In order to also serialize the properties, we use the __dir__() method
+                # Filtering by everything that is not a method gives us both attributes and properties
+                # We also (still) skip private attributes/properties, so everything that starts with an underscore
+                return {
+                    k: _convert_object_to_dict(getattr(obj_, k))
+                    for k in obj_.__dir__()
+                    if not k.startswith("_") and type(getattr(obj_, k, "")).__name__ != "method"
+                }
             return obj_
 
         return self.match(key, _convert_object_to_dict(obj))
@@ -218,7 +233,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:
@@ -306,7 +321,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
@@ -365,6 +380,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:
@@ -378,7 +410,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.3.0 → localstack_snapshot-0.3.2}/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.3.0 → localstack_snapshot-0.3.2}/localstack_snapshot/snapshots/transformer.py

@@ -102,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:

{localstack_snapshot-0.3.0 → localstack_snapshot-0.3.2}/localstack_snapshot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-snapshot
-Version: 0.3.0
+Version: 0.3.2
 Summary: Extracted snapshot testing lib for LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License: 

{localstack_snapshot-0.3.0 → localstack_snapshot-0.3.2}/pyproject.toml

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

{localstack_snapshot-0.3.0 → localstack_snapshot-0.3.2}/tests/test_snapshots.py

@@ -1,4 +1,5 @@
 import io
+from enum import Enum
 
 import pytest
 
@@ -75,6 +76,67 @@ class TestSnapshotManager:
         sm.match_object("key_a", CustomObject(name="myname"))
         sm._assert_all()
 
+    def test_match_object_lists_and_iterators(self):
+        class CustomObject:
+            def __init__(self, name):
+                self.name = name
+                self.my_list = [9, 8, 7, 6, 5]
+                self.my_iterator = (x for x in range(5))
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {
+            "key_a": {"name": "myname", "my_iterator": [0, 1, 2, 3, 4], "my_list": [9, 8, 7, 6, 5]}
+        }
+        sm.match_object("key_a", CustomObject(name="myname"))
+        sm._assert_all()
+
+    def test_match_object_include_properties(self):
+        class CustomObject:
+            def __init__(self, name):
+                self.name = name
+                self._internal = "n/a"
+
+            def some_method(self):
+                # method should not be serialized
+                return False
+
+            @property
+            def some_prop(self):
+                # properties should be serialized
+                return True
+
+            @property
+            def some_iterator(self):
+                for i in range(3):
+                    yield i
+
+            @property
+            def _private_prop(self):
+                # private properties should be ignored
+                return False
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {
+            "key_a": {"name": "myname", "some_prop": True, "some_iterator": [0, 1, 2]}
+        }
+        sm.match_object("key_a", CustomObject(name="myname"))
+        sm._assert_all()
+
+    def test_match_object_enums(self):
+        class TestEnum(Enum):
+            value1 = "Value 1"
+            value2 = "Value 2"
+
+        class CustomObject:
+            def __init__(self, name):
+                self.name = name
+                self.my_enum = TestEnum.value2
+
+        sm = SnapshotSession(scope_key="A", verify=True, base_file_path="", update=False)
+        sm.recorded_state = {"key_a": {"name": "myname", "my_enum": "Value 2"}}
+        sm.match_object("key_a", CustomObject(name="myname"))
+        sm._assert_all()
+
     def test_match_object_change(self):
         class CustomObject:
             def __init__(self, name):
@@ -191,6 +253,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 +402,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.3.0 → localstack_snapshot-0.3.2}/tests/test_transformer.py

@@ -5,6 +5,7 @@ import pytest
 
 from localstack_snapshot.snapshots.transformer import (
     JsonStringTransformer,
+    ResponseMetaDataTransformer,
     SortingTransformer,
     TimestampTransformer,
     TransformContext,
@@ -405,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.3.0/localstack_snapshot/__init__.py

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