using new utils and fixtures in tests/indexes

Author: SaturnFromTitan

pandas/tests/base/test_ops.py

@@ -29,18 +29,11 @@
     TimedeltaIndex,
     Timestamp,
 )
-from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
+from pandas.tests.base.utils import allow_na_ops
 import pandas.util.testing as tm
 
 
 class Ops:
-    def _allow_na_ops(self, obj):
-        """Whether to skip test cases including NaN"""
-        if (isinstance(obj, Index) and obj.is_boolean()) or not obj._can_hold_na:
-            # don't test boolean / integer dtypes
-            return False
-        return True
-
     def setup_method(self, method):
         self.bool_index = tm.makeBoolIndex(10, name="a")
         self.int_index = tm.makeIntIndex(10, name="a")
@@ -83,53 +76,6 @@ def setup_method(self, method):
 
         self.objs = self.indexes + self.series + self.narrow_series
 
-    def check_ops_properties(self, props, filter=None, ignore_failures=False):
-        for op in props:
-            for o in self.is_valid_objs:
-
-                # if a filter, skip if it doesn't match
-                if filter is not None:
-                    filt = o.index if isinstance(o, Series) else o
-                    if not filter(filt):
-                        continue
-
-                try:
-                    if isinstance(o, Series):
-                        expected = Series(getattr(o.index, op), index=o.index, name="a")
-                    else:
-                        expected = getattr(o, op)
-                except (AttributeError):
-                    if ignore_failures:
-                        continue
-
-                result = getattr(o, op)
-
-                # these could be series, arrays or scalars
-                if isinstance(result, Series) and isinstance(expected, Series):
-                    tm.assert_series_equal(result, expected)
-                elif isinstance(result, Index) and isinstance(expected, Index):
-                    tm.assert_index_equal(result, expected)
-                elif isinstance(result, np.ndarray) and isinstance(
-                    expected, np.ndarray
-                ):
-                    tm.assert_numpy_array_equal(result, expected)
-                else:
-                    assert result == expected
-
-            # freq raises AttributeError on an Int64Index because its not
-            # defined we mostly care about Series here anyhow
-            if not ignore_failures:
-                for o in self.not_valid_objs:
-
-                    # an object that is datetimelike will raise a TypeError,
-                    # otherwise an AttributeError
-                    err = AttributeError
-                    if issubclass(type(o), DatetimeIndexOpsMixin):
-                        err = TypeError
-
-                    with pytest.raises(err):
-                        getattr(o, op)
-
 
 @pytest.mark.parametrize("klass", [Series, DataFrame])
 def test_binary_ops_docs(klass):
@@ -314,7 +260,7 @@ def test_value_counts_unique_nunique_null(self, null_obj):
             klass = type(o)
             values = o._ndarray_values
 
-            if not self._allow_na_ops(o):
+            if not allow_na_ops(o):
                 continue
 
             # special assign to the numpy array
@@ -796,7 +742,7 @@ def test_fillna(self):
                 o = orig.copy()
                 klass = type(o)
 
-                if not self._allow_na_ops(o):
+                if not allow_na_ops(o):
                     continue
 
                 if needs_i8_conversion(o):

pandas/tests/base/utils.py

@@ -1,10 +1,8 @@
-from typing import Any, Callable, List, Type
+from typing import Any
 
 import numpy as np
-import pytest
 
 from pandas import Index, Series
-from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
 import pandas.util.testing as tm
 
 
@@ -14,46 +12,21 @@ def allow_na_ops(obj: Any) -> bool:
     return not is_bool_index and obj._can_hold_na
 
 
-def check_ops_properties_valid(obj: Any, props: List[str], filter: Callable) -> None:
+def check_ops_properties_valid(obj: Any, op: str) -> None:
     """ Validates that certain properties are available """
