Merge pull request #364 from 15r10nk/fix-dataclasses-as-dict-keys

fix: dataclasses as dictionary keys

Author: 15r10nk

.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ${{matrix.os}}
     strategy:
       matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14', pypy3.9, pypy3.10]
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14', pypy3.11]
         os: [ubuntu-latest, windows-2022, macos-14]
         extra_deps: ['"--with=pydantic<2"', '"--with=pydantic>2"']
         is_insider:
@@ -47,9 +47,7 @@ jobs:
         - os: macos-14
           python-version: '3.13'
         - os: macos-14
-          python-version: pypy3.9
-        - os: macos-14
-          python-version: pypy3.10
+          python-version: pypy3.11
 
         - os: windows-2022
           python-version: '3.10'
@@ -60,9 +58,7 @@ jobs:
         - os: windows-2022
           python-version: '3.13'
         - os: windows-2022
-          python-version: pypy3.9
-        - os: windows-2022
-          python-version: pypy3.10
+          python-version: pypy3.11
 
     env:
       TOP: ${{github.workspace}}

changelog.d/20260423_172841_15r10nk-git.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- Fixed snapshot comparison for dicts where keys are dataclass instances (or other custom objects used as dict keys), which previously caused corrupted snapshots — either collapsing multiple entries into one or appending duplicate keys on subsequent runs ([#363](https://github.com/15r10nk/inline-snapshot/issues/363)).
+- Fixed tuple snapshot updates to compare elements positionally rather than using sequence alignment, so existing expressions (e.g. `3 + 3`) are preserved when elements are removed from or added to a tuple.

src/inline_snapshot/_customize/_builder.py

@@ -161,6 +161,8 @@ def create_dict(self, value: dict) -> Custom:
             self._get_handler_recursive(k): self._get_handler_recursive(v)
             for k, v in value.items()
         }
+        assert len(value) == len(custom)
+
         return CustomDict(value=custom)
 
     @property

src/inline_snapshot/_customize/_custom_call.py

@@ -11,7 +11,7 @@
 from ._custom import Custom
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class CustomDefault(Custom):
     value: Custom = field(compare=False)
 
@@ -30,7 +30,7 @@ def unwrap_default(value):
     return value
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class CustomCall(Custom):
     node_type = ast.Call
     function: Custom = field(compare=False)

src/inline_snapshot/_customize/_custom_dict.py

@@ -11,7 +11,7 @@
 from ._custom import Custom
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class CustomDict(Custom):
     node_type = ast.Dict
     value: dict[Custom, Custom] = field(compare=False)

src/inline_snapshot/_customize/_custom_external.py

@@ -15,7 +15,7 @@
 from ._custom import Custom
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class CustomExternal(Custom):
     value: Any
     format: str | None = None

src/inline_snapshot/_customize/_custom_unmanaged.py

@@ -10,7 +10,7 @@
 from ._custom import Custom
 
 
-@dataclass()
+@dataclass(eq=False)
 class CustomUnmanaged(Custom):
     value: Any
 

src/inline_snapshot/_new_adapter.py

@@ -228,9 +228,9 @@ def compare_CustomCode(
 
         return new_value
 
-    def compare_CustomSequence(
-        self, old_value: CustomSequence, old_node: ast.AST, new_value: CustomSequence
-    ) -> Generator[ChangeBase, None, CustomSequence]:
+    def compare_CustomList(
+        self, old_value: CustomList, old_node: ast.AST, new_value: CustomList
+    ) -> Generator[ChangeBase, None, CustomList]:
 
         if old_node is not None:
             assert isinstance(
@@ -288,8 +288,47 @@ def compare_CustomSequence(
 
         return type(new_value)(result)
 
-    compare_CustomTuple = compare_CustomSequence
-    compare_CustomList = compare_CustomSequence
+    def compare_CustomTuple(
+        self, old_value: CustomTuple, old_node: ast.AST, new_value: CustomTuple
+    ) -> Generator[ChangeBase, None, CustomTuple]:
+        """Compare tuples positionally: match elements at the same index,
+        delete surplus old elements, insert extra new elements."""
+
+        if old_node is not None:
+            assert isinstance(old_node, ast.Tuple)
+
+        old_elts = old_value.value
+        new_elts = new_value.value
+        old_nodes = old_node.elts if old_node is not None else [None] * len(old_elts)
+
+        common = min(len(old_elts), len(new_elts))
+        result = []
+
+        # compare paired elements
+        for old_elem, old_node_elem, new_elem in zip(old_elts, old_nodes, new_elts):
+            v = yield from self.compare(old_elem, old_node_elem, new_elem)
+            result.append(v)
+
+        # delete surplus old elements
+        for old_elem, old_node_elem in zip(old_elts[common:], old_nodes[common:]):
+            yield Delete("fix", self.context.file, old_node_elem, old_elem)
+
+        # insert extra new elements
+        if len(new_elts) > common:
+            to_insert = []
+            for new_elem in new_elts[common:]:
+                new_code = yield from new_elem._code_repr(self.context)
+                to_insert.append((new_code, new_elem))
+                result.append(new_elem)
+            yield ListInsert(
+                "fix",
+                self.context.file,
+                old_node,
+                common,
+                *zip(*to_insert),  # type:ignore
+            )
+
+        return CustomTuple(result)
 
     def compare_CustomDict(
         self, old_value: CustomDict, old_node: ast.Dict, new_value: CustomDict

tests/adapter/test_dataclass.py

@@ -778,6 +778,46 @@ def test_A():
     )
 
 
+def test_dataclass_as_dict_key_create():
+    """Regression test for CustomCall-keyed dicts: when a dataclass instance is
+    used as a dict key, the snapshot should be created correctly and should not
+    corrupt values on subsequent runs (issue #363 / duplicate report)."""
+    Example(
+        """\
+from dataclasses import dataclass
+from inline_snapshot import snapshot
+
+@dataclass(frozen=True)
+class Container:
+    value: int
+
+def test_something():
+    data = {Container(40): 40, Container(2): 2}
+    assert data == snapshot()
+"""
+    ).run_inline(
+        ["--inline-snapshot=create"],
+        changed_files=snapshot(
+            {
+                "tests/test_something.py": """\
+from dataclasses import dataclass
+from inline_snapshot import snapshot
+
+@dataclass(frozen=True)
+class Container:
+    value: int
+
+def test_something():
+    data = {Container(40): 40, Container(2): 2}
+    assert data == snapshot({Container(value=40): 40, Container(value=2): 2})
+"""
+            }
+        ),
+    ).run_inline(
+        ["--inline-snapshot=fix"], changed_files=snapshot({})
+    )
+
+
 @pytest.mark.skipif(
     sys.version_info < (3, 10),
     reason="NewType is a function in 3.9 and cannot be checked with isinstance or serialized to code",

tests/adapter/test_sequence.py

@@ -119,3 +119,77 @@ def test_tuple():
         ["--inline-snapshot=fix"],
         changed_files=snapshot({}),
     )
+
+
+def test_tuple_fix_shorter():
+    """Tuple shrinks: surplus old elements are deleted, paired elements fixed.
+    Expressions in paired positions are preserved."""
+    Example(
+        """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (1, 5) == snapshot((0+1, 2, 3, 4, 5))
+"""
+    ).run_inline(
+        ["--inline-snapshot=fix"],
+        changed_files=snapshot(
+            {
+                "tests/test_something.py": """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (1, 5) == snapshot((0+1, 5))
+"""
+            }
+        ),
+    )
+
+
+def test_tuple_fix_longer():
+    """Tuple grows: paired elements are fixed, extra new elements are inserted."""
+    Example(
+        """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (1, 2, 3, 4, 5, 6) == snapshot((0+1, 3))
+"""
+    ).run_inline(
+        ["--inline-snapshot=fix"],
+        changed_files=snapshot(
+            {
+                "tests/test_something.py": """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (1, 2, 3, 4, 5, 6) == snapshot((0+1, 2, 3, 4, 5, 6))
+"""
+            }
+        ),
+    )
+
+
+def test_tuple_update_preserves_expression():
+    """Tuple update: elements whose values haven't changed keep their original
+    expression (e.g. ``2+2`` is not rewritten to ``4``)."""
+    Example(
+        """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (4, 99) == snapshot((2+2, 1+1))
+"""
+    ).run_inline(
+        ["--inline-snapshot=fix"],
+        changed_files=snapshot(
+            {
+                "tests/test_something.py": """\
+from inline_snapshot import snapshot
+
+def test_tuple():
+    assert (4, 99) == snapshot((2+2, 99))
+"""
+            }
+        ),
+    )