Rationalise period's offset tests

Author: bonjourmauko

openfisca_core/periods/instant_.py

@@ -5,6 +5,8 @@
 import calendar
 import datetime
 
+from openfisca_core.types import Period
+
 from .. import periods
 from . import config
 
@@ -73,7 +75,7 @@ def __str__(self) -> str:
         return instant_str
 
     @property
-    def date(self) -> "datetime.date":
+    def date(self) -> datetime.date:
         """The date representation of the ``Instant``.
 
         Example:
@@ -139,7 +141,7 @@ def day(self) -> int:
 
         return self[2]
 
-    def period(self, unit: str, size: int = 1) -> "periods.Period":
+    def period(self, unit: str, size: int = 1) -> Period:
         """Creates a new ``Period`` starting at ``self``.
 
         Args:
@@ -166,7 +168,7 @@ def period(self, unit: str, size: int = 1) -> "periods.Period":
         assert isinstance(size, int) and size >= 1, 'Invalid size: {} of type {}'.format(size, type(size))
         return periods.Period((unit, self, size))
 
-    def offset(self, offset: Union[str, int], unit: str) -> "Instant":
+    def offset(self, offset: Union[str, int], unit: str) -> Instant:
         """Increments/decrements the given instant with offset units.
 
         Args:

openfisca_core/periods/period_.py

@@ -107,7 +107,7 @@ def __str__(self) -> str:
         return '{}:{}-{:02d}:{}'.format(unit, year, month, size)
 
     @property
-    def date(self) -> "datetime.date":
+    def date(self) -> datetime.date:
         """The date representation of the ``period``'s' start date.
 
         Returns:
@@ -152,7 +152,7 @@ def days(self) -> int:
 
         return (self.stop.date - self.start.date).days + 1
 
-    def intersection(self, start: "Period", stop: "Period") -> Optional["Period"]:
+    def intersection(self, start: Period, stop: Period) -> Optional[Period]:
         """Intersects a period within ``start`` and ``stop`` boundaries.
 
         Args:
@@ -172,28 +172,37 @@ def intersection(self, start: "Period", stop: "Period") -> Optional["Period"]:
             Period(('day', Instant((2023, 1, 1)), 562))
 
         """
+        intersection_start: Instant
+        intersection_stop: Instant
+        period_start: Instant = self[1]
+        period_stop: Instant = self.stop
 
         if start is None and stop is None:
             return self
-        period_start = self[1]
-        period_stop = self.stop
+
         if start is None:
             start = period_start
+
         if stop is None:
             stop = period_stop
+
         if stop < period_start or period_stop < start:
             return None
-        intersection_start = max(period_start, start)
-        intersection_stop = min(period_stop, stop)
+
+        intersection_start = Instant(max(period_start, start))
+        intersection_stop = Instant(min(period_stop, stop))
+
         if intersection_start == period_start and intersection_stop == period_stop:
             return self
+
         if intersection_start.day == 1 and intersection_start.month == 1 \
                 and intersection_stop.day == 31 and intersection_stop.month == 12:
             return self.__class__((
                 'year',
                 intersection_start,
                 intersection_stop.year - intersection_start.year + 1,
                 ))
