fix: hold a repeated hour apart in match.is_now, and read a mapping by its keys under ignore and include

Author: Solganis

assertpy2/_engine/_equality.py

@@ -230,14 +230,17 @@ def _flattened(node: Any, through: frozenset[str], depth: int = 0) -> Any:
             type(node),
             {name: _flattened(value, through, deeper) for name, value in model_field_values(node).items()},
         )
-    if isinstance(node, tuple) and hasattr(node, "_fields"):
-        return type(node)(*[_flattened(item, through, deeper) for item in node])
-    if isinstance(node, (list, tuple)):
-        return type(node)(_flattened(item, through, deeper) for item in node)
-    if isinstance(node, dict):
+    # what a value is, is asked of its class from here on: a value may answer `isinstance` itself
+    held: Any = node
+    kind = type(held)
+    if issubclass(kind, tuple) and hasattr(held, "_fields"):
+        return kind(*[_flattened(item, through, deeper) for item in held])
+    if issubclass(kind, (list, tuple)):
+        return kind(_flattened(item, through, deeper) for item in held)
+    if issubclass(kind, dict):
         # a key stays as held: taken apart, a record used as one could not be hashed
-        rebuilt = {key: _flattened(value, through, deeper) for key, value in node.items()}
-        return rebuilt if type(node) is dict else _as_its_class(node, rebuilt)
+        rebuilt = {key: _flattened(value, through, deeper) for key, value in held.items()}
+        return rebuilt if kind is dict else _as_its_class(held, rebuilt)
     return node
 
 
@@ -293,19 +296,19 @@ def _mend(memo: dict[int, Any]) -> None:
     nothing, so that ends.  A field attrs compares through a key is held raw, and stays so.
     """
     for rebuilt in list(memo.values()):
-        if isinstance(rebuilt, dict):
+        if issubclass(type(rebuilt), dict):
             raw = rebuilt.compared_by if isinstance(rebuilt, TakenApart) else ()
             for key, value in rebuilt.items():
                 if key not in raw:
                     rebuilt[key] = _mended(value, memo)
-        elif isinstance(rebuilt, list):
+        elif issubclass(type(rebuilt), list):
             rebuilt[:] = [_mended(item, memo) for item in rebuilt]
 
 
 def _mended(value: Any, memo: dict[int, Any]) -> Any:
     """*value* as it was rebuilt where it was left as it was, or made again where it is a tuple holding such a one."""
     rebuilt = memo.get(id(value), value)
-    if rebuilt is not value or not isinstance(value, tuple):
+    if rebuilt is not value or not issubclass(type(value), tuple):
         return rebuilt
     items = [_mended(item, memo) for item in value]
     if all(new is old for new, old in zip(items, value, strict=True)):
@@ -343,11 +346,11 @@ def _flattened_once(node: Any, through: frozenset[str], memo: dict[int, Any]) ->
         for name, value in fields.items():
             taken[name] = value if name in taken.compared_by else _flattened_once(value, through, memo)
         return taken
-    if not isinstance(node, (list, tuple, dict)):
+    if not issubclass(type(node), (list, tuple, dict)):
         return node
     # no generator: through one a level was three frames on Python 3.10, 331 levels deep against 496
     rebuilt: Any
-    if isinstance(node, dict):
+    if issubclass(type(node), dict):
         rebuilt = memo[id(node)] = {} if type(node) is dict else _of_its_class(node)
         put = _put_into(rebuilt)
         for key, value in node.items():
@@ -400,19 +403,30 @@ def _read_through(obj: object) -> frozenset[str] | None:
     return None
 
 
-def as_fields(value: object, beside: object = None) -> dict | None:
-    """A plain dict as itself, anything else through `comparable_fields`.
+def as_fields(value: object, beside: object = None) -> Any:
+    """A dict or another mapping by its keys, anything else through `comparable_fields`.
 
     A dict *beside* a record taken apart all the way down is taken apart as deep.  Left as held, a record the
     dict holds was compared whole against the fields of the equal one the record holds, and the two differed.
+    A dict that is a record as well stays as held: taken apart it was read by its fields, and a key it held
+    beside them was gone.
+
+    What is a dict is asked of the class, since a value may answer `isinstance` itself.  A mapping that is no
+    dict and no record is its keys too: refused, a `MappingProxyType` beside a record was called not dict-like,
+    and a `ChainMap` was read through the attribute it keeps its maps in.
     """
