Edouard Vanbelle
297 lines
11 KiB
Python
297 lines
11 KiB
Python
"""CalDAV REPORT method coverage via python-caldav.
|
||
|
||
The REPORT verb (RFC 4791 §7) is how clients do bulk sync + filtered
|
||
lookup. Three subtypes matter for OxiCloud's server surface:
|
||
|
||
* `calendar-query` (§7.8) — filter events by time-range /
|
||
property. `search(start=..., end=...)` in pycaldav emits this.
|
||
* `calendar-multiget` (§7.9) — batch fetch by href list. Used
|
||
when the client already knows which UIDs it wants.
|
||
* `sync-collection` (§7.9 / RFC 6578) — token-based delta sync.
|
||
Not exercised here yet — the server delegates to `list_events`
|
||
(no per-token filtering), so a coverage test would just
|
||
replicate the calendar-query case. Leave for later once real
|
||
sync-token support lands.
|
||
|
||
The tests seed a fresh calendar with three timed events an hour
|
||
apart, then exercise each REPORT shape. Row-count assertions are
|
||
safe here because the seeded events are all masters (non-recurring),
|
||
so master/exception folding doesn't apply — one URL per UID matches
|
||
one row in DB.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import textwrap
|
||
import uuid
|
||
from datetime import datetime, timezone
|
||
|
||
import caldav
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
# Helpers — mirror the pattern from test_recurring.py /
|
||
# test_ical_coverage.py. Deliberately duplicated for now;
|
||
# promote to conftest.py once a fourth test file shows up.
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
|
||
def _dedent(ical: str) -> str:
|
||
return textwrap.dedent(ical).strip().replace("\n", "\r\n") + "\r\n"
|
||
|
||
|
||
def _put_ical(calendar: caldav.Calendar, uid: str, body: str) -> None:
|
||
url = str(calendar.url).rstrip("/") + f"/{uid}.ics"
|
||
r = calendar.client.request(
|
||
url,
|
||
method="PUT",
|
||
body=body,
|
||
headers={"Content-Type": "text/calendar; charset=utf-8"},
|
||
)
|
||
if r.status < 200 or r.status >= 300:
|
||
raise AssertionError(
|
||
f"PUT {url} → HTTP {r.status}\nbody: {body!r}\nresponse: {r.raw!r}"
|
||
)
|
||
|
||
|
||
def _seed_three_events(calendar: caldav.Calendar) -> list[str]:
|
||
"""Seed three non-recurring events, one hour apart, starting
|
||
2026-01-01T09:00 UTC. Returns the list of UIDs in wall-clock
|
||
order (index 0 = earliest).
|
||
|
||
Non-recurring is deliberate: it isolates REPORT semantics from
|
||
master/exception folding (which is phase-4 territory)."""
|
||
uids: list[str] = []
|
||
times = [
|
||
("20260101T090000Z", "20260101T093000Z", "Morning standup"),
|
||
("20260101T100000Z", "20260101T110000Z", "Mid-morning sync"),
|
||
("20260101T140000Z", "20260101T150000Z", "Afternoon review"),
|
||
]
|
||
for start, end, summary in times:
|
||
uid = f"report-{uuid.uuid4().hex[:8]}"
|
||
_put_ical(
|
||
calendar,
|
||
uid,
|
||
_dedent(
|
||
f"""\
|
||
BEGIN:VCALENDAR
|
||
VERSION:2.0
|
||
PRODID:-//pycaldav report coverage//EN
|
||
BEGIN:VEVENT
|
||
UID:{uid}
|
||
DTSTAMP:20260101T080000Z
|
||
DTSTART:{start}
|
||
DTEND:{end}
|
||
SUMMARY:{summary}
|
||
END:VEVENT
|
||
END:VCALENDAR
|
||
"""
|
||
),
|
||
)
|
||
uids.append(uid)
|
||
return uids
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
# calendar-query REPORT
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
|
||
def test_calendar_query_time_range_returns_events_in_window(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""A time-range filter that spans the middle of the seeded
|
||
day should return only the events whose (DTSTART, DTEND)
|
||
overlaps the window. RFC 4791 §9.9 defines overlap: an event
|
||
overlaps a range if DTSTART < range_end AND DTEND > range_start."""
|
||
uids = _seed_three_events(fresh_calendar)
|
||
|
||
# Window: 09:30 → 12:00 UTC. Overlaps events 0 (09:00–09:30
|
||
# touches the boundary at 09:30; RFC excludes exact touch)
|
||
# and event 1 (10:00–11:00, wholly inside). Excludes event 2
|
||
# (14:00–15:00, well outside).
|
||
window_start = datetime(2026, 1, 1, 9, 30, tzinfo=timezone.utc)
|
||
window_end = datetime(2026, 1, 1, 12, 0, tzinfo=timezone.utc)
|
||
|
||
found = fresh_calendar.search(
|
||
start=window_start,
|
||
end=window_end,
|
||
event=True,
|
||
expand=False,
|
||
)
|
||
found_uids = {_uid_from_event_data(e.data) for e in found}
|
||
|
||
# Event 1 (10:00–11:00) is definitely in-window; event 2 (14:00–
|
||
# 15:00) is definitely out. Event 0's overlap is boundary-
|
||
# dependent (server interpretation varies at exact-touch). The
|
||
# strong invariant: event 1 in, event 2 out.
|
||
assert uids[1] in found_uids, (
|
||
f"Event 1 (mid-morning, wholly inside window) missing from "
|
||
f"time-range REPORT. Got: {found_uids}"
|
||
)
|
||
assert uids[2] not in found_uids, (
|
||
f"Event 2 (afternoon, wholly outside window) leaked into "
|
||
f"time-range REPORT. Got: {found_uids}"
|
||
)
|
||
|
||
|
||
def test_calendar_query_time_range_after_all_events_returns_empty(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""A window that starts after every seeded event returns
|
||
zero results — proves the range filter is actually applied,
|
||
not silently ignored (which would surface as "all events
|
||
returned regardless of window")."""
|
||
_seed_three_events(fresh_calendar)
|
||
|
||
window_start = datetime(2027, 1, 1, 0, 0, tzinfo=timezone.utc)
|
||
window_end = datetime(2027, 1, 2, 0, 0, tzinfo=timezone.utc)
|
||
|
||
found = fresh_calendar.search(
|
||
start=window_start,
|
||
end=window_end,
|
||
event=True,
|
||
expand=False,
|
||
)
|
||
assert found == [], (
|
||
f"Expected empty result for window one year past all seeded "
|
||
f"events; got {len(found)} entries."
|
||
)
|
||
|
||
|
||
def test_calendar_query_time_range_before_all_events_returns_empty(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""Symmetric to the after-window case."""
|
||
_seed_three_events(fresh_calendar)
|
||
|
||
window_start = datetime(2025, 1, 1, 0, 0, tzinfo=timezone.utc)
|
||
window_end = datetime(2025, 1, 2, 0, 0, tzinfo=timezone.utc)
|
||
|
||
found = fresh_calendar.search(
|
||
start=window_start,
|
||
end=window_end,
|
||
event=True,
|
||
expand=False,
|
||
)
|
||
assert found == []
|
||
|
||
|
||
def test_calendar_query_no_filter_returns_every_event(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""`calendar.events()` (pycaldav) issues a calendar-query without
|
||
a time-range — the server routes this via `list_events`, so
|
||
every event in the calendar surfaces. Row count = 3 seeded
|
||
events (all non-recurring, so 1 URL per row)."""
|
||
uids = _seed_three_events(fresh_calendar)
|
||
|
||
all_events = fresh_calendar.events()
|
||
found_uids = {_uid_from_event_data(e.data) for e in all_events}
|
||
|
||
for expected in uids:
|
||
assert expected in found_uids, (
|
||
f"Seeded event {expected} missing from unfiltered "
|
||
f"calendar-query REPORT. Got: {found_uids}"
|
||
)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
# calendar-multiget REPORT
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
|
||
def test_calendar_multiget_by_href_returns_the_targeted_events(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""calendar-multiget takes an explicit href list and returns
|
||
exactly those. Two hrefs → two responses. The server's
|
||
`get_events_by_ical_uids` (indexed `ical_uid = ANY(...)`) is
|
||
what pays for this instead of listing the whole calendar."""
|
||
uids = _seed_three_events(fresh_calendar)
|
||
|
||
base = str(fresh_calendar.url).rstrip("/") + "/"
|
||
# Target the first two events; skip event 2.
|
||
hrefs = [f"{base}{uids[0]}.ics", f"{base}{uids[1]}.ics"]
|
||
xml = _multiget_body(hrefs)
|
||
|
||
r = fresh_calendar.client.request(
|
||
str(fresh_calendar.url),
|
||
method="REPORT",
|
||
body=xml,
|
||
headers={"Content-Type": "application/xml; charset=utf-8", "Depth": "1"},
|
||
)
|
||
assert 200 <= r.status < 300, (
|
||
f"REPORT calendar-multiget → HTTP {r.status}\nbody: {r.raw!r}"
|
||
)
|
||
xml_body = r.raw.decode("utf-8") if isinstance(r.raw, bytes) else r.raw
|
||
|
||
assert uids[0] in xml_body, (
|
||
f"Requested UID {uids[0]} missing from multiget response."
|
||
)
|
||
assert uids[1] in xml_body, (
|
||
f"Requested UID {uids[1]} missing from multiget response."
|
||
)
|
||
assert uids[2] not in xml_body, (
|
||
f"UID {uids[2]} (not requested) leaked into multiget response."
|
||
)
|
||
|
||
|
||
def test_calendar_multiget_unknown_href_is_silently_absent(
|
||
fresh_calendar: caldav.Calendar,
|
||
) -> None:
|
||
"""CalDAV multiget semantics: a requested href that doesn't
|
||
exist is silently absent from the response (not an error).
|
||
Some servers emit a `<D:status>404</D:status>` per-href entry;
|
||
the minimum bar is that the server must NOT 500 and must NOT
|
||
invent data."""
|
||
uids = _seed_three_events(fresh_calendar)
|
||
|
||
base = str(fresh_calendar.url).rstrip("/") + "/"
|
||
ghost_uid = f"does-not-exist-{uuid.uuid4().hex[:8]}"
|
||
hrefs = [f"{base}{uids[0]}.ics", f"{base}{ghost_uid}.ics"]
|
||
|
||
r = fresh_calendar.client.request(
|
||
str(fresh_calendar.url),
|
||
method="REPORT",
|
||
body=_multiget_body(hrefs),
|
||
headers={"Content-Type": "application/xml; charset=utf-8", "Depth": "1"},
|
||
)
|
||
assert 200 <= r.status < 300, (
|
||
f"REPORT multiget with an unknown href must not 500 — got "
|
||
f"HTTP {r.status}\nresponse: {r.raw!r}"
|
||
)
|
||
xml_body = r.raw.decode("utf-8") if isinstance(r.raw, bytes) else r.raw
|
||
assert uids[0] in xml_body, (
|
||
"Existing UID missing from multiget that also targeted a ghost href."
|
||
)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────
|
||
# Low-level helpers
|
||
# ─────────────────────────────────────────────────────────────
|
||
|
||
|
||
def _uid_from_event_data(data: str) -> str | None:
|
||
"""Pull the UID out of a raw iCalendar body. Cheap enough for a
|
||
handful of events per test."""
|
||
for line in data.replace("\r\n", "\n").split("\n"):
|
||
if line.startswith("UID:"):
|
||
return line[4:].strip()
|
||
return None
|
||
|
||
|
||
def _multiget_body(hrefs: list[str]) -> str:
|
||
"""Assemble a minimal RFC 4791 §7.9 calendar-multiget REPORT
|
||
XML body for the given href list."""
|
||
href_xml = "\n ".join(f"<D:href>{h}</D:href>" for h in hrefs)
|
||
return f"""<?xml version="1.0" encoding="UTF-8"?>
|
||
<C:calendar-multiget xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
|
||
<D:prop>
|
||
<D:getetag/>
|
||
<C:calendar-data/>
|
||
</D:prop>
|
||
{href_xml}
|
||
</C:calendar-multiget>
|
||
"""
|