+
         if intersection_start.day == 1 and intersection_stop.day == calendar.monthrange(intersection_stop.year,
                 intersection_stop.month)[1]:
             return self.__class__((
@@ -238,7 +247,7 @@ def get_subperiods(self, unit):
         if unit == config.DAY:
             return [self.first_day.offset(i, config.DAY) for i in range(self.size_in_days)]
 
-    def offset(self, offset: Union[str, int], unit: Optional[str] = None) -> "Period":
+    def offset(self, offset: Union[str, int], unit: Optional[str] = None) -> Period:
         """Increment (or decrement) the given ``period`` with offset units.
 
         Args:
@@ -265,7 +274,7 @@ def offset(self, offset: Union[str, int], unit: Optional[str] = None) -> "Period
 
         return self.__class__((self[0], self[1].offset(offset, self[0] if unit is None else unit), self[2]))
 
-    def contains(self, other: "Period") -> bool:
+    def contains(self, other: Period) -> bool:
         """Checks if a ``period`` contains another one.
 
         Args:
@@ -432,7 +441,7 @@ def stop(self) -> "Instant":
         return Instant((year, month, day))
 
     @property
-    def unit(self) -> int:
+    def unit(self) -> str:
         """The ``unit`` of the ``Period``.
 
         Returns:
@@ -452,28 +461,28 @@ def unit(self) -> int:
 
     @property
     def last_3_months(self):
-        return self.first_month.start.period('month', 3).offset(-3)
+        return self.first_month.start.period("month", 3).offset(-3)
 
     @property
     def last_month(self):
         return self.first_month.offset(-1)
 
     @property
     def last_year(self):
-        return self.start.offset("first-of", "year").period('year').offset(-1)
+        return self.start.offset("first-of", "year").period("year").offset(-1)
 
     @property
     def n_2(self):
-        return self.start.offset("first-of", "year").period('year').offset(-2)
+        return self.start.offset("first-of", "year").period("year").offset(-2)
 
     @property
     def this_year(self):
-        return self.start.offset("first-of", "year").period('year')
+        return self.start.offset("first-of", "year").period("year")
 
     @property
     def first_month(self):
-        return self.start.offset("first-of", "month").period('month')
+        return self.start.offset("first-of", "month").period("month")
 
     @property
     def first_day(self):
-        return self.start.period('day')
+        return self.start.period("day")

openfisca_core/periods/tests/test_period.py

@@ -4,6 +4,11 @@
 from openfisca_core.periods import Instant, Period
 
 
+@pytest.fixture
+def instant():
+    return Instant((2022, 12, 31))
+
+
 @pytest.mark.parametrize("date_unit, instant, size, expected", [
     [periods.YEAR, Instant((2022, 1, 1)), 1, "2022"],
     [periods.MONTH, Instant((2022, 1, 1)), 12, "2022"],
@@ -34,20 +39,48 @@ def test_str_with_days(date_unit, instant, size, expected):
     assert str(Period((date_unit, instant, size))) == expected
 
 
-@pytest.mark.parametrize("period, unit, length, first, last", [
-    (periods.period('year:2014:2'), periods.YEAR, 2, periods.period('2014'), periods.period('2015')),
-    (periods.period(2017), periods.MONTH, 12, periods.period('2017-01'), periods.period('2017-12')),
-    (periods.period('year:2014:2'), periods.MONTH, 24, periods.period('2014-01'), periods.period('2015-12')),
-    (periods.period('month:2014-03:3'), periods.MONTH, 3, periods.period('2014-03'), periods.period('2014-05')),
-    (periods.period(2017), periods.DAY, 365, periods.period('2017-01-01'), periods.period('2017-12-31')),
-    (periods.period('year:2014:2'), periods.DAY, 730, periods.period('2014-01-01'), periods.period('2015-12-31')),
-    (periods.period('month:2014-03:3'), periods.DAY, 92, periods.period('2014-03-01'), periods.period('2014-05-31')),
+@pytest.mark.parametrize("period_unit, unit, start, cease, count", [
+    [periods.YEAR, periods.YEAR, Instant((2022, 1, 1)), Instant((2024, 1, 1)), 3],
+    [periods.YEAR, periods.MONTH, Instant((2022, 12, 1)), Instant((2025, 11, 1)), 36],
+    [periods.YEAR, periods.DAY, Instant((2022, 12, 31)), Instant((2025, 12, 30)), 1096],
+    [periods.MONTH, periods.MONTH, Instant((2022, 12, 1)), Instant((2023, 2, 1)), 3],
+    [periods.MONTH, periods.DAY, Instant((2022, 12, 31)), Instant((2023, 3, 30)), 90],
+    [periods.DAY, periods.DAY, Instant((2022, 12, 31)), Instant((2023, 1, 2)), 3],
     ])
-def test_subperiods(period, unit, length, first, last):
+def test_subperiods(instant, period_unit, unit, start, cease, count):
+    period = Period((period_unit, instant, 3))
     subperiods = period.get_subperiods(unit)
-    assert len(subperiods) == length
-    assert subperiods[0] == first
-    assert subperiods[-1] == last
+    assert len(subperiods) == count
+    assert subperiods[0] == Period((unit, start, 1))
+    assert subperiods[-1] == Period((unit, cease, 1))
+
+
+@pytest.mark.parametrize("period_unit, offset, unit, expected", [
+    [periods.YEAR, "first-of", periods.YEAR, Period(('year', Instant((2022, 1, 1)), 3))],
+    [periods.YEAR, "first-of", periods.MONTH, Period(('year', Instant((2022, 12, 1)), 3))],
+    [periods.YEAR, "last-of", periods.YEAR, Period(('year', Instant((2022, 12, 31)), 3))],
+    [periods.YEAR, "last-of", periods.MONTH, Period(('year', Instant((2022, 12, 31)), 3))],
+    [periods.YEAR, -3, periods.YEAR, Period(('year', Instant((2019, 12, 31)), 3))],
+    [periods.YEAR, 1, periods.MONTH, Period(('year', Instant((2023, 1, 31)), 3))],
+    [periods.YEAR, 3, periods.DAY, Period(('year', Instant((2023, 1, 3)), 3))],
+    [periods.MONTH, "first-of", periods.YEAR, Period(('month', Instant((2022, 1, 1)), 3))],
+    [periods.MONTH, "first-of", periods.MONTH, Period(('month', Instant((2022, 12, 1)), 3))],
+    [periods.MONTH, "last-of", periods.YEAR, Period(('month', Instant((2022, 12, 31)), 3))],
+    [periods.MONTH, "last-of", periods.MONTH, Period(('month', Instant((2022, 12, 31)), 3))],
+    [periods.MONTH, -3, periods.YEAR, Period(('month', Instant((2019, 12, 31)), 3))],
+    [periods.MONTH, 1, periods.MONTH, Period(('month', Instant((2023, 1, 31)), 3))],
+    [periods.MONTH, 3, periods.DAY, Period(('month', Instant((2023, 1, 3)), 3))],
+    [periods.DAY, "first-of", periods.YEAR, Period(('day', Instant((2022, 1, 1)), 3))],
+    [periods.DAY, "first-of", periods.MONTH, Period(('day', Instant((2022, 12, 1)), 3))],
+    [periods.DAY, "last-of", periods.YEAR, Period(('day', Instant((2022, 12, 31)), 3))],
+    [periods.DAY, "last-of", periods.MONTH, Period(('day', Instant((2022, 12, 31)), 3))],
+    [periods.DAY, -3, periods.YEAR, Period(('day', Instant((2019, 12, 31)), 3))],
+    [periods.DAY, 1, periods.MONTH, Period(('day', Instant((2023, 1, 31)), 3))],
+    [periods.DAY, 3, periods.DAY, Period(('day', Instant((2023, 1, 3)), 3))],
+    ])
+def test_offset(instant, period_unit, offset, unit, expected):
+    period = Period((period_unit, instant, 3))
+    assert period.offset(offset, unit) == expected
 
 
 @pytest.mark.parametrize("date_unit, instant, size, expected", [