fix: wipe async test calendars instead of deleting to avoid Nextcloud trashbin slowdown

Calendar.delete() now accepts a wipe parameter (None/True/False tristate):
- True: wipe all objects, keep the calendar itself (never sends HTTP DELETE)
- False: always attempt HTTP DELETE
- None (default): existing auto-detect behaviour (wipe if delete unsupported)

The four async test fixtures (async_calendar, async_task_list, async_calendar2,
async_journal_list) are refactored to use stable cal_ids instead of unique
timestamped names.  At fixture teardown, servers where delete-calendar.free-
namespace is not supported (Nextcloud trashbin) now wipe objects via
calendar.delete(wipe=True) rather than HTTP-deleting the calendar.

Root cause of the >1-hour CI runs: each async test created a uniquely-named
calendar and deleted it; on Nextcloud every deletion moves the calendar to the
trashbin.  After ~30 async tests, Nextcloud's SQLite database held 30+ trashed
calendars, making every subsequent request from the sync test suite take ~50 s
instead of <1 s.  Reusing a single stable calendar per fixture and wiping its
objects keeps the trashbin empty and the database small.

The async_task_list fixture is also simplified: the previous logic that shared
the sync suite's pythoncaldav-test-tasks calendar with Cyrus (to avoid cross-
calendar UID conflicts) is no longer needed because the wipe-at-teardown
guarantees the UID is absent before the sync suite runs.

prompt: the github runs takes more than an hour now.  It's not expected to
take more than 15-30 minutes
followup-prompt: Can we wipe the calendar instead of deleting it, and use the
same calendar for all the tests?  The delete-function already supports wiping,
but only when the calendar does not support delete.  Perhaps the delete-function
could have a wipe-parameter, tristate, False = don't wipe, True = wipe instead
of delete, None => wipe the calendar if deletion is not supported.  And then we
should mark up somehow in the feature setup that the tests should wipe nextcloud
rather than delete.  Also, why the need of having different logic in the async
and sync?  If the sync tests don't need unique calendars, why do the async test
need it?

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

AI Prompts:
claude-sonnet-4-6: the gihub runs takes more than an hour now.  It's not expected to take more than 15-30 minutes
claude-sonnet-4-6: Can we wipe the calendar instead of deleting it, and use the same calendar for all the tests?  The delete-function already supports wiping, but only when the calendar does not support delete.  Perhaps the delete-function could have a wipe-parameter, tristate, False = don't wipe, True = wipe isntead of delete, None => wipe the calendar if deletion is not supported.  And then we should mark up somehow in the feature setup that the tests should wipe nextcloud rather than delete.  Also, why the need of having different logic in the async and sync?  If the sync tests don't need unique calendars, why do the async test need it?
claude-sonnet-4-6: github runs still fail
claude-sonnet-4-6: I think we're on the wrong track here.  The caldav-server-tester reports full support for many of the features now set to "unknown"

Author: tobixen

CHANGELOG.md

@@ -12,6 +12,12 @@ Changelogs prior to v3.0 is pruned, but was available in the v3.1 release
 
 This project should adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html), though for pre-releases PEP 440 takes precedence.
 
+## [Unreleased]
+
+### Added
+
+* `Calendar.delete(wipe=None)` now accepts a `wipe` parameter.  `wipe=True` wipes all objects from the calendar without deleting the calendar itself — useful for servers like Nextcloud where calendar deletion moves the calendar to a trashbin without freeing the URL namespace.  `wipe=False` always attempts a HTTP DELETE regardless of server support.  The existing `None` default preserves current auto-detect behaviour.
+
 ## [3.2.0] - 2026-04-24
 
 The two most significant news in v3.2 are **relatively well-tested support for scheduling** (RFC6638) and **better-tested support for async**.  Care should still be taken, those features are backed by many tests, but lacks testing for how well they support real-world use-case scenarios.  While async support was added in version 3.0, it was not well-enough tested.  Still only a fraction of all the integration tests for sync usage has been duplicated in the async integration test, I expect to release 3.2.1 with symmetric async integration tests before 2025-07.

caldav/collection.py

@@ -786,44 +786,64 @@ async def _async_create(self, path, mkcol, method, name, display_name) -> None:
                         exc_info=True,
                     )
 
-    def delete(self):
+    def delete(self, wipe=None):
         """Delete the calendar.
 
         For async clients, returns a coroutine that must be awaited.
+
+        wipe: tristate controlling cleanup behaviour
+          None (default) – wipe all objects instead of deleting if the server
+                           doesn't support calendar deletion
+          True           – wipe all objects and return without deleting the
+                           calendar itself (useful for servers where deletion
+                           moves calendars to a trashbin)
+          False          – always attempt to delete the calendar via HTTP DELETE
         """
         if self.is_async_client:
-            return self._async_delete()
+            return self._async_delete(wipe=wipe)
+
+        if wipe is True:
+            for obj in self.search():
+                obj.delete()
+            return
 
         ## TODO: remove quirk handling from the functional tests
         ## TODO: this needs test code
         quirk_info = self.client.features.is_supported("delete-calendar", dict)
