100% test coverage (#32)

Author: crusaderky

.github/workflows/pytest.yml

@@ -33,6 +33,7 @@ jobs:
         environment:
           - smoke
           - mindeps
+          - no-optional
           - py39
           - py311
           - py314

pixi.lock

@@ -257,6 +257,7 @@ mindeps = { features = ["mindeps", "smoke", "tests"] }
 py39 = { features = ["py39", "optional", "smoke", "tests"] }
 py311 = { features = ["py311", "optional", "smoke", "tests"] }
 py314 = { features = ["py314", "optional", "smoke", "tests"], solve-group = "py314" }
+no-optional = { features = ["py314", "smoke", "tests"], solve-group = "py314" }
 nogil = { features = ["nogil", "smoke", "tests"], no-default-feature = true }
 upstream = { features = ["upstream", "smoke", "tests"], no-default-feature = true }
 smoke = { features = ["smoke"] }

pyproject.toml

@@ -35,6 +35,10 @@ def is_array_like(dtype: str) -> bool:
     return dtype in {"int", "float", "complex", "bool", "str", "list", "tuple"}
 
 
+def is_basic_noncontainer(x: object) -> bool:
+    return type(x) in {bool, int, float, type(None), str, bytes}
+
+
 def recursive_diff(
     lhs: Any,
     rhs: Any,
@@ -174,10 +178,10 @@ def diff(msg: str, print_path: list[object] = path) -> str:
             yield diff(f"LHS {msg_lhs}; RHS {msg_rhs}")
         return
 
-    # Don't add internalized objects
-    if not isinstance(lhs, (bool, int, float, type(None), str, bytes)):
+    # Don't add potentially internalized objects
+    if not is_basic_noncontainer(lhs):
         seen_lhs = [*seen_lhs, id(lhs)]
-    if not isinstance(rhs, (bool, int, float, type(None), str, bytes)):
+    if not is_basic_noncontainer(rhs):
         seen_rhs = [*seen_rhs, id(rhs)]
     # End of recursion detection
 
@@ -410,10 +414,13 @@ def diff(msg: str, print_path: list[object] = path) -> str:
                 # e.g. bool or str
                 diffs = lhs.values != rhs.values
 
+                # NumPy <1.26:
                 # Comparison between two non-scalar, incomparable types
-                # (like strings and numbers) will return True
+                # (like strings and numbers) returns True
+                # FutureWarning: elementwise comparison failed; returning scalar
+                # instead, but in the future will perform elementwise comparison
                 if diffs is True:
-                    diffs = np.full(lhs.shape, dtype=bool, fill_value=True)
+                    diffs = np.ones(lhs.shape, dtype=bool)
 
             if diffs.ndim > 1 and lhs.dims[-1] == "__stacked__":
                 # N>0 original dimensions, some (but not all) of which are in
@@ -549,8 +556,9 @@ def _dtype_str(obj: object) -> str:
     """
     try:
         dtype = type(obj).__name__
-    except AttributeError:
-        # Base types don't have __name__
+    except AttributeError:  # pragma: nocover
+        # FIXME This used to be triggered in Python 2. Is it still possible to get here?
+        # Maybe some poorly written C extensions?
         dtype = str(type(obj))
 
     if isinstance(obj, np.integer):

recursive_diff/recursive_diff.py

@@ -3,6 +3,7 @@
 import importlib
 
 import numpy as np
+import pandas as pd
 import pytest
 from packaging.version import Version
 
@@ -39,11 +40,12 @@ def _import_or_skip(modname: str) -> tuple:
 has_netcdf = has_h5netcdf or has_netcdf4 or has_scipy
 requires_netcdf = pytest.mark.skipif(not has_netcdf, reason="No NetCDF engine found")
 
-NP_GE_126 = Version(np.__version__) >= Version("1.26")
+NUMPY_GE_126 = Version(np.__version__) >= Version("1.26")
+PANDAS_GE_200 = Version(pd.__version__) >= Version("2.0")
 
 
 def filter_old_numpy_warnings(testfunc):
-    if NP_GE_126:
+    if NUMPY_GE_126:
         return testfunc
     return pytest.mark.filterwarnings(
         "ignore:elementwise comparison failed:DeprecationWarning",

recursive_diff/tests/__init__.py

@@ -5,23 +5,21 @@
 import pandas as pd
 import pytest
 import xarray
-from packaging.version import Version
 
 from recursive_diff import cast, recursive_diff
-from recursive_diff.tests import filter_old_numpy_warnings, requires_dask
-
-PANDAS_GE_200 = Version(pd.__version__).release >= (2, 0)
+from recursive_diff.tests import PANDAS_GE_200, filter_old_numpy_warnings, requires_dask
 
 
 class Rectangle:
-    """Sample class to test custom comparisons"""
+    """Sample class to test custom comparisons."""
 
     def __init__(self, w, h):
         self.w = w
         self.h = h
 
     def __eq__(self, other):
-        return self.w == other.w and self.h == other.h
+        # Never invoked thanks to @cast.register
+        raise AssertionError("__eq__ should not be called")  # pragma: nocover
 
     def __repr__(self):
         return f"Rectangle({self.w}, {self.h})"
@@ -37,7 +35,8 @@ def __init__(self, w, h):
         self.h = h
 
     def __eq__(self, other):
-        return self.w == other.w and self.h == other.h
+        # Never invoked thanks to @cast.register
+        raise AssertionError("__eq__ should not be called")  # pragma: nocover
 
 
 @cast.register(Rectangle)
@@ -309,6 +308,14 @@ def test_numpy():
         "[data][0, 1]: 2 != 4 (abs: 2.0e+00, rel: 1.0e+00)",
     )
 
+    # list vs. numpy
+    check(
+        [[1, 4, 3], [4, 5, 6]],
+        np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64),
+        "object type differs: list != ndarray<int64>",
+        "[data][0, 1]: 4 != 2 (abs: -2.0e+00, rel: -5.0e-01)",
+    )
+
     # numpy vs. other object
     check(
         np.array([0, 0], dtype=np.int64),
@@ -487,6 +494,14 @@ def test_pandas_rangeindex():
         f"object type differs: RangeIndex != {int_index}",
     )
 
+    # Regular index vs RangeIndex
+    check(
+        pd.Index([0, 1, 2]),
+        pd.RangeIndex(4),
+        "3 is in RHS only",
+        f"object type differs: {int_index} != RangeIndex",
+    )
+
 
 def test_pandas_multiindex():
     lhs = pd.MultiIndex.from_tuples(