CLN/TST: Remove Base Class and all subclasses and fixturize data (#34179)

Author: charlesdong1991

pandas/tests/window/common.py

@@ -1,28 +1,8 @@
-from datetime import datetime
-
 import numpy as np
-from numpy.random import randn
 
-from pandas import DataFrame, Series, bdate_range
+from pandas import Series
 import pandas._testing as tm
 
-N, K = 100, 10
-
-
-class Base:
-
-    _nan_locs = np.arange(20, 40)
-    _inf_locs = np.array([])
-
-    def _create_data(self):
-        arr = randn(N)
-        arr[self._nan_locs] = np.NaN
-
-        self.arr = arr
-        self.rng = bdate_range(datetime(2009, 1, 1), periods=N)
-        self.series = Series(arr.copy(), index=self.rng)
-        self.frame = DataFrame(randn(N, K), index=self.rng, columns=np.arange(K))
-
 
 def check_pairwise_moment(frame, dispatch, name, **kwargs):
     def get_result(obj, obj2=None):

pandas/tests/window/conftest.py

@@ -1,9 +1,12 @@
+from datetime import datetime
+
 import numpy as np
+from numpy.random import randn
 import pytest
 
 import pandas.util._test_decorators as td
 
-from pandas import DataFrame, Series, notna
+from pandas import DataFrame, Series, bdate_range, notna
 
 
 @pytest.fixture(params=[True, False])
@@ -242,3 +245,60 @@ def no_nans(x):
 def consistency_data(request):
     """Create consistency data"""
     return request.param
+
+
+def _create_arr():
+    """Internal function to mock an array."""
+    arr = randn(100)
+    locs = np.arange(20, 40)
+    arr[locs] = np.NaN
+    return arr
+
+
+def _create_rng():
+    """Internal function to mock date range."""
+    rng = bdate_range(datetime(2009, 1, 1), periods=100)
+    return rng
+
+
+def _create_series():
+    """Internal function to mock Series."""
+    arr = _create_arr()
+    series = Series(arr.copy(), index=_create_rng())
+    return series
+
+
+def _create_frame():
+    """Internal function to mock DataFrame."""
+    rng = _create_rng()
+    return DataFrame(randn(100, 10), index=rng, columns=np.arange(10))
+
+
+@pytest.fixture
+def nan_locs():
+    """Make a range as loc fixture."""
+    return np.arange(20, 40)
+
+
+@pytest.fixture
+def arr():
+    """Make an array as fixture."""
+    return _create_arr()
+
+
+@pytest.fixture
+def frame():
+    """Make mocked frame as fixture."""
+    return _create_frame()
+
+
+@pytest.fixture
+def series():
+    """Make mocked series as fixture."""
+    return _create_series()
+
+
+@pytest.fixture(params=[_create_series(), _create_frame()])
+def which(request):
+    """Turn parametrized which as fixture for series and frame"""
+    return request.param

pandas/tests/window/moments/test_moments_consistency_ewm.py

@@ -4,7 +4,6 @@
 
 from pandas import DataFrame, Series, concat
 from pandas.tests.window.common import (
-    Base,
     check_binary_ew,
     check_binary_ew_min_periods,
     check_pairwise_moment,
@@ -19,13 +18,9 @@
 )
 
 
-class TestEwmMomentsConsistency(Base):
-    def setup_method(self, method):
-        self._create_data()
-
-    @pytest.mark.parametrize("func", ["cov", "corr"])
-    def test_ewm_pairwise_cov_corr(self, func):
-        check_pairwise_moment(self.frame, "ewm", func, span=10, min_periods=5)
+@pytest.mark.parametrize("func", ["cov", "corr"])
+def test_ewm_pairwise_cov_corr(func, frame):
+    check_pairwise_moment(frame, "ewm", func, span=10, min_periods=5)
 
 
 @pytest.mark.parametrize("name", ["cov", "corr"])

pandas/tests/window/moments/test_moments_consistency_expanding.py

@@ -7,7 +7,6 @@
 from pandas import DataFrame, Index, MultiIndex, Series, isna, notna
 import pandas._testing as tm
 from pandas.tests.window.common import (
-    Base,
     moments_consistency_cov_data,
     moments_consistency_is_constant,
     moments_consistency_mock_mean,
@@ -18,132 +17,145 @@
 )
 
 
-class TestExpandingMomentsConsistency(Base):
-    def setup_method(self, method):
-        self._create_data()
+def _check_expanding(
+    func, static_comp, preserve_nan=True, series=None, frame=None, nan_locs=None
+):
 
-    def test_expanding_corr(self):
-        A = self.series.dropna()
-        B = (A + randn(len(A)))[:-5]
+    series_result = func(series)
+    assert isinstance(series_result, Series)
+    frame_result = func(frame)
+    assert isinstance(frame_result, DataFrame)
 
-        result = A.expanding().corr(B)
+    result = func(series)
+    tm.assert_almost_equal(result[10], static_comp(series[:11]))
 
-        rolling_result = A.rolling(window=len(A), min_periods=1).corr(B)
+    if preserve_nan:
+        assert result.iloc[nan_locs].isna().all()
 
-        tm.assert_almost_equal(rolling_result, result)
 
-    def test_expanding_count(self):
-        result = self.series.expanding(min_periods=0).count()
-        tm.assert_almost_equal(
-            result, self.series.rolling(window=len(self.series), min_periods=0).count()
-        )
+def _check_expanding_has_min_periods(func, static_comp, has_min_periods):
+    ser = Series(randn(50))
 
-    def test_expanding_quantile(self):
-        result = self.series.expanding().quantile(0.5)
+    if has_min_periods:
+        result = func(ser, min_periods=30)
+        assert result[:29].isna().all()
+        tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
 
-        rolling_result = self.series.rolling(
-            window=len(self.series), min_periods=1
-        ).quantile(0.5)
+        # min_periods is working correctly
+        result = func(ser, min_periods=15)
+        assert isna(result.iloc[13])
+        assert notna(result.iloc[14])
 
-        tm.assert_almost_equal(result, rolling_result)
+        ser2 = Series(randn(20))
+        result = func(ser2, min_periods=5)
+        assert isna(result[3])
+        assert notna(result[4])
 
-    def test_expanding_cov(self):
-        A = self.series
-        B = (A + randn(len(A)))[:-5]
+        # min_periods=0
+        result0 = func(ser, min_periods=0)
+        result1 = func(ser, min_periods=1)
+        tm.assert_almost_equal(result0, result1)
+    else:
+        result = func(ser)
+        tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
 
-        result = A.expanding().cov(B)
 
-        rolling_result = A.rolling(window=len(A), min_periods=1).cov(B)
+def test_expanding_corr(series):
+    A = series.dropna()
+    B = (A + randn(len(A)))[:-5]
 
-        tm.assert_almost_equal(rolling_result, result)
+    result = A.expanding().corr(B)
 
-    def test_expanding_cov_pairwise(self):
-        result = self.frame.expanding().corr()
+    rolling_result = A.rolling(window=len(A), min_periods=1).corr(B)
 
-        rolling_result = self.frame.rolling(
-            window=len(self.frame), min_periods=1
-        ).corr()
+    tm.assert_almost_equal(rolling_result, result)
 
-        tm.assert_frame_equal(result, rolling_result)
 
-    def test_expanding_corr_pairwise(self):
-        result = self.frame.expanding().corr()
+def test_expanding_count(series):
+    result = series.expanding(min_periods=0).count()
+    tm.assert_almost_equal(
+        result, series.rolling(window=len(series), min_periods=0).count()
+    )
 
-        rolling_result = self.frame.rolling(
-            window=len(self.frame), min_periods=1
-        ).corr()
-        tm.assert_frame_equal(result, rolling_result)
 
-    @pytest.mark.parametrize("has_min_periods", [True, False])
-    @pytest.mark.parametrize(
-        "func,static_comp",
-        [("sum", np.sum), ("mean", np.mean), ("max", np.max), ("min", np.min)],
-        ids=["sum", "mean", "max", "min"],
-    )
-    def test_expanding_func(self, func, static_comp, has_min_periods):
-        def expanding_func(x, min_periods=1, center=False, axis=0):
-            exp = x.expanding(min_periods=min_periods, center=center, axis=axis)
-            return getattr(exp, func)()
-
-        self._check_expanding(expanding_func, static_comp, preserve_nan=False)
-        self._check_expanding_has_min_periods(
-            expanding_func, static_comp, has_min_periods
-        )
+def test_expanding_quantile(series):
+    result = series.expanding().quantile(0.5)
+
+    rolling_result = series.rolling(window=len(series), min_periods=1).quantile(0.5)
+
+    tm.assert_almost_equal(result, rolling_result)
+
 
-    @pytest.mark.parametrize("has_min_periods", [True, False])
-    def test_expanding_apply(self, engine_and_raw, has_min_periods):
+def test_expanding_cov(series):
+    A = series
+    B = (A + randn(len(A)))[:-5]
 
-        engine, raw = engine_and_raw
+    result = A.expanding().cov(B)
 
-        def expanding_mean(x, min_periods=1):
+    rolling_result = A.rolling(window=len(A), min_periods=1).cov(B)
 
-            exp = x.expanding(min_periods=min_periods)
-            result = exp.apply(lambda x: x.mean(), raw=raw, engine=engine)
-            return result
+    tm.assert_almost_equal(rolling_result, result)
 
-        # TODO(jreback), needed to add preserve_nan=False
-        # here to make this pass
-        self._check_expanding(expanding_mean, np.mean, preserve_nan=False)
-        self._check_expanding_has_min_periods(expanding_mean, np.mean, has_min_periods)
 
-    def _check_expanding(self, func, static_comp, preserve_nan=True):
+def test_expanding_cov_pairwise(frame):
+    result = frame.expanding().cov()
 
-        series_result = func(self.series)
-        assert isinstance(series_result, Series)
-        frame_result = func(self.frame)
-        assert isinstance(frame_result, DataFrame)
+    rolling_result = frame.rolling(window=len(frame), min_periods=1).cov()
 
-        result = func(self.series)
-        tm.assert_almost_equal(result[10], static_comp(self.series[:11]))
+    tm.assert_frame_equal(result, rolling_result)
 
-        if preserve_nan:
-            assert result.iloc[self._nan_locs].isna().all()
 
-    def _check_expanding_has_min_periods(self, func, static_comp, has_min_periods):
-        ser = Series(randn(50))
+def test_expanding_corr_pairwise(frame):
+    result = frame.expanding().corr()
 
-        if has_min_periods:
-            result = func(ser, min_periods=30)
-            assert result[:29].isna().all()
-            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+    rolling_result = frame.rolling(window=len(frame), min_periods=1).corr()
+    tm.assert_frame_equal(result, rolling_result)
 
-            # min_periods is working correctly
-            result = func(ser, min_periods=15)
-            assert isna(result.iloc[13])
-            assert notna(result.iloc[14])
 
-            ser2 = Series(randn(20))
-            result = func(ser2, min_periods=5)
-            assert isna(result[3])
-            assert notna(result[4])
+@pytest.mark.parametrize("has_min_periods", [True, False])
+@pytest.mark.parametrize(
+    "func,static_comp",
+    [("sum", np.sum), ("mean", np.mean), ("max", np.max), ("min", np.min)],
+    ids=["sum", "mean", "max", "min"],
+)
+def test_expanding_func(func, static_comp, has_min_periods, series, frame, nan_locs):
+    def expanding_func(x, min_periods=1, center=False, axis=0):
+        exp = x.expanding(min_periods=min_periods, center=center, axis=axis)
+        return getattr(exp, func)()
+
+    _check_expanding(
+        expanding_func,
+        static_comp,
+        preserve_nan=False,
+        series=series,
+        frame=frame,
+        nan_locs=nan_locs,
+    )
+    _check_expanding_has_min_periods(expanding_func, static_comp, has_min_periods)
+
 
-            # min_periods=0
-            result0 = func(ser, min_periods=0)
-            result1 = func(ser, min_periods=1)
-            tm.assert_almost_equal(result0, result1)
-        else:
-            result = func(ser)
-            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+@pytest.mark.parametrize("has_min_periods", [True, False])
+def test_expanding_apply(engine_and_raw, has_min_periods, series, frame, nan_locs):
+
+    engine, raw = engine_and_raw
+
+    def expanding_mean(x, min_periods=1):
+
+        exp = x.expanding(min_periods=min_periods)
+        result = exp.apply(lambda x: x.mean(), raw=raw, engine=engine)
+        return result
+
+    # TODO(jreback), needed to add preserve_nan=False
+    # here to make this pass
+    _check_expanding(
+        expanding_mean,
+        np.mean,
+        preserve_nan=False,
+        series=series,
+        frame=frame,
+        nan_locs=nan_locs,
+    )
+    _check_expanding_has_min_periods(expanding_mean, np.mean, has_min_periods)
 
 
 @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])