-        wipe = not self.client.features.is_supported("delete-calendar")
+        if wipe is None:
+            wipe = not self.client.features.is_supported("delete-calendar")
         if quirk_info["support"] == "fragile":
             ## Do some retries on deleting the calendar
-            for x in range(0, 20):
+            for _ in range(0, 20):
                 try:
                     super().delete()
                 except error.DeleteError:
                     pass
                 try:
-                    x = self.get_events()
+                    self.get_events()
                     sleep(0.3)
                 except error.NotFoundError:
                     wipe = False
                     break
 
         if wipe:
-            for x in self.search():
-                x.delete()
+            for obj in self.search():
+                obj.delete()
         else:
             super().delete()
 
-    async def _async_delete(self):
+    async def _async_delete(self, wipe=None):
         """Async implementation of Calendar.delete()."""
         import asyncio
 
+        if wipe is True:
+            for obj in await self.search():
+                await obj.delete()
+            return
+
         quirk_info = self.client.features.is_supported("delete-calendar", dict)
-        wipe = not self.client.features.is_supported("delete-calendar")
+        if wipe is None:
+            wipe = not self.client.features.is_supported("delete-calendar")
 
         if quirk_info["support"] == "fragile":
             # Do some retries on deleting the calendar

tests/test_async_integration.py

@@ -221,88 +221,79 @@ async def async_principal(self, async_client: Any) -> Any:
 
     @pytest_asyncio.fixture
     async def async_calendar(self, async_client: Any) -> Any:
-        """Create a test calendar or use an existing one if creation not supported."""
+        """Create or find a stable test calendar, wiping it before and after use.
+
+        Uses a stable cal_id so the calendar is reused across tests.  For servers
+        where deletion moves calendars to a trashbin (e.g. Nextcloud), we wipe
+        objects only rather than deleting the calendar, keeping the trashbin empty.
+        """
         from caldav.aio import AsyncPrincipal
         from caldav.lib.error import AuthorizationError, NotFoundError
 
-        from .fixture_helpers import aget_or_create_test_calendar
+        from .fixture_helpers import aget_or_create_test_calendar, cleanup_calendar_objects
+
+        feats = getattr(async_client, "features", None)
 
-        calendar_name = f"async-test-{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+        def _feat(name: str) -> bool:
+            return feats.is_supported(name) if feats else True
+
+        delete_frees_namespace = _feat("delete-calendar.free-namespace")
 
-        # Try to get principal for calendar operations
         principal = None
         try:
             principal = await AsyncPrincipal.create(async_client)
         except (NotFoundError, AuthorizationError):
             pass
 
-        # Use shared helper for calendar setup
         calendar, created = await aget_or_create_test_calendar(
-            async_client, principal, calendar_name=calendar_name
+            async_client,
+            principal,
+            calendar_name="pythoncaldav-async-test",
+            cal_id="pythoncaldav-async-test",
         )
 
         if calendar is None:
             pytest.skip("Could not create or find a calendar for testing")
 
+        await cleanup_calendar_objects(calendar)
+
         yield calendar
 
-        # Only cleanup if we created the calendar
-        if created:
+        if delete_frees_namespace and created:
             try:
                 await calendar.delete()
             except Exception:
                 pass
+        else:
+            await cleanup_calendar_objects(calendar)
 
     @pytest_asyncio.fixture
     async def async_task_list(self, async_client: Any) -> Any:
