CLN/TST: Convert tests/tseries/offset to pytest idioms

pandas/tests/tseries/offsets/common.py

@@ -3,19 +3,6 @@
 """
 from __future__ import annotations
 
-from datetime import datetime
-
-from pandas._libs.tslibs import Timestamp
-from pandas._libs.tslibs.offsets import (
-    FY5253,
-    BaseOffset,
-    DateOffset,
-    FY5253Quarter,
-    LastWeekOfMonth,
-    Week,
-    WeekOfMonth,
-)
-
 
 def assert_offset_equal(offset, base, expected):
     actual = offset + base
@@ -48,39 +35,3 @@ class WeekDay:
     FRI = 4
     SAT = 5
     SUN = 6
-
-
-class Base:
-    _offset: type[BaseOffset] | None = None
-    d = Timestamp(datetime(2008, 1, 2))
-
-    def _get_offset(self, klass, value=1, normalize=False):
-        # create instance from offset class
-        if klass is FY5253:
-            klass = klass(
-                n=value,
-                startingMonth=1,
-                weekday=1,
-                variation="last",
-                normalize=normalize,
-            )
-        elif klass is FY5253Quarter:
-            klass = klass(
-                n=value,
-                startingMonth=1,
-                weekday=1,
-                qtr_with_extra_week=1,
-                variation="last",
-                normalize=normalize,
-            )
-        elif klass is LastWeekOfMonth:
-            klass = klass(n=value, weekday=5, normalize=normalize)
-        elif klass is WeekOfMonth:
-            klass = klass(n=value, week=1, weekday=5, normalize=normalize)
-        elif klass is Week:
-            klass = klass(n=value, weekday=5, normalize=normalize)
-        elif klass is DateOffset:
-            klass = klass(days=value, normalize=normalize)
-        else:
-            klass = klass(value, normalize=normalize)
-        return klass

pandas/tests/tseries/offsets/conftest.py

@@ -1,5 +1,8 @@
+import datetime
+
 import pytest
 
+from pandas._libs.tslibs import Timestamp
 from pandas._libs.tslibs.offsets import MonthOffset
 
 import pandas.tseries.offsets as offsets
@@ -29,3 +32,11 @@ def month_classes(request):
     Fixture for month based datetime offsets available for a time series.
     """
     return request.param
+
+
+@pytest.fixture
+def dt():
+    """
+    Fixture for common Timestamp.
+    """
+    return Timestamp(datetime.datetime(2008, 1, 2))

pandas/tests/tseries/offsets/test_business_day.py

@@ -24,42 +24,51 @@
     _testing as tm,
 )
 from pandas.tests.tseries.offsets.common import (
-    Base,
     assert_is_on_offset,
     assert_offset_equal,
 )
 
 from pandas.tseries import offsets as offsets
 
 
-class TestBusinessDay(Base):
-    _offset: type[BDay] = BDay
+@pytest.fixture
+def dt():
+    return datetime(2008, 1, 1)
 
-    def setup_method(self):
-        self.d = datetime(2008, 1, 1)
-        self.nd = np.datetime64("2008-01-01 00:00:00")
 
-        self.offset = self._offset()
-        self.offset1 = self.offset
-        self.offset2 = self._offset(2)
+@pytest.fixture
+def _offset():
+    return BDay
 
-    def test_different_normalize_equals(self):
+
+@pytest.fixture
+def offset(_offset):
+    return _offset()
+
+
+@pytest.fixture
+def offset2(_offset):
+    return _offset(2)
+
+
+class TestBusinessDay:
+    def test_different_normalize_equals(self, _offset, offset2):
         # GH#21404 changed __eq__ to return False when `normalize` does not match
-        offset = self._offset()
-        offset2 = self._offset(normalize=True)
+        offset = _offset()
+        offset2 = _offset(normalize=True)
         assert offset != offset2
 
-    def test_repr(self):
-        assert repr(self.offset) == "<BusinessDay>"
-        assert repr(self.offset2) == "<2 * BusinessDays>"
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<BusinessDay>"
+        assert repr(offset2) == "<2 * BusinessDays>"
 
         expected = "<BusinessDay: offset=datetime.timedelta(days=1)>"
-        assert repr(self.offset + timedelta(1)) == expected
+        assert repr(offset + timedelta(1)) == expected
 
-    def test_with_offset(self):
-        offset = self.offset + timedelta(hours=2)
+    def test_with_offset(self, dt, offset):
+        offset = offset + timedelta(hours=2)
 
-        assert (self.d + offset) == datetime(2008, 1, 2, 2)
+        assert (dt + offset) == datetime(2008, 1, 2, 2)
 
     @pytest.mark.parametrize(
         "td",
@@ -70,49 +79,42 @@ def test_with_offset(self):
         ],
         ids=lambda x: type(x),
     )
-    def test_with_offset_index(self, td):
+    def test_with_offset_index(self, td, dt, offset):
 
