Python `set`s inside `dataclasses` are not matched accordingly

[Genfood]

Describe the bug

When asserting a set of strings nested inside a dataclass against the snapshot, the test may fail, due to the unsorted nature of sets. This is not the case for integer set or sets that are not nested inside a dataclass.

To reproduce

@dataclass
class Test:
    my_str_set: set[str]

    def __eq__(self, value: object) -> bool:
        self.my_str_set == value.my_str_set

    # my_int_set: set[int]


def test_set(snapshot: SnapshotAssertion) -> None:
    assert snapshot == Test({"1", " 2", "3", "4", "5", "6", "7"})
    # assert snapshot == Test({1, 2, 3, 4, 5, 6, 7})
    # assert snapshot == {"1", " 2", "3", "4", "5", "6", "7"}

Expected behavior

The snapshot test should work out of the box, with nested sets.

Environment (please complete the following information):

• OS: Windows 11
• Syrupy Version: 4.9.1
• Python Version: 3.10.19

[Genfood]

As I understand for dataclasses the __repr__ method is used to serialize objects. Nevertheless, I suggest a feature that allows comparing dataclasses out of the box.

I prototyped a quick add on which isnt properly tested yet, but looks promising:
The file src>syrupy>amber>serializer.py may be edited as following:

@classmethod
    def _serialize(
        cls,
        data: "SerializableData",
        # ... (rest of arguments stay the same)
    ) -> str:
    # ... depth checks and other code
    serialize_method = cls.serialize_unknown
    if isinstance(data, str):
        serialize_method = cls.serialize_string
    elif isinstance(data, (int, float)):
        serialize_method = cls.serialize_number
    elif isinstance(data, (set, frozenset)):
        serialize_method = cls.serialize_set
    elif isinstance(data, (dict, MappingProxyType)):
        serialize_method = cls.serialize_dict
    elif cls.__is_namedtuple(data):
        serialize_method = cls.serialize_namedtuple
    elif isinstance(data, (list, tuple, GeneratorType)):
        serialize_method = cls.serialize_iterable
    elif isinstance(data, FunctionType):
        serialize_method = cls.serialize_function
# --- ADDED check for dataclass
    elif dataclasses.is_dataclass(data) and not isinstance(data, type):
        serialize_method = cls.serialize_dataclass
# ---
    return serialize_method(**serialize_kwargs)



@classmethod
def serialize_dataclass(cls, data: Any, **kwargs: Any) -> str:
    # This is deterministic for the fields themselves.
    fields = dataclasses.fields(data)

    return cls.serialize_custom_iterable(
        data=data,
        resolve_entries=(
            [f.name for f in fields],
            attr_getter,
            None
        ),
        separator="=",
        open_paren="",
        close_paren="",
        **kwargs,
    )

The advantage is that we now have the same behavior for types nested inside a dataclass, as for anything we serialize. As well as a deterministic serialization, to perform snapshot tests against most dataclass objects.

Let me know if you like that idea and if I should prepare a PR.

[noahnu]

A PR is welcome. Note that it's possible to do this as an extension without patching syrupy directly, but first party support for this is a good idea. Note that this would be a breaking change, so I might defer the release a bit to see if there's any other changes we want to batch together for syrupy v6.