OpenFisca-Core-test 46.0.0__py3-none-any.whl

openfisca_core/periods/tests/helpers/test_helpers.py

@@ -0,0 +1,65 @@
+import datetime
+
+import pytest
+
+from openfisca_core import periods
+from openfisca_core.periods import DateUnit, Instant, Period
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        (None, None),
+        (Instant((1, 1, 1)), datetime.date(1, 1, 1)),
+        (Instant((4, 2, 29)), datetime.date(4, 2, 29)),
+        ((1, 1, 1), datetime.date(1, 1, 1)),
+    ],
+)
+def test_instant_date(arg, expected) -> None:
+    assert periods.instant_date(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        (Instant((-1, 1, 1)), ValueError),
+        (Instant((1, -1, 1)), ValueError),
+        (Instant((1, 13, -1)), ValueError),
+        (Instant((1, 1, -1)), ValueError),
+        (Instant((1, 1, 32)), ValueError),
+        (Instant((1, 2, 29)), ValueError),
+        (Instant(("1", 1, 1)), TypeError),
+        ((1,), TypeError),
+        ((1, 1), TypeError),
+    ],
+)
+def test_instant_date_with_an_invalid_argument(arg, error) -> None:
+    with pytest.raises(error):
+        periods.instant_date(arg)
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        (Period((DateUnit.WEEKDAY, Instant((1, 1, 1)), 5)), "100_5"),
+        (Period((DateUnit.WEEK, Instant((1, 1, 1)), 26)), "200_26"),
+        (Period((DateUnit.DAY, Instant((1, 1, 1)), 365)), "100_365"),
+        (Period((DateUnit.MONTH, Instant((1, 1, 1)), 12)), "200_12"),
+        (Period((DateUnit.YEAR, Instant((1, 1, 1)), 2)), "300_2"),
+        (Period((DateUnit.ETERNITY, Instant((1, 1, 1)), 1)), "400_1"),
+    ],
+)
+def test_key_period_size(arg, expected) -> None:
+    assert periods.key_period_size(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        ((DateUnit.DAY, None, 1), AttributeError),
+        ((DateUnit.MONTH, None, -1000), AttributeError),
+    ],
+)
+def test_key_period_size_when_an_invalid_argument(arg, error):
+    with pytest.raises(error):
+        periods.key_period_size(arg)

openfisca_core/periods/tests/helpers/test_instant.py

@@ -0,0 +1,73 @@
+import datetime
+
+import pytest
+
+from openfisca_core import periods
+from openfisca_core.periods import DateUnit, Instant, InstantError, Period
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        (datetime.date(1, 1, 1), Instant((1, 1, 1))),
+        (Instant((1, 1, 1)), Instant((1, 1, 1))),
+        (Period((DateUnit.DAY, Instant((1, 1, 1)), 365)), Instant((1, 1, 1))),
+        (-1, Instant((-1, 1, 1))),
+        (0, Instant((0, 1, 1))),
+        (1, Instant((1, 1, 1))),
+        (999, Instant((999, 1, 1))),
+        (1000, Instant((1000, 1, 1))),
+        ("1000", Instant((1000, 1, 1))),
+        ("1000-01", Instant((1000, 1, 1))),
+        ("1000-01-01", Instant((1000, 1, 1))),
+        ((-1,), Instant((-1, 1, 1))),
+        ((-1, -1), Instant((-1, -1, 1))),
+        ((-1, -1, -1), Instant((-1, -1, -1))),
+    ],
+)
+def test_instant(arg, expected) -> None:
+    assert periods.instant(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        (None, InstantError),
+        (DateUnit.YEAR, ValueError),
+        (DateUnit.ETERNITY, ValueError),
+        ("1000-0", ValueError),
+        ("1000-0-0", ValueError),
+        ("1000-1", ValueError),
+        ("1000-1-1", ValueError),
+        ("1", ValueError),
+        ("a", ValueError),
+        ("year", ValueError),
+        ("eternity", ValueError),
+        ("999", ValueError),
+        ("1:1000-01-01", ValueError),
+        ("a:1000-01-01", ValueError),
+        ("year:1000-01-01", ValueError),
+        ("year:1000-01-01:1", ValueError),
+        ("year:1000-01-01:3", ValueError),
+        ("1000-01-01:a", ValueError),
+        ("1000-01-01:1", ValueError),
+        ((), InstantError),
+        ({}, InstantError),
+        ("", InstantError),
+        ((None,), InstantError),
+        ((None, None), InstantError),
+        ((None, None, None), InstantError),
+        ((None, None, None, None), InstantError),
+        (("-1",), InstantError),
+        (("-1", "-1"), InstantError),
+        (("-1", "-1", "-1"), InstantError),
+        (("1-1",), InstantError),
+        (("1-1-1",), InstantError),
+        ((datetime.date(1, 1, 1),), InstantError),
+        ((Instant((1, 1, 1)),), InstantError),
+        ((Period((DateUnit.DAY, Instant((1, 1, 1)), 365)),), InstantError),
+    ],
+)
+def test_instant_with_an_invalid_argument(arg, error) -> None:
+    with pytest.raises(error):
+        periods.instant(arg)