pandas/tests/window/moments/test_moments_consistency_rolling.py

@@ -12,7 +12,6 @@
 import pandas._testing as tm
 from pandas.core.window.common import _flex_binary_moment
 from pandas.tests.window.common import (
-    Base,
     check_pairwise_moment,
     moments_consistency_cov_data,
     moments_consistency_is_constant,
@@ -33,60 +32,56 @@ def _rolling_consistency_cases():
                 yield window, min_periods, center
 
 
-class TestRollingMomentsConsistency(Base):
-    def setup_method(self, method):
-        self._create_data()
+# binary moments
+def test_rolling_cov(series):
+    A = series
+    B = A + randn(len(A))
 
-    # binary moments
-    def test_rolling_cov(self):
-        A = self.series
-        B = A + randn(len(A))
+    result = A.rolling(window=50, min_periods=25).cov(B)
+    tm.assert_almost_equal(result[-1], np.cov(A[-50:], B[-50:])[0, 1])
 
-        result = A.rolling(window=50, min_periods=25).cov(B)
-        tm.assert_almost_equal(result[-1], np.cov(A[-50:], B[-50:])[0, 1])
 
-    def test_rolling_corr(self):
-        A = self.series
-        B = A + randn(len(A))
+def test_rolling_corr(series):
+    A = series
+    B = A + randn(len(A))
 
-        result = A.rolling(window=50, min_periods=25).corr(B)
-        tm.assert_almost_equal(result[-1], np.corrcoef(A[-50:], B[-50:])[0, 1])
+    result = A.rolling(window=50, min_periods=25).corr(B)
+    tm.assert_almost_equal(result[-1], np.corrcoef(A[-50:], B[-50:])[0, 1])
 
-        # test for correct bias correction
-        a = tm.makeTimeSeries()
-        b = tm.makeTimeSeries()
-        a[:5] = np.nan
-        b[:10] = np.nan
+    # test for correct bias correction
+    a = tm.makeTimeSeries()
+    b = tm.makeTimeSeries()
+    a[:5] = np.nan
+    b[:10] = np.nan
 
-        result = a.rolling(window=len(a), min_periods=1).corr(b)
-        tm.assert_almost_equal(result[-1], a.corr(b))
+    result = a.rolling(window=len(a), min_periods=1).corr(b)
+    tm.assert_almost_equal(result[-1], a.corr(b))
 
-    @pytest.mark.parametrize("func", ["cov", "corr"])
-    def test_rolling_pairwise_cov_corr(self, func):
-        check_pairwise_moment(self.frame, "rolling", func, window=10, min_periods=5)
 
-    @pytest.mark.parametrize("method", ["corr", "cov"])
-    def test_flex_binary_frame(self, method):
-        series = self.frame[1]
+@pytest.mark.parametrize("func", ["cov", "corr"])
+def test_rolling_pairwise_cov_corr(func, frame):
+    check_pairwise_moment(frame, "rolling", func, window=10, min_periods=5)
 
-        res = getattr(series.rolling(window=10), method)(self.frame)
-        res2 = getattr(self.frame.rolling(window=10), method)(series)
-        exp = self.frame.apply(lambda x: getattr(series.rolling(window=10), method)(x))
 
-        tm.assert_frame_equal(res, exp)
-        tm.assert_frame_equal(res2, exp)
+@pytest.mark.parametrize("method", ["corr", "cov"])
+def test_flex_binary_frame(method, frame):
+    series = frame[1]
 
-        frame2 = self.frame.copy()
-        frame2.values[:] = np.random.randn(*frame2.shape)
+    res = getattr(series.rolling(window=10), method)(frame)
+    res2 = getattr(frame.rolling(window=10), method)(series)
+    exp = frame.apply(lambda x: getattr(series.rolling(window=10), method)(x))
 
-        res3 = getattr(self.frame.rolling(window=10), method)(frame2)
-        exp = DataFrame(
-            {
-                k: getattr(self.frame[k].rolling(window=10), method)(frame2[k])
-                for k in self.frame
-            }
-        )
-        tm.assert_frame_equal(res3, exp)
+    tm.assert_frame_equal(res, exp)
+    tm.assert_frame_equal(res2, exp)
+
+    frame2 = frame.copy()
+    frame2.values[:] = np.random.randn(*frame2.shape)
+
+    res3 = getattr(frame.rolling(window=10), method)(frame2)
+    exp = DataFrame(
+        {k: getattr(frame[k].rolling(window=10), method)(frame2[k]) for k in frame}
+    )
+    tm.assert_frame_equal(res3, exp)
 
 
 @pytest.mark.slow

pandas/tests/window/moments/test_moments_ewm.py

@@ -5,66 +5,62 @@
 
 from pandas import DataFrame, Series
 from pandas.core.window import EWM
-from pandas.tests.window.common import Base
 
 
-class TestEWM(Base):
-    def setup_method(self, method):
-        self._create_data()
+def test_doc_string():
 
-    def test_doc_string(self):
+    df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+    df
+    df.ewm(com=0.5).mean()
 
-        df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
-        df
-        df.ewm(com=0.5).mean()
 
-    @pytest.mark.parametrize("which", ["series", "frame"])
-    def test_constructor(self, which):
-        o = getattr(self, which)
-        c = o.ewm
+def test_constructor(which):
 
-        # valid
-        c(com=0.5)
-        c(span=1.5)
-        c(alpha=0.5)
-        c(halflife=0.75)
-        c(com=0.5, span=None)
-        c(alpha=0.5, com=None)
-        c(halflife=0.75, alpha=None)
+    c = which.ewm
 
-        # not valid: mutually exclusive
-        with pytest.raises(ValueError):
-            c(com=0.5, alpha=0.5)
-        with pytest.raises(ValueError):
-            c(span=1.5, halflife=0.75)
-        with pytest.raises(ValueError):
-            c(alpha=0.5, span=1.5)
+    # valid
+    c(com=0.5)
+    c(span=1.5)
+    c(alpha=0.5)
+    c(halflife=0.75)
+    c(com=0.5, span=None)
+    c(alpha=0.5, com=None)
+    c(halflife=0.75, alpha=None)
 
-        # not valid: com < 0
-        with pytest.raises(ValueError):
-            c(com=-0.5)
+    # not valid: mutually exclusive
+    with pytest.raises(ValueError):
+        c(com=0.5, alpha=0.5)
+    with pytest.raises(ValueError):
+        c(span=1.5, halflife=0.75)
+    with pytest.raises(ValueError):
+        c(alpha=0.5, span=1.5)
 
-        # not valid: span < 1
-        with pytest.raises(ValueError):
-            c(span=0.5)
+    # not valid: com < 0
+    with pytest.raises(ValueError):
+        c(com=-0.5)
+
+    # not valid: span < 1
+    with pytest.raises(ValueError):
+        c(span=0.5)
+
+    # not valid: halflife <= 0
+    with pytest.raises(ValueError):
+        c(halflife=0)
 
-        # not valid: halflife <= 0
+    # not valid: alpha <= 0 or alpha > 1
+    for alpha in (-0.5, 1.5):
         with pytest.raises(ValueError):
-            c(halflife=0)
+            c(alpha=alpha)
 
-        # not valid: alpha <= 0 or alpha > 1
-        for alpha in (-0.5, 1.5):
-            with pytest.raises(ValueError):
-                c(alpha=alpha)
 
-    @pytest.mark.parametrize("method", ["std", "mean", "var"])
-    def test_numpy_compat(self, method):
-        # see gh-12811
-        e = EWM(Series([2, 4, 6]), alpha=0.5)
+@pytest.mark.parametrize("method", ["std", "mean", "var"])
+def test_numpy_compat(method):
+    # see gh-12811
+    e = EWM(Series([2, 4, 6]), alpha=0.5)
 
-        msg = "numpy operations are not valid with window objects"
+    msg = "numpy operations are not valid with window objects"
 
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(e, method)(1, 2, 3)
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(e, method)(dtype=np.float64)
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(e, method)(1, 2, 3)
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(e, method)(dtype=np.float64)

pandas/tests/window/moments/test_moments_rolling.py

@@ -7,112 +7,111 @@
 from pandas import DataFrame, Series
 import pandas._testing as tm
 from pandas.core.window import Expanding
-from pandas.tests.window.common import Base
-
-
-class TestExpanding(Base):
-    def setup_method(self, method):
-        self._create_data()
-
-    def test_doc_string(self):
-
-        df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
-        df
-        df.expanding(2).sum()
-
-    @pytest.mark.parametrize("which", ["series", "frame"])
-    def test_constructor(self, which):
-        # GH 12669
-
-        o = getattr(self, which)
-        c = o.expanding
-
-        # valid
-        c(min_periods=1)
-        c(min_periods=1, center=True)
-        c(min_periods=1, center=False)
-
-        # not valid
-        for w in [2.0, "foo", np.array([2])]:
-            with pytest.raises(ValueError):
-                c(min_periods=w)
-            with pytest.raises(ValueError):
-                c(min_periods=1, center=w)
-
-    @pytest.mark.parametrize("method", ["std", "mean", "sum", "max", "min", "var"])
-    def test_numpy_compat(self, method):
-        # see gh-12811
-        e = Expanding(Series([2, 4, 6]), window=2)
-
-        msg = "numpy operations are not valid with window objects"
-
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(e, method)(1, 2, 3)
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(e, method)(dtype=np.float64)
-
-    @pytest.mark.parametrize(
-        "expander",
-        [
-            1,
-            pytest.param(
-                "ls",
-                marks=pytest.mark.xfail(
-                    reason="GH#16425 expanding with offset not supported"
-                ),
+
+
+def test_doc_string():
+
+    df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+    df
+    df.expanding(2).sum()
+
+
+def test_constructor(which):
+    # GH 12669
+
+    c = which.expanding
+
+    # valid
+    c(min_periods=1)
+    c(min_periods=1, center=True)
+    c(min_periods=1, center=False)
+
+    # not valid
+    for w in [2.0, "foo", np.array([2])]:
+        with pytest.raises(ValueError):
+            c(min_periods=w)
+        with pytest.raises(ValueError):
+            c(min_periods=1, center=w)
+
+
+@pytest.mark.parametrize("method", ["std", "mean", "sum", "max", "min", "var"])
+def test_numpy_compat(method):
+    # see gh-12811
+    e = Expanding(Series([2, 4, 6]), window=2)
+
+    msg = "numpy operations are not valid with window objects"
+
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(e, method)(1, 2, 3)
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(e, method)(dtype=np.float64)
+
+
+@pytest.mark.parametrize(
+    "expander",
+    [
+        1,
+        pytest.param(
+            "ls",
+            marks=pytest.mark.xfail(
+                reason="GH#16425 expanding with offset not supported"
             ),
-        ],
-    )
-    def test_empty_df_expanding(self, expander):
-        # GH 15819 Verifies that datetime and integer expanding windows can be
-        # applied to empty DataFrames
-
-        expected = DataFrame()
-        result = DataFrame().expanding(expander).sum()
-        tm.assert_frame_equal(result, expected)
-
-        # Verifies that datetime and integer expanding windows can be applied
-        # to empty DataFrames with datetime index
-        expected = DataFrame(index=pd.DatetimeIndex([]))
-        result = DataFrame(index=pd.DatetimeIndex([])).expanding(expander).sum()
-        tm.assert_frame_equal(result, expected)
-
-    def test_missing_minp_zero(self):
-        # https://github.com/pandas-dev/pandas/pull/18921
-        # minp=0
-        x = pd.Series([np.nan])
-        result = x.expanding(min_periods=0).sum()
-        expected = pd.Series([0.0])
-        tm.assert_series_equal(result, expected)
-
-        # minp=1
-        result = x.expanding(min_periods=1).sum()
-        expected = pd.Series([np.nan])
-        tm.assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("klass", [pd.Series, pd.DataFrame])
-    def test_iter_raises(self, klass):
-        # https://github.com/pandas-dev/pandas/issues/11704
-        # Iteration over a Window
-        obj = klass([1, 2, 3, 4])
-        with pytest.raises(NotImplementedError):
-            iter(obj.expanding(2))
-
-    def test_expanding_axis(self, axis_frame):
-        # see gh-23372.
-        df = DataFrame(np.ones((10, 20)))
-        axis = df._get_axis_number(axis_frame)
-
-        if axis == 0:
-            expected = DataFrame(
-                {i: [np.nan] * 2 + [float(j) for j in range(3, 11)] for i in range(20)}
-            )
-        else:
-            # axis == 1
-            expected = DataFrame([[np.nan] * 2 + [float(i) for i in range(3, 21)]] * 10)
-
-        result = df.expanding(3, axis=axis_frame).sum()
-        tm.assert_frame_equal(result, expected)
+        ),
+    ],
+)
+def test_empty_df_expanding(expander):
+    # GH 15819 Verifies that datetime and integer expanding windows can be
+    # applied to empty DataFrames
+
+    expected = DataFrame()
+    result = DataFrame().expanding(expander).sum()
+    tm.assert_frame_equal(result, expected)
+
+    # Verifies that datetime and integer expanding windows can be applied
+    # to empty DataFrames with datetime index
+    expected = DataFrame(index=pd.DatetimeIndex([]))
+    result = DataFrame(index=pd.DatetimeIndex([])).expanding(expander).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_missing_minp_zero():
+    # https://github.com/pandas-dev/pandas/pull/18921
+    # minp=0
+    x = pd.Series([np.nan])
+    result = x.expanding(min_periods=0).sum()
+    expected = pd.Series([0.0])
+    tm.assert_series_equal(result, expected)
+
+    # minp=1
+    result = x.expanding(min_periods=1).sum()
+    expected = pd.Series([np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("klass", [pd.Series, pd.DataFrame])
+def test_iter_raises(klass):
+    # https://github.com/pandas-dev/pandas/issues/11704
+    # Iteration over a Window
+    obj = klass([1, 2, 3, 4])
+    with pytest.raises(NotImplementedError):
+        iter(obj.expanding(2))
+
+
+def test_expanding_axis(axis_frame):
+    # see gh-23372.
+    df = DataFrame(np.ones((10, 20)))
+    axis = df._get_axis_number(axis_frame)
+
+    if axis == 0:
+        expected = DataFrame(
+            {i: [np.nan] * 2 + [float(j) for j in range(3, 11)] for i in range(20)}
+        )
+    else:
+        # axis == 1
+        expected = DataFrame([[np.nan] * 2 + [float(i) for i in range(3, 21)]] * 10)
+
+    result = df.expanding(3, axis=axis_frame).sum()
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("constructor", [Series, DataFrame])

pandas/tests/window/test_api.py

@@ -7,70 +7,62 @@
 import pandas as pd
 from pandas import Series
 from pandas.core.window import Window
-from pandas.tests.window.common import Base
-
-
-@pytest.mark.filterwarnings("ignore:can't resolve package:ImportWarning")
-class TestWindow(Base):
-    def setup_method(self, method):
-        self._create_data()
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize("which", ["series", "frame"])
-    def test_constructor(self, which):
-        # GH 12669
-
-        o = getattr(self, which)
-        c = o.rolling
-
-        # valid
-        c(win_type="boxcar", window=2, min_periods=1)
-        c(win_type="boxcar", window=2, min_periods=1, center=True)
-        c(win_type="boxcar", window=2, min_periods=1, center=False)
-
-        # not valid
-        for w in [2.0, "foo", np.array([2])]:
-            with pytest.raises(ValueError, match="min_periods must be an integer"):
-                c(win_type="boxcar", window=2, min_periods=w)
-            with pytest.raises(ValueError, match="center must be a boolean"):
-                c(win_type="boxcar", window=2, min_periods=1, center=w)
-
-        for wt in ["foobar", 1]:
-            with pytest.raises(ValueError, match="Invalid win_type"):
-                c(win_type=wt, window=2)
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize("which", ["series", "frame"])
-    def test_constructor_with_win_type(self, which, win_types):
-        # GH 12669
-        o = getattr(self, which)
-        c = o.rolling
-        c(win_type=win_types, window=2)
-
-    @pytest.mark.parametrize("method", ["sum", "mean"])
-    def test_numpy_compat(self, method):
-        # see gh-12811
-        w = Window(Series([2, 4, 6]), window=[0, 2])
-
-        msg = "numpy operations are not valid with window objects"
-
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(w, method)(1, 2, 3)
-        with pytest.raises(UnsupportedFunctionCall, match=msg):
-            getattr(w, method)(dtype=np.float64)
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize("arg", ["median", "kurt", "skew"])
-    def test_agg_function_support(self, arg):
-        df = pd.DataFrame({"A": np.arange(5)})
-        roll = df.rolling(2, win_type="triang")
-
-        msg = f"'{arg}' is not a valid function for 'Window' object"
-        with pytest.raises(AttributeError, match=msg):
-            roll.agg(arg)
-
-        with pytest.raises(AttributeError, match=msg):
-            roll.agg([arg])
-
-        with pytest.raises(AttributeError, match=msg):
-            roll.agg({"A": arg})
+
+
+@td.skip_if_no_scipy
+def test_constructor(which):
+    # GH 12669
+    c = which.rolling
+
+    # valid
+    c(win_type="boxcar", window=2, min_periods=1)
+    c(win_type="boxcar", window=2, min_periods=1, center=True)
+    c(win_type="boxcar", window=2, min_periods=1, center=False)
+
+    # not valid
+    for w in [2.0, "foo", np.array([2])]:
+        with pytest.raises(ValueError, match="min_periods must be an integer"):
+            c(win_type="boxcar", window=2, min_periods=w)
+        with pytest.raises(ValueError, match="center must be a boolean"):
+            c(win_type="boxcar", window=2, min_periods=1, center=w)
+
+    for wt in ["foobar", 1]:
+        with pytest.raises(ValueError, match="Invalid win_type"):
+            c(win_type=wt, window=2)
+
+
+@td.skip_if_no_scipy
+def test_constructor_with_win_type(which, win_types):
+    # GH 12669
+    c = which.rolling
+    c(win_type=win_types, window=2)
+
+
+@pytest.mark.parametrize("method", ["sum", "mean"])
+def test_numpy_compat(method):
+    # see gh-12811
+    w = Window(Series([2, 4, 6]), window=[0, 2])
+
+    msg = "numpy operations are not valid with window objects"
+
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(w, method)(1, 2, 3)
+    with pytest.raises(UnsupportedFunctionCall, match=msg):
+        getattr(w, method)(dtype=np.float64)
+
+
+@td.skip_if_no_scipy
+@pytest.mark.parametrize("arg", ["median", "kurt", "skew"])
+def test_agg_function_support(arg):
+    df = pd.DataFrame({"A": np.arange(5)})
+    roll = df.rolling(2, win_type="triang")
+
+    msg = f"'{arg}' is not a valid function for 'Window' object"
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg(arg)
+
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg([arg])
+
+    with pytest.raises(AttributeError, match=msg):
+        roll.agg({"A": arg})