fix: improve get_supported_components() — RFC compliance, async, hints

RFC 4791 §5.2.3 states that absent supported-calendar-component-set means
the server accepts all component types.  Previously the method raised
KeyError (fallback path) or returned an empty list (protocol-layer path).

Changes:
- Returns the RFC-compliant component set when the property is absent,
  adjusted per compatibility hints (e.g. excludes VTODO if save-load.todo
  is unsupported for the given server)
- Fixes async path that returned an unawaited coroutine instead of the result
- Removes dead _find_objects_and_props() fallback code
- Replaces no_supported_components_support flag with get-supported-components
  feature, allowing caldav-server-tester to track it
- Adds create-calendar.with-supported-component-types feature definition

Fixes #653

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

Author: tobixen

CHANGELOG.md

@@ -18,6 +18,7 @@ This project should adhere to [Semantic Versioning](https://semver.org/spec/v2.0
 
 * Reusing a `CalDAVSearcher` across multiple `search()` calls could yield inconsistent results: the first call would return only pending tasks (correct), but subsequent calls would change behaviour because `icalendar_searcher.Searcher.check_component()` mutated the `include_completed` field from `None` to `False` as a side-effect.  Fixed by passing a copy with `include_completed` already resolved to `filter_search_results()`, leaving the original searcher object unchanged.  Fixes https://github.com/python-caldav/caldav/issues/650
 * `_resolve_properties()` would crash with `UnboundLocalError` in production mode when a server returned an empty or unrecognisable PROPFIND response (the response paths did not match the request URI and there was more than one or zero paths returned).  Fixed by returning `{}` instead of falling through to an unbound variable.  Related: https://github.com/pycalendar/calendar-cli/issues/114
+* `Calendar.get_supported_components()` raised `KeyError` when the server did not include the `supported-calendar-component-set` property in its response.  RFC 4791 section 5.2.3 states this property is optional and that its absence means all component types are accepted; the method now returns the RFC default `["VEVENT", "VTODO", "VJOURNAL"]` in that case, trimmed by any known server limitations from the compatibility hints (e.g. if `save-load.todo` is `unsupported`, `VTODO` is excluded).  Fixes https://github.com/python-caldav/caldav/issues/653
 
 ## [3.1.0] - 2026-03-19
 

caldav/collection.py

@@ -745,29 +745,49 @@ async def _async_calendar_delete(self):
         else:
             await self._async_delete()
 
-    def get_supported_components(self) -> list[Any]:
+    def _supported_components_from_response(self, response: Any, with_fallback: bool) -> list[Any]:
+        """Extract supported component types from a propfind DAVResponse.
+
+        Both the sync and async paths produce a DAVResponse via propfind,
+        which always populates response.results via the protocol layer.
+        """
+        for result in response.results or []:
+            components = result.properties.get(cdav.SupportedCalendarComponentSet().tag)
+            if components:
+                return components
+        ## Property absent: RFC 4791 s.5.2.3 says accept all types; trim by known server limits
+        if not with_fallback:
+            raise error.PropfindError("supported-calendar-component-set not supported")
+        rfc_default = ["VEVENT"]
+        if self.client and self.client.features.is_supported("save-load.todo"):
+            rfc_default.append("VTODO")
+        if self.client and self.client.features.is_supported("save-load.journal"):
+            rfc_default.append("VJOURNAL")
+        return rfc_default
+
+    def get_supported_components(self, with_fallback=True) -> list[Any]:
         """
         returns a list of component types supported by the calendar, in
         string format (typically ['VJOURNAL', 'VTODO', 'VEVENT'])
+
+        RFC 4791 section 5.2.3: supported-calendar-component-set is optional.
+        When absent, the server MUST accept all component types, so we return
+        the RFC default list (trimmed by known server limitations from
+        compatibility hints) rather than raising or returning empty.
+        See https://github.com/python-caldav/caldav/issues/653
         """
         if self.url is None:
             raise ValueError("Unexpected value None for self.url")
-
+        if self.is_async_client:
+            return self._async_get_supported_components(with_fallback)
         props = [cdav.SupportedCalendarComponentSet()]
         response = self.get_properties(props, parse_response_xml=False)
+        return self._supported_components_from_response(response, with_fallback)
 
-        # Use protocol layer results if available
-        if response.results:
-            for result in response.results:
-                components = result.properties.get(cdav.SupportedCalendarComponentSet().tag)
-                if components:
-                    return components
-            return []
-
-        # Fallback for mocked responses without protocol parsing
-        response_list = response._find_objects_and_props()
-        prop = response_list[unquote(self.url.path)][cdav.SupportedCalendarComponentSet().tag]
-        return [supported.get("name") for supported in prop]
+    async def _async_get_supported_components(self, with_fallback=True) -> list[Any]:
+        props = [cdav.SupportedCalendarComponentSet()]
+        response = await self._async_get_properties(props, parse_response_xml=False)
+        return self._supported_components_from_response(response, with_fallback)
 
     def save_with_invites(self, ical: str, attendees, **attendeeoptions) -> None:
         """

caldav/compatibility_hints.py

@@ -82,6 +82,12 @@ class FeatureSet:
         "get-current-user-principal.has-calendar": {
             "type": "server-observation",
             "description": "Principal has one or more calendars.  Some servers and providers comes with a pre-defined calendar for each user, for other servers a calendar has to be explicitly created (supported means there exists a calendar - it may be because the calendar was already provisioned together with the principal, or it may be because a calendar was created manually, the checks can't see the difference)"},
+        "get-supported-components": {
+            "description": "Server returns the supported-calendar-component-set property (RFC 4791 section 5.2.3).  The property is optional: when absent the RFC mandates that all component types are accepted, so 'unsupported' here is not a protocol violation, but the client cannot determine the actual supported set without trying.",
+        },
+        "create-calendar.with-supported-component-types": {
+            "description": "Server honours the supported-calendar-component-set restriction set at MKCALENDAR time.  When 'full', the server both advertises (or enforces) the restriction; when 'unsupported', the restriction is silently ignored (wrong-type objects can be saved to the calendar).  When 'ungraceful', the MKCALENDAR request itself fails when a component set is specified.",
+        },
         "rate-limit": {
             "type": "client-feature",
             "description": "client (or test code) must sleep a bit between requests.  Pro-active rate limiting is done through interval and count, server-flagged rate-limiting is controlled through default_sleep/max_sleep",
@@ -809,9 +815,6 @@ def dotted_feature_set_list(self, compact=False):
     'non_existing_raises_other':
         """Robur raises AuthorizationError when trying to access a non-existing resource (while 404 is expected).  Probably so one shouldn't probe a public name space?""",
 
-    'no_supported_components_support':
-        """The supported components prop query does not work""",
-
     'no_relships':
         """The calendar server does not support child/parent relationships between calendar components""",
 
@@ -1227,11 +1230,11 @@ def dotted_feature_set_list(self, compact=False):
     'old_flags': [
         'non_existing_raises_other', ## AuthorizationError instead of NotFoundError
         'no_scheduling',
-        'no_supported_components_support',
         'no_relships',
     ],
     'test-calendar': {'cleanup-regime': 'wipe-calendar'},
     "sync-token": {"support": "ungraceful"},
+    "get-supported-components": {"support": "unsupported"},
 }
 
 posteo = {
@@ -1404,12 +1407,9 @@ def dotted_feature_set_list(self, compact=False):
     'old_flags': [
         ## Known, work in progress
         'no_scheduling',
-
-        ## Known, not a breach of standard
-        'no_supported_components_support',
-
-        ## I haven't raised this one with them yet
-    ]
+    ],
+    ## Known, not a breach of standard
+    "get-supported-components": {"support": "unsupported"},
 }
 
 gmx = {

tests/test_caldav.py

@@ -1819,7 +1819,6 @@ def testCreateCalendarAndEventFromVobject(self):
         assert len(c.get_events()) == cnt
 
     def testGetSupportedComponents(self):
-        self.skip_on_compatibility_flag("no_supported_components_support")
         c = self._fixCalendar()
 
         components = c.get_supported_components()

tests/test_caldav_unit.py

@@ -552,6 +552,76 @@ def testPathWithEscapedCharacters(self):
             url="https://somwhere.in.the.universe.example/some/caldav/root/133bahgr6ohlo9ungq0it45vf8%40group.calendar.google.com/events/"
         ).get_supported_components() == ["VEVENT"]
 