-    for op in props:
-        # if a filter, skip if it doesn't match
-        index = obj.index if isinstance(obj, Series) else obj
-        if not filter(index):
-            continue
-
-        try:
-            if isinstance(obj, Series):
-                expected = Series(getattr(obj.index, op), index=obj.index, name="a")
-            else:
-                expected = getattr(obj, op)
-        except AttributeError:
-            continue
-
-        result = getattr(obj, op)
-
-        # these could be series, arrays or scalars
-        if isinstance(result, Series) and isinstance(expected, Series):
-            tm.assert_series_equal(result, expected)
-        elif isinstance(result, Index) and isinstance(expected, Index):
-            tm.assert_index_equal(result, expected)
-        elif isinstance(result, np.ndarray) and isinstance(expected, np.ndarray):
-            tm.assert_numpy_array_equal(result, expected)
-        else:
-            assert result == expected
-
-
-def check_ops_properties_invalid(obj: Any, props: List[str]) -> None:
-    """ Validates that certain properties are not available """
-    for op in props:
-        # freq raises AttributeError on an Int64Index because its not
-        # defined we mostly care about Series here anyhow
-
-        # an object that is datetimelike will raise a TypeError,
-        # otherwise an AttributeError
-        err: Type[Exception] = AttributeError
-        if issubclass(type(obj), DatetimeIndexOpsMixin):
-            err = TypeError
-
-        with pytest.raises(err):
-            getattr(obj, op)
+    if isinstance(obj, Series):
+        expected = Series(getattr(obj.index, op), index=obj.index, name="a")
+    else:
+        expected = getattr(obj, op)
+
+    result = getattr(obj, op)
+
+    # these could be series, arrays or scalars
+    if isinstance(result, Series) and isinstance(expected, Series):
+        tm.assert_series_equal(result, expected)
+    elif isinstance(result, Index) and isinstance(expected, Index):
+        tm.assert_index_equal(result, expected)
+    elif isinstance(result, np.ndarray) and isinstance(expected, np.ndarray):
+        tm.assert_numpy_array_equal(result, expected)
+    else:
+        assert result == expected

pandas/tests/indexes/datetimes/test_ops.py

@@ -12,14 +12,12 @@
     Index,
     PeriodIndex,
     Series,
+    TimedeltaIndex,
     Timestamp,
     bdate_range,
     date_range,
 )
-from pandas.tests.base.utils import (
-    check_ops_properties_invalid,
-    check_ops_properties_valid,
-)
+from pandas.tests.base.utils import check_ops_properties_valid
 import pandas.util.testing as tm
 
 from pandas.tseries.offsets import BDay, BMonthEnd, CDay, Day, Hour
@@ -28,18 +26,22 @@
 
 
 class TestDatetimeIndexOps:
-    def test_ops_properties(self, index_or_series_obj):
+    @pytest.mark.parametrize("op", DatetimeIndex._datetimelike_ops)
+    def test_valid_ops_properties(self, op, index_or_series_obj):
+        obj = index_or_series_obj
+        if isinstance(obj, DatetimeIndex):
+            check_ops_properties_valid(obj, op)
+
+    @pytest.mark.parametrize("op", DatetimeIndex._datetimelike_ops)
+    def test_invalid_ops_properties(self, op, index_or_series_obj):
         obj = index_or_series_obj
-        is_valid = isinstance(obj, (DatetimeIndex, PeriodIndex))
-        if is_valid:
-            filter_ = lambda x: isinstance(x, DatetimeIndex)
-            check_ops_properties_valid(obj, DatetimeIndex._field_ops, filter_)
-            check_ops_properties_valid(obj, DatetimeIndex._object_ops, filter_)
-            check_ops_properties_valid(obj, DatetimeIndex._bool_ops, filter_)
-        else:
-            check_ops_properties_invalid(obj, DatetimeIndex._field_ops)
-            check_ops_properties_invalid(obj, DatetimeIndex._object_ops)
-            check_ops_properties_invalid(obj, DatetimeIndex._bool_ops)
+        if isinstance(obj, (DatetimeIndex, PeriodIndex)):
+            return
+        if op == "freq" and isinstance(obj, TimedeltaIndex):
+            return
+
+        with pytest.raises((AttributeError, TypeError)):
+            getattr(obj, op)
 
     def test_ops_properties_basic(self, datetime_series):
 