-        """Create a task list for todo tests.
-
-        For servers that don't support mixed calendars (like Zimbra), todos must
-        be stored in a separate task list with supported_calendar_component_set=["VTODO"].
-
-        Calendar naming strategy:
-        - Servers with cross-calendar UID uniqueness (Cyrus, OX) or no mixed-calendar
-          support: use "pythoncaldav-test-tasks" (shared with sync suite) to avoid
-          duplicate-UID conflicts.
-        - Servers where calendar deletion doesn't free the namespace (Nextcloud trashbin):
-          use unique timestamped names to avoid stale state from previous runs.
-        - All other servers: use stable "pythoncaldav-async-test".
+        """Create or find a stable task-list calendar, wiping it before and after use.
+
+        For servers that don't support mixed calendars (e.g. Zimbra), a VTODO-only
+        calendar is used.  The calendar is reused across tests via a stable cal_id
+        rather than being deleted and recreated, avoiding trashbin accumulation on
+        servers like Nextcloud.
         """
         from caldav.aio import AsyncPrincipal
         from caldav.lib.error import AuthorizationError, NotFoundError
 
         from .fixture_helpers import aget_or_create_test_calendar, cleanup_calendar_objects
 
-        feats = getattr(async_client, "features", None) or None
+        feats = getattr(async_client, "features", None)
 
         def _feat(name: str) -> bool:
             return feats.is_supported(name) if feats else True
 
         supports_mixed = _feat("save-load.todo.mixed-calendar")
-        cross_cal_uid_issues = not _feat("save.duplicate-uid.cross-calendar")
         delete_frees_namespace = _feat("delete-calendar.free-namespace")
 
-        # Determine cal_id and whether we share state with the sync test suite
-        if not supports_mixed or cross_cal_uid_issues:
-            # Must share with sync suite to avoid cross-calendar UID conflicts
-            component_set: list[str] | None = ["VTODO"] if not supports_mixed else None
-            cal_id = "pythoncaldav-test-tasks"
-            shared_with_sync = True
-        elif not delete_frees_namespace:
-            # Deletion goes to trashbin (e.g. Nextcloud): use unique name so
-            # stale objects from a previous run don't cause duplicate-UID errors.
-            component_set = None
-            cal_id = f"pythoncaldav-async-test-{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
-            shared_with_sync = False
-        else:
-            component_set = None
-            cal_id = "pythoncaldav-async-test"
-            shared_with_sync = False
-
+        component_set: list[str] | None = ["VTODO"] if not supports_mixed else None
+        cal_id = "pythoncaldav-async-test-tasks"
         supports_displayname = _feat("create-calendar.set-displayname")
         calendar_name = cal_id if supports_displayname else None
 
-        # Try to get principal for calendar operations
         principal = None
         try:
             principal = await AsyncPrincipal.create(async_client)
@@ -324,24 +315,28 @@ def _feat(name: str) -> bool:
 
         yield calendar
 
-        # Delete only if we created it and it's not shared with the sync suite.
-        # For shared calendars, objects were already wiped at setup; deleting the
-        # calendar here would break sync tests that run later in the same session.
-        if created and not shared_with_sync:
+        if delete_frees_namespace and created:
             try:
                 await calendar.delete()
             except Exception:
                 pass
+        else:
+            await cleanup_calendar_objects(calendar)
 
     @pytest_asyncio.fixture
     async def async_calendar2(self, async_client: Any) -> Any:
-        """Create a second test calendar for tests that need two distinct calendars."""
+        """Create or find a stable second test calendar for tests needing two calendars."""
         from caldav.aio import AsyncPrincipal
         from caldav.lib.error import AuthorizationError, NotFoundError
 
-        from .fixture_helpers import aget_or_create_test_calendar
+        from .fixture_helpers import aget_or_create_test_calendar, cleanup_calendar_objects
+
+        feats = getattr(async_client, "features", None)
+
+        def _feat(name: str) -> bool:
+            return feats.is_supported(name) if feats else True
 
-        calendar_name = f"async-test2-{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+        delete_frees_namespace = _feat("delete-calendar.free-namespace")
 
         principal = None
         try:
@@ -350,29 +345,44 @@ async def async_calendar2(self, async_client: Any) -> Any:
             pass
 
         calendar, created = await aget_or_create_test_calendar(
-            async_client, principal, calendar_name=calendar_name
+            async_client,
+            principal,
+            calendar_name="pythoncaldav-async-test-2",
+            cal_id="pythoncaldav-async-test-2",
         )
 
         if calendar is None:
             pytest.skip("Could not create or find a second calendar for testing")
 
+        await cleanup_calendar_objects(calendar)
+
         yield calendar
 
-        if created:
+        if delete_frees_namespace and created:
             try:
                 await calendar.delete()
             except Exception:
                 pass
+        else:
+            await cleanup_calendar_objects(calendar)
 
     @pytest_asyncio.fixture
     async def async_journal_list(self, async_client: Any) -> Any:
-        """Create a VJOURNAL calendar for journal tests."""
+        """Create or find a stable VJOURNAL calendar, wiping it before and after use."""
         from caldav.aio import AsyncPrincipal
         from caldav.lib.error import AuthorizationError, NotFoundError
 
-        from .fixture_helpers import aget_or_create_test_calendar
+        from .fixture_helpers import aget_or_create_test_calendar, cleanup_calendar_objects
+
+        feats = getattr(async_client, "features", None)
 
-        calendar_name = f"async-journal-{datetime.now().strftime('%Y%m%d%H%M%S%f')}"
+        def _feat(name: str) -> bool:
+            return feats.is_supported(name) if feats else True
+
+        delete_frees_namespace = _feat("delete-calendar.free-namespace")
+        supports_displayname = _feat("create-calendar.set-displayname")
+        cal_id = "pythoncaldav-async-journal"
+        calendar_name = cal_id if supports_displayname else None
 
         principal = None
         try:
@@ -384,19 +394,24 @@ async def async_journal_list(self, async_client: Any) -> Any:
             async_client,
             principal,
             calendar_name=calendar_name,
+            cal_id=cal_id,
             supported_calendar_component_set=["VJOURNAL"],
         )
 
         if calendar is None:
             pytest.skip("Could not create or find a journal list for testing")
 
+        await cleanup_calendar_objects(calendar)
+
         yield calendar
 
-        if created:
+        if delete_frees_namespace and created:
             try:
                 await calendar.delete()
             except Exception:
                 pass
+        else:
+            await cleanup_calendar_objects(calendar)
 
     async def _make_async_client_with_params(self, **overrides: Any) -> Any:
         """Build a fresh async client from this server's config with kwargs overridden.