From 11cb9b32b205a021d22bf207586f0a3fd22e8dcc Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Tue, 17 Nov 2026 19:51:39 +0100 Subject: [PATCH 1/6] test: seed again after a write robur fails Robur leaves about one request in 60 unanswered (a 70-second hang, then a reset) and answers some PUTs with a 500, so the listing test, which seeds 120 items, failed nearly every run on robur on a write it is not about. The CalDAV suite's seed now tries a failed write up to three times, taking the item as stored when it can be read back. Prompts: > [pick from the task list: "calendaring: remaining conformance > failures on Ox, Zimbra and others"] (...) One of the priorities > should be to ensure the compliance tests passes (sic) on all the > servers, was that task completed yet? > Continue. Robur should pass, if just retrying hard enough. I > suppose it is possible to run several times with `pytest > --last-failed` or something like that? Assisted-By: Claude Opus 5.5 --- tests/_async/test_caldav_conformance.py | 134 +++++++++++++++++++++++- tests/_sync/test_caldav_conformance.py | 134 +++++++++++++++++++++++- 2 files changed, 266 insertions(+), 2 deletions(-) diff --git a/tests/_async/test_caldav_conformance.py b/tests/_async/test_caldav_conformance.py index 71dafca..6e364f9 100644 --- a/tests/_async/test_caldav_conformance.py +++ b/tests/_async/test_caldav_conformance.py @@ -3,14 +3,29 @@ from __future__ import annotations +from collections.abc import Sequence from typing import Any import pytest from conftest import wait_for_server -from calendaring import AsyncBackend +from calendaring import ( + AlreadyExistsError, + AsyncBackend, + AsyncCollection, + AsyncItem, + BackendError, + Event, + Item, + NotFoundError, + TransportError, +) +from calendaring.loss import ALLOW from calendaring.testing import AsyncConformance +# A failed write is tried this many times in all while seeding +SEED_ATTEMPTS = 3 + class CalDAVConformance(AsyncConformance): # A CalDAV server is probed, not known in advance (§5.1). @@ -23,9 +38,126 @@ async def open_backend(self) -> AsyncBackend: wait_for_server(backend, self.monkeypatch) return backend + async def seed(self, collection: AsyncCollection, items: Sequence[Item]) -> list[AsyncItem]: + """Store each item, again after a failed write, unless it got there after all. + + Seeding is setup, not what a test is about. Robur leaves about one + request in 60 unanswered (a 70-second hang, then a reset) and answers + some PUTs with a 500, so a test that seeds 120 items fails most runs on + a write that has nothing to do with it. Every ``BackendError`` is + retried, since it carries no status to tell a 500 from a refusal; a + refusal costs two more tries and is raised all the same. A clash is + only taken for a lost answer on a retry: the UIDs are fresh. + """ + seeded = [] + for item in items: + for attempt in range(SEED_ATTEMPTS): + try: + seeded.append(await collection.add(item, loss=ALLOW)) + break + except AlreadyExistsError: + if attempt == 0 or not await self._seeded(collection, item, seeded): + raise + break + except BackendError: + if await self._seeded(collection, item, seeded): + break + if attempt == SEED_ATTEMPTS - 1: + raise + return seeded + + @staticmethod + async def _seeded(collection: AsyncCollection, item: Item, seeded: list[AsyncItem]) -> bool: + """Whether a write whose answer was lost stored ``item``; if so it joins ``seeded``. A failed read says no.""" + try: + seeded.append(await collection.get(item.uid)) + except (NotFoundError, BackendError): + return False + return True + return seeded + class TestCalDAVServers(CalDAVConformance): @pytest.fixture(autouse=True) def _server(self, caldav_server: Any, monkeypatch: pytest.MonkeyPatch) -> None: self.server = caldav_server self.monkeypatch = monkeypatch + + +class _DroppingCollection: + """Fails ``add`` as told: a lost answer after storing the item or before, or a 500.""" + + def __init__(self, outcomes: list[str], gets: list[str] | None = None) -> None: + self.outcomes = outcomes # per add: "ok", "stored-then-lost", "lost" or "refused" (a 500, nothing stored) + self.gets = gets or [] # per get: "ok", "lost" (no answer) or "missing" (not found yet, though stored) + self.stored: dict[str, Any] = {} + self.adds = 0 + + async def add(self, item: Any, **_: Any) -> Any: + outcome = self.outcomes[self.adds] if self.adds < len(self.outcomes) else "ok" + self.adds += 1 + if outcome not in ("lost", "refused"): + if item.uid in self.stored: + raise AlreadyExistsError(item.uid, taken="uid") + self.stored[item.uid] = item + if outcome == "refused": + raise BackendError("PutError at '500 Internal Server Error'") + if outcome != "ok": + raise TransportError("read timed out") + return item + + async def get(self, uid: str) -> Any: + outcome = self.gets.pop(0) if self.gets else "ok" + if outcome == "lost": + raise TransportError("read timed out") + try: + if outcome == "missing": + raise KeyError(uid) + return self.stored[uid] + except KeyError: + raise NotFoundError(uid) from None + + +@pytest.mark.parametrize( + ("outcomes", "gets", "adds"), + [ + (["stored-then-lost"], [], 1), + (["lost"], [], 2), + (["lost", "stored-then-lost"], [], 2), + (["refused"], [], 2), + (["lost"], ["lost"], 2), + (["stored-then-lost"], ["lost"], 2), + ], +) +async def test_seed_gets_past_a_lost_answer(outcomes: list[str], gets: list[str], adds: int) -> None: + """Robur leaves about one request in 60 unanswered, and answers some PUTs with a 500; seeding 120 items fails most runs without this.""" + collection = _DroppingCollection(outcomes, gets) + item = Event.new(summary="paged 0") + seeded = await CalDAVConformance().seed(collection, [item]) # type: ignore[arg-type] + assert [i.uid for i in seeded] == [item.uid] + assert collection.adds == adds + + +async def test_seed_gives_up_on_a_server_that_never_answers() -> None: + collection = _DroppingCollection(["lost"] * 10) + with pytest.raises(TransportError): + await CalDAVConformance().seed(collection, [Event.new(summary="paged 0")]) # type: ignore[arg-type] + assert collection.adds == SEED_ATTEMPTS + + +async def test_seed_does_not_take_a_clash_it_did_not_cause() -> None: + """A fresh UID that is taken before any retry is a leftover or a backend bug, not a lost answer.""" + item = Event.new(summary="paged 0") + collection = _DroppingCollection([]) + collection.stored[item.uid] = item + with pytest.raises(AlreadyExistsError): + await CalDAVConformance().seed(collection, [item]) # type: ignore[arg-type] + assert collection.adds == 1 + + +async def test_seed_gives_up_on_a_clash_it_cannot_read() -> None: + """The lost write landed, but the item cannot be read back: the clash on the retry is raised.""" + collection = _DroppingCollection(["stored-then-lost"], ["missing", "missing"]) + with pytest.raises(AlreadyExistsError): + await CalDAVConformance().seed(collection, [Event.new(summary="paged 0")]) # type: ignore[arg-type] + assert collection.adds == 2 diff --git a/tests/_sync/test_caldav_conformance.py b/tests/_sync/test_caldav_conformance.py index 2a3ca0b..77d2aba 100644 --- a/tests/_sync/test_caldav_conformance.py +++ b/tests/_sync/test_caldav_conformance.py @@ -3,14 +3,29 @@ from __future__ import annotations +from collections.abc import Sequence from typing import Any import pytest from conftest import wait_for_server -from calendaring import Backend +from calendaring import ( + AlreadyExistsError, + Backend, + Collection, + SyncItem, + BackendError, + Event, + Item, + NotFoundError, + TransportError, +) +from calendaring.loss import ALLOW from calendaring.testing import SyncConformance +# A failed write is tried this many times in all while seeding +SEED_ATTEMPTS = 3 + class CalDAVConformance(SyncConformance): # A CalDAV server is probed, not known in advance (§5.1). @@ -23,9 +38,126 @@ def open_backend(self) -> Backend: wait_for_server(backend, self.monkeypatch) return backend + def seed(self, collection: Collection, items: Sequence[Item]) -> list[SyncItem]: + """Store each item, again after a failed write, unless it got there after all. + + Seeding is setup, not what a test is about. Robur leaves about one + request in 60 unanswered (a 70-second hang, then a reset) and answers + some PUTs with a 500, so a test that seeds 120 items fails most runs on + a write that has nothing to do with it. Every ``BackendError`` is + retried, since it carries no status to tell a 500 from a refusal; a + refusal costs two more tries and is raised all the same. A clash is + only taken for a lost answer on a retry: the UIDs are fresh. + """ + seeded = [] + for item in items: + for attempt in range(SEED_ATTEMPTS): + try: + seeded.append(collection.add(item, loss=ALLOW)) + break + except AlreadyExistsError: + if attempt == 0 or not self._seeded(collection, item, seeded): + raise + break + except BackendError: + if self._seeded(collection, item, seeded): + break + if attempt == SEED_ATTEMPTS - 1: + raise + return seeded + + @staticmethod + def _seeded(collection: Collection, item: Item, seeded: list[SyncItem]) -> bool: + """Whether a write whose answer was lost stored ``item``; if so it joins ``seeded``. A failed read says no.""" + try: + seeded.append(collection.get(item.uid)) + except (NotFoundError, BackendError): + return False + return True + return seeded + class TestCalDAVServers(CalDAVConformance): @pytest.fixture(autouse=True) def _server(self, caldav_server: Any, monkeypatch: pytest.MonkeyPatch) -> None: self.server = caldav_server self.monkeypatch = monkeypatch + + +class _DroppingCollection: + """Fails ``add`` as told: a lost answer after storing the item or before, or a 500.""" + + def __init__(self, outcomes: list[str], gets: list[str] | None = None) -> None: + self.outcomes = outcomes # per add: "ok", "stored-then-lost", "lost" or "refused" (a 500, nothing stored) + self.gets = gets or [] # per get: "ok", "lost" (no answer) or "missing" (not found yet, though stored) + self.stored: dict[str, Any] = {} + self.adds = 0 + + def add(self, item: Any, **_: Any) -> Any: + outcome = self.outcomes[self.adds] if self.adds < len(self.outcomes) else "ok" + self.adds += 1 + if outcome not in ("lost", "refused"): + if item.uid in self.stored: + raise AlreadyExistsError(item.uid, taken="uid") + self.stored[item.uid] = item + if outcome == "refused": + raise BackendError("PutError at '500 Internal Server Error'") + if outcome != "ok": + raise TransportError("read timed out") + return item + + def get(self, uid: str) -> Any: + outcome = self.gets.pop(0) if self.gets else "ok" + if outcome == "lost": + raise TransportError("read timed out") + try: + if outcome == "missing": + raise KeyError(uid) + return self.stored[uid] + except KeyError: + raise NotFoundError(uid) from None + + +@pytest.mark.parametrize( + ("outcomes", "gets", "adds"), + [ + (["stored-then-lost"], [], 1), + (["lost"], [], 2), + (["lost", "stored-then-lost"], [], 2), + (["refused"], [], 2), + (["lost"], ["lost"], 2), + (["stored-then-lost"], ["lost"], 2), + ], +) +def test_seed_gets_past_a_lost_answer(outcomes: list[str], gets: list[str], adds: int) -> None: + """Robur leaves about one request in 60 unanswered, and answers some PUTs with a 500; seeding 120 items fails most runs without this.""" + collection = _DroppingCollection(outcomes, gets) + item = Event.new(summary="paged 0") + seeded = CalDAVConformance().seed(collection, [item]) # type: ignore[arg-type] + assert [i.uid for i in seeded] == [item.uid] + assert collection.adds == adds + + +def test_seed_gives_up_on_a_server_that_never_answers() -> None: + collection = _DroppingCollection(["lost"] * 10) + with pytest.raises(TransportError): + CalDAVConformance().seed(collection, [Event.new(summary="paged 0")]) # type: ignore[arg-type] + assert collection.adds == SEED_ATTEMPTS + + +def test_seed_does_not_take_a_clash_it_did_not_cause() -> None: + """A fresh UID that is taken before any retry is a leftover or a backend bug, not a lost answer.""" + item = Event.new(summary="paged 0") + collection = _DroppingCollection([]) + collection.stored[item.uid] = item + with pytest.raises(AlreadyExistsError): + CalDAVConformance().seed(collection, [item]) # type: ignore[arg-type] + assert collection.adds == 1 + + +def test_seed_gives_up_on_a_clash_it_cannot_read() -> None: + """The lost write landed, but the item cannot be read back: the clash on the retry is raised.""" + collection = _DroppingCollection(["stored-then-lost"], ["missing", "missing"]) + with pytest.raises(AlreadyExistsError): + CalDAVConformance().seed(collection, [Event.new(summary="paged 0")]) # type: ignore[arg-type] + assert collection.adds == 2 From ef6c16024d4c45cf3f688a8632c235422ff5dad1 Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Tue, 17 Nov 2026 19:51:39 +0100 Subject: [PATCH 2/6] docs: conformance on Bedework 5, gmx and robur The 2026-11-03 known failure, added ATTENDEE parameters, has been handled since; the section now gives the latest results per server. Prompts: > [pick from the task list: "calendaring: remaining conformance > failures on Ox, Zimbra and others"] (...) One of the priorities > should be to ensure the compliance tests passes (sic) on all the > servers, was that task completed yet? > Continue. Robur should pass, if just retrying hard enough. I > suppose it is possible to run several times with `pytest > --last-failed` or something like that? Assisted-By: Claude Opus 5.5 --- docs/caldav-servers.md | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/docs/caldav-servers.md b/docs/caldav-servers.md index 367984e..e507d68 100644 --- a/docs/caldav-servers.md +++ b/docs/caldav-servers.md @@ -26,13 +26,15 @@ nothing waits for an index that lags behind writes: three stories fail on Bedework 3 (an event or task just written is not found yet), and purelymail fails most stories that search. -## The conformance tests: a known failure, 2026-11-03 - -SOGo adds `RSVP=TRUE` and `PARTSTAT` to an ATTENDEE that had none, and Ox -adds `EMAIL=`. caldav records this -(`save-load.icalendar.attendee-params`), but no capability declaration -can say that a server *adds* parameters: LOSSY only describes a server -dropping or rewriting what it was sent. The round trip and `verify` -therefore report the attendees on these servers as changed, and the -tests fail. Whether verification should tolerate added parameters, or -`attendees` should count as LOSSY there, is undecided. +## The conformance tests (`tests/*/test_caldav_conformance.py`), 2026-11-17 + +One server at a time, with caldav's master branch. Zimbra, Ox, Cyrus, +Davical, Davis, Baikal, Nextcloud, Radicale, Xandikos, CCS, Bedework 3 +and Stalwart passed on 2026-11-12. SOGo waits for caldav's SOGo hints; +ecloud, purelymail, infomaniak, posteo and jeanes have not been run. + +| Server | Result | Why | +|---|---|---| +| Bedework 5 (sync suite only) | pass, 35 skipped | the skips need tasks or journals, which its calendar does not hold. It stores each ATTENDEE twice, and caldav drops the copy | +| gmx | pass | | +| robur | passes on rerun | about one request in 60 hangs for 70 s and is then reset, and some PUTs get a 500; seeding retries a failed write, but a test that reads 120 items still fails some runs, and `--last-failed` passed them all | From 12f960fb7ad5c18412ab5400d1812c5dbb9332a9 Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Tue, 17 Nov 2026 19:51:39 +0100 Subject: [PATCH 3/6] docs: native is None only after an ETag answer The changelog fragment said a written item's `native` stays None until it is read back. The design document is more precise: only when the server answers the write with an ETag, until get(), search() or reload() reads it. Fragment of https://github.com/PyCalendar/calendaring/issues/29. Prompt: [fix issues found during the review process] Assisted-By: Claude Opus 5.5 --- news/29.documentation.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/news/29.documentation.rst b/news/29.documentation.rst index 9ab3696..df14a6f 100644 --- a/news/29.documentation.rst +++ b/news/29.documentation.rst @@ -1 +1 @@ -The design documents no longer say that recurring-task completion works like caldav's: ``task.complete()`` on a recurring task (an ``RRULE`` or ``RDATE``) or an occurrence of one raises ``UnsupportedError`` on every backend until edit-icalendar has it, with the CalDAV escape hatch described meanwhile. They also say that on CalDAV an item returned by a write has ``native`` set to ``None`` until it is read back, and list edit-icalendar under the roadmap's risks. +The design documents no longer say that recurring-task completion works like caldav's: ``task.complete()`` on a recurring task (an ``RRULE`` or ``RDATE``) or an occurrence of one raises ``UnsupportedError`` on every backend until edit-icalendar has it, with the CalDAV escape hatch described meanwhile. They also say that on CalDAV an item returned by a write has ``native`` set to ``None`` whenever the server answers with an ETag, until ``get()``, ``search()`` or ``reload()`` reads it, and list edit-icalendar under the roadmap's risks. From fecd195633a1d56a49627690a4bae491fd68afd7 Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Wed, 18 Nov 2026 06:26:00 +0100 Subject: [PATCH 4/6] fix: a default VALUE type is no change Infomaniak stores URL as URL;VALUE=URI. URI is URL's default type (RFC 5545 section 3.8.4.6), so nothing was lost, yet verify reported a difference and the conformance round trip of the time-zone series failed there. A VALUE parameter now compares as absent when it names the property's default type, taken from icalendar's own type table. Prompt: [Continue working on getting the conformance tests passing] Assisted-By: Claude Opus 5.5 Reviewed-by: Tobias Brox --- news/+added-parameters.bugfix.rst | 2 +- src/calendaring/_mapping.py | 15 ++++++++++++++- tests/test_mapping.py | 26 ++++++++++++++++++++++++++ 3 files changed, 41 insertions(+), 2 deletions(-) diff --git a/news/+added-parameters.bugfix.rst b/news/+added-parameters.bugfix.rst index 64e9ba6..0ab5f1c 100644 --- a/news/+added-parameters.bugfix.rst +++ b/news/+added-parameters.bugfix.rst @@ -1 +1 @@ -``verify=True`` and the conformance suite no longer count a parameter the server adds as a difference where it says nothing about the value: SOGo adding ``RSVP=TRUE`` to an ATTENDEE, or Ox adding ``EMAIL=``, loses nothing, and neither does Ox adding the organizer as an attendee. A parameter the server drops or changes still is one, and so is one it adds with a meaning of its own, such as a TZID or ``PARTSTAT=DECLINED``. +``verify=True`` and the conformance suite no longer count a parameter the server adds as a difference where it says nothing about the value: SOGo adding ``RSVP=TRUE`` to an ATTENDEE, or Ox adding ``EMAIL=``, loses nothing, and neither does Ox adding the organizer as an attendee. A parameter the server drops or changes still is one, and so is one it adds with a meaning of its own, such as a TZID or ``PARTSTAT=DECLINED``. A ``VALUE`` naming the property's default type, such as infomaniak's ``URL;VALUE=URI``, is no difference either. diff --git a/src/calendaring/_mapping.py b/src/calendaring/_mapping.py index 774dc19..338a6ed 100644 --- a/src/calendaring/_mapping.py +++ b/src/calendaring/_mapping.py @@ -21,6 +21,7 @@ import icalendar import recurring_ical_events from icalendar.parser import Contentline +from icalendar.prop import TypesFactory from .capabilities import Capabilities, Feature, Support from .items import X_PLANNED_END, X_PLANNED_START @@ -348,11 +349,23 @@ def _without_defaults(line: bytes) -> tuple[Any, ...]: (key.upper(), tuple(sorted(_zone(str(v)) if key.upper() == "TZID" else str(v) for v in values))) for key, raw in params.items() for values in [raw if isinstance(raw, list) else [raw]] - if not (len(values) == 1 and PARAMETER_DEFAULTS.get(key.upper()) == str(values[0]).upper()) + if not (len(values) == 1 and _default(name, key) == str(values[0]).upper()) ) return name.upper(), tuple(kept), value +def _default(name: str, key: str) -> str | None: + """A parameter's RFC 5545 default on property ``name``: for VALUE the property's own type (URL's is URI). + + icalendar names a list property's type with a ``-list`` suffix (RDATE's is ``date-time-list``), + which no VALUE parameter carries. + """ + if key.upper() == "VALUE": + default = TypesFactory.instance().types_map.get(name) + return default.upper().removesuffix("-LIST") if default else None + return PARAMETER_DEFAULTS.get(key.upper()) + + @functools.cache def _zone(tzid: str) -> str: """A time zone by how it behaves, so that one tzdata renamed into another (Europe/Oslo, now a link to Berlin) compares equal. diff --git a/tests/test_mapping.py b/tests/test_mapping.py index 94404a2..ab9c0d8 100644 --- a/tests/test_mapping.py +++ b/tests/test_mapping.py @@ -165,6 +165,32 @@ def test_a_parameter_added_with_its_default_is_no_difference() -> None: assert differences(sent.icalendar, stored_as(sent, defaults)) == [] +def test_a_value_type_spelled_out_at_its_default_is_no_difference() -> None: + """Infomaniak stores URL as URL;VALUE=URI, its default type (RFC 5545 §3.8.4.6); another type is a change.""" + sent = Event.new(summary="x", start=datetime(2026, 11, 3, 9, tzinfo=UTC)) + sent.component.add("URL", "https://meet.example.com/weekly") + text = sent.icalendar.to_ical().decode() + line = "URL:https://meet.example.com/weekly" + assert line in text + as_uri = icalendar.Calendar.from_ical(text.replace(line, "URL;VALUE=URI:https://meet.example.com/weekly")) + assert differences(sent.icalendar, as_uri) == [] + as_text = icalendar.Calendar.from_ical(text.replace(line, "URL;VALUE=TEXT:https://meet.example.com/weekly")) + assert [d.property for d in differences(sent.icalendar, as_text)] == ["URL"] + + +def test_a_date_time_type_spelled_out_is_no_difference_but_a_date_is() -> None: + """VALUE=DATE-TIME is the default of DTSTART, and of RDATE's list type; VALUE=DATE changes what is read.""" + sent = Event.new(summary="x", start=datetime(2026, 11, 3, 9, tzinfo=UTC)) + sent.component.add("RDATE", datetime(2026, 11, 10, 9, tzinfo=UTC)) + text = sent.icalendar.to_ical().decode() + for prop in ("DTSTART", "RDATE"): + line = next(x for x in text.splitlines() if x.startswith(prop + ":")) + spelled = icalendar.Calendar.from_ical(text.replace(line, line.replace(":", ";VALUE=DATE-TIME:", 1))) + assert differences(sent.icalendar, spelled) == [], prop + as_date = icalendar.Calendar.from_ical(text.replace(line, line.replace(":", ";VALUE=DATE:", 1))) + assert prop in [d.property for d in differences(sent.icalendar, as_date)], prop + + def test_a_parameter_the_server_added_is_no_difference() -> None: sent = Event.new(summary="x", start=datetime(2026, 11, 3, 9, tzinfo=UTC)) sent.component.add("ATTENDEE", "mailto:bob@example.com", parameters={"CN": "Bob"}) From f3b808eaaf47741cff1cfd64d7cd9d6ee7e5e8b3 Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Wed, 18 Nov 2026 06:26:01 +0100 Subject: [PATCH 5/6] docs: conformance on four more servers Results of the 2026-11-17 runs; ecloud is still being run. Prompt: [Continue working on getting the conformance tests passing] Assisted-By: Claude Opus 5.5 Reviewed-by: Tobias Brox --- docs/caldav-servers.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/caldav-servers.md b/docs/caldav-servers.md index e507d68..785d008 100644 --- a/docs/caldav-servers.md +++ b/docs/caldav-servers.md @@ -31,10 +31,14 @@ purelymail fails most stories that search. One server at a time, with caldav's master branch. Zimbra, Ox, Cyrus, Davical, Davis, Baikal, Nextcloud, Radicale, Xandikos, CCS, Bedework 3 and Stalwart passed on 2026-11-12. SOGo waits for caldav's SOGo hints; -ecloud, purelymail, infomaniak, posteo and jeanes have not been run. +ecloud has not been run to the end. | Server | Result | Why | |---|---|---| | Bedework 5 (sync suite only) | pass, 35 skipped | the skips need tasks or journals, which its calendar does not hold. It stores each ATTENDEE twice, and caldav drops the copy | | gmx | pass | | | robur | passes on rerun | about one request in 60 hangs for 70 s and is then reset, and some PUTs get a 500; seeding retries a failed write, but a test that reads 120 items still fails some runs, and `--last-failed` passed them all | +| purelymail | pass | run alone, in 1 h 54 | +| infomaniak | pass, 2 skipped | its calendar holds no journals. It stores URL as `URL;VALUE=URI`, which verify took for a change before 2026-11-18 | +| posteo | pass, 10 skipped | it cannot make calendars, so the 8 tests that need a second one (move, a token from another collection, creating one) skip; and it holds no journals | +| jeanes | pass | 5 h 09: the account held 469 leftover calendars, each listing one PROPFIND per calendar. 384 were deleted through DSM's web API during the run | From 16cf5c52a0ba57d9fb34812097f48006c3524db2 Mon Sep 17 00:00:00 2001 From: Tobias Brox Date: Wed, 18 Nov 2026 08:17:29 +0100 Subject: [PATCH 6/6] test: drop an unreachable return from _seeded Prompt: [fix issues found during the review process] Assisted-By: Claude Opus 5.5 Reviewed-by: Tobias Brox --- tests/_async/test_caldav_conformance.py | 1 - tests/_sync/test_caldav_conformance.py | 1 - 2 files changed, 2 deletions(-) diff --git a/tests/_async/test_caldav_conformance.py b/tests/_async/test_caldav_conformance.py index 6e364f9..a5ec72a 100644 --- a/tests/_async/test_caldav_conformance.py +++ b/tests/_async/test_caldav_conformance.py @@ -74,7 +74,6 @@ async def _seeded(collection: AsyncCollection, item: Item, seeded: list[AsyncIte except (NotFoundError, BackendError): return False return True - return seeded class TestCalDAVServers(CalDAVConformance): diff --git a/tests/_sync/test_caldav_conformance.py b/tests/_sync/test_caldav_conformance.py index 77d2aba..089c110 100644 --- a/tests/_sync/test_caldav_conformance.py +++ b/tests/_sync/test_caldav_conformance.py @@ -74,7 +74,6 @@ def _seeded(collection: Collection, item: Item, seeded: list[SyncItem]) -> bool: except (NotFoundError, BackendError): return False return True - return seeded class TestCalDAVServers(CalDAVConformance):