Adding fixtures to series tests as per #22550

pandas/tests/series/test_quantile.py

@@ -11,25 +11,23 @@
 from pandas.core.dtypes.common import is_integer
 import pandas.util.testing as tm
 
-from .common import TestData
 
+class TestSeriesQuantile():
 
-class TestSeriesQuantile(TestData):
+    def test_quantile(self, datetime_series):
 
-    def test_quantile(self):
+        q = datetime_series.quantile(0.1)
+        assert q == np.percentile(datetime_series.dropna(), 10)
 
-        q = self.ts.quantile(0.1)
-        assert q == np.percentile(self.ts.dropna(), 10)
-
-        q = self.ts.quantile(0.9)
-        assert q == np.percentile(self.ts.dropna(), 90)
+        q = datetime_series.quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
 
         # object dtype
-        q = Series(self.ts, dtype=object).quantile(0.9)
-        assert q == np.percentile(self.ts.dropna(), 90)
+        q = Series(datetime_series, dtype=object).quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
 
         # datetime64[ns] dtype
-        dts = self.ts.index.to_series()
+        dts = datetime_series.index.to_series()
         q = dts.quantile(.2)
         assert q == Timestamp('2000-01-10 19:12:00')
 
@@ -45,38 +43,38 @@ def test_quantile(self):
         msg = 'percentiles should all be in the interval \\[0, 1\\]'
         for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
             with tm.assert_raises_regex(ValueError, msg):
-                self.ts.quantile(invalid)
+                datetime_series.quantile(invalid)
 
-    def test_quantile_multi(self):
+    def test_quantile_multi(self, datetime_series):
 
         qs = [.1, .9]
-        result = self.ts.quantile(qs)
-        expected = pd.Series([np.percentile(self.ts.dropna(), 10),
-                              np.percentile(self.ts.dropna(), 90)],
-                             index=qs, name=self.ts.name)
+        result = datetime_series.quantile(qs)
+        expected = pd.Series([np.percentile(datetime_series.dropna(), 10),
+                              np.percentile(datetime_series.dropna(), 90)],
+                             index=qs, name=datetime_series.name)
         tm.assert_series_equal(result, expected)
 
-        dts = self.ts.index.to_series()
+        dts = datetime_series.index.to_series()
         dts.name = 'xxx'
         result = dts.quantile((.2, .2))
         expected = Series([Timestamp('2000-01-10 19:12:00'),
                            Timestamp('2000-01-10 19:12:00')],
                           index=[.2, .2], name='xxx')
         tm.assert_series_equal(result, expected)
 
