Fix: parent features with explicit defaults not overridden by subfeature derivation

When a feature like create-calendar has an explicit default (full), it
represents an independent capability.  The _derive_from_subfeatures
logic should not override that default based on subfeature statuses.

Previously, create-calendar would incorrectly derive as unsupported
when only create-calendar.set-displayname was set to unsupported
(the Zimbra case: calendar creation works, but setting display name
on creation does not).

The fix guards the final derivation attempt (before falling back to
default) with the same 'default' not in feature_info check used
in the tree-walk phase.

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

Author: tobixen

caldav/compatibility_hints.py

@@ -468,11 +468,15 @@ def is_supported(self, feature, return_type=bool, return_defaults=True, accept_f
             if '.' not in feature_:
                 if not return_defaults:
                     return None
-                # Before returning default, check if we have subfeatures with explicit values
-                # If subfeatures exist and have mixed support levels, we should derive the parent status
-                derived = self._derive_from_subfeatures(feature_, feature_info, return_type, accept_fragile)
-                if derived is not None:
-                    return derived
+                # For features WITHOUT an explicit default (i.e. pure grouping features),
+                # derive status from subfeatures.  Features WITH a default represent
+                # independent capabilities and their default should not be overridden
+                # by subfeature statuses (e.g. create-calendar is supported even if
+                # create-calendar.set-displayname is not).
+                if 'default' not in feature_info:
+                    derived = self._derive_from_subfeatures(feature_, feature_info, return_type, accept_fragile)
+                    if derived is not None:
+                        return derived
                 return self._convert_node(self._default(feature_info), feature_info, return_type, accept_fragile)
             feature_ = feature_[:feature_.rfind('.')]
 
@@ -970,8 +974,6 @@ def dotted_feature_set_list(self, compact=False):
     "calendar_order",
     "calendar_color"
     ]
-    ## TODO: there may be more, it should be organized and moved here.
-    ## Search for 'zimbra' in the code repository!
 }
 
 bedework = {

tests/test_compatibility_hints.py

@@ -324,6 +324,27 @@ def test_independent_subfeature_not_derived(self) -> None:
         auto_result = fs.is_supported("create-calendar.auto", return_type=dict)
         assert auto_result == {"support": "unsupported"}
 
+    def test_parent_default_not_overridden_by_subfeature_derivation(self) -> None:
+        """Test that a parent with an explicit default is not overridden by subfeature derivation.
+
+        Zimbra scenario: create-calendar.set-displayname is unsupported, but
+        create-calendar has an explicit default of 'full'.  The parent feature
+        represents an independent capability (calendar creation works), so the
+        subfeature status should not override the default.
+        """
+        fs = FeatureSet()
+        fs._server_features = {
+            "create-calendar.set-displayname": {"support": "unsupported"},
+        }
+
+        # create-calendar should return its default (full), NOT derive unsupported
+        # from .set-displayname
+        result = fs.is_supported("create-calendar", return_type=dict)
+        assert result == {"support": "full"}, (
+            f"create-calendar should default to 'full' even when "
+            f".set-displayname is unsupported, but got {result}"
+        )
+
     def test_hierarchical_vs_independent_subfeatures(self) -> None:
         """Test that hierarchical subfeatures derive parent, but independent ones don't"""
         fs = FeatureSet()