openfisca_core/periods/tests/helpers/test_period.py

@@ -0,0 +1,134 @@
+import datetime
+
+import pytest
+
+from openfisca_core import periods
+from openfisca_core.periods import DateUnit, Instant, Period, PeriodError
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        ("eternity", Period((DateUnit.ETERNITY, Instant((-1, -1, -1)), -1))),
+        ("ETERNITY", Period((DateUnit.ETERNITY, Instant((-1, -1, -1)), -1))),
+        (
+            DateUnit.ETERNITY,
+            Period((DateUnit.ETERNITY, Instant((-1, -1, -1)), -1)),
+        ),
+        (datetime.date(1, 1, 1), Period((DateUnit.DAY, Instant((1, 1, 1)), 1))),
+        (Instant((1, 1, 1)), Period((DateUnit.DAY, Instant((1, 1, 1)), 1))),
+        (
+            Period((DateUnit.DAY, Instant((1, 1, 1)), 365)),
+            Period((DateUnit.DAY, Instant((1, 1, 1)), 365)),
+        ),
+        (-1, Period((DateUnit.YEAR, Instant((-1, 1, 1)), 1))),
+        (0, Period((DateUnit.YEAR, Instant((0, 1, 1)), 1))),
+        (1, Period((DateUnit.YEAR, Instant((1, 1, 1)), 1))),
+        (999, Period((DateUnit.YEAR, Instant((999, 1, 1)), 1))),
+        (1000, Period((DateUnit.YEAR, Instant((1000, 1, 1)), 1))),
+        ("1001", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("1001-01", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 1))),
+        ("1001-01-01", Period((DateUnit.DAY, Instant((1001, 1, 1)), 1))),
+        ("1004-02-29", Period((DateUnit.DAY, Instant((1004, 2, 29)), 1))),
+        ("1001-W01", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 1))),
+        ("1001-W01-1", Period((DateUnit.WEEKDAY, Instant((1000, 12, 29)), 1))),
+        ("year:1001", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-01", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-01-01", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-W01", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 1))),
+        ("year:1001-W01-1", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 1))),
+        ("year:1001:1", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-01:1", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-01-01:1", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("year:1001-W01:1", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 1))),
+        ("year:1001-W01-1:1", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 1))),
+        ("year:1001:3", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 3))),
+        ("year:1001-01:3", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 3))),
+        ("year:1001-01-01:3", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 3))),
+        ("year:1001-W01:3", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 3))),
+        ("year:1001-W01-1:3", Period((DateUnit.YEAR, Instant((1000, 12, 29)), 3))),
+        ("month:1001-01", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 1))),
+        ("month:1001-01-01", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 1))),
+        ("week:1001-W01", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 1))),
+        ("week:1001-W01-1", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 1))),
+        ("month:1001-01:1", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 1))),
+        ("month:1001-01:3", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 3))),
+        ("month:1001-01-01:3", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 3))),
+        ("week:1001-W01:1", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 1))),
+        ("week:1001-W01:3", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 3))),
+        ("week:1001-W01-1:3", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 3))),
+        ("day:1001-01-01", Period((DateUnit.DAY, Instant((1001, 1, 1)), 1))),
+        ("day:1001-01-01:3", Period((DateUnit.DAY, Instant((1001, 1, 1)), 3))),
+        ("weekday:1001-W01-1", Period((DateUnit.WEEKDAY, Instant((1000, 12, 29)), 1))),
+        (
+            "weekday:1001-W01-1:3",
+            Period((DateUnit.WEEKDAY, Instant((1000, 12, 29)), 3)),
+        ),
+    ],
+)
+def test_period(arg, expected) -> None:
+    assert periods.period(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        (None, PeriodError),
+        (DateUnit.YEAR, PeriodError),
+        ("1", PeriodError),
+        ("999", PeriodError),
+        ("1000-0", PeriodError),
+        ("1000-13", PeriodError),
+        ("1000-W0", PeriodError),
+        ("1000-W54", PeriodError),
+        ("1000-0-0", PeriodError),
+        ("1000-1-0", PeriodError),
+        ("1000-2-31", PeriodError),
+        ("1000-W0-0", PeriodError),
+        ("1000-W1-0", PeriodError),
+        ("1000-W1-8", PeriodError),
+        ("a", PeriodError),
+        ("year", PeriodError),
+        ("1:1000", PeriodError),
+        ("a:1000", PeriodError),
+        ("month:1000", PeriodError),
+        ("week:1000", PeriodError),
+        ("day:1000-01", PeriodError),
+        ("weekday:1000-W1", PeriodError),
+        ("1000:a", PeriodError),
+        ("1000:1", PeriodError),
+        ("1000-01:1", PeriodError),
+        ("1000-01-01:1", PeriodError),
+        ("1000-W1:1", PeriodError),
+        ("1000-W1-1:1", PeriodError),
+        ("month:1000:1", PeriodError),
+        ("week:1000:1", PeriodError),
+        ("day:1000:1", PeriodError),
+        ("day:1000-01:1", PeriodError),
+        ("weekday:1000:1", PeriodError),
+        ("weekday:1000-W1:1", PeriodError),
+        ((), PeriodError),
+        ({}, PeriodError),
+        ("", PeriodError),
+        ((None,), PeriodError),
+        ((None, None), PeriodError),
+        ((None, None, None), PeriodError),
+        ((None, None, None, None), PeriodError),
+        ((Instant((1, 1, 1)),), PeriodError),
+        ((Period((DateUnit.DAY, Instant((1, 1, 1)), 365)),), PeriodError),
+        ((1,), PeriodError),
+        ((1, 1), PeriodError),
+        ((1, 1, 1), PeriodError),
+        ((-1,), PeriodError),
+        ((-1, -1), PeriodError),
+        ((-1, -1, -1), PeriodError),
+        (("-1",), PeriodError),
+        (("-1", "-1"), PeriodError),
+        (("-1", "-1", "-1"), PeriodError),
+        (("1-1",), PeriodError),
+        (("1-1-1",), PeriodError),
+    ],
+)
+def test_period_with_an_invalid_argument(arg, error) -> None:
+    with pytest.raises(error):
+        periods.period(arg)