-    if not isinstance(value, dict):
-        return comparable_fields(value)
-    through = None if isinstance(beside, dict) else _read_through(beside)
-    return value if through is None else cast("dict", _fields_through(value, through))
+    if not issubclass(type(value), dict):
+        own = _read_through(value)
+        if own is not None:
+            return _fields_through(value, own)
+        return value if mapping_shaped(value, check_values=False) else comparable_fields(value)
+    through = None if issubclass(type(beside), dict) else _read_through(beside)
+    if through is None or _read_through(value) is not None:
+        return value
+    return _fields_through(value, through)
 
 
-def fields_pair(value: object, other: object) -> tuple[dict | None, dict | None]:
+def fields_pair(value: object, other: object) -> tuple[Any, Any]:
     """Two values through their fields, each read beside the other (`as_fields`)."""
     return as_fields(value, other), as_fields(other, value)
 
@@ -817,7 +831,7 @@ def _nested_differs(
 
 def _keyed(value: object, beside: object) -> Any:
     """A mapping as what a key path reads it through, its keys, and anything else through its fields."""
-    if mapping_shaped(value, check_values=False) and not isinstance(value, dict):
+    if mapping_shaped(value, check_values=False) and not issubclass(type(value), dict):
         return value
     return as_fields(value, beside)
 

assertpy2/_engine/_introspection.py

@@ -316,7 +316,8 @@ def is_mapping_like(obj: object) -> TypeGuard[MappingLike]:
         return True
     if type(obj) in _ATOMIC_TYPES:
         return False
-    return isinstance(obj, MappingLike) and callable(obj.keys)
+    # read with a default: a value may say it is a dict through `__class__` and have no `keys` at all
+    return isinstance(obj, MappingLike) and callable(getattr(obj, "keys", None))
 
 
 def keyed_snapshot(candidate: object) -> MappingLike | None:

assertpy2/_matcher_impls.py

@@ -5,7 +5,7 @@
 import sys
 import uuid as _uuid_mod
 from dataclasses import dataclass
-from datetime import date, datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
 from fractions import Fraction
 from types import UnionType
@@ -1359,8 +1359,9 @@ def __init__(self, delta: timedelta):
     def matches(self, value: Any) -> bool:
         if not isinstance(value, datetime):
             return False
-        # `datetime.now(tzinfo)` matches the value's awareness, so the subtraction never mixes naive and aware
-        return abs(value - datetime.now(value.tzinfo)) <= self._delta
+        # as moments: on one zone object the two readings of a repeated hour subtract to nothing, an hour apart
+        now = datetime.now(timezone.utc) if value.utcoffset() is not None else datetime.now()
+        return abs(value - now) <= self._delta
 
     def describe(self) -> str:
         return f"a datetime within {self._delta} of now"

tests/test_dict_compare.py

@@ -1,6 +1,7 @@
 import collections
 import dataclasses
 import sys
+import types
 import typing
 
 import pytest
@@ -900,6 +901,122 @@ def test_a_record_under_two_dicts_is_read_by_its_fields_only_where_a_path_enters
             assert_that(actual).is_equal_to(expected, ignore="v")
         assert_that(actual).is_equal_to(expected, ignore=["v", ("next", "missing")])
 
+    def test_the_diff_of_a_failed_sequence_goes_as_deep_on_the_dict_side(self):
+        actual, expected = [{"v": 0, "next": _Holder(1)}], [_Holder(0, _Holder(2))]
+        with pytest.raises(AssertionFailure) as caught:
+            assert_that(actual).is_equal_to(expected, ignore="missing")
+        assert_that([entry.path for entry in caught.value.diff.entries]).is_equal_to(["[0].next.v"])
+
+    def test_a_dict_that_is_a_record_as_well_keeps_its_keys(self):
+        @dataclasses.dataclass
+        class Keyed(dict):
+            v: int
+
+        @dataclasses.dataclass
+        class Record:
+            v: int
+
+        held = Keyed(1)
+        held["extra"] = 2
+        for value, other in ((held, Record(1)), (Record(1), held)):
+            with pytest.raises(AssertionFailure):
+                assert_that(value).is_equal_to(other, ignore="missing")
+        assert_that(held).is_equal_to({"extra": 2}, ignore="missing")
+        assert_that(_equality.as_fields(held, Record(1))).is_same_as(held)
+
+    def test_what_is_a_dict_is_asked_of_the_class_and_not_of_the_value(self):
+        class SaysDict:
+            __class__ = property(lambda self: dict)
+
+            def __init__(self):
+                self.v = 0
+                self.next = None
+
+        says = SaysDict()
+        assert_that(isinstance(says, dict)).is_true()
+        assert_that(_equality.as_fields(says)).is_not_same_as(says)
+        assert_that(_equality.as_fields({"v": 0}, says)).is_equal_to({"v": 0})
+        assert_that(says).is_equal_to(_Holder(0), ignore="missing")
+        assert_that(_Holder(0)).is_equal_to(says, ignore="missing")
+        assert_that({"o": says}).is_equal_to({"o": _Holder(9)}, ignore=("o", "v"))
+
+    @pytest.mark.parametrize("kind", [dict, list, tuple])
+    def test_a_value_that_says_what_it_is_not_is_left_whole_where_it_is_held(self, kind):
+        says = type("Says", (), {"__class__": property(lambda self: kind), "_fields": ()})()
+        assert_that(isinstance(says, kind)).is_true()
+        a_list_that_says = type("AListThatSays", (list,), {"__class__": property(lambda self: kind)})([1])
+        a_tuple_that_says = type("ATupleThatSays", (tuple,), {"__class__": property(lambda self: kind)})((1,))
+        ring = {"v": 0, "next": says, "more": a_list_that_says, "and": a_tuple_that_says}
+        ring["me"] = ring
+        for payload in ({"v": 0, "next": says}, {"v": 0, "next": [says]}, _Holder(0, says), ring):
+            with pytest.raises(AssertionFailure):
+                assert_that(payload).is_equal_to(_Holder(0, _Holder(1)), ignore="missing")
+
+    def test_a_dict_that_is_a_record_is_read_where_it_is_held_as_its_own_equality_reads_it(self):
+        @dataclasses.dataclass
+        class Keyed(dict):
+            v: int
+
+        @dataclasses.dataclass
+        class Plain:
+            v: int
+
+        held = Keyed(1)
+        held["extra"] = 2
+        assert_that(held == Keyed(1)).is_true()
+        # by its fields, which is how a record holding it was always read: its own `==` does not read its keys
+        assert_that(_Holder(0, held)).is_equal_to(_Holder(0, Plain(1)), ignore="missing")
+        assert_that({"v": 0, "next": held}).is_equal_to(_Holder(0, Plain(1)), ignore="missing")
+
+    @pytest.mark.parametrize(
+        "mapping",
+        [types.MappingProxyType, lambda held: collections.ChainMap(held)],
+        ids=["a mapping proxy", "a chain map"],
+    )
+    def test_a_mapping_that_is_no_dict_is_read_by_its_keys_beside_a_record(self, mapping):
+        record = _Holder(0, None)
+        assert_that(mapping({"v": 0, "next": None})).is_equal_to(record, ignore="missing")
+        assert_that(record).is_equal_to(mapping({"v": 0, "next": None}), ignore="missing")
+        assert_that(record).is_equal_to(mapping({"v": 9, "next": None}), ignore="v")
+        for value, other in ((mapping({"v": 1, "next": None}), record), (record, mapping({"v": 1, "next": None}))):
+            with pytest.raises(AssertionFailure) as caught:
+                assert_that(value).is_equal_to(other, ignore="missing")
+            assert_that([entry.path for entry in caught.value.diff.entries]).is_equal_to(["v"])
+        with pytest.raises(AssertionFailure):
+            assert_that(mapping({"v": 0, "next": None, "more": 1})).is_equal_to(record, ignore="missing")
+
+    def test_a_record_that_answers_as_a_mapping_is_still_read_by_its_fields(self):
+        @dataclasses.dataclass
+        class Row:
+            v: int
+            next: object = None
+
+            def keys(self):
+                return ["column"]
+
+            def __getitem__(self, key):
+                return "cell"
+
+            def __iter__(self):
+                return iter(self.keys())
+
+        assert_that(Row(0)).is_equal_to(_Holder(0), ignore="missing")
+        assert_that(_Holder(0)).is_equal_to(Row(0), ignore="missing")
+        with pytest.raises(AssertionFailure):
+            assert_that(Row(1)).is_equal_to(_Holder(0), ignore="missing")
+
+    def test_a_dict_beside_a_model_is_read_through_the_dataclasses_a_model_is_read_through(self):
+        pydantic = pytest.importorskip("pydantic")
+
+        class Shape(pydantic.BaseModel):
+            at: _Holder
+            name: str = "s"
+
+        shape, payload = Shape(at=_Holder(1)), {"at": {"v": 1, "next": None}, "name": "s"}
+        assert_that(payload).is_equal_to(shape, ignore="missing")
+        assert_that(shape).is_equal_to(payload, ignore="missing")
+        assert_that({"at": _Holder(1), "name": "s"}).is_equal_to(shape, ignore="missing")
+
     def test_the_matcher_answers_as_the_builder_does(self):
         record, payload = _Holder(0, _Holder(1)), {"v": 0, "next": _Holder(1)}
         assert_that(match.equal_to(payload, ignore="v").matches(record)).is_true()

tests/test_matchers.py

@@ -1,12 +1,12 @@
 import io
 import re
 import typing
-from datetime import date, datetime, timedelta, timezone
+from datetime import date, datetime, timedelta, timezone, tzinfo
 from math import inf, nan
 
 import pytest
 
-from assertpy2 import AssertionFailure, Matcher, assert_that, match
+from assertpy2 import AssertionFailure, Matcher, _matcher_impls, assert_that, match
 from assertpy2.matchers import AllOfMatcher, AnyOfMatcher, BaseMatcher, EachMatcher, HasPropertyMatcher, NotMatcher
 
 
@@ -33,6 +33,55 @@ def test_is_now_refuses_what_is_no_span_as_it_did(self):
         with pytest.raises(TypeError, match="unsupported type for timedelta seconds component"):
             match.is_now("soon")
 
+    def test_is_now_holds_the_two_readings_of_a_repeated_hour_an_hour_apart(self, monkeypatch):
+        class FallsBack(tzinfo):
+            """Two hours east until its clocks read 03:00 on 1 November 2026, then 02:00 again and one hour east."""
+
+            def utcoffset(self, moment):
+                wall = moment.replace(tzinfo=None)
+                early = wall < datetime(2026, 11, 1, 2) or (wall < datetime(2026, 11, 1, 3) and not moment.fold)
+                return timedelta(hours=2 if early else 1)
+
+            def tzname(self, moment):
+                return "falls back"
+
+            def dst(self, moment):
+                return None
+
+        real = datetime
+        second = datetime(2026, 11, 1, 2, 30, tzinfo=FallsBack(), fold=1)
+
+        class EveryDatetimeIsOne(type):
+            def __instancecheck__(cls, instance):
+                return isinstance(instance, real)
+
+        class Pinned(datetime, metaclass=EveryDatetimeIsOne):
+            @classmethod
+            def now(cls, tz=None):
+                return second.astimezone(tz)
+
+        monkeypatch.setattr(_matcher_impls, "datetime", Pinned)
+        first = second.replace(fold=0)
+        assert_that(first == second).is_true()
+        assert_that(first.utcoffset() - second.utcoffset()).is_equal_to(timedelta(hours=1))
+        assert_that(match.is_now(0).matches(second)).is_true()
+        assert_that(match.is_now(0).matches(first)).is_false()
+        assert_that(match.is_now(timedelta(minutes=59)).matches(first)).is_false()
+        assert_that(match.is_now(timedelta(hours=1)).matches(first)).is_true()
+
+    def test_is_now_reads_a_zone_that_gives_no_offset_as_no_zone(self):
+        class GivesNoOffset(tzinfo):
+            def utcoffset(self, moment):
+                return None
+
+            def tzname(self, moment):
+                return None
+
+            def dst(self, moment):
+                return None
+
+        assert_that(match.is_now(5).matches(datetime.now().replace(tzinfo=GivesNoOffset()))).is_true()
+
     def test_is_now_takes_a_delta_of_nothing(self):
         assert_that(match.is_now(0).describe()).is_equal_to("a datetime within 0:00:00 of now")
         assert_that(match.is_now(timedelta()).matches(datetime.now() - timedelta(seconds=1))).is_false()