test: Fix yet more tests to work without polars (pandas, pyarrow) (#2250)

* test: Fix yet more tests to work without polars (pandas, pyarrow)

Split and/or skip tests requiring `polars` when they are unavailable.
Whenever that was a low-hanging fruit, also imports of `pandas`
and `pyarrow` were made optional.

Part of bug #1726

* Cover `tests/expr_and_series/arithmetic_test.py`

* Port remaining `tests/expr_and_series` tests

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Try adding empty `else` branch to `from_dict_test`

* Cover `collect_test`

* Try extend() approach

* Update tests/from_dict_test.py

Co-authored-by: Dan Redding <[email protected]>

* Fix coverage in `tests/translate/from_native_test.py`

* be quiet coverage

https://github.com/narwhals-dev/narwhals/actions/runs/13951644267/job/39052438974?pr=2250

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Dan Redding <[email protected]>

Author: 3 people

tests/expr_and_series/arithmetic_test.py

@@ -3,9 +3,6 @@
 from typing import Any
 
 import hypothesis.strategies as st
-import pandas as pd
-import polars as pl
-import pyarrow as pa
 import pytest
 from hypothesis import assume
 from hypothesis import given
@@ -161,7 +158,10 @@ def test_truediv_same_dims(
 @pytest.mark.slow
 @given(left=st.integers(-100, 100), right=st.integers(-100, 100))
 @pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
-def test_floordiv(left: int, right: int) -> None:
+def test_floordiv_pandas(left: int, right: int) -> None:
+    pytest.importorskip("pandas")
+    import pandas as pd
+
     # hypothesis complains if we add `constructor` as an argument, so this
     # test is a bit manual unfortunately
     assume(right != 0)
@@ -183,10 +183,36 @@ def test_floordiv(left: int, right: int) -> None:
         pd.DataFrame({"a": [left]}).convert_dtypes(), eager_only=True
     ).select(nw.col("a") // right)
     assert_equal_data(result, expected)
+
+
+@pytest.mark.slow
+@given(left=st.integers(-100, 100), right=st.integers(-100, 100))
+@pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
+def test_floordiv_polars(left: int, right: int) -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    # hypothesis complains if we add `constructor` as an argument, so this
+    # test is a bit manual unfortunately
+    assume(right != 0)
+    expected = {"a": [left // right]}
     result = nw.from_native(pl.DataFrame({"a": [left]}), eager_only=True).select(
         nw.col("a") // right
     )
     assert_equal_data(result, expected)
+
+
+@pytest.mark.slow
+@given(left=st.integers(-100, 100), right=st.integers(-100, 100))
+@pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
+def test_floordiv_pyarrow(left: int, right: int) -> None:
+    pytest.importorskip("pyarrow")
+    import pyarrow as pa
+
+    # hypothesis complains if we add `constructor` as an argument, so this
+    # test is a bit manual unfortunately
+    assume(right != 0)
+    expected = {"a": [left // right]}
     result = nw.from_native(pa.table({"a": [left]}), eager_only=True).select(
         nw.col("a") // right
     )
@@ -196,7 +222,10 @@ def test_floordiv(left: int, right: int) -> None:
 @pytest.mark.slow
 @given(left=st.integers(-100, 100), right=st.integers(-100, 100))
 @pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
-def test_mod(left: int, right: int) -> None:
+def test_mod_pandas(left: int, right: int) -> None:
+    pytest.importorskip("pandas")
+    import pandas as pd
+
     # hypothesis complains if we add `constructor` as an argument, so this
     # test is a bit manual unfortunately
     assume(right != 0)
@@ -209,10 +238,36 @@ def test_mod(left: int, right: int) -> None:
         pd.DataFrame({"a": [left]}).convert_dtypes(), eager_only=True
     ).select(nw.col("a") % right)
     assert_equal_data(result, expected)
+
+
+@pytest.mark.slow
+@given(left=st.integers(-100, 100), right=st.integers(-100, 100))
+@pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
+def test_mod_polars(left: int, right: int) -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    # hypothesis complains if we add `constructor` as an argument, so this
+    # test is a bit manual unfortunately
+    assume(right != 0)
+    expected = {"a": [left % right]}
     result = nw.from_native(pl.DataFrame({"a": [left]}), eager_only=True).select(
         nw.col("a") % right
     )
     assert_equal_data(result, expected)
+
+
+@pytest.mark.slow
+@given(left=st.integers(-100, 100), right=st.integers(-100, 100))
+@pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available")
+def test_mod_pyarrow(left: int, right: int) -> None:
+    pytest.importorskip("pyarrow")
+    import pyarrow as pa
+
+    # hypothesis complains if we add `constructor` as an argument, so this
+    # test is a bit manual unfortunately
+    assume(right != 0)
+    expected = {"a": [left % right]}
     result = nw.from_native(pa.table({"a": [left]}), eager_only=True).select(
         nw.col("a") % right
     )

tests/expr_and_series/dt/ordinal_day_test.py

@@ -3,14 +3,15 @@
 from datetime import datetime
 
 import hypothesis.strategies as st
-import pandas as pd
-import polars as pl
 import pytest
 from hypothesis import given
 
 import narwhals.stable.v1 as nw
 from tests.utils import PANDAS_VERSION
 
+pytest.importorskip("pandas")
+import pandas as pd
+
 
 @given(dates=st.datetimes(min_value=datetime(1960, 1, 1), max_value=datetime(1980, 1, 1)))
 @pytest.mark.skipif(
@@ -30,8 +31,21 @@ def test_ordinal_day(dates: datetime) -> None:
         pd.Series([dates]).convert_dtypes(dtype_backend="numpy_nullable"),
         series_only=True,
     ).dt.ordinal_day()[0]
+    assert result_pda == result_pd
+    assert result_pdn == result_pd
+    assert result_pdms == result_pd
+
+
+@given(dates=st.datetimes(min_value=datetime(1960, 1, 1), max_value=datetime(1980, 1, 1)))
+@pytest.mark.skipif(
+    PANDAS_VERSION < (2, 0, 0),
+    reason="pyarrow dtype not available",
+)
+@pytest.mark.slow
+def test_ordinal_day_polars(dates: datetime) -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    result_pd = nw.from_native(pd.Series([dates]), series_only=True).dt.ordinal_day()[0]
     result_pl = nw.from_native(pl.Series([dates]), series_only=True).dt.ordinal_day()[0]
-    assert result_pd == result_pl
-    assert result_pda == result_pl
-    assert result_pdn == result_pl
-    assert result_pdms == result_pl
+    assert result_pl == result_pd

tests/expr_and_series/dt/total_minutes_test.py

@@ -3,14 +3,15 @@
 from datetime import timedelta
 
 import hypothesis.strategies as st
-import pandas as pd
-import polars as pl
 import pytest
 from hypothesis import given
 
 import narwhals.stable.v1 as nw
 from tests.utils import PANDAS_VERSION
 
+pytest.importorskip("pandas")
+import pandas as pd
+
 
 @given(
     timedeltas=st.timedeltas(
@@ -34,10 +35,27 @@ def test_total_minutes(timedeltas: timedelta) -> None:
         pd.Series([timedeltas]).convert_dtypes(dtype_backend="numpy_nullable"),
         series_only=True,
     ).dt.total_minutes()[0]
+    assert result_pda == result_pd
+    assert result_pdn == result_pd
+    assert result_pdns == result_pd
+
+
+@given(
+    timedeltas=st.timedeltas(
+        min_value=-timedelta(days=5, minutes=70, seconds=10),
+        max_value=timedelta(days=3, minutes=90, seconds=60),
+    )
+)
+@pytest.mark.skipif(PANDAS_VERSION < (2, 2, 0), reason="pyarrow dtype not available")
+@pytest.mark.slow
+def test_total_minutes_polars(timedeltas: timedelta) -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    result_pd = nw.from_native(
+        pd.Series([timedeltas]), series_only=True
+    ).dt.total_minutes()[0]
     result_pl = nw.from_native(
         pl.Series([timedeltas]), series_only=True
     ).dt.total_minutes()[0]
-    assert result_pd == result_pl
-    assert result_pda == result_pl
-    assert result_pdn == result_pl
-    assert result_pdns == result_pl
+    assert result_pl == result_pd

tests/expr_and_series/rolling_var_test.py

@@ -5,9 +5,6 @@
 from typing import Any
 
 import hypothesis.strategies as st
-import pandas as pd
-import polars as pl
-import pyarrow as pa
 import pytest
 from hypothesis import given
 
@@ -20,6 +17,9 @@
 if TYPE_CHECKING:
     from narwhals.typing import Frame
 
+pytest.importorskip("pandas")
+import pandas as pd
+
 data = {"a": [1.0, 2.0, 1.0, 3.0, 1.0, 4.0, 1.0]}
 
 kwargs_and_expected = (
@@ -112,6 +112,9 @@ def test_rolling_var_series(
 @pytest.mark.filterwarnings("ignore:.*is_sparse is deprecated:DeprecationWarning")
 @pytest.mark.filterwarnings("ignore:.*:narwhals.exceptions.NarwhalsUnstableWarning")
 def test_rolling_var_hypothesis(center: bool, values: list[float]) -> None:  # noqa: FBT001
+    pytest.importorskip("pyarrow")
+    import pyarrow as pa
+
     s = pd.Series(values)
     window_size = random.randint(2, len(s))  # noqa: S311
     min_samples = random.randint(2, window_size)  # noqa: S311
@@ -134,6 +137,33 @@ def test_rolling_var_hypothesis(center: bool, values: list[float]) -> None:  # n
     expected_dict = nw.from_native(expected, eager_only=True).to_dict(as_series=False)
     assert_equal_data(result, expected_dict)
 
+
+@given(
+    center=st.booleans(),
+    values=st.lists(st.floats(-10, 10), min_size=5, max_size=10),
+)
+@pytest.mark.skipif(PANDAS_VERSION < (1,), reason="too old for pyarrow")
+@pytest.mark.skipif(POLARS_VERSION < (1,), reason="different null behavior")
+@pytest.mark.filterwarnings("ignore:.*is_sparse is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:.*:narwhals.exceptions.NarwhalsUnstableWarning")
+def test_rolling_var_hypothesis_polars(center: bool, values: list[float]) -> None:  # noqa: FBT001
+    pytest.importorskip("polars")
+    import polars as pl
+
+    s = pd.Series(values)
+    window_size = random.randint(2, len(s))  # noqa: S311
+    min_samples = random.randint(2, window_size)  # noqa: S311
+    ddof = random.randint(0, min_samples - 1)  # noqa: S311
+    mask = random.sample(range(len(s)), 2)
+
+    s[mask] = None
+    df = pd.DataFrame({"a": s})
+    expected = (
+        s.rolling(window=window_size, center=center, min_periods=min_samples)
+        .var(ddof=ddof)
+        .to_frame("a")
+    )
+
     result = nw.from_native(pl.from_pandas(df)).select(
         nw.col("a").rolling_var(
             window_size, center=center, min_samples=min_samples, ddof=ddof