-        dti = DatetimeIndex([self.d])
+        dti = DatetimeIndex([dt])
         expected = DatetimeIndex([datetime(2008, 1, 2, 2)])
 
-        result = dti + (td + self.offset)
+        result = dti + (td + offset)
         tm.assert_index_equal(result, expected)
 
-        result = dti + (self.offset + td)
+        result = dti + (offset + td)
         tm.assert_index_equal(result, expected)
 
-    def test_eq(self):
-        assert self.offset2 == self.offset2
-
-    def test_mul(self):
-        pass
+    def test_eq(self, offset2):
+        assert offset2 == offset2
 
-    def test_hash(self):
-        assert hash(self.offset2) == hash(self.offset2)
+    def test_hash(self, offset2):
+        assert hash(offset2) == hash(offset2)
 
-    def test_call(self):
+    def test_call(self, dt, offset2):
         with tm.assert_produces_warning(FutureWarning):
             # GH#34171 DateOffset.__call__ is deprecated
-            assert self.offset2(self.d) == datetime(2008, 1, 3)
-            assert self.offset2(self.nd) == datetime(2008, 1, 3)
+            assert offset2(dt) == datetime(2008, 1, 3)
+            assert offset2(np.datetime64("2008-01-01 00:00:00")) == datetime(2008, 1, 3)
 
-    def testRollback1(self):
-        assert self._offset(10).rollback(self.d) == self.d
+    def testRollback1(self, dt, _offset):
+        assert _offset(10).rollback(dt) == dt
 
-    def testRollback2(self):
-        assert self._offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4)
+    def testRollback2(self, _offset):
+        assert _offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4)
 
-    def testRollforward1(self):
-        assert self._offset(10).rollforward(self.d) == self.d
+    def testRollforward1(self, dt, _offset):
+        assert _offset(10).rollforward(dt) == dt
 
-    def testRollforward2(self):
-        assert self._offset(10).rollforward(datetime(2008, 1, 5)) == datetime(
-            2008, 1, 7
-        )
-
-    def test_roll_date_object(self):
-        offset = self._offset()
+    def testRollforward2(self, _offset):
+        assert _offset(10).rollforward(datetime(2008, 1, 5)) == datetime(2008, 1, 7)
 
+    def test_roll_date_object(self, offset):
         dt = date(2012, 9, 15)
 
         result = offset.rollback(dt)
@@ -128,14 +130,15 @@ def test_roll_date_object(self):
         result = offset.rollforward(dt)
         assert result == datetime(2012, 9, 15)
 
-    def test_is_on_offset(self):
-        tests = [
-            (self._offset(), datetime(2008, 1, 1), True),
-            (self._offset(), datetime(2008, 1, 5), False),
-        ]
-
-        for offset, d, expected in tests:
-            assert_is_on_offset(offset, d, expected)
+    @pytest.mark.parametrize(
+        "dt, expected",
+        [
+            (datetime(2008, 1, 1), True),
+            (datetime(2008, 1, 5), False),
+        ],
+    )
+    def test_is_on_offset(self, offset, dt, expected):
+        assert_is_on_offset(offset, dt, expected)
 
     apply_cases: list[tuple[int, dict[datetime, datetime]]] = [
         (
@@ -194,22 +197,22 @@ def test_is_on_offset(self):
     ]
 
     @pytest.mark.parametrize("case", apply_cases)
-    def test_apply(self, case):
+    def test_apply(self, case, _offset):
         n, cases = case
-        offset = self._offset(n)
+        offset = _offset(n)
         for base, expected in cases.items():
             assert_offset_equal(offset, base, expected)
 
-    def test_apply_large_n(self):
+    def test_apply_large_n(self, _offset):
         dt = datetime(2012, 10, 23)
 
-        result = dt + self._offset(10)
+        result = dt + _offset(10)
         assert result == datetime(2012, 11, 6)
 
-        result = dt + self._offset(100) - self._offset(100)
+        result = dt + _offset(100) - _offset(100)
         assert result == dt
 
-        off = self._offset() * 6
+        off = _offset() * 6
         rs = datetime(2012, 1, 1) - off
         xp = datetime(2011, 12, 23)
         assert rs == xp
@@ -219,18 +222,18 @@ def test_apply_large_n(self):
         xp = datetime(2011, 12, 26)
         assert rs == xp
 
-        off = self._offset() * 10
+        off = _offset() * 10
         rs = datetime(2014, 1, 5) + off  # see #5890
         xp = datetime(2014, 1, 17)
         assert rs == xp
 
-    def test_apply_corner(self):
-        if self._offset is BDay:
+    def test_apply_corner(self, _offset):
+        if _offset is BDay:
             msg = "Only know how to combine business day with datetime or timedelta"
         else:
             msg = (
                 "Only know how to combine trading day "
                 "with datetime, datetime64 or timedelta"
             )
         with pytest.raises(ApplyTypeError, match=msg):
-            self._offset()._apply(BMonthEnd())
+            _offset()._apply(BMonthEnd())