fix: prevent 513 setup errors and async/sync UID conflicts in CI

Three root causes addressed:

1. verify_docker() in commit e643035 was broadened to return True when
   the `docker compose` plugin is available, even when the standalone
   `docker-compose` binary is absent.  But start.sh scripts require the
   standalone binary, so on GitHub CI: docker_available=True → all docker
   server directories registered → setup called → docker-compose: command
   not found (exit 127) → 513 test setup ERRORs.
   Fix: verify_docker() checks only the standalone `docker-compose` binary.
   On GitHub CI it now returns False, so only service containers that are
   already accessible are registered (via the is_accessible() branch of
   the existing `docker_available or server.is_accessible()` check).
   Locally, where docker-compose is installed, auto-start still works.

2. async_task_list used stable cal_id "pythoncaldav-async-test" for all
   mixed-calendar servers, including Cyrus which has
   save.duplicate-uid.cross-calendar=ungraceful.  Async test created UID
   well_known_1 in pythoncaldav-async-test; sync testObjectByUID tried the
   same UID in pythoncaldav-test-tasks → Cyrus 403.  This conflict was
   latent in 2a2d0ca but only surfaces once async tests actually reach
   Cyrus (which this branch enables).
   Fix: use "pythoncaldav-test-tasks" (same as sync suite) for any server
   with cross-calendar UID uniqueness enforcement.

3. Nextcloud's calendar deletion goes to trashbin (delete-calendar.free-
   namespace=fragile), so the next fixture invocation would find the old
   calendar, cleanup_calendar_objects would silently fail, and leftover
   objects triggered duplicate-UID 500 errors.
   Fix: use unique timestamped cal_id for servers where
   delete-calendar.free-namespace is not supported.

prompt: the github run fails (investigate and fix CI failures on branch async-github-testruns)
followup-prompt: continue implementing the three fixes identified in the previous session
followup-prompt: it is intended that it should be possible to run pytest without having to manually start all the test servers
followup-prompt: regarding the async/sync uid conflict, why don't we have that in the main branch?

Author: tobixen

tests/test_async_integration.py

@@ -260,20 +260,47 @@ async def async_task_list(self, async_client: Any) -> Any:
         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"].
 
-        Uses the same stable cal_id ("pythoncaldav-test-tasks") as the sync test suite
-        so that both share state rather than accumulate duplicate-UID conflicts on
-        servers with cross-calendar UID uniqueness (e.g. OX).  Objects are wiped
-        before each test for isolation.
+        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".
         """
         from caldav.aio import AsyncPrincipal
         from caldav.lib.error import AuthorizationError, NotFoundError
 
         from .fixture_helpers import aget_or_create_test_calendar, cleanup_calendar_objects
 
-        # Check if server supports mixed calendars
-        supports_mixed = True
-        if hasattr(async_client, "features") and async_client.features:
-            supports_mixed = async_client.features.is_supported("save-load.todo.mixed-calendar")
+        feats = getattr(async_client, "features", None) or 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
+
+        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
@@ -282,19 +309,6 @@ async def async_task_list(self, async_client: Any) -> Any:
         except (NotFoundError, AuthorizationError):
             pass
 
-        # For servers without mixed calendar support, create a dedicated task list.
-        # Use the same stable cal_id as the sync test suite so servers with
-        # cross-calendar duplicate-UID detection (e.g. OX) don't reject objects
-        # that also exist in the sync test's calendar.
-        component_set = ["VTODO"] if not supports_mixed else None
-        cal_id = "pythoncaldav-test-tasks" if not supports_mixed else "pythoncaldav-async-test"
-        supports_displayname = (
-            async_client.features.is_supported("create-calendar.set-displayname")
-            if hasattr(async_client, "features") and async_client.features
-            else True
-        )
-        calendar_name = cal_id if supports_displayname else None
-
         calendar, created = await aget_or_create_test_calendar(
             async_client,
             principal,
@@ -310,8 +324,10 @@ async def async_task_list(self, async_client: Any) -> Any:
 
         yield calendar
 
-        # Only cleanup if we created the calendar
-        if created:
+        # 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:
             try:
                 await calendar.delete()
             except Exception:

tests/test_servers/base.py

@@ -319,9 +319,11 @@ def _run(*cmd: str) -> bool:
             except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
                 return False
 
-        # Accept either the legacy standalone binary or the modern plugin form.
-        compose_ok = _run("docker-compose", "--version") or _run("docker", "compose", "version")
-        return compose_ok and _run("docker", "ps")
+        # start.sh scripts use the standalone `docker-compose` binary, so we
+        # only return True when that binary is actually present.  The `docker
+        # compose` plugin form is NOT sufficient — start.sh will exit 127 if
+        # only the plugin is available (e.g. on GitHub Actions runners).
+        return _run("docker-compose", "--version") and _run("docker", "ps")
 
     def start(self) -> None:
         """