fix: exit serialization early on detection of a cycle

src/syrupy/serializers/amber.py

@@ -6,6 +6,7 @@
     Any,
     Dict,
     Iterable,
+    List,
     Set,
 )
 
@@ -17,6 +18,8 @@
 
 
 class DataSerializer:
+    _max_depth: int = 99
+    _max_depth_value: str = "..."
     indent: str = "  "
     name_marker: str = "# name:"
     divider: str = "---"
@@ -89,7 +92,9 @@ def object_type(cls, data: "SerializableData") -> str:
         return f"<class '{data.__class__.__name__}'>"
 
     @classmethod
-    def serialize_string(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_string(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
         if "\n" in data:
             return (
                 cls.with_indent("'\n", indent)
@@ -99,27 +104,40 @@ def serialize_string(cls, data: "SerializableData", indent: int = 0) -> str:
         return cls.with_indent(repr(data), indent)
 
     @classmethod
-    def serialize_number(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_number(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
         return cls.with_indent(repr(data), indent)
 
     @classmethod
-    def serialize_set(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_set(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
         return (
             cls.with_indent(f"{cls.object_type(data)} {{\n", indent)
-            + "".join([f"{cls.serialize(d, indent + 1)},\n" for d in cls.sort(data)])
+            + "".join(
+                [
+                    f"{cls.serialize(d, indent=indent + 1, visited=visited)},\n"
+                    for d in cls.sort(data)
+                ]
+            )
             + cls.with_indent("}", indent)
         )
 
     @classmethod
-    def serialize_dict(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_dict(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
         return (
             cls.with_indent(f"{cls.object_type(data)} {{\n", indent)
             + "".join(
                 [
                     (
-                        cls.serialize(key, indent + 1)
+                        cls.serialize(key, indent=indent + 1)
                         + ": "
-                        + cls.serialize(data[key], indent + 1).lstrip(cls.indent)
+                        + cls.serialize(
+                            data[key], indent=indent + 1, visited=visited
+                        ).lstrip(cls.indent)
                         + ",\n"
                     )
                     for key in cls.sort(data.keys())
@@ -129,31 +147,52 @@ def serialize_dict(cls, data: "SerializableData", indent: int = 0) -> str:
         )
 
     @classmethod
-    def serialize_iterable(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_iterable(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
         open_paren, close_paren = next(
             paren[1]
             for paren in {list: "[]", tuple: "()", GeneratorType: "()"}.items()
             if isinstance(data, paren[0])
         )
         return (
             cls.with_indent(f"{cls.object_type(data)} {open_paren}\n", indent)
-            + "".join([f"{cls.serialize(d, indent + 1)},\n" for d in data])
+            + "".join(
+                [
+                    f"{cls.serialize(d, indent=indent + 1, visited=visited)},\n"
+                    for d in data
+                ]
+            )
             + cls.with_indent(close_paren, indent)
         )
 
     @classmethod
-    def serialize(cls, data: "SerializableData", indent: int = 0) -> str:
+    def serialize_unknown(
+        cls, data: Any, *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
+        return cls.with_indent(repr(data), indent)
+
+    @classmethod
+    def serialize(
+        cls, data: "SerializableData", *, indent: int = 0, visited: List[Any] = []
+    ) -> str:
+        if indent > cls._max_depth or data in visited:
+            data = cls._max_depth_value
+
+        serialize_kwargs = dict(data=data, indent=indent, visited=[*visited, data])
         if isinstance(data, str):
-            return cls.serialize_string(data, indent)
+            serialize_method = cls.serialize_string
         elif isinstance(data, (int, float)):
-            return cls.serialize_number(data, indent)
+            serialize_method = cls.serialize_number
         elif isinstance(data, (set, frozenset)):
-            return cls.serialize_set(data, indent)
+            serialize_method = cls.serialize_set
         elif isinstance(data, dict):
-            return cls.serialize_dict(data, indent)
+            serialize_method = cls.serialize_dict
         elif isinstance(data, (list, tuple, GeneratorType)):
-            return cls.serialize_iterable(data, indent)
-        return cls.with_indent(repr(data), indent)
+            serialize_method = cls.serialize_iterable
+        else:
+            serialize_method = cls.serialize_unknown
+        return serialize_method(**serialize_kwargs)
 
 
 class AmberSnapshotSerializer(AbstractSnapshotSerializer):
@@ -162,12 +201,10 @@ class AmberSnapshotSerializer(AbstractSnapshotSerializer):
 
     ```
     # name: test_name_1
-
-     data
+      data
     ---
     # name: test_name_2
-
-     data
+      data
     ```
     """
 

tests/__snapshots__/test_amber_serializer.ambr

@@ -1,6 +1,22 @@
 # name: TestClass.test_name
   'this is in a test class'
 ---
+# name: test_cycle[cyclic0]
+  <class 'list'> [
+    1,
+    2,
+    3,
+    '...',
+  ]
+---
+# name: test_cycle[cyclic1]
+  <class 'dict'> {
+    'a': 1,
+    'b': 2,
+    'c': 3,
+    'd': '...',
+  }
+---
 # name: test_dict[actual0]
   <class 'dict'> {
     'a': <class 'dict'> {

tests/test_amber_serializer.py

@@ -72,6 +72,18 @@ def test_list(snapshot):
     assert snapshot == [1, 2, "string", {"key": "value"}]
 
 
+list_cycle = [1, 2, 3]
+list_cycle.append(list_cycle)
+
+dict_cycle = {"a": 1, "b": 2, "c": 3}
+dict_cycle.update(d=dict_cycle)
+
+
+@pytest.mark.parametrize("cyclic", [list_cycle, dict_cycle])
+def test_cycle(cyclic, snapshot):
+    assert cyclic == snapshot
+
+
 class TestClass:
     def test_name(self, snapshot):
         assert snapshot == "this is in a test class"