fix(python): Ensure assert_frame_not_equal and `assert_series_not_e…

…qual` raise on mismatched input types (pola-rs#18402)

py-polars/polars/testing/asserts/frame.py

@@ -257,6 +257,7 @@ def assert_frame_not_equal(
     """
     __tracebackhide__ = True
 
+    _assert_correct_input_type(left, right)
     try:
         assert_frame_equal(
             left=left,
@@ -272,5 +273,5 @@ def assert_frame_not_equal(
     except AssertionError:
         return
     else:
-        msg = "frames are equal"
+        msg = "frames are equal (but are expected not to be)"
         raise AssertionError(msg)

py-polars/polars/testing/asserts/series.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from polars._utils.deprecation import deprecate_renamed_parameter
 from polars.datatypes import (
@@ -20,6 +20,19 @@
     from polars import DataType
 
 
+def _assert_correct_input_type(left: Any, right: Any) -> bool:
+    __tracebackhide__ = True
+
+    if not (isinstance(left, Series) and isinstance(right, Series)):
+        raise_assertion_error(
+            "inputs",
+            "unexpected input types",
+            type(left).__name__,
+            type(right).__name__,
+        )
+    return True
+
+
 @deprecate_renamed_parameter("check_dtype", "check_dtypes", version="0.20.31")
 def assert_series_equal(
     left: Series,
@@ -90,13 +103,7 @@ def assert_series_equal(
     """
     __tracebackhide__ = True
 
-    if not (isinstance(left, Series) and isinstance(right, Series)):  # type: ignore[redundant-expr]
-        raise_assertion_error(
-            "inputs",
-            "unexpected input types",
-            type(left).__name__,
-            type(right).__name__,
-        )
+    _assert_correct_input_type(left, right)
 
     if left.len() != right.len():
         raise_assertion_error("Series", "length mismatch", left.len(), right.len())
@@ -404,6 +411,7 @@ def assert_series_not_equal(
     """
     __tracebackhide__ = True
 
+    _assert_correct_input_type(left, right)
     try:
         assert_series_equal(
             left=left,
@@ -419,5 +427,5 @@ def assert_series_not_equal(
     except AssertionError:
         return
     else:
-        msg = "Series are equal"
+        msg = "Series are equal (but are expected not to be)"
         raise AssertionError(msg)

py-polars/tests/unit/testing/test_assert_frame_equal.py

@@ -278,13 +278,17 @@ def test_assert_frame_equal_pass() -> None:
     assert_frame_equal(df1, df2)
 
 
-def test_assert_frame_equal_types() -> None:
+@pytest.mark.parametrize(
+    "assert_function",
+    [assert_frame_equal, assert_frame_not_equal],
+)
+def test_assert_frame_equal_types(assert_function: Any) -> None:
     df1 = pl.DataFrame({"a": [1, 2]})
     srs1 = pl.Series(values=[1, 2], name="a")
     with pytest.raises(
         AssertionError, match=r"inputs are different \(unexpected input types\)"
     ):
-        assert_frame_equal(df1, srs1)  # type: ignore[arg-type]
+        assert_function(df1, srs1)
 
 
 def test_assert_frame_equal_length_mismatch() -> None:
@@ -295,6 +299,7 @@ def test_assert_frame_equal_length_mismatch() -> None:
         match=r"DataFrames are different \(number of rows does not match\)",
     ):
         assert_frame_equal(df1, df2)
+    assert_frame_not_equal(df1, df2)
 
 
 def test_assert_frame_equal_column_mismatch() -> None:
@@ -304,6 +309,7 @@ def test_assert_frame_equal_column_mismatch() -> None:
         AssertionError, match="columns \\['a'\\] in left DataFrame, but not in right"
     ):
         assert_frame_equal(df1, df2)
+    assert_frame_not_equal(df1, df2)
 
 
 def test_assert_frame_equal_column_mismatch2() -> None:
@@ -314,6 +320,7 @@ def test_assert_frame_equal_column_mismatch2() -> None:
         match="columns \\['b', 'c'\\] in right LazyFrame, but not in left",
     ):
         assert_frame_equal(df1, df2)
+    assert_frame_not_equal(df1, df2)
 
 
 def test_assert_frame_equal_column_mismatch_order() -> None:
@@ -323,6 +330,7 @@ def test_assert_frame_equal_column_mismatch_order() -> None:
         assert_frame_equal(df1, df2)
 
     assert_frame_equal(df1, df2, check_column_order=False)
+    assert_frame_not_equal(df1, df2)
 
 
 def test_assert_frame_equal_check_row_order() -> None:
@@ -331,25 +339,33 @@ def test_assert_frame_equal_check_row_order() -> None:
 
     with pytest.raises(AssertionError, match="value mismatch for column 'a'"):
         assert_frame_equal(df1, df2)
+
     assert_frame_equal(df1, df2, check_row_order=False)
+    assert_frame_not_equal(df1, df2)
 
 
 def test_assert_frame_equal_check_row_col_order() -> None:
     df1 = pl.DataFrame({"a": [1, 2], "b": [4, 3]})
-    df3 = pl.DataFrame({"b": [3, 4], "a": [2, 1]})
+    df2 = pl.DataFrame({"b": [3, 4], "a": [2, 1]})
 
     with pytest.raises(AssertionError, match="columns are not in the same order"):
-        assert_frame_equal(df1, df3, check_row_order=False)
-    assert_frame_equal(df1, df3, check_row_order=False, check_column_order=False)
+        assert_frame_equal(df1, df2, check_row_order=False)
+
+    assert_frame_equal(df1, df2, check_row_order=False, check_column_order=False)
+    assert_frame_not_equal(df1, df2)
 
 
-def test_assert_frame_equal_check_row_order_unsortable() -> None:
+@pytest.mark.parametrize(
+    "assert_function",
+    [assert_frame_equal, assert_frame_not_equal],
+)
+def test_assert_frame_equal_check_row_order_unsortable(assert_function: Any) -> None:
     df1 = pl.DataFrame({"a": [object(), object()], "b": [3, 4]})
     df2 = pl.DataFrame({"a": [object(), object()], "b": [4, 3]})
     with pytest.raises(
         TypeError, match="cannot set `check_row_order=False`.*unsortable columns"
     ):
-        assert_frame_equal(df1, df2, check_row_order=False)
+        assert_function(df1, df2, check_row_order=False)
 
 
 def test_assert_frame_equal_dtypes_mismatch() -> None:
@@ -360,6 +376,9 @@ def test_assert_frame_equal_dtypes_mismatch() -> None:
     with pytest.raises(AssertionError, match="dtypes do not match"):
         assert_frame_equal(df1, df2, check_column_order=False)
 
+    assert_frame_not_equal(df1, df2, check_column_order=False)
+    assert_frame_not_equal(df1, df2)
+
 
 def test_assert_frame_not_equal() -> None:
     df = pl.DataFrame({"a": [1, 2]})