use fixtures

Author: jreback

pandas/conftest.py

@@ -1,3 +1,4 @@
+from collections import abc
 from datetime import date, time, timedelta, timezone
 from decimal import Decimal
 import operator
@@ -894,3 +895,38 @@ def index_or_series(request):
     See GH#29725
     """
     return request.param
+
+
+@pytest.fixture
+def dict_subclass():
+    """
+    Fixture for a dictionary subclass.
+    """
+
+    class TestSubDict(dict):
+        def __init__(self, *args, **kwargs):
+            dict.__init__(self, *args, **kwargs)
+
+    return TestSubDict
+
+
+@pytest.fixture
+def non_mapping_dict_subclass():
+    """
+    Fixture for a non-mapping dictionary subclass.
+    """
+
+    class TestNonDictMapping(abc.Mapping):
+        def __init__(self, underlying_dict):
+            self._data = underlying_dict
+
+        def __getitem__(self, key):
+            return self._data.__getitem__(key)
+
+        def __iter__(self):
+            return self._data.__iter__()
+
+        def __len__(self):
+            return self._data.__len__()
+
+    return TestNonDictMapping

pandas/tests/frame/test_constructors.py

@@ -511,17 +511,17 @@ def test_constructor_with_embedded_frames(self):
         result = df2.loc[1, 0]
         tm.assert_frame_equal(result, df1 + 10)
 
-    def test_constructor_subclass_dict(self, float_frame):
+    def test_constructor_subclass_dict(self, float_frame, dict_subclass):
         # Test for passing dict subclass to constructor
         data = {
-            "col1": tm.TestSubDict((x, 10.0 * x) for x in range(10)),
-            "col2": tm.TestSubDict((x, 20.0 * x) for x in range(10)),
+            "col1": dict_subclass((x, 10.0 * x) for x in range(10)),
+            "col2": dict_subclass((x, 20.0 * x) for x in range(10)),
         }
         df = DataFrame(data)
         refdf = DataFrame({col: dict(val.items()) for col, val in data.items()})
         tm.assert_frame_equal(refdf, df)
 
-        data = tm.TestSubDict(data.items())
+        data = dict_subclass(data.items())
         df = DataFrame(data)
         tm.assert_frame_equal(refdf, df)
 

pandas/tests/series/test_api.py

@@ -126,8 +126,8 @@ def test_constructor_dict(self):
         expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"])
         tm.assert_series_equal(result, expected)
 
-    def test_constructor_subclass_dict(self):
-        data = tm.TestSubDict((x, 10.0 * x) for x in range(10))
+    def test_constructor_subclass_dict(self, dict_subclass):
+        data = dict_subclass((x, 10.0 * x) for x in range(10))
         series = Series(data)
         expected = Series(dict(data.items()))
         tm.assert_series_equal(series, expected)

pandas/tests/series/test_apply.py

@@ -627,19 +627,19 @@ class DictWithoutMissing(dict):
         expected = Series([np.nan, np.nan, "three"])
         tm.assert_series_equal(result, expected)
 
-    def test_map_abc_mapping(self):
+    def test_map_abc_mapping(self, non_mapping_dict_subclass):
         # https://github.com/pandas-dev/pandas/issues/29733
         # Check collections.abc.Mapping support as mapper for Series.map
         s = Series([1, 2, 3])
-        not_a_dictionary = tm.TestNonDictMapping({3: "three"})
+        not_a_dictionary = non_mapping_dict_subclass({3: "three"})
         result = s.map(not_a_dictionary)
         expected = Series([np.nan, np.nan, "three"])
         tm.assert_series_equal(result, expected)
 
-    def test_map_abc_mapping_with_missing(self):
+    def test_map_abc_mapping_with_missing(self, non_mapping_dict_subclass):
         # https://github.com/pandas-dev/pandas/issues/29733
         # Check collections.abc.Mapping support as mapper for Series.map
-        class NonDictMappingWithMissing(tm.TestNonDictMapping):
+        class NonDictMappingWithMissing(non_mapping_dict_subclass):
             def __missing__(self, key):
                 return "missing"
 

pandas/tests/series/test_constructors.py

@@ -1089,9 +1089,9 @@ def create_data(constructor):
         tm.assert_series_equal(result_datetime, expected)
         tm.assert_series_equal(result_Timestamp, expected)
 
-    def test_constructor_mapping(self):
+    def test_constructor_mapping(self, non_mapping_dict_subclass):
         # GH 29788
-        ndm = tm.TestNonDictMapping({3: "three"})
+        ndm = non_mapping_dict_subclass({3: "three"})
         result = Series(ndm)
         expected = Series(["three"], index=[3])
 

pandas/util/testing.py

@@ -1,5 +1,5 @@
 import bz2
-from collections import Counter, abc
+from collections import Counter
 from contextlib import contextmanager
 from datetime import datetime
 from functools import wraps
@@ -2123,25 +2123,6 @@ def makeMissingDataframe(density=0.9, random_state=None):
     return df
 
 
-class TestSubDict(dict):
-    def __init__(self, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
-
-
-class TestNonDictMapping(abc.Mapping):
-    def __init__(self, underlying_dict):
-        self._data = underlying_dict
-
-    def __getitem__(self, key):
-        return self._data.__getitem__(key)
-
-    def __iter__(self):
-        return self._data.__iter__()
-
-    def __len__(self):
-        return self._data.__len__()
-
-
 def optional_args(decorator):
     """allows a decorator to take optional positional and keyword arguments.
     Assumes that taking a single, callable, positional argument means that