-        result = self.ts.quantile([])
-        expected = pd.Series([], name=self.ts.name, index=Index(
+        result = datetime_series.quantile([])
+        expected = pd.Series([], name=datetime_series.name, index=Index(
             [], dtype=float))
         tm.assert_series_equal(result, expected)
 
-    def test_quantile_interpolation(self):
+    def test_quantile_interpolation(self, datetime_series):
         # see gh-10174
 
         # interpolation = linear (default case)
-        q = self.ts.quantile(0.1, interpolation='linear')
-        assert q == np.percentile(self.ts.dropna(), 10)
-        q1 = self.ts.quantile(0.1)
-        assert q1 == np.percentile(self.ts.dropna(), 10)
+        q = datetime_series.quantile(0.1, interpolation='linear')
+        assert q == np.percentile(datetime_series.dropna(), 10)
+        q1 = datetime_series.quantile(0.1)
+        assert q1 == np.percentile(datetime_series.dropna(), 10)
 
         # test with and without interpolation keyword
         assert q == q1

pandas/tests/series/test_rank.py

@@ -13,14 +13,13 @@
 from pandas.compat import product
 from pandas.util.testing import assert_series_equal
 import pandas.util.testing as tm
-from pandas.tests.series.common import TestData
 from pandas._libs.tslib import iNaT
 from pandas._libs.algos import Infinity, NegInfinity
 from itertools import chain
 import pandas.util._test_decorators as td
 
 
-class TestSeriesRank(TestData):
+class TestSeriesRank():
     s = Series([1, 3, 4, 2, nan, 2, 1, 5, nan, 3])
 
     results = {
@@ -32,20 +31,20 @@ class TestSeriesRank(TestData):
         'dense': np.array([1, 3, 4, 2, nan, 2, 1, 5, nan, 3]),
     }
 
-    def test_rank(self):
+    def test_rank(self, datetime_series):
         pytest.importorskip('scipy.stats.special')
         rankdata = pytest.importorskip('scipy.stats.rankdata')
 
-        self.ts[::2] = np.nan
-        self.ts[:10][::3] = 4.
+        datetime_series[::2] = np.nan
+        datetime_series[:10][::3] = 4.
 
-        ranks = self.ts.rank()
-        oranks = self.ts.astype('O').rank()
+        ranks = datetime_series.rank()
+        oranks = datetime_series.astype('O').rank()
 
         assert_series_equal(ranks, oranks)
 
-        mask = np.isnan(self.ts)
-        filled = self.ts.fillna(np.inf)
+        mask = np.isnan(datetime_series)
+        filled = datetime_series.fillna(np.inf)
 
         # rankdata returns a ndarray
         exp = Series(rankdata(filled), index=filled.index, name='ts')

pandas/tests/series/test_replace.py

@@ -8,11 +8,9 @@
 import pandas._libs.lib as lib
 import pandas.util.testing as tm
 
-from .common import TestData
 
-
-class TestSeriesReplace(TestData):
-    def test_replace(self):
+class TestSeriesReplace():
+    def test_replace(self, datetime_series):
         N = 100
         ser = pd.Series(np.random.randn(N))
         ser[0:4] = np.nan
@@ -70,7 +68,7 @@ def test_replace(self):
         filled[4] = 0
         tm.assert_series_equal(ser.replace(np.inf, 0), filled)
 
-        ser = pd.Series(self.ts.index)
+        ser = pd.Series(datetime_series.index)
         tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
 
         # malformed

pandas/tests/series/test_repr.py

@@ -17,10 +17,8 @@
 from pandas import compat
 import pandas.util.testing as tm
 
-from .common import TestData
 
-
-class TestSeriesRepr(TestData):
+class TestSeriesRepr():
 
     def test_multilevel_name_print(self):
         index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], ['one', 'two',
@@ -60,24 +58,24 @@ def test_name_printing(self):
         s = Series(index=date_range('20010101', '20020101'), name='test')
         assert "Name: test" in repr(s)
 
-    def test_repr(self):
-        str(self.ts)
-        str(self.series)
-        str(self.series.astype(int))
-        str(self.objSeries)
+    def test_repr(self, datetime_series, string_series, object_series, empty_series):
+        str(datetime_series)
+        str(string_series)
+        str(string_series.astype(int))
+        str(object_series)
 
         str(Series(tm.randn(1000), index=np.arange(1000)))
         str(Series(tm.randn(1000), index=np.arange(1000, 0, step=-1)))
 
         # empty
-        str(self.empty)
+        str(empty_series)
 
         # with NaNs
-        self.series[5:7] = np.NaN
-        str(self.series)
+        string_series[5:7] = np.NaN
+        str(string_series)
 
         # with Nones
-        ots = self.ts.astype('O')
+        ots = datetime_series.astype('O')
         ots[::2] = None
         repr(ots)
 
@@ -87,8 +85,8 @@ def test_repr(self):
                      ('foo', 'bar', 'baz'), (1, 2), ('foo', 1, 2.3),
                      (u('\u03B1'), u('\u03B2'), u('\u03B3')),
                      (u('\u03B1'), 'bar')]:
-            self.series.name = name
-            repr(self.series)
+            string_series.name = name
+            repr(string_series)
 
         biggie = Series(tm.randn(1000), index=np.arange(1000),
                         name=('foo', 'bar', 'baz'))

pandas/tests/series/test_sorting.py

@@ -10,27 +10,25 @@
 from pandas.util.testing import assert_series_equal, assert_almost_equal
 import pandas.util.testing as tm
 
-from .common import TestData
 
+class TestSeriesSorting():
 
-class TestSeriesSorting(TestData):
-
-    def test_sortlevel_deprecated(self):
-        ts = self.ts.copy()
+    def test_sortlevel_deprecated(self, datetime_series):
+        ts = datetime_series.copy()
 
         # see gh-9816
         with tm.assert_produces_warning(FutureWarning):
             ts.sortlevel()
 
-    def test_sort_values(self):
+    def test_sort_values(self, datetime_series):
 
         # check indexes are reordered corresponding with the values
         ser = Series([3, 2, 4, 1], ['A', 'B', 'C', 'D'])
         expected = Series([1, 2, 3, 4], ['D', 'B', 'A', 'C'])
         result = ser.sort_values()
         tm.assert_series_equal(expected, result)
 
-        ts = self.ts.copy()
+        ts = datetime_series.copy()
         ts[:5] = np.NaN
         vals = ts.values
 
@@ -75,11 +73,11 @@ def test_sort_values(self):
                       lambda: ts.sort_values(ascending='foobar'))
 
         # inplace=True
