Antoine Van Elstraete
d7d31e14ff
Co-authored-by: Codex/gpt-5.6-terra <codex-gpt-5-6-terra@agents.invalid>
467 lines
15 KiB
Python
467 lines
15 KiB
Python
"""Integration tests for the M11 pipeline orchestration."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from datetime import date, datetime
|
|
from typing import Any, cast
|
|
|
|
import pytest
|
|
from pydantic import SecretStr
|
|
|
|
from pronote_sync.config.settings import AppSettings, PronoteSettings, Settings
|
|
from pronote_sync.errors import PipelineCriticalError, PipelineWarning
|
|
from pronote_sync.models.agenda import Lesson, LessonStatus, SchoolEvent
|
|
from pronote_sync.models.diff import AgendaDiff
|
|
from pronote_sync.models.homework import Homework
|
|
from pronote_sync.models.message import Message
|
|
from pronote_sync.models.sync import CalDAVSyncResult, CalDAVSyncStatus
|
|
from pronote_sync.pipeline.run import PipelineRunner
|
|
from pronote_sync.sources.pronote.fallback import PronoteFetcher
|
|
from pronote_sync.sync.diff import AgendaComparator
|
|
|
|
|
|
class StubFetcher:
|
|
"""Pronote fetcher returning deterministic data and recording its calls."""
|
|
|
|
def __init__(self, calls: list[str], lesson: Lesson, homework: Homework) -> None:
|
|
"""Store the dependencies required by the stub.
|
|
|
|
:param calls: Shared call-order recorder.
|
|
:param lesson: Lesson returned by the agenda method.
|
|
:param homework: Homework returned by the homework method.
|
|
"""
|
|
self._calls = calls
|
|
self._lesson = lesson
|
|
self._homework = homework
|
|
|
|
def fetch_agenda(self) -> tuple[list[Lesson], list[SchoolEvent]]:
|
|
"""Return one lesson for the target date.
|
|
|
|
:return: The lesson and no school event.
|
|
:rtype: tuple[list[Lesson], list[SchoolEvent]]
|
|
"""
|
|
self._calls.append("fetch")
|
|
return [self._lesson], []
|
|
|
|
def fetch_homework(self, target_date: date) -> list[Homework]:
|
|
"""Return the configured homework.
|
|
|
|
:param target_date: Requested due date.
|
|
:return: The configured homework.
|
|
:rtype: list[Homework]
|
|
"""
|
|
self._calls.append("fetch_homework")
|
|
assert target_date == self._lesson.start.date()
|
|
return [self._homework]
|
|
|
|
def fetch_messages(self) -> list[Message]:
|
|
"""Return no Pronote messages.
|
|
|
|
:return: An empty list.
|
|
:rtype: list[Message]
|
|
"""
|
|
self._calls.append("fetch_messages")
|
|
return []
|
|
|
|
def fetch_informations(self) -> list[Message]:
|
|
"""Return no Pronote information messages.
|
|
|
|
:return: An empty list.
|
|
:rtype: list[Message]
|
|
"""
|
|
self._calls.append("fetch_informations")
|
|
return []
|
|
|
|
|
|
class StubChannel:
|
|
"""Notification channel recording its send attempts."""
|
|
|
|
def __init__(self, calls: list[str]) -> None:
|
|
"""Store the shared call-order recorder.
|
|
|
|
:param calls: Shared call-order recorder.
|
|
"""
|
|
self._calls = calls
|
|
self.messages: list[Any] = []
|
|
|
|
def send(self, message: Any) -> bool:
|
|
"""Record an outgoing message.
|
|
|
|
:param message: Message produced by the runner.
|
|
:return: Always ``True``.
|
|
:rtype: bool
|
|
"""
|
|
self.messages.append(message)
|
|
self._calls.append("send")
|
|
return True
|
|
|
|
|
|
class StubComparator:
|
|
"""Agenda comparator recording comparison calls."""
|
|
|
|
def __init__(self, calls: list[str]) -> None:
|
|
"""Store the shared call-order recorder.
|
|
|
|
:param calls: Shared call-order recorder.
|
|
"""
|
|
self._calls = calls
|
|
|
|
def compare(self, lessons: list[Lesson], target_date: date) -> AgendaDiff:
|
|
"""Return an empty diff after recording the comparison.
|
|
|
|
:param lessons: Normalized lessons.
|
|
:param target_date: Target digest date.
|
|
:return: Empty agenda diff.
|
|
:rtype: AgendaDiff
|
|
"""
|
|
self._calls.append("compare")
|
|
return AgendaDiff(target_date=target_date)
|
|
|
|
|
|
@pytest.fixture
|
|
def pipeline_inputs() -> tuple[Lesson, Homework]:
|
|
"""Return deterministic Pronote data targeting 2026-09-09.
|
|
|
|
:return: A lesson and homework pair.
|
|
:rtype: tuple[Lesson, Homework]
|
|
"""
|
|
lesson = Lesson(
|
|
id="lesson-1",
|
|
start=datetime(2026, 9, 9, 8, 0),
|
|
end=datetime(2026, 9, 9, 9, 0),
|
|
subject="Maths",
|
|
group=None,
|
|
status=LessonStatus.NORMAL,
|
|
content=None,
|
|
)
|
|
homework = Homework(
|
|
id="homework-1",
|
|
subject="Maths",
|
|
assigned_on=None,
|
|
due_on=date(2026, 9, 9),
|
|
text="Exercise 1",
|
|
)
|
|
return lesson, homework
|
|
|
|
|
|
def successful_sync_result() -> CalDAVSyncResult:
|
|
"""Construit un résultat CalDAV de succès compatible avec mypy.
|
|
|
|
:return: Résultat de synchronisation sans changement.
|
|
:rtype: CalDAVSyncResult
|
|
"""
|
|
return CalDAVSyncResult(status=CalDAVSyncStatus.SUCCESS, added=0, updated=0, removed=0)
|
|
|
|
|
|
def _record_ical_fetch(calls: list[str], url: str) -> str:
|
|
"""Enregistre un téléchargement iCal simulé.
|
|
|
|
:param calls: Liste partagée des téléchargements.
|
|
:param url: URL iCal reçue par la source.
|
|
:return: Contenu iCal minimal simulé.
|
|
:rtype: str
|
|
"""
|
|
calls.append(url)
|
|
return "BEGIN:VCALENDAR"
|
|
|
|
|
|
def test_runner_executes_steps_in_contractual_order(
|
|
pipeline_inputs: tuple[Lesson, Homework],
|
|
) -> None:
|
|
"""The runner executes fetch, blog, comparison, CalDAV, synthesis, then XMPP."""
|
|
lesson, homework = pipeline_inputs
|
|
calls: list[str] = []
|
|
|
|
def synchronize(data: Any, settings: Settings) -> CalDAVSyncResult:
|
|
"""Record the CalDAV step.
|
|
|
|
:param data: Normalized Pronote data.
|
|
:param settings: Effective settings.
|
|
:return: Successful result.
|
|
:rtype: CalDAVSyncResult
|
|
"""
|
|
del data, settings
|
|
calls.append("caldav_sync")
|
|
return successful_sync_result()
|
|
|
|
class RaisingSynthesisProvider:
|
|
"""Synthesis provider used solely to record the optional stage."""
|
|
|
|
def generate(self, input_data: Any) -> None:
|
|
"""Record synthesis and return no result.
|
|
|
|
:param input_data: Synthesis input.
|
|
:return: No synthesis.
|
|
:rtype: None
|
|
"""
|
|
del input_data
|
|
calls.append("synthesis")
|
|
return None
|
|
|
|
runner = PipelineRunner(
|
|
settings=Settings(),
|
|
pronote_fetcher=StubFetcher(calls, lesson, homework),
|
|
caldav_synchronizer=synchronize,
|
|
agenda_comparator=cast("AgendaComparator", StubComparator(calls)),
|
|
synthesis_provider=RaisingSynthesisProvider(),
|
|
channel=StubChannel(calls),
|
|
now_provider=lambda: datetime(2026, 9, 8, 7, 0),
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is not None
|
|
assert errors == []
|
|
assert calls == [
|
|
"fetch",
|
|
"fetch_homework",
|
|
"fetch_messages",
|
|
"fetch_informations",
|
|
"compare",
|
|
"caldav_sync",
|
|
"synthesis",
|
|
"send",
|
|
]
|
|
|
|
|
|
def test_runner_continues_to_xmpp_when_synthesis_fails(
|
|
pipeline_inputs: tuple[Lesson, Homework],
|
|
) -> None:
|
|
"""A non-critical synthesis exception produces a warning and still sends XMPP."""
|
|
lesson, homework = pipeline_inputs
|
|
calls: list[str] = []
|
|
|
|
class FailingSynthesisProvider:
|
|
"""Synthesis provider raising a non-critical error."""
|
|
|
|
def generate(self, input_data: Any) -> None:
|
|
"""Raise a deterministic optional-stage failure.
|
|
|
|
:param input_data: Synthesis input.
|
|
:raises RuntimeError: Always.
|
|
"""
|
|
del input_data
|
|
raise RuntimeError("synthetic AI failure")
|
|
|
|
runner = PipelineRunner(
|
|
settings=Settings(),
|
|
pronote_fetcher=StubFetcher(calls, lesson, homework),
|
|
caldav_synchronizer=lambda data, settings: successful_sync_result(),
|
|
synthesis_provider=FailingSynthesisProvider(),
|
|
channel=StubChannel(calls),
|
|
now_provider=lambda: datetime(2026, 9, 8, 7, 0),
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is not None
|
|
assert calls[-1] == "send"
|
|
assert len(errors) == 1
|
|
assert isinstance(errors[0], PipelineWarning)
|
|
assert errors[0].step == "synthesis"
|
|
|
|
|
|
def test_runner_dry_run_skips_caldav_and_xmpp_writes(
|
|
pipeline_inputs: tuple[Lesson, Homework],
|
|
) -> None:
|
|
"""Dry-run bypasses both mutable destination boundaries."""
|
|
lesson, homework = pipeline_inputs
|
|
calls: list[str] = []
|
|
|
|
def dry_run_caldav(data: Any, settings: Settings) -> CalDAVSyncResult:
|
|
"""Verify that the CalDAV boundary receives dry-run settings.
|
|
|
|
:param data: Normalized Pronote data.
|
|
:param settings: Effective settings.
|
|
:return: A skipped result.
|
|
:rtype: CalDAVSyncResult
|
|
"""
|
|
del data
|
|
calls.append("caldav_sync")
|
|
assert settings.app.dry_run is True
|
|
return CalDAVSyncResult(status=CalDAVSyncStatus.SKIPPED, added=0, updated=0, removed=0)
|
|
|
|
runner = PipelineRunner(
|
|
settings=Settings(app=AppSettings(dry_run=True)),
|
|
pronote_fetcher=StubFetcher(calls, lesson, homework),
|
|
caldav_synchronizer=dry_run_caldav,
|
|
channel=StubChannel(calls),
|
|
now_provider=lambda: datetime(2026, 9, 8, 7, 0),
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is not None
|
|
assert errors == []
|
|
assert "caldav_sync" in calls
|
|
assert "send" not in calls
|
|
|
|
|
|
def test_runner_without_theoretical_agenda_produces_an_empty_diff(
|
|
pipeline_inputs: tuple[Lesson, Homework],
|
|
) -> None:
|
|
"""A disabled theoretical agenda reaches XMPP with no agenda changes."""
|
|
lesson, homework = pipeline_inputs
|
|
calls: list[str] = []
|
|
channel = StubChannel(calls)
|
|
runner = PipelineRunner(
|
|
settings=Settings(app=AppSettings(theoretical_agenda_path=None)),
|
|
pronote_fetcher=StubFetcher(calls, lesson, homework),
|
|
caldav_synchronizer=lambda data, settings: successful_sync_result(),
|
|
channel=channel,
|
|
now_provider=lambda: datetime(2026, 9, 8, 7, 0),
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is not None
|
|
assert errors == []
|
|
assert len(channel.messages) == 1
|
|
assert channel.messages[0].changes == ()
|
|
|
|
|
|
def test_runner_reports_critical_error_when_no_pronote_source_is_available() -> None:
|
|
"""No configured Pronote source returns an explicit critical pipeline error."""
|
|
settings = Settings(pronote=PronoteSettings())
|
|
runner = PipelineRunner(
|
|
settings=settings,
|
|
pronote_fetcher=PronoteFetcher(settings, object()), # type: ignore[arg-type]
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is None
|
|
assert len(errors) == 1
|
|
assert isinstance(errors[0], PipelineCriticalError)
|
|
assert errors[0].step is None
|
|
assert "ni la source iCal ni pronotepy" in errors[0].message
|
|
|
|
|
|
def test_from_settings_without_theoretical_agenda_does_not_instantiate_comparator(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Missing theoretical configuration keeps comparison disabled without constructing it."""
|
|
import pronote_sync.pipeline.run as run_module
|
|
|
|
def forbidden_comparator(provider: object) -> None:
|
|
"""Fail if comparison is constructed without configuration.
|
|
|
|
:param provider: The provider unexpectedly supplied.
|
|
:raises AssertionError: Always.
|
|
"""
|
|
del provider
|
|
raise AssertionError("AgendaComparator must not be instantiated")
|
|
|
|
monkeypatch.setattr(run_module, "AgendaComparator", forbidden_comparator)
|
|
|
|
runner = PipelineRunner.from_settings(Settings(app=AppSettings(theoretical_agenda_path=None)))
|
|
|
|
assert runner._agenda_comparator is None
|
|
|
|
|
|
def test_from_settings_with_theoretical_agenda_instantiates_comparator(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Configured theoretical agenda constructs the comparator with its provider."""
|
|
import pronote_sync.pipeline.run as run_module
|
|
|
|
provider = object()
|
|
constructed_with: list[object] = []
|
|
|
|
class RecordingComparator:
|
|
"""Comparator constructor recording the supplied provider."""
|
|
|
|
def __init__(self, received_provider: object) -> None:
|
|
"""Record the provider used by the composition root.
|
|
|
|
:param received_provider: The constructed theoretical provider.
|
|
"""
|
|
constructed_with.append(received_provider)
|
|
|
|
monkeypatch.setattr(run_module, "get_theoretical_provider", lambda *args: provider)
|
|
monkeypatch.setattr(run_module, "AgendaComparator", RecordingComparator)
|
|
|
|
runner = PipelineRunner.from_settings(
|
|
Settings(app=AppSettings(theoretical_agenda_path="/agenda.json"))
|
|
)
|
|
|
|
assert constructed_with == [provider]
|
|
assert isinstance(runner._agenda_comparator, RecordingComparator)
|
|
|
|
|
|
def test_runner_reuses_ical_download_and_parse_within_one_run(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
pipeline_inputs: tuple[Lesson, Homework],
|
|
) -> None:
|
|
"""An iCal agenda/homework selection downloads and parses once per runner run."""
|
|
import pronote_sync.sources.pronote.fallback as fallback_module
|
|
|
|
lesson, _ = pipeline_inputs
|
|
settings = Settings(
|
|
pronote=PronoteSettings(
|
|
ical_url=SecretStr("https://pronote.example.test/calendar.ics"),
|
|
agenda_source="ical",
|
|
homework_source="ical",
|
|
)
|
|
)
|
|
fetch_calls: list[str] = []
|
|
monkeypatch.setattr(
|
|
fallback_module,
|
|
"fetch_ical",
|
|
lambda url: _record_ical_fetch(fetch_calls, url),
|
|
)
|
|
monkeypatch.setattr(fallback_module, "parse_ical", lambda raw: ([lesson], [], []))
|
|
|
|
class NoMessageClient:
|
|
"""Minimal pronotepy client for non-critical M11 fetches."""
|
|
|
|
def get_messages(self) -> list[Message]:
|
|
"""Return no messages.
|
|
|
|
:return: An empty list.
|
|
:rtype: list[Message]
|
|
"""
|
|
return []
|
|
|
|
def get_informations(self) -> list[Message]:
|
|
"""Return no information messages.
|
|
|
|
:return: An empty list.
|
|
:rtype: list[Message]
|
|
"""
|
|
return []
|
|
|
|
def get_lessons(self, start: date, end: date) -> list[Lesson]:
|
|
"""Ne retourne aucun cours de repli.
|
|
|
|
:param start: Début de la fenêtre.
|
|
:param end: Fin de la fenêtre.
|
|
:return: Liste vide.
|
|
:rtype: list[Lesson]
|
|
"""
|
|
del start, end
|
|
return []
|
|
|
|
def get_homeworks(self, start: date, end: date) -> list[Homework]:
|
|
"""Ne retourne aucun devoir de repli.
|
|
|
|
:param start: Début de la fenêtre.
|
|
:param end: Fin de la fenêtre.
|
|
:return: Liste vide.
|
|
:rtype: list[Homework]
|
|
"""
|
|
del start, end
|
|
return []
|
|
|
|
runner = PipelineRunner(
|
|
settings=settings,
|
|
pronote_fetcher=PronoteFetcher(settings, NoMessageClient()),
|
|
now_provider=lambda: datetime(2026, 9, 8, 7, 0),
|
|
)
|
|
|
|
data, errors = runner.run()
|
|
|
|
assert data is not None
|
|
assert errors == []
|
|
assert fetch_calls == ["https://pronote.example.test/calendar.ics"]
|