openfisca_core/periods/tests/test_instant.py

@@ -0,0 +1,32 @@
+import pytest
+
+from openfisca_core.periods import DateUnit, Instant
+
+
+@pytest.mark.parametrize(
+    ("instant", "offset", "unit", "expected"),
+    [
+        (Instant((2020, 2, 29)), "first-of", DateUnit.YEAR, Instant((2020, 1, 1))),
+        (Instant((2020, 2, 29)), "first-of", DateUnit.MONTH, Instant((2020, 2, 1))),
+        (Instant((2020, 2, 29)), "first-of", DateUnit.WEEK, Instant((2020, 2, 24))),
+        (Instant((2020, 2, 29)), "first-of", DateUnit.DAY, None),
+        (Instant((2020, 2, 29)), "first-of", DateUnit.WEEKDAY, None),
+        (Instant((2020, 2, 29)), "last-of", DateUnit.YEAR, Instant((2020, 12, 31))),
+        (Instant((2020, 2, 29)), "last-of", DateUnit.MONTH, Instant((2020, 2, 29))),
+        (Instant((2020, 2, 29)), "last-of", DateUnit.WEEK, Instant((2020, 3, 1))),
+        (Instant((2020, 2, 29)), "last-of", DateUnit.DAY, None),
+        (Instant((2020, 2, 29)), "last-of", DateUnit.WEEKDAY, None),
+        (Instant((2020, 2, 29)), -3, DateUnit.YEAR, Instant((2017, 2, 28))),
+        (Instant((2020, 2, 29)), -3, DateUnit.MONTH, Instant((2019, 11, 29))),
+        (Instant((2020, 2, 29)), -3, DateUnit.WEEK, Instant((2020, 2, 8))),
+        (Instant((2020, 2, 29)), -3, DateUnit.DAY, Instant((2020, 2, 26))),
+        (Instant((2020, 2, 29)), -3, DateUnit.WEEKDAY, Instant((2020, 2, 26))),
+        (Instant((2020, 2, 29)), 3, DateUnit.YEAR, Instant((2023, 2, 28))),
+        (Instant((2020, 2, 29)), 3, DateUnit.MONTH, Instant((2020, 5, 29))),
+        (Instant((2020, 2, 29)), 3, DateUnit.WEEK, Instant((2020, 3, 21))),
+        (Instant((2020, 2, 29)), 3, DateUnit.DAY, Instant((2020, 3, 3))),
+        (Instant((2020, 2, 29)), 3, DateUnit.WEEKDAY, Instant((2020, 3, 3))),
+    ],
+)
+def test_offset(instant, offset, unit, expected) -> None:
+    assert instant.offset(offset, unit) == expected

