242 lines
9.3 KiB
Python
242 lines
9.3 KiB
Python
|
"""Consistency property tests for occurrences_between vs occurs_on.
|
|||
|
|
|
|||
|
|
The done-condition: occurrences_between returns an ordered, duplicate-
|
|||
|
|
free list of dates that agrees EXACTLY with calling occurs_on on every
|
|||
|
|
date in the range. This module proves that agreement two ways:
|
|||
|
|
|
|||
|
|
1. An exhaustive sweep over a fixed grid of rules (every rule type ×
|
|||
|
|
several intervals × several windows) cross-checked date by date.
|
|||
|
|
|
|||
|
|
2. A randomized property test (seeded, deterministic) over randomly
|
|||
|
|
generated rules and ranges asserting the two functions never
|
|||
|
|
disagree. Seeds are fixed so failures are reproducible.
|
|||
|
|
"""
|
|||
|
|
from __future__ import annotations
|
|||
|
|
|
|||
|
|
import datetime
|
|||
|
|
import random
|
|||
|
|
|
|||
|
|
import pytest
|
|||
|
|
|
|||
|
|
from custom_components.nestquest.recurrence import (
|
|||
|
|
RuleType,
|
|||
|
|
RuleValidationError,
|
|||
|
|
ScheduleRule,
|
|||
|
|
occurs_on,
|
|||
|
|
occurrences_between,
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def _d(date: str) -> datetime.date:
|
|||
|
|
return datetime.date.fromisoformat(date)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def _check_consistency(
|
|||
|
|
rule: ScheduleRule, start: str, end: str
|
|||
|
|
) -> list[str]:
|
|||
|
|
"""Cross-check occurrences_between against per-date occurs_on.
|
|||
|
|
|
|||
|
|
Returns the occurrences_between result after asserting, for every
|
|||
|
|
date in [start, end]: occurs_on(date) is True iff the date appears
|
|||
|
|
in the result. Also asserts the list is ordered and duplicate-free.
|
|||
|
|
"""
|
|||
|
|
result = occurrences_between(rule, start, end)
|
|||
|
|
# Ordered and duplicate-free.
|
|||
|
|
assert result == sorted(set(result)), (
|
|||
|
|
f"occurrences_between must be ordered, duplicate-free: {result}"
|
|||
|
|
)
|
|||
|
|
# Exact agreement with occurs_on over every date in the range.
|
|||
|
|
cursor = _d(start)
|
|||
|
|
end_date = _d(end)
|
|||
|
|
expected: list[str] = []
|
|||
|
|
while cursor <= end_date:
|
|||
|
|
if occurs_on(rule, cursor):
|
|||
|
|
expected.append(cursor.isoformat())
|
|||
|
|
cursor += datetime.timedelta(days=1)
|
|||
|
|
assert result == expected, (
|
|||
|
|
f"disagreement for {rule.to_dict()} over [{start}, {end}]:\n"
|
|||
|
|
f" occurrences_between: {result}\n"
|
|||
|
|
f" per-date occurs_on: {expected}"
|
|||
|
|
)
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ---------------------------------------------------------------------------
|
|||
|
|
# Exhaustive grid over rule shapes, intervals and windows
|
|||
|
|
# ---------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
|
|||
|
|
_GRID_RULES = [
|
|||
|
|
ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-03-01"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.DAILY, interval=2,
|
|||
|
|
start_date="2026-03-01"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.DAILY, interval=3,
|
|||
|
|
start_date="2026-03-15", end_date="2027-01-31"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
|
|||
|
|
start_date="2026-03-03"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={1, 3, 5},
|
|||
|
|
interval=2, start_date="2026-03-06",
|
|||
|
|
end_date="2027-06-30"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 4},
|
|||
|
|
start_date="2026-03-06"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
|
|||
|
|
start_date="2026-03-31"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=29,
|
|||
|
|
interval=2, start_date="2026-01-29"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
|
|||
|
|
nth_weekday_weekday=1, start_date="2026-03-03"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=-1,
|
|||
|
|
nth_weekday_weekday=4, start_date="2026-03-06",
|
|||
|
|
end_date="2028-12-31"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.YEARLY, month=2, day_of_month=29,
|
|||
|
|
start_date="2026-02-28"),
|
|||
|
|
ScheduleRule(rule_type=RuleType.YEARLY, month=6, day_of_month=15,
|
|||
|
|
interval=2, start_date="2026-06-15"),
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
_GRID_WINDOWS = [
|
|||
|
|
("2026-01-01", "2026-03-31"), # mostly before start
|
|||
|
|
("2026-03-01", "2026-03-01"), # single day == anchor
|
|||
|
|
("2026-03-01", "2026-03-31"), # within window
|
|||
|
|
("2026-08-01", "2026-08-31"), # mid-window month
|
|||
|
|
("2026-12-01", "2027-01-31"), # year boundary
|
|||
|
|
("2028-01-01", "2028-03-01"), # leap year span
|
|||
|
|
("2029-01-01", "2029-12-31"), # far out
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
|
|||
|
|
@pytest.mark.parametrize(
|
|||
|
|
"rule_index,window_index",
|
|||
|
|
[
|
|||
|
|
(rule_index, window_index)
|
|||
|
|
for rule_index in range(len(_GRID_RULES))
|
|||
|
|
for window_index in range(len(_GRID_WINDOWS))
|
|||
|
|
],
|
|||
|
|
)
|
|||
|
|
def test_grid_occurrences_between_matches_occurs_on(
|
|||
|
|
rule_index, window_index
|
|||
|
|
) -> None:
|
|||
|
|
rule = _GRID_RULES[rule_index]
|
|||
|
|
window = _GRID_WINDOWS[window_index]
|
|||
|
|
_check_consistency(rule, window[0], window[1])
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ---------------------------------------------------------------------------
|
|||
|
|
# Randomized property test (seeded, deterministic)
|
|||
|
|
# ---------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
|
|||
|
|
def _generate_random_rules(rng: random.Random, count: int) -> list[ScheduleRule]:
|
|||
|
|
"""Random but valid rules: shapes, intervals, anchors, windows.
|
|||
|
|
|
|||
|
|
Any random combo the model rejects (genuinely invalid combinations)
|
|||
|
|
is skipped — the property only needs VALID rules; the assertion at
|
|||
|
|
the end bounds how many may be rejected.
|
|||
|
|
"""
|
|||
|
|
rules: list[ScheduleRule] = []
|
|||
|
|
shapes = list(RuleType)
|
|||
|
|
for index in range(count):
|
|||
|
|
shape = shapes[rng.randrange(len(shapes))]
|
|||
|
|
interval = rng.choice([1, 2, 3, 7])
|
|||
|
|
anchor = datetime.date(
|
|||
|
|
rng.choice([2024, 2025, 2026, 2027, 2028]),
|
|||
|
|
rng.randrange(1, 13),
|
|||
|
|
rng.randrange(1, 28),
|
|||
|
|
)
|
|||
|
|
end_offset = rng.choice([45, 120, 400, 800])
|
|||
|
|
end = anchor + datetime.timedelta(days=end_offset)
|
|||
|
|
common = {
|
|||
|
|
"rule_type": shape,
|
|||
|
|
"interval": interval,
|
|||
|
|
"start_date": anchor.isoformat(),
|
|||
|
|
"end_date": end.isoformat(),
|
|||
|
|
}
|
|||
|
|
try:
|
|||
|
|
if shape is RuleType.WEEKLY:
|
|||
|
|
rules.append(ScheduleRule(
|
|||
|
|
**common,
|
|||
|
|
weekday_set={
|
|||
|
|
rng.randrange(7)
|
|||
|
|
for _ in range(rng.randrange(1, 4))
|
|||
|
|
},
|
|||
|
|
))
|
|||
|
|
elif shape is RuleType.CUSTOM_DAYS:
|
|||
|
|
rules.append(ScheduleRule(
|
|||
|
|
**common,
|
|||
|
|
weekday_set={
|
|||
|
|
rng.randrange(7)
|
|||
|
|
for _ in range(rng.randrange(1, 4))
|
|||
|
|
},
|
|||
|
|
))
|
|||
|
|
elif shape is RuleType.MONTHLY_DAY:
|
|||
|
|
rules.append(ScheduleRule(
|
|||
|
|
**common, day_of_month=rng.randrange(1, 32)
|
|||
|
|
))
|
|||
|
|
elif shape is RuleType.MONTHLY_WEEKDAY:
|
|||
|
|
rules.append(ScheduleRule(
|
|||
|
|
**common,
|
|||
|
|
nth_weekday=rng.choice([-1, 1, 2, 3, 4, 5]),
|
|||
|
|
nth_weekday_weekday=rng.randrange(7),
|
|||
|
|
))
|
|||
|
|
elif shape is RuleType.YEARLY:
|
|||
|
|
rules.append(ScheduleRule(
|
|||
|
|
**common,
|
|||
|
|
month=rng.randrange(1, 13),
|
|||
|
|
day_of_month=rng.choice([None, rng.randrange(1, 29)]),
|
|||
|
|
))
|
|||
|
|
else: # DAILY
|
|||
|
|
rules.append(ScheduleRule(**common))
|
|||
|
|
except RuleValidationError:
|
|||
|
|
continue
|
|||
|
|
assert len(rules) >= count * 3 // 4, "too many random rules rejected"
|
|||
|
|
return rules
|
|||
|
|
|
|||
|
|
|
|||
|
|
def test_random_rules_never_disagree_between_the_two_functions() -> None:
|
|||
|
|
"""The property: for randomly generated rules and ranges,
|
|||
|
|
occurrences_between(rule, s, e) == [d for d in s..e if occurs_on]."""
|
|||
|
|
rng = random.Random(0xFEA7) # fixed seed for reproducibility
|
|||
|
|
rules = _generate_random_rules(rng, count=40)
|
|||
|
|
checked = 0
|
|||
|
|
for rule in rules:
|
|||
|
|
anchor = datetime.date.fromisoformat(rule.start_date)
|
|||
|
|
for offset_days, span_days in ((-30, 60), (0, 14), (10, 90),
|
|||
|
|
(100, 200)):
|
|||
|
|
range_start = anchor + datetime.timedelta(days=offset_days)
|
|||
|
|
range_end = range_start + datetime.timedelta(days=span_days)
|
|||
|
|
_check_consistency(
|
|||
|
|
rule, range_start.isoformat(), range_end.isoformat()
|
|||
|
|
)
|
|||
|
|
checked += 1
|
|||
|
|
assert checked >= 40 * 4 * 3 // 4, checked
|
|||
|
|
|
|||
|
|
|
|||
|
|
def test_random_ranges_include_year_and_leap_spans() -> None:
|
|||
|
|
"""Every rule is probed across a range that spans Jan 1 (twice) and
|
|||
|
|
a February 29 — the Dec 1..Mar 1 two-year span always covers both."""
|
|||
|
|
rng = random.Random(42)
|
|||
|
|
rules = _generate_random_rules(rng, count=12)
|
|||
|
|
for rule in rules:
|
|||
|
|
anchor = datetime.date.fromisoformat(rule.start_date)
|
|||
|
|
probe_start = datetime.date(anchor.year, 12, 1)
|
|||
|
|
probe_end = datetime.date(anchor.year + 2, 3, 1)
|
|||
|
|
# The span always contains two Jan 1s and a Feb 28/29 pair.
|
|||
|
|
assert probe_end >= probe_start
|
|||
|
|
_check_consistency(
|
|||
|
|
rule, probe_start.isoformat(), probe_end.isoformat()
|
|||
|
|
)
|
|||
|
|
# An additional probe pinned ON a Feb 29 window (2028 leap):
|
|||
|
|
# every rule is cross-checked over Feb 1 - Mar 15 2028.
|
|||
|
|
_check_consistency(rule, "2028-02-01", "2028-03-15")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def test_occurrences_between_single_day_range_matches_occurs_on() -> None:
|
|||
|
|
"""A one-day range is the exact occurs_on of that date."""
|
|||
|
|
for rule in _GRID_RULES:
|
|||
|
|
for day in ("2026-03-05", "2026-03-15", "2027-06-15"):
|
|||
|
|
single = occurrences_between(rule, day, day)
|
|||
|
|
if occurs_on(rule, _d(day)):
|
|||
|
|
assert single == [day], (rule.to_dict(), day, single)
|
|||
|
|
else:
|
|||
|
|
assert single == [], (rule.to_dict(), day, single)
|