-        ts = self.ts.copy()
+        ts = datetime_series.copy()
         ts.sort_values(ascending=False, inplace=True)
-        tm.assert_series_equal(ts, self.ts.sort_values(ascending=False))
+        tm.assert_series_equal(ts, datetime_series.sort_values(ascending=False))
         tm.assert_index_equal(ts.index,
-                              self.ts.sort_values(ascending=False).index)
+                              datetime_series.sort_values(ascending=False).index)
 
         # GH 5856/5853
         # Series.sort_values operating on a view
@@ -91,55 +89,55 @@ def f():
 
         pytest.raises(ValueError, f)
 
-    def test_sort_index(self):
-        rindex = list(self.ts.index)
+    def test_sort_index(self, datetime_series):
+        rindex = list(datetime_series.index)
         random.shuffle(rindex)
 
-        random_order = self.ts.reindex(rindex)
+        random_order = datetime_series.reindex(rindex)
         sorted_series = random_order.sort_index()
-        assert_series_equal(sorted_series, self.ts)
+        assert_series_equal(sorted_series, datetime_series)
 
         # descending
         sorted_series = random_order.sort_index(ascending=False)
         assert_series_equal(sorted_series,
-                            self.ts.reindex(self.ts.index[::-1]))
+                            datetime_series.reindex(datetime_series.index[::-1]))
 
         # compat on level
         sorted_series = random_order.sort_index(level=0)
-        assert_series_equal(sorted_series, self.ts)
+        assert_series_equal(sorted_series, datetime_series)
 
         # compat on axis
         sorted_series = random_order.sort_index(axis=0)
-        assert_series_equal(sorted_series, self.ts)
+        assert_series_equal(sorted_series, datetime_series)
 
         pytest.raises(ValueError, lambda: random_order.sort_values(axis=1))
 
         sorted_series = random_order.sort_index(level=0, axis=0)
-        assert_series_equal(sorted_series, self.ts)
+        assert_series_equal(sorted_series, datetime_series)
 
         pytest.raises(ValueError,
                       lambda: random_order.sort_index(level=0, axis=1))
 
-    def test_sort_index_inplace(self):
+    def test_sort_index_inplace(self, datetime_series):
 
         # For #11402
-        rindex = list(self.ts.index)
+        rindex = list(datetime_series.index)
         random.shuffle(rindex)
 
         # descending
-        random_order = self.ts.reindex(rindex)
+        random_order = datetime_series.reindex(rindex)
         result = random_order.sort_index(ascending=False, inplace=True)
 
         assert result is None
-        tm.assert_series_equal(random_order, self.ts.reindex(
-            self.ts.index[::-1]))
+        tm.assert_series_equal(random_order, datetime_series.reindex(
+            datetime_series.index[::-1]))
 
         # ascending
-        random_order = self.ts.reindex(rindex)
+        random_order = datetime_series.reindex(rindex)
         result = random_order.sort_index(ascending=True, inplace=True)
 
         assert result is None
-        tm.assert_series_equal(random_order, self.ts)
+        tm.assert_series_equal(random_order, datetime_series)
 
     @pytest.mark.parametrize("level", ['A', 0])  # GH 21052
     def test_sort_index_multiindex(self, level):