openfisca_core/periods/tests/test_parsers.py

@@ -0,0 +1,129 @@
+import pytest
+
+from openfisca_core.periods import (
+    DateUnit,
+    Instant,
+    InstantError,
+    ParserError,
+    Period,
+    PeriodError,
+    _parsers,
+)
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        ("1001", Instant((1001, 1, 1))),
+        ("1001-01", Instant((1001, 1, 1))),
+        ("1001-12", Instant((1001, 12, 1))),
+        ("1001-01-01", Instant((1001, 1, 1))),
+        ("2028-02-29", Instant((2028, 2, 29))),
+        ("1001-W01", Instant((1000, 12, 29))),
+        ("1001-W52", Instant((1001, 12, 21))),
+        ("1001-W01-1", Instant((1000, 12, 29))),
+    ],
+)
+def test_parse_instant(arg, expected) -> None:
+    assert _parsers.parse_instant(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        (None, InstantError),
+        ({}, InstantError),
+        ((), InstantError),
+        ([], InstantError),
+        (1, InstantError),
+        ("", InstantError),
+        ("à", InstantError),
+        ("1", InstantError),
+        ("-1", InstantError),
+        ("999", InstantError),
+        ("1000-0", InstantError),
+        ("1000-1", ParserError),
+        ("1000-1-1", InstantError),
+        ("1000-00", InstantError),
+        ("1000-13", InstantError),
+        ("1000-01-00", InstantError),
+        ("1000-01-99", InstantError),
+        ("2029-02-29", ParserError),
+        ("1000-W0", InstantError),
+        ("1000-W1", InstantError),
+        ("1000-W99", InstantError),
+        ("1000-W1-0", InstantError),
+        ("1000-W1-1", InstantError),
+        ("1000-W1-99", InstantError),
+        ("1000-W01-0", InstantError),
+        ("1000-W01-00", InstantError),
+    ],
+)
+def test_parse_instant_with_invalid_argument(arg, error) -> None:
+    with pytest.raises(error):
+        _parsers.parse_instant(arg)
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        ("1001", Period((DateUnit.YEAR, Instant((1001, 1, 1)), 1))),
+        ("1001-01", Period((DateUnit.MONTH, Instant((1001, 1, 1)), 1))),
+        ("1001-12", Period((DateUnit.MONTH, Instant((1001, 12, 1)), 1))),
+        ("1001-01-01", Period((DateUnit.DAY, Instant((1001, 1, 1)), 1))),
+        ("1001-W01", Period((DateUnit.WEEK, Instant((1000, 12, 29)), 1))),
+        ("1001-W52", Period((DateUnit.WEEK, Instant((1001, 12, 21)), 1))),
+        ("1001-W01-1", Period((DateUnit.WEEKDAY, Instant((1000, 12, 29)), 1))),
+    ],
+)
+def test_parse_period(arg, expected) -> None:
+    assert _parsers.parse_period(arg) == expected
+
+
+@pytest.mark.parametrize(
+    ("arg", "error"),
+    [
+        (None, PeriodError),
+        ({}, PeriodError),
+        ((), PeriodError),
+        ([], PeriodError),
+        (1, PeriodError),
+        ("", PeriodError),
+        ("à", PeriodError),
+        ("1", PeriodError),
+        ("-1", PeriodError),
+        ("999", PeriodError),
+        ("1000-0", PeriodError),
+        ("1000-1", ParserError),
+        ("1000-1-1", PeriodError),
+        ("1000-00", PeriodError),
+        ("1000-13", PeriodError),
+        ("1000-01-00", PeriodError),
+        ("1000-01-99", PeriodError),
+        ("1000-W0", PeriodError),
+        ("1000-W1", PeriodError),
+        ("1000-W99", PeriodError),
+        ("1000-W1-0", PeriodError),
+        ("1000-W1-1", PeriodError),
+        ("1000-W1-99", PeriodError),
+        ("1000-W01-0", PeriodError),
+        ("1000-W01-00", PeriodError),
+    ],
+)
+def test_parse_period_with_invalid_argument(arg, error) -> None:
+    with pytest.raises(error):
+        _parsers.parse_period(arg)
+
+
+@pytest.mark.parametrize(
+    ("arg", "expected"),
+    [
+        ("2022", DateUnit.YEAR),
+        ("2022-01", DateUnit.MONTH),
+        ("2022-01-01", DateUnit.DAY),
+        ("2022-W01", DateUnit.WEEK),
+        ("2022-W01-1", DateUnit.WEEKDAY),
+    ],
+)
+def test_parse_unit(arg, expected) -> None:
+    assert _parsers.parse_unit(arg) == expected