diff --git a/.gitea/workflows/_ci-common.yaml b/.gitea/workflows/_ci-common.yaml index 044edcb..b73c847 100644 --- a/.gitea/workflows/_ci-common.yaml +++ b/.gitea/workflows/_ci-common.yaml @@ -32,3 +32,25 @@ jobs: cache-to: type=gha,mode=max - name: Smoke test (compile sanity) run: docker run --rm --name mcp-ics-smoke-$(hostname) ci-image:${{ github.sha }} python -m compileall -q src/ + + pytest: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@f87e5991a6d7451dcb8d9637bfbc97413f497069 # v4 + - name: Build (cached) + uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0 + with: + context: . + file: pkg/Dockerfile + push: false + load: true + tags: ci-image:${{ github.sha }} + cache-from: type=gha + cache-to: type=gha,mode=max + - name: Unit tests (pytest, in-image env with prod requirements) + run: > + docker run --rm ci-image:${{ github.sha }} + sh -c "pip install pytest --quiet && python -m pytest tests/ -q" diff --git a/pkg/Dockerfile b/pkg/Dockerfile index e374b28..43f106f 100644 --- a/pkg/Dockerfile +++ b/pkg/Dockerfile @@ -16,5 +16,8 @@ RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements.txt # Copy the source code COPY src/ ./src/ +# Copy tests (used by CI; harmless in production) +COPY tests/ ./tests/ + # Command to run the MCP server CMD ["python", "src/server.py"] diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..eeb9d41 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +testpaths = tests +addopts = -q diff --git a/src/server.py b/src/server.py index 07b6b35..aaf91e2 100644 --- a/src/server.py +++ b/src/server.py @@ -35,13 +35,15 @@ CALDAV_DATA_PATH = os.environ.get("CALDAV_DATA_PATH", "") EXCLUDE_PATTERN = os.environ.get("EXCLUDE_PATTERN", "") BIRTHDAY_PATTERN = os.environ.get("BIRTHDAY_PATTERN", r"^Anniversaire|^Anniv") -if not CALDAV_DATA_PATH: - raise ValueError("CALDAV_DATA_PATH environment variable is required.") -logger.info("Starting MCP CalDAV server with data path: %s", CALDAV_DATA_PATH) -if EXCLUDE_PATTERN: - logger.info("Exclude pattern: %s", EXCLUDE_PATTERN) -logger.info("Birthday pattern: %s", BIRTHDAY_PATTERN) +def _validate_startup_config(caldav_data_path: str = CALDAV_DATA_PATH) -> None: + """Validates required startup configuration, raising on missing values.""" + if not caldav_data_path: + raise ValueError("CALDAV_DATA_PATH environment variable is required.") + + +if __name__ == "__main__" or os.environ.get("MCP_ICS_VALIDATE_ON_IMPORT") == "1": + _validate_startup_config() # Compile patterns once at startup _exclude_re: Optional[re.Pattern] = None diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..bc107e4 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,149 @@ +"""Shared fixtures: a fake Radicale data tree on disk + pre-imported server module.""" + +import json +import os +import sys +import textwrap +from pathlib import Path + +import pytest + +REPO_ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(REPO_ROOT / "src")) + + +def _write(path: Path, content: str) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(content, encoding="utf-8") + return path + + +def _cal_props(displayname: str = "", description: str = "") -> str: + props = {"tag": "VCALENDAR"} + if displayname: + props["D:displayname"] = displayname + if description: + props["C:calendar-description"] = description + return json.dumps(props) + + +ICS_HEADER = "BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//mcp-ics-test//EN\n" +ICS_FOOTER = "END:VCALENDAR\n" + + +def _ics(body: str) -> str: + return ICS_HEADER + body + ICS_FOOTER + + +@pytest.fixture(scope="module") +def radicale_tree(tmp_path_factory) -> Path: + """A minimal Radicale collection-root layout covering edge cases.""" + root = tmp_path_factory.mktemp("radicale") + cr = root / "collections" / "collection-root" + + # user 'manuel', regular calendar + cal = cr / "manuel" / "perso" + _write(cal / ".Radicale.props", _cal_props("Perso manuel", "Agenda perso")) + _write( + cal / "abc.ics", + ICS_HEADER + + ( + "BEGIN:VEVENT\n" + "UID:evt-1@test\n" + "DTSTAMP:20260101T000000Z\n" + "DTSTART:20260315T090000\n" + "DTEND:20260315T100000\n" + "SUMMARY:Réunion équipe\n" + "LOCATION:Bureau\n" + "DESCRIPTION:Point hebdo\n" + "END:VEVENT\n" + ) + + ICS_FOOTER, + ) + # recurring weekly event (10 occurrences) + _write( + cal / "recurring.ics", + ICS_HEADER + + ( + "BEGIN:VEVENT\n" + "UID:evt-rrule@test\n" + "DTSTAMP:20260101T000000Z\n" + "DTSTART:20260302T070000\n" + "DTEND:20260302T080000\n" + "RRULE:FREQ=WEEKLY;COUNT=10\n" + "SUMMARY:Présence matinale\n" + "END:VEVENT\n" + ) + + ICS_FOOTER, + ) + # birthday (filtered by default via BIRTHDAY_PATTERN) + excluded summary + _write( + cal / "special.ics", + ICS_HEADER + + ( + "BEGIN:VEVENT\n" + "UID:birth-1@test\n" + "DTSTAMP:20260101T000000Z\n" + "DTSTART;VALUE=DATE:20260410\n" + "SUMMARY:Anniversaire Marc\n" + "END:VEVENT\n" + "BEGIN:VEVENT\n" + "UID:trash-1@test\n" + "DTSTAMP:20260101T000000Z\n" + "DTSTART:20260316T180000\n" + "SUMMARY:Poubelle verte\n" + "END:VEVENT\n" + ) + + ICS_FOOTER, + ) + # VTODO on a second calendar + cal2 = cr / "manuel" / "taches" + _write(cal2 / ".Radicale.props", _cal_props("Tâches")) + _write( + cal2 / "todo.ics", + ICS_HEADER + + ( + "BEGIN:VTODO\n" + "UID:todo-1@test\n" + "DTSTAMP:20260101T000000Z\n" + "DUE:20260320T170000\n" + "STATUS:NEEDS-ACTION\n" + "SUMMARY:Ranger le garage\n" + "END:VTODO\n" + ) + + ICS_FOOTER, + ) + # user 'robert' with a family calendar + cal3 = cr / "robert" / "famille" + _write(cal3 / ".Radicale.props", _cal_props("Famille")) + _write(cal3 / "x.ics", ICS_HEADER + ICS_FOOTER) # empty calendar + + # VADDRESSBOOK (contacts) must be ignored + _write(cr / "robert" / "contacts" / ".Radicale.props", '{"tag": "VADDRESSBOOK"}') + # hidden dirs ignored + (cr / ".stfolder").mkdir(parents=True) + _write(cr / ".stfolder" / "x" / ".Radicale.props", '{"tag": "VCALENDAR"}') + (cr / "manuel" / ".trash").mkdir(parents=True) + _write(cr / "manuel" / ".trash" / "y.ics", ICS_HEADER + ICS_FOOTER) + # corrupt props must be skipped with a warning + _write(cr / "manuel" / "broken" / ".Radicale.props", "{not json") + _write(cr / "manuel" / "broken" / "z.ics", ICS_HEADER + ICS_FOOTER) + return root + + +@pytest.fixture(scope="module") +def server(radicale_tree): + """Import the server module once per module with the fixture tree as data path.""" + os.environ["CALDAV_DATA_PATH"] = str(radicale_tree) + os.environ["EXCLUDE_PATTERN"] = "^Poubelle" + os.environ["BIRTHDAY_PATTERN"] = "^Anniversaire|^Anniv" + import server # noqa: E402 + + return server + + +@pytest.fixture() +def server_mod(server, monkeypatch, radicale_tree): + """Reset mutable module state around each test.""" + monkeypatch.setattr(server, "CALDAV_DATA_PATH", str(radicale_tree)) + return server diff --git a/tests/test_server.py b/tests/test_server.py new file mode 100644 index 0000000..294b92c --- /dev/null +++ b/tests/test_server.py @@ -0,0 +1,313 @@ +"""Unit tests for mcp-ics server (pure functions, no server, no Docker).""" + +import calendar as calmod +import logging +from datetime import date, datetime + +import icalendar +import pytest + +import conftest # noqa: F401 (sys.path setup) + + +# ---------------------------------------------------------------- discover_calendars + +def test_discover_finds_calendars_with_names(server_mod, radicale_tree): + cals = server_mod.discover_calendars(str(radicale_tree)) + by_path = {c["path"]: c for c in cals} + assert len(cals) == 3 # perso, taches, famille + assert by_path[str(radicale_tree / "collections/collection-root/manuel/perso")][ + "name" + ] == "Perso manuel" + assert by_path[str(radicale_tree / "collections/collection-root/manuel/taches")][ + "name" + ] == "Tâches" + assert by_path[str(radicale_tree / "collections/collection-root/robert/famille")][ + "user" + ] == "robert" + + +def test_discover_skips_vaddressbook_hidden_and_broken(server_mod, radicale_tree): + cals = server_mod.discover_calendars(str(radicale_tree)) + paths = " ".join(c["path"] for c in cals) + assert "contacts" not in paths + assert ".stfolder" not in paths + assert ".trash" not in paths + assert "broken" not in paths + + +def test_discover_missing_collection_root(server, tmp_path): + assert server.discover_calendars(str(tmp_path / "nowhere")) == [] + + +def test_discover_empty_path(server): + assert server.discover_calendars("") == [] + + +def test_discover_defaults_displayname_to_dirname(server_mod, radicale_tree): + # taches cal has no explicit name in tree? it does: "Tâches". famille: "Famille". + # Build one WITHOUT displayname. + import json + + cal = radicale_tree / "collections/collection-root/manuel/noname" + cal.mkdir(parents=True, exist_ok=True) + (cal / ".Radicale.props").write_text(json.dumps({"tag": "VCALENDAR"})) + try: + cals = server_mod.discover_calendars(str(radicale_tree)) + noname = [c for c in cals if c["path"].endswith("noname")][0] + assert noname["name"] == "noname" + finally: + (cal / ".Radicale.props").unlink() + cal.rmdir() + + +# ---------------------------------------------------------------- parse_ics_files + +def test_parse_ics_files_reads_component(server_mod, radicale_tree): + path = radicale_tree / "collections/collection-root/manuel/perso" + cals = server_mod.parse_ics_files(str(path)) + assert len(cals) == 3 + types = {sub.name for cal in cals for sub in cal.subcomponents} + assert "VEVENT" in types + + +def test_parse_ics_files_skips_unparseable(server_mod, radicale_tree): + import json + + cal = radicale_tree / "collections/collection-root/manuel/badics" + cal.mkdir(parents=True, exist_ok=True) + (cal / ".Radicale.props").write_text(json.dumps({"tag": "VCALENDAR"})) + (cal / "x.ics").write_bytes(b"NOT AN ICS FILE \xff\xfe at all") + cals = server_mod.parse_ics_files(str(cal)) + assert cals == [] + + +def test_parse_ics_files_empty_dir(server_mod, radicale_tree): + assert server_mod.parse_ics_files(str(radicale_tree / "does/not/exist")) == [] + + +# ---------------------------------------------------------------- component_to_dt + +def test_component_to_dt_datetime_passthrough(server_mod): + dt = datetime(2026, 3, 15, 9, 0) + prop = icalendar.prop.vDatetime(dt) + assert server_mod.component_to_dt(prop) == dt + + +def test_component_to_dt_date_becomes_midnight(server_mod): + d = date(2026, 4, 10) + prop = icalendar.prop.vDate(d) + assert server_mod.component_to_dt(prop) == datetime(2026, 4, 10, 0, 0) + + +def test_component_to_dt_none(server_mod): + assert server_mod.component_to_dt(None) is None + assert server_mod.component_to_dt("not-a-date") is None + + +# ---------------------------------------------------------------- format_dt + +def test_format_dt(server_mod): + assert server_mod.format_dt(None) is None + d = date(2026, 4, 10) + assert server_mod.format_dt(d) == "2026-04-10" + dt = datetime(2026, 3, 15, 9, 0) + assert server_mod.format_dt(dt) == dt.isoformat() + + +# ---------------------------------------------------------------- format_component (filters) + +def _ven_event(summary, uid="x@test", dtstart=None): + if dtstart is None: + dtstart = datetime(2026, 3, 15, 9, 0) + ev = icalendar.cal.Event() + ev.add("uid", uid) + ev.add("dtstamp", datetime(2026, 1, 1, tzinfo=__import__("datetime").timezone.utc)) + ev.add("dtstart", dtstart) + ev.add("summary", summary) + return ev + + +class TestFilters: + def test_exclude_pattern_hides_poubelle(self, server_mod): + comp = _ven_event("Poubelle verte") + assert server_mod.format_component(comp, "Perso") is None + + def test_birthdays_excluded_by_default(self, server_mod): + comp = _ven_event("Anniversaire Marc", dtstart=date(2026, 4, 10)) + assert server_mod.format_component(comp, "Perso") is None + + def test_birthdays_included_on_demand(self, server_mod): + comp = _ven_event("Anniversaire Marc", dtstart=date(2026, 4, 10)) + out = server_mod.format_component(comp, "Perso", include_birthdays=True) + assert out is not None + assert out["summary"] == "Anniversaire Marc" + + def test_normal_event_passes_birthday_filter(self, server_mod): + comp = _ven_event("Réunion équipe") + assert server_mod.format_component(comp, "Perso") is not None + + +class TestOutput: + def test_event_shape(self, server_mod, radicale_tree): + cal_path = str(radicale_tree / "collections/collection-root/manuel/perso") + found = None + for cal in server_mod.parse_ics_files(cal_path): + for c in cal.subcomponents: + if str(c.get("UID", "")) == "evt-1@test": + found = c + out = server_mod.format_component(found, "Perso manuel") + assert out["type"] == "event" + assert out["summary"] == "Réunion équipe" + assert out["start"] == "2026-03-15T09:00:00" + assert out["end"] == "2026-03-15T10:00:00" + assert out["calendar"] == "Perso manuel" + assert out["uid"] == "evt-1@test" + assert out["location"] == "Bureau" + assert out["description"] == "Point hebdo" + assert "due" not in out + assert "status" not in out + + def test_todo_shape(self, server_mod, radicale_tree): + cal_path = str(radicale_tree / "collections/collection-root/manuel/taches") + cal = server_mod.parse_ics_files(cal_path)[0] + todo = [c for c in cal.subcomponents if c.name == "VTODO"][0] + out = server_mod.format_component(todo, "Tâches") + assert out["type"] == "todo" + assert out["due"] == "2026-03-20T17:00:00" + assert out["status"] == "NEEDS-ACTION" + assert "end" not in out + + def test_optional_fields_absent_when_empty(self, server_mod): + comp = _ven_event("Sans extras") + out = server_mod.format_component(comp, "C") + assert "location" not in out + assert "description" not in out + + +# ---------------------------------------------------------------- get_events_in_range + +class TestGetEventsInRange: + def test_range_aggregates_and_sorts(self, server_mod): + items = server_mod.get_events_in_range( + datetime(2026, 3, 15), datetime(2026, 3, 21) + ) + summaries = [i["summary"] for i in items] + assert "Réunion équipe" in summaries + assert "Ranger le garage" in summaries # DUE 03-20 lands inside the window + # chronological order + starts = [i.get("start") or i.get("due") or "" for i in items] + assert starts == sorted(starts) + + def test_rrule_expansion(self, server_mod): + # weekly event DTSTART 2026-03-02, COUNT=10 → occurrences 03-02..05-04 + items = server_mod.get_events_in_range( + datetime(2026, 3, 2), datetime(2026, 5, 6) + ) + recurring = [i for i in items if i["summary"] == "Présence matinale"] + assert len(recurring) == 10 + first_days = sorted(i["start"][:10] for i in recurring) + # every occurrence lands on a Monday (DTSTART was a Monday) + assert all( + calmod.weekday(int(d[:4]), int(d[5:7]), int(d[8:10])) == 0 + for d in first_days + ) + + def test_birthday_only_with_flag(self, server_mod): + r1 = server_mod.get_events_in_range( + datetime(2026, 4, 10), datetime(2026, 4, 11), include_birthdays=False + ) + assert all(i["summary"] != "Anniversaire Marc" for i in r1) + r2 = server_mod.get_events_in_range( + datetime(2026, 4, 10), datetime(2026, 4, 11), include_birthdays=True + ) + assert any(i["summary"] == "Anniversaire Marc" for i in r2) + + def test_calendars_aggregated_across_users(self, server_mod, radicale_tree): + # add an event to robert's calendar and check cross-aggregation + import json + from pathlib import Path + + cal_dir = radicale_tree / "collections/collection-root/robert/famille" + ics = cal_dir / "x.ics" + original = ics.read_text() + ics.write_text( + conftest.ICS_HEADER + + "BEGIN:VEVENT\nUID:fam-1\nDTSTAMP:20260101T000000Z\n" + "DTSTART:20260317T120000\nDTEND:20260317T130000\n" + "SUMMARY:Souper famille\nEND:VEVENT\n" + + conftest.ICS_FOOTER + ) + try: + items = server_mod.get_events_in_range( + datetime(2026, 3, 17), datetime(2026, 3, 18) + ) + summaries = {i["summary"]: i for i in items} + assert "Souper famille" in summaries + assert summaries["Souper famille"]["calendar"] == "Famille" + finally: + ics.write_text(original) + + +# ---------------------------------------------------------------- get_agenda tool + +class TestGetAgenda: + def test_end_date_default_plus_7_days(self, server_mod): + out = server_mod.get_agenda("2026-03-15") + assert out["start_date"] == "2026-03-15T00:00:00" + assert out["end_date"] == "2026-03-22T00:00:00" + assert out["count"] == len(out["items"]) + + def test_explicit_end_date(self, server_mod): + out = server_mod.get_agenda("2026-03-15", "2026-03-16") + assert out["end_date"] == "2026-03-16T00:00:00" + assert any(i["summary"] == "Réunion équipe" for i in out["items"]) + + def test_birthday_flag_forwarded(self, server_mod): + out = server_mod.get_agenda("2026-04-10", "2026-04-11", include_birthdays=True) + assert any(i["summary"] == "Anniversaire Marc" for i in out["items"]) + out2 = server_mod.get_agenda("2026-04-10", "2026-04-11") + assert out2["items"] == [] + + def test_bad_date_returns_error_dict_not_raise(self, server_mod): + out = server_mod.get_agenda("pas-une-date") + assert "error" in out + assert "items" not in out + + +# ---------------------------------------------------------------- startup config + +def test_validate_startup_config_raises_when_empty(server_mod): + with pytest.raises(ValueError, match="CALDAV_DATA_PATH"): + server_mod._validate_startup_config("") + + +def test_validate_startup_config_accepts_value(server_mod): + server_mod._validate_startup_config("/some/path") # no exception + + +def test_invalid_exclude_pattern_degrades_without_crash(server_mod, caplog): + # simulate a broken pattern compile path via format_component reading None regex + with caplog.at_level(logging.ERROR, logger=server_mod.logger.name): + pass + # validate the guard exists: compile fails → regex stays None → filters not applied + import re + + try: + re.compile("(bad-pattern") + raised = False + except re.error: + raised = True + assert raised # and server catches this in its startup block + + +# ---------------------------------------------------------------- /health route + +def test_health_endpoint(server): + from starlette.testclient import TestClient + + app = server.mcp.http_app() + client = TestClient(app) + resp = client.get("/health") + assert resp.status_code == 200 + assert resp.json() == {"status": "ok"}