test: pytest suite (31 tests) + lazy config validation + CI pytest job

- src/server.py: CALDAV_DATA_PATH validation moved from import-time to
  _validate_startup_config(), called on __main__ or MCP_ICS_VALIDATE_ON_IMPORT=1.
  Module is now importable in tests without env setup.
- tests/: Radicale fixture tree (VCALENDAR/VADDRESSBOOK, hidden dirs, corrupt
  props, bad ics), covers discover_calendars, parse_ics_files, component_to_dt,
  format_dt, format_component (exclude/birthday filters, VEVENT vs VTODO shape),
  get_events_in_range (RRULE expansion, cross-calendar aggregation, sort),
  get_agenda (default +7d end, error dict, flag forwarding), /health endpoint,
  _validate_startup_config. 31 tests, <2s.
- .gitea/workflows/_ci-common.yaml: new pytest job running the test suite
  inside the built CI image (prod requirements).
- pkg/Dockerfile: COPY tests/

.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"

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"]

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+testpaths = tests
+addopts = -q

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

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

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"}