pandas/tests/indexes/period/test_ops.py

@@ -2,28 +2,29 @@
 import pytest
 
 import pandas as pd
-from pandas import DatetimeIndex, Index, NaT, PeriodIndex, Series
+from pandas import DatetimeIndex, Index, NaT, PeriodIndex, Series, TimedeltaIndex
 from pandas.core.arrays import PeriodArray
-from pandas.tests.base.utils import (
-    check_ops_properties_invalid,
-    check_ops_properties_valid,
-)
+from pandas.tests.base.utils import check_ops_properties_valid
 import pandas.util.testing as tm
 
 
 class TestPeriodIndexOps:
-    def test_ops_properties(self, index_or_series_obj):
+    @pytest.mark.parametrize("op", PeriodArray._datetimelike_ops)
+    def test_valid_ops_properties(self, op, index_or_series_obj):
         obj = index_or_series_obj
-        is_valid = isinstance(obj, (DatetimeIndex, PeriodIndex))
-        if is_valid:
-            filter_ = lambda x: isinstance(x, PeriodIndex)
-            check_ops_properties_valid(obj, PeriodArray._field_ops, filter_)
-            check_ops_properties_valid(obj, PeriodArray._object_ops, filter_)
-            check_ops_properties_valid(obj, PeriodArray._bool_ops, filter_)
-        else:
-            check_ops_properties_invalid(obj, PeriodArray._field_ops)
-            check_ops_properties_invalid(obj, PeriodArray._object_ops)
-            check_ops_properties_invalid(obj, PeriodArray._bool_ops)
+        if isinstance(obj, PeriodIndex):
+            check_ops_properties_valid(obj, op)
+
+    @pytest.mark.parametrize("op", PeriodArray._datetimelike_ops)
+    def test_invalid_ops_properties(self, op, index_or_series_obj):
+        obj = index_or_series_obj
+        if isinstance(obj, (PeriodIndex, DatetimeIndex)):
+            return
+        if op == "freq" and isinstance(obj, TimedeltaIndex):
+            return
+
+        with pytest.raises((AttributeError, TypeError)):
+            getattr(obj, op)
 
     def test_resolution(self):
         for freq, expected in zip(

pandas/tests/indexes/timedeltas/test_ops.py

@@ -6,21 +6,30 @@
 from pandas.core.dtypes.generic import ABCDateOffset
 
 import pandas as pd
-from pandas import Series, TimedeltaIndex, timedelta_range
+from pandas import DatetimeIndex, PeriodIndex, Series, TimedeltaIndex, timedelta_range
 from pandas.tests.base.utils import check_ops_properties_valid
 import pandas.util.testing as tm
 
 from pandas.tseries.offsets import Day, Hour
 
 
 class TestTimedeltaIndexOps:
-    def test_ops_properties(self, index_or_series_obj):
+    @pytest.mark.parametrize("op", TimedeltaIndex._datetimelike_ops)
+    def test_valid_ops_properties(self, op, index_or_series_obj):
         obj = index_or_series_obj
-        is_valid = isinstance(obj, TimedeltaIndex)
-        if is_valid:
-            filter_ = lambda x: isinstance(x, TimedeltaIndex)
-            check_ops_properties_valid(obj, TimedeltaIndex._field_ops, filter_)
-            check_ops_properties_valid(obj, TimedeltaIndex._object_ops, filter_)
+        if isinstance(obj, TimedeltaIndex):
+            check_ops_properties_valid(obj, op)
+
+    @pytest.mark.parametrize("op", TimedeltaIndex._datetimelike_ops)
+    def test_invalid_ops_properties(self, op, index_or_series_obj):
+        obj = index_or_series_obj
+        if isinstance(obj, TimedeltaIndex):
+            return
+        if op == "freq" and isinstance(obj, (DatetimeIndex, PeriodIndex)):
+            return
+
+        with pytest.raises((AttributeError, TypeError)):
+            getattr(obj, op)
 
     def test_value_counts_unique(self):
         # GH 7735