test: gate the comp-type-less time-range Run 2 on a ReportError rejection

CI failure on Cyrus: testSearchWithoutCompTypeWithDateRange's second run
forced search.time-range.comp-type-optional ON and asserted the event was
returned, relying on the reactive HTTP-400 fallback.  But that fallback only
recovers from a ReportError (SabreDAV's 400) - Cyrus instead returns nothing
(CI) or 403 (locally), so the forced run either found nothing or crashed.

The forced "Run 2" is only meaningful where the raw comp-type-less time-range
query raises a ReportError (Baikal, Nextcloud).  The test now probes the raw
behaviour first and only runs Run 2 in that case; other servers exercise just
the proactive split (Run 1).  The reactive fallback itself remains covered
deterministically by the unit test.

#681

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: tobixen

docs/source/http-libraries.rst

@@ -30,12 +30,15 @@ According to
 https://github.com/python-caldav/caldav/issues/611#issuecomment-4278875543
 the httpx development seems stagnant, and httpx is even flagged as a
 supply-chain risk in some Reddit-discussions.  It seems like the http
-user space is filled with drama and intrigues.
+user space is filled with drama and intrigues.  httpxyz is a
+maintained fork of httpx.  For async communication, the fallback chain
+now is niquests, httpxyz and finally httpx if import of the former two
+fails.
 
 Fallbacks
 ---------
 
-To enable the fallbacks, just ensure the requests and/or httpx library is available and that niquests isn't available.  In virtual environments, fix the dependencies in `pyproject.toml`.
+To enable the fallbacks, just ensure the requests and/or httpxyz/httpx library is available and that niquests isn't available.  In virtual environments, fix the dependencies in `pyproject.toml`.
 
 Recommendations
 ---------------

pyproject.toml

@@ -53,7 +53,7 @@ classifiers = [
 
 dependencies = [
   "lxml",
-  "niquests",
+  "niquests", ## see docs/source/http-libraries.rst
   "recurring-ical-events>=2.0.0",
   "typing_extensions;python_version<'3.11'",
   "icalendar>6.0.0",

tests/test_async_integration.py

@@ -577,21 +577,39 @@ async def _assert_event_found():
         ## Run 1: the server's real feature configuration (proactive comp-type split)
         await _assert_event_found()
 
-        ## Run 2: force search.time-range.comp-type-optional ON, so the library
-        ## sends the comp-type-less time-range query verbatim and must recover from
-        ## the server's rejection via the reactive fallback (issue #681 item 4).
-        features = async_calendar.client.features
-        key = "search.time-range.comp-type-optional"
-        had_key = key in features._server_features
-        saved = features._server_features.get(key)
-        features.set_feature(key, {"support": "full"})
+        ## Determine how this server reacts to the raw comp-type-less time-range
+        ## query.  Only SabreDAV-style servers reject it with a ReportError (HTTP
+        ## 400) - the case the reactive fallback (issue #681 item 4) recovers from.
+        ## Others return nothing or a different error (e.g. Cyrus may answer 403),
+        ## where forcing the feature on is an unrecoverable misconfiguration.
+        from caldav.lib import error
+
         try:
-            await _assert_event_found()
-        finally:
-            if had_key:
-                features._server_features[key] = saved
-            else:
-                features._server_features.pop(key, None)
+            await async_calendar.search(start=start, end=end, compatibility_workarounds=False)
+            raw_report_error = False
+        except error.ReportError:
+            raw_report_error = True
+        except error.DAVError:
+            raw_report_error = False
+
+        ## Run 2 (only meaningful where the raw query raises a ReportError): force
+        ## the feature ON and verify the reactive fallback recovers and finds the event.
+        if raw_report_error:
+            features = async_calendar.client.features
+            key = "search.time-range.comp-type-optional"
+            had_key = key in features._server_features
+            saved = features._server_features.get(key)
+            features.set_feature(key, {"support": "full"})
+            try:
+                objects = await async_calendar.search(start=start, end=end)
+                assert [o for o in objects if uid in o.data], (
+                    "reactive fallback did not recover the comp-type-less time-range search"
+                )
+            finally:
+                if had_key:
+                    features._server_features[key] = saved
+                else:
+                    features._server_features.pop(key, None)
 
     @pytest.mark.asyncio
     async def test_search_without_comptype_with_category(self, async_calendar: Any) -> None:

tests/test_caldav.py

@@ -3466,21 +3466,39 @@ def _assert_event_found():
         ## Run 1: the server's real feature configuration (proactive comp-type split)
         _assert_event_found()
 
-        ## Run 2: force search.time-range.comp-type-optional ON, so the library
-        ## sends the comp-type-less time-range query verbatim and must recover from
-        ## the server's rejection via the reactive fallback (issue #681 item 4).
-        features = self.caldav.features
-        key = "search.time-range.comp-type-optional"
-        had_key = key in features._server_features
-        saved = features._server_features.get(key)
-        features.set_feature(key, {"support": "full"})
+        ## Determine how this server reacts to the raw comp-type-less time-range
+        ## query.  Only SabreDAV-style servers (Baikal, Nextcloud) reject it with a
+        ## ReportError (HTTP 400) - that is the case the reactive fallback (issue
+        ## #681 item 4) is designed to recover from.  Others return nothing, or a
+        ## different error (e.g. Cyrus may answer 403), where forcing the feature on
+        ## is an unrecoverable misconfiguration not worth asserting on.
         try:
-            _assert_event_found()
-        finally:
-            if had_key:
-                features._server_features[key] = saved
-            else:
-                features._server_features.pop(key, None)
+            cal.search(start=start, end=end, compatibility_workarounds=False)
+            raw_report_error = False
+        except error.ReportError:
+            raw_report_error = True
+        except error.DAVError:
+            raw_report_error = False
+
+        ## Run 2 (only meaningful where the raw query raises a ReportError): force
+        ## search.time-range.comp-type-optional ON and verify the reactive fallback
+        ## recovers and still finds the event.
+        if raw_report_error:
+            features = self.caldav.features
+            key = "search.time-range.comp-type-optional"
+            had_key = key in features._server_features
+            saved = features._server_features.get(key)
+            features.set_feature(key, {"support": "full"})
+            try:
+                objects = cal.search(start=start, end=end)
+                assert [o for o in objects if uid in o.data], (
+                    "reactive fallback did not recover the comp-type-less time-range search"
+                )
+            finally:
+                if had_key:
+                    features._server_features[key] = saved
+                else:
+                    features._server_features.pop(key, None)
 
     def testSearchWithoutCompTypeWithCategory(self):
         """Test for https://github.com/python-caldav/caldav/issues/681