test: test-server fallback without session locks

get_davclient()'s test-server fallback called claim_server() on every
server, but the caldav.testing and config-file servers that a
pip-installed caldav uses have none, so every server was skipped.  A
server that failed to start also kept its claim until the process
exited.  Without fcntl (Windows), embedded and external servers now
start unlocked instead of failing; docker servers still need fcntl.

Prompt: dismiss the false positive and merge 776.  Leave 768 for a while
[the false positive: a CodeQL "file is not always closed" warning on a
test fixture; 776 is #776 -
its merge review found the bugs fixed here; 768 is
#768, unrelated]
Followup-Prompt: do the needful [fix the bug the merge review found -
the fallback skipping every server of a pip-installed caldav - plus the
claim left held after a failed start and the missing fcntl on Windows]

Assisted-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Reviewed-by: Tobias Brox <tobias@redpill-linpro.com>

Author: tobixen

caldav/config.py

@@ -413,12 +413,17 @@ def _get_test_server_config(
 
     for server in _collect_test_servers(name, config_file):
         was_already_started = server._started
+        # Servers from caldav.testing (pip-installed caldav) have no session lock
+        claim = getattr(server, "claim_server", None)
+        claimed = False
         try:
             # Another process using this server: try the next one rather than wait
-            server.claim_server(server.name, 0)
+            claimed = bool(claim and claim(server.name, 0))
             server.start()
         except Exception as e:
             logging.warning("Failed to start test server %s: %s", server.name, e)
+            if claimed:
+                server.release_server(server.name)
             continue
         logging.info("Using test server: %s at %s", server.name, server.url)
         return _test_server_to_params(server, was_already_started)

tests/test_servers/base.py

@@ -144,10 +144,16 @@ def claim_server(name: str, timeout: float | None = None) -> bool:
         Returns True if the lock was taken just now, False if this process
         already held it.  Anything learned about the server before a fresh
         claim may be stale, since its previous user may have stopped it.
+
+        Without ``fcntl`` (Windows) nothing is locked between processes.
         """
-        import fcntl
         import time
 
+        try:
+            import fcntl
+        except ImportError:
+            fcntl = None  # type: ignore[assignment]
+
         with _session_locks_mutex:
             if name in _session_locks:
                 return False
@@ -163,7 +169,7 @@ def claim_server(name: str, timeout: float | None = None) -> bool:
             try:
                 deadline = time.monotonic() + timeout
                 announced = False
-                while True:
+                while fcntl:
                     try:
                         fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
                         break
@@ -191,6 +197,14 @@ def claim_server(name: str, timeout: float | None = None) -> bool:
             _session_locks[name] = lock_file
             return True
 
+    @staticmethod
+    def release_server(name: str) -> None:
+        """Give up a claim taken by ``claim_server()``, letting other runs have the server."""
+        with _session_locks_mutex:
+            lock_file = _session_locks.pop(name, None)
+        if lock_file:
+            lock_file.close()
+
     def claim(self) -> bool:
         """``claim_server()`` for this server."""
         return self.claim_server(self.name)

tests/test_servers/test_base.py

@@ -227,6 +227,48 @@ def test_get_davclient_falls_through_busy_server(
         assert time.monotonic() - t0 < 5
         assert params is not None and "Free" in params["url"]
 
+    def test_fallback_uses_servers_without_session_lock(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Pip-installed caldav has no tests/ and so no claim_server() on its servers."""
+        from caldav import config
+
+        server = config._ConfiguredServer("Lambda", {"url": "http://localhost:1/Lambda/"})
+        monkeypatch.setattr(config, "_collect_test_servers", lambda name, config_file: [server])
+        params = config._get_test_server_config(None, environment=False)
+        assert params is not None and "Lambda" in params["url"]
+
+    def test_fallback_releases_server_that_failed_to_start(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        import fcntl
+
+        from caldav import config
+
+        class BrokenServer(base.ExternalTestServer):
+            def start(self) -> None:
+                self.claim()
+                raise RuntimeError("does not start")
+
+        broken = BrokenServer({"name": "Mu", "url": "http://localhost:1/Mu/"})
+        free = base.ExternalTestServer({"name": "Nu", "url": "http://localhost:1/Nu/"})
+        monkeypatch.setattr(
+            config, "_collect_test_servers", lambda name, config_file: [broken, free]
+        )
+        params = config._get_test_server_config(None, environment=False)
+        assert params is not None and "Nu" in params["url"]
+        assert "Mu" not in base._session_locks
+        with open(base._lock_path("Mu", ".session"), "a+") as other:
+            fcntl.flock(other, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+    def test_claim_without_fcntl(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """No fcntl (Windows): no lock between processes, but claims still work."""
+        import sys
+
+        monkeypatch.setitem(sys.modules, "fcntl", None)
+        assert base.TestServer.claim_server("Xi") is True
+        assert base.TestServer.claim_server("Xi") is False
+
     def test_waiting_run_restarts_container_stopped_meanwhile(self, tmp_path: Path) -> None:
         """Collection saw the container up, but its owner stopped it before we got the lock."""
         counter = tmp_path / "runs"