+    def test_get_supported_components_present(self):
+        """Test get_supported_components when the property is present in the server response."""
+        xml = b"""<multistatus xmlns="DAV:">
+  <response xmlns="DAV:">
+    <href>/some/caldav/root/testcal/</href>
+    <propstat>
+      <prop>
+        <supported-calendar-component-set xmlns="urn:ietf:params:xml:ns:caldav">
+          <comp xmlns="urn:ietf:params:xml:ns:caldav" name="VEVENT"/>
+        </supported-calendar-component-set>
+      </prop>
+      <status>HTTP/1.1 200 OK</status>
+    </propstat>
+  </response>
+</multistatus>"""
+        client = MockedDAVClient(xml)
+        assert client.calendar(
+            url="https://somwhere.in.the.universe.example/some/caldav/root/testcal/"
+        ).get_supported_components() == ["VEVENT"]
+
+    def test_get_supported_components_absent(self):
+        """RFC 4791 says supported-calendar-component-set is optional.
+        When absent, the server MUST accept all component types, and the
+        client MUST assume that all component types are accepted.
+        Regression for https://github.com/python-caldav/caldav/issues/653"""
+        xml = b"""<D:multistatus xmlns:D="DAV:">
+  <D:response>
+    <D:href>/some/caldav/root/testcal/</D:href>
+    <D:propstat>
+      <D:status>HTTP/1.1 200 OK</D:status>
+      <D:prop/>
+    </D:propstat>
+  </D:response>
+</D:multistatus>"""
+        client = MockedDAVClient(xml)
+        components = client.calendar(
+            url="https://somwhere.in.the.universe.example/some/caldav/root/testcal/"
+        ).get_supported_components()
+        assert "VEVENT" in components
+        assert "VTODO" in components
+        assert "VJOURNAL" in components
+
+    def test_get_supported_components_absent_hints(self):
+        """When supported-calendar-component-set is absent, the RFC default is filtered
+        by compatibility hints: if the server is known not to support VTODO or VJOURNAL,
+        those should be excluded from the returned list.
+        See https://github.com/python-caldav/caldav/issues/653"""
+        from caldav.compatibility_hints import FeatureSet
+
+        xml = b"""<D:multistatus xmlns:D="DAV:">
+  <D:response>
+    <D:href>/some/caldav/root/testcal/</D:href>
+    <D:propstat>
+      <D:status>HTTP/1.1 200 OK</D:status>
+      <D:prop/>
+    </D:propstat>
+  </D:response>
+</D:multistatus>"""
+        client = MockedDAVClient(xml)
+        client.features = FeatureSet(
+            {
+                "save-load.todo": {"support": "unsupported"},
+                "save-load.journal": {"support": "unsupported"},
+            }
+        )
+        components = client.calendar(
+            url="https://somwhere.in.the.universe.example/some/caldav/root/testcal/"
+        ).get_supported_components()
+        assert components == ["VEVENT"]
+
     def testAbsoluteURL(self):
         """Version 0.7.0 does not handle responses with absolute URLs very well, ref https://github.com/python-caldav/caldav/pull/103"""
         ## none of this should initiate any communication
@@ -779,27 +849,6 @@ def test_get_calendars(self):
         calendar_home_set = CalendarSet(client, url="/dav/tobias%40redpill-linpro.com/")
         assert len(calendar_home_set.get_calendars()) == 1
 
-        def test_supported_components(self):
-            xml = """
-<multistatus xmlns="DAV:">
-  <response xmlns="DAV:">
-    <href>/17149682/calendars/testcalendar-0da571c7-139c-479a-9407-8ce9ed20146d/</href>
-    <propstat>
-      <prop>
-        <supported-calendar-component-set xmlns="urn:ietf:params:xml:ns:caldav">
-          <comp xmlns="urn:ietf:params:xml:ns:caldav" name="VEVENT"/>
-        </supported-calendar-component-set>
-      </prop>
-      <status>HTTP/1.1 200 OK</status>
-    </propstat>
-  </response>
-</multistatus>"""
-            client = MockedDAVClient(xml)
-            assert Calendar(
-                client=client,
-                url="/17149682/calendars/testcalendar-0da571c7-139c-479a-9407-8ce9ed20146d/",
-            ).get_supported_components() == ["VEVENT"]
-
     def test_xml_parsing(self):
         """
         DAVResponse has quite some code to parse the XML received from the