TST: Use fixtures instead of setup_method for index tests (pandas-dev#28865)

Author: jschendel

pandas/tests/indexes/common.py

@@ -5,28 +5,29 @@
 from pandas.core.indexes.api import Index, MultiIndex
 import pandas.util.testing as tm
 
-indices_list = [
-    tm.makeUnicodeIndex(100),
-    tm.makeStringIndex(100),
-    tm.makeDateIndex(100),
-    tm.makePeriodIndex(100),
-    tm.makeTimedeltaIndex(100),
-    tm.makeIntIndex(100),
-    tm.makeUIntIndex(100),
-    tm.makeRangeIndex(100),
-    tm.makeFloatIndex(100),
-    Index([True, False]),
-    tm.makeCategoricalIndex(100),
-    tm.makeIntervalIndex(100),
-    Index([]),
-    MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
-    Index([0, 0, 1, 1, 2, 2]),
-]
-
-
-@pytest.fixture(params=indices_list, ids=lambda x: type(x).__name__)
+indices_dict = {
+    "unicode": tm.makeUnicodeIndex(100),
+    "string": tm.makeStringIndex(100),
+    "datetime": tm.makeDateIndex(100),
+    "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]),
+    "categorical": tm.makeCategoricalIndex(100),
+    "interval": tm.makeIntervalIndex(100),
+    "empty": Index([]),
+    "tuples": MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
+    "repeats": Index([0, 0, 1, 1, 2, 2]),
+}
+
+
+@pytest.fixture(params=indices_dict.keys())
 def indices(request):
-    return request.param
+    # copy to avoid mutation, e.g. setting .name
+    return indices_dict[request.param].copy()
 
 
 @pytest.fixture(params=[1, np.array(1, dtype=np.int64)])

pandas/tests/indexes/conftest.py

@@ -58,13 +58,14 @@ def test_view(self):
         tm.assert_index_equal(result, i_view)
 
     def test_map_callable(self):
-        expected = self.index + self.index.freq
-        result = self.index.map(lambda x: x + x.freq)
+        index = self.create_index()
+        expected = index + index.freq
+        result = index.map(lambda x: x + x.freq)
         tm.assert_index_equal(result, expected)
 
         # map to NaT
-        result = self.index.map(lambda x: pd.NaT if x == self.index[0] else x)
-        expected = pd.Index([pd.NaT] + self.index[1:].tolist())
+        result = index.map(lambda x: pd.NaT if x == index[0] else x)
+        expected = pd.Index([pd.NaT] + index[1:].tolist())
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -75,23 +76,24 @@ def test_map_callable(self):
         ],
     )
     def test_map_dictlike(self, mapper):
-        expected = self.index + self.index.freq
+        index = self.create_index()
+        expected = index + index.freq
 
         # don't compare the freqs
         if isinstance(expected, pd.DatetimeIndex):
             expected.freq = None
 
-        result = self.index.map(mapper(expected, self.index))
+        result = index.map(mapper(expected, index))
         tm.assert_index_equal(result, expected)
 
-        expected = pd.Index([pd.NaT] + self.index[1:].tolist())
-        result = self.index.map(mapper(expected, self.index))
+        expected = pd.Index([pd.NaT] + index[1:].tolist())
+        result = index.map(mapper(expected, index))
         tm.assert_index_equal(result, expected)
 
         # empty map; these map to np.nan because we cannot know
         # to re-infer things
-        expected = pd.Index([np.nan] * len(self.index))
-        result = self.index.map(mapper([], []))
+        expected = pd.Index([np.nan] * len(index))
+        result = index.map(mapper([], []))
         tm.assert_index_equal(result, expected)
 
     def test_asobject_deprecated(self):

pandas/tests/indexes/datetimelike.py

@@ -1,4 +1,5 @@
 """ generic tests from the Datetimelike class """
+import pytest
 
 from pandas import DatetimeIndex, date_range
 from pandas.util import testing as tm
@@ -9,12 +10,12 @@
 class TestDatetimeIndex(DatetimeLike):
     _holder = DatetimeIndex
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=tm.makeDateIndex(10),
-            index_dec=date_range("20130110", periods=10, freq="-1D"),
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[tm.makeDateIndex(10), date_range("20130110", periods=10, freq="-1D")],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return request.param
 
     def create_index(self):
         return date_range("20130101", periods=5)

pandas/tests/indexes/datetimes/test_datetimelike.py

@@ -14,10 +14,9 @@ class TestBase(Base):
 
     _holder = IntervalIndex
 
-    def setup_method(self, method):
-        self.index = IntervalIndex.from_arrays([0, 1], [1, 2])
-        self.index_with_nan = IntervalIndex.from_tuples([(0, 1), np.nan, (1, 2)])
-        self.indices = dict(intervalIndex=tm.makeIntervalIndex(10))
+    @pytest.fixture
+    def indices(self):
+        return tm.makeIntervalIndex(10)
 
     def create_index(self, closed="right"):
         return IntervalIndex.from_breaks(range(11), closed=closed)

pandas/tests/indexes/interval/test_base.py

@@ -25,12 +25,15 @@
 class TestPeriodIndex(DatetimeLike):
     _holder = PeriodIndex
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=tm.makePeriodIndex(10),
-            index_dec=period_range("20130101", periods=10, freq="D")[::-1],
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[
+            tm.makePeriodIndex(10),
+            period_range("20130101", periods=10, freq="D")[::-1],
+        ],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return request.param
 
     def create_index(self):
         return period_range("20130101", periods=5, freq="D")