Reject sequences nested in a sequence of a different type in approx

ApproxSequenceLike guarded against nesting with isinstance(x, type(expected)),
which only caught an element of the same type as the container. A tuple inside a
list, or a list inside a tuple, passed the guard and was handed to ApproxScalar,
where it was compared exactly instead of approximately. That returned a wrong
bool rather than raising, so [(1.20000000000001,)] == approx([(1.2,)]) was False
while the flat (1.20000000000001,) == approx((1.2,)) was True.

Use _is_sequence_like, the same predicate approx() uses to dispatch to
ApproxSequenceLike, so nesting is rejected consistently. Mappings are excluded
so that a dict nested in a sequence keeps its current behaviour.

Closes #11945

Author: Kayvan-Zahiri

changelog/11945.bugfix.rst

@@ -0,0 +1,4 @@
+:func:`pytest.approx` now rejects a sequence nested inside a sequence of a different type,
+such as a tuple inside a list. Previously only same-type nesting was detected, so these
+values reached the scalar comparison and were compared exactly rather than approximately,
+which silently returned the wrong result instead of raising ``TypeError``.

src/_pytest/approx.py

@@ -358,7 +358,14 @@ def __init__(
         __tracebackhide__ = True
 
         for index, x in enumerate(expected):
-            if isinstance(x, type(expected)):
+            # Use the same predicate the dispatcher uses to recognise a sequence,
+            # so that nesting is rejected consistently. Comparing against
+            # `type(expected)` only caught an element of the *same* type, which let
+            # a tuple inside a list (and a list inside a tuple) through to
+            # ApproxScalar, where it was compared exactly instead of approximately.
+            # Mappings are left alone: they are not sequences, and rejecting them
+            # here would change behaviour beyond this fix.
+            if _is_sequence_like(x) and not isinstance(x, Mapping):
                 msg = "pytest.approx() does not support nested data structures: {!r} at index {}\n  full sequence: {}"
                 raise TypeError(msg.format(x, index, pprint.pformat(expected)))
 

testing/python/approx.py

@@ -924,6 +924,11 @@ def test_foo():
         [
             pytest.param([[1]], "data structures", id="nested-list"),
             pytest.param({"key": {"key": 1}}, "dictionaries", id="nested-dict"),
+            # GH#11945: the guard compared each element against type(expected),
+            # so a sequence nested inside a sequence of a *different* type was
+            # not rejected and ended up being compared exactly.
+            pytest.param([(1,)], "data structures", id="tuple-in-list"),
+            pytest.param(([1],), "data structures", id="list-in-tuple"),
         ],
     )
     def test_expected_value_type_error(self, x, name):
@@ -933,6 +938,20 @@ def test_expected_value_type_error(self, x, name):
         ):
             approx(x)
 
+    @pytest.mark.parametrize(
+        "actual, expected",
+        [
+            pytest.param([(1.2,)], [(1.2,)], id="tuple-in-list"),
+            pytest.param(([1.2],), ([1.2],), id="list-in-tuple"),
+        ],
+    )
+    def test_nested_mixed_sequence_not_silently_compared(self, actual, expected):
+        # GH#11945: these used to return a bool from an exact comparison, so
+        # `[(1.20000000000001,)] == approx([(1.2,)])` was False while the flat
+        # `(1.20000000000001,) == approx((1.2,))` was True.
+        with pytest.raises(TypeError):
+            assert actual == approx(expected)
+
     @pytest.mark.parametrize(
         "x",
         [