CLN: Refactor pandas/tests/base - part3

pandas/conftest.py

@@ -841,6 +841,16 @@ def tick_classes(request):
     )
 
 
+@pytest.fixture
+def datetime_series():
+    """
+    Fixture for Series of floats with DatetimeIndex
+    """
+    s = tm.makeTimeSeries()
+    s.name = "ts"
+    return s
+
+
 @pytest.fixture
 def float_frame():
     """

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,74 +76,29 @@ 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(self, klass):
-        op_map = {
-            "add": "+",
-            "sub": "-",
-            "mul": "*",
-            "mod": "%",
-            "pow": "**",
-            "truediv": "/",
-            "floordiv": "//",
-        }
-        for op_name in op_map:
-            operand1 = klass.__name__.lower()
-            operand2 = "other"
-            op = op_map[op_name]
-            expected_str = " ".join([operand1, op, operand2])
-            assert expected_str in getattr(klass, op_name).__doc__
-
-            # reverse version of the binary ops
-            expected_str = " ".join([operand2, op, operand1])
-            assert expected_str in getattr(klass, "r" + op_name).__doc__
+
+@pytest.mark.parametrize("klass", [Series, DataFrame])
+@pytest.mark.parametrize(
+    "op_name, op",
+    [
+        ("add", "+"),
+        ("sub", "-"),
+        ("mul", "*"),
+        ("mod", "%"),
+        ("pow", "**"),
+        ("truediv", "/"),
+        ("floordiv", "//"),
+    ],
+)
+def test_binary_ops_docs(klass, op_name, op):
+    operand1 = klass.__name__.lower()
+    operand2 = "other"
+    expected_str = " ".join([operand1, op, operand2])
+    assert expected_str in getattr(klass, op_name).__doc__
+
+    # reverse version of the binary ops
+    expected_str = " ".join([operand2, op, operand1])
+    assert expected_str in getattr(klass, "r" + op_name).__doc__
 
 
 class TestTranspose(Ops):
@@ -313,7 +261,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
@@ -795,7 +743,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

@@ -0,0 +1,32 @@
+from typing import Any
+
+import numpy as np
+
+from pandas import Index, Series
+import pandas.util.testing as tm
+
+
+def allow_na_ops(obj: Any) -> bool:
+    """Whether to skip test cases including NaN"""
+    is_bool_index = isinstance(obj, Index) and obj.is_boolean()
+    return not is_bool_index and obj._can_hold_na
+
+
+def check_ops_properties_valid(obj: Any, op: str) -> None:
+    """ Validates that certain properties are available """
+    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/common.py

@@ -287,10 +287,12 @@ def test_ensure_copied_data(self, indices):
         if isinstance(indices, PeriodIndex):
             # Needs "freq" specification:
             init_kwargs["freq"] = indices.freq
+        elif isinstance(indices, DatetimeIndex) and indices.tz is not None:
+            pytest.skip()
         elif isinstance(indices, (RangeIndex, MultiIndex, CategoricalIndex)):
             # RangeIndex cannot be initialized from data
             # MultiIndex and CategoricalIndex are tested separately
-            return
+            pytest.skip()
 
         index_type = type(indices)
         result = index_type(indices.values, copy=True, **init_kwargs)
@@ -450,7 +452,10 @@ def test_set_ops_error_cases(self, case, method, indices):
 
     def test_intersection_base(self, indices):
         if isinstance(indices, CategoricalIndex):
-            return
+            pytest.skip()
+        if isinstance(indices, DatetimeIndex) and indices.tz is not None:
+            # TODO: This should probably be fixed
+            pytest.skip()
 
         first = indices[:5]
         second = indices[:3]
@@ -469,6 +474,10 @@ def test_intersection_base(self, indices):
                 first.intersection([1, 2, 3])
 
     def test_union_base(self, indices):
+        if isinstance(indices, DatetimeIndex) and indices.tz is not None:
+            # TODO: This should probably be fixed
+            pytest.skip()
+
         first = indices[3:]
         second = indices[:5]
         everything = indices

pandas/tests/indexes/conftest.py

@@ -9,13 +9,14 @@
     "unicode": tm.makeUnicodeIndex(100),
     "string": tm.makeStringIndex(100),
     "datetime": tm.makeDateIndex(100),
+    "localized-datetime": tm.makeDateIndex(100, tz="US/Eastern"),
     "period": tm.makePeriodIndex(100),
     "timedelta": tm.makeTimedeltaIndex(100),
     "int": tm.makeIntIndex(100),
     "uint": tm.makeUIntIndex(100),
     "range": tm.makeRangeIndex(100),
     "float": tm.makeFloatIndex(100),
-    "bool": Index([True, False]),
+    "bool": tm.makeBoolIndex(2),
     "categorical": tm.makeCategoricalIndex(100),
     "interval": tm.makeIntervalIndex(100),
     "empty": Index([]),
@@ -50,3 +51,51 @@ def zero(request):
     # For testing division by (or of) zero for Index with length 5, this
     # gives several scalar-zeros and length-5 vector-zeros
     return request.param
+
+
+def _create_series(index):
+    """ Helper for the _series dict """
+    data = np.random.randn(len(index))
+    return pd.Series(data, index=index, name=index.name)
+
+
+_series = {
+    f"series-with-{i_id}-index": _create_series(i) for i_id, i in indices_dict.items()
+}
+
+
+def _create_narrow_series(data_dtype):
+    """ Helper for the _narrow_series dict """
+    index = indices_dict["int"].copy()
+    size = len(index)
+    if np.issubdtype(data_dtype, np.float):
+        data = np.random.choice(size, size=size, replace=False)
+    elif np.issubdtype(data_dtype, np.integer):
+        data = np.random.randn(size)
+    else:
+        raise ValueError(f"Received an unexpected data_dtype: {data_dtype}")
+
+    return pd.Series(data.astype(data_dtype), index=index, name="a")
+
+
+_narrow_series = {
+    "float32-series": _create_narrow_series(np.float32),
+    "int8-series": _create_narrow_series(np.int8),
+    "int16-series": _create_narrow_series(np.int16),
+    "int32-series": _create_narrow_series(np.int32),
+    "uint8-series": _create_narrow_series(np.uint8),
+    "uint16-series": _create_narrow_series(np.uint16),
+    "uint32-series": _create_narrow_series(np.uint32),
+}
+
+_all_objs = {**indices_dict, **_series, **_narrow_series}
+
+
+@pytest.fixture(params=_all_objs.keys())
+def index_or_series_obj(request):
+    """
+    Fixture for tests on indexes, series and series with a narrow dtype
+
+    copy to avoid mutation, e.g. setting .name
+    """
+    return _all_objs[request.param].copy(deep=True)

pandas/tests/indexes/datetimes/test_ops.py

@@ -12,39 +12,45 @@
     Index,
     PeriodIndex,
     Series,
+    TimedeltaIndex,
     Timestamp,
     bdate_range,
     date_range,
 )
-from pandas.tests.base.test_ops import Ops
+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
 
 START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
 
 
-class TestDatetimeIndexOps(Ops):
-    def setup_method(self, method):
-        super().setup_method(method)
-        mask = lambda x: (isinstance(x, DatetimeIndex) or isinstance(x, PeriodIndex))
-        self.is_valid_objs = [o for o in self.objs if mask(o)]
-        self.not_valid_objs = [o for o in self.objs if not mask(o)]
+class TestDatetimeIndexOps:
+    @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
+        if isinstance(obj, (DatetimeIndex, PeriodIndex)):
+            pytest.skip()
+        if op == "freq" and isinstance(obj, TimedeltaIndex):
+            pytest.skip()
 
-    def test_ops_properties(self):
-        f = lambda x: isinstance(x, DatetimeIndex)
-        self.check_ops_properties(DatetimeIndex._field_ops, f)
-        self.check_ops_properties(DatetimeIndex._object_ops, f)
-        self.check_ops_properties(DatetimeIndex._bool_ops, f)
+        with pytest.raises((AttributeError, TypeError)):
+            getattr(obj, op)
 
-    def test_ops_properties_basic(self):
+    def test_ops_properties_basic(self, datetime_series):
 
         # sanity check that the behavior didn't change
         # GH#7206
         msg = "'Series' object has no attribute '{}'"
         for op in ["year", "day", "second", "weekday"]:
             with pytest.raises(AttributeError, match=msg.format(op)):
-                getattr(self.dt_series, op)
+                getattr(datetime_series, op)
 
         # attribute access should still work!
         s = Series(dict(year=2000, month=1, day=10))

pandas/tests/indexes/period/test_ops.py

@@ -2,24 +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.test_ops import Ops
+from pandas.tests.base.utils import check_ops_properties_valid
 import pandas.util.testing as tm
 
 
-class TestPeriodIndexOps(Ops):
-    def setup_method(self, method):
-        super().setup_method(method)
-        mask = lambda x: (isinstance(x, DatetimeIndex) or isinstance(x, PeriodIndex))
-        self.is_valid_objs = [o for o in self.objs if mask(o)]
-        self.not_valid_objs = [o for o in self.objs if not mask(o)]
+class TestPeriodIndexOps:
+    @pytest.mark.parametrize("op", PeriodArray._datetimelike_ops)
+    def test_valid_ops_properties(self, op, index_or_series_obj):
+        obj = index_or_series_obj
+        if isinstance(obj, PeriodIndex):
+            check_ops_properties_valid(obj, op)
 
-    def test_ops_properties(self):
-        f = lambda x: isinstance(x, PeriodIndex)
-        self.check_ops_properties(PeriodArray._field_ops, f)
-        self.check_ops_properties(PeriodArray._object_ops, f)
-        self.check_ops_properties(PeriodArray._bool_ops, f)
+    @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)):
+            pytest.skip()
+        if op == "freq" and isinstance(obj, TimedeltaIndex):
+            pytest.skip()
+
+        with pytest.raises((AttributeError, TypeError)):
+            getattr(obj, op)
 
     def test_resolution(self):
         for freq, expected in zip(