work in progress

Author: tobixen

caldav/compatibility_hints.py

@@ -77,7 +77,7 @@ class FeatureSet:
         },
     }
 
-    def __init__(self, feature_set):
+    def __init__(self, feature_set_dict):
         """
         TODO: describe the feature_set better.
 
@@ -104,18 +104,21 @@ def __init__(self, feature_set):
         ## (anyways, that is an internal design decision that may be
         ## changed ... but we need test code in place)
         self._server_features = {}
-        self.copyFeatureSet(feature_set)
+        self.copyFeatureSet(feature_set_dict)
 
-    def _copyFeature(def_node, server_node, value):
+    def _copyFeature(self, def_node, server_node, value):
         if isinstance(value, str) and not 'support' in server_node:
             server_node['support'] = value
         elif isinstance(value, dict):
             if value.get('features'):
                 raise NotImplementedError("todo ... work in progress ... need to recursively process the feature set")
             server_node.update(value)
 
-    def copyFeatureSet(feature_set):
+    def copyFeatureSet(self, feature_set):
         for feature in feature_set:
+            ## TODO: temp - should be removed
+            if feature == 'old_flags':
+                continue
             fpath = feature.split('.')
             def_tree = self.FEATURES
             server_tree = self._server_features
@@ -126,15 +129,33 @@ def copyFeatureSet(feature_set):
                 if not step in server_tree:
                     server_tree[step] = {}
                 server_node = server_tree[step]
-                if not 'features' in def_tree:
+                if not 'features' in def_node:
                     server_tree = None
                     def_tree = None
                 else:
                     if not 'features' in server_node:
                         server_node['features'] = {}
                     server_tree = server_node['features']
                     def_tree = def_node['features']
-            self._copyFeature(def_node, server_node, feature_set[fpath])
+            self._copyFeature(def_node, server_node, feature_set[feature])
+
+    def check_support(self, feature, return_type=bool):
+        """
+        Work in progress
+
+        TODO: write a better docstring
+        """
+        feature_info = self.find_feature(feature)
+        support = self._server_features.get(feature, {'support': 'full'})
+        if return_type == str:
+            ## TODO: consider type, be smarter about it
+            return support.get('support', support.get('enable', support.get('behaviour')))
+        elif return_type == dict:
+            return support
+        elif return_type == bool:
+            ## TODO: consider type, be smarter about it
+            return support.get('support', 'full') == 'full' and not support.get('enable') and not support.get('behaviour')
+
 
     def find_feature(self, feature: str) -> dict:
         """

tests/test_caldav.py

@@ -40,7 +40,8 @@
 from .conf import test_xandikos
 from .conf import xandikos_host
 from .conf import xandikos_port
-from caldav import compatibility_hints
+from caldav.compatibility_hints import FeatureSet
+from caldav.compatibility_hints import incompatibility_description ## TEMP - should be removed in the future
 from caldav.davclient import DAVClient
 from caldav.davclient import DAVResponse
 from caldav.davclient import get_davclient
@@ -666,49 +667,38 @@ def check_support(self, feature, return_type=bool):
 
         TODO: write a better docstring
         """
-        feature_info = compatibility_hints.FEATURES.find_feature(feature)
-        support = self.features.get(feature, {'support': 'full'})
-        if return_type == str:
-            ## TODO: consider type, be smarter about it
-            return support.get('support', support.get('enable', support.get('behaviour')))
-        elif return_type == dict:
-            return support
-        elif return_type == bool:
-            ## TODO: consider type, be smarter about it
-            return support.get('support', 'full') == 'full' and not support.get('enable') and not support.get('behaviour')
-            
+        return self.features.check_support(feature, return_type)
+
     def check_compatibility_flag(self, flag):
         ## yield an assertion error if checking for the wrong thig
-        assert flag in compatibility_hints.incompatibility_description
-        return flag in self.features['old_flags']
+        assert flag in incompatibility_description
+        return flag in self.old_features
 
     def skip_on_compatibility_flag(self, flag):
         if self.check_compatibility_flag(flag):
-            msg = compatibility_hints.incompatibility_description[flag]
+            msg = incompatibility_description[flag]
             pytest.skip("Test skipped due to server incompatibility issue: " + msg)
 
     def skip_unless_support(self, feature):
         if self.check_support(feature):
-            msg = compatibility_hints.FEATURES.find_feature(feature).get('description', feature)
+            msg = self.features.find_feature(feature).get('description', feature)
             pytest.skip("Test skipped due to server incompatibility issue: " + msg)
 
     def setup_method(self):
         logging.debug("############## test setup")
-        self.features = {}
         self.cleanup_regime = self.server_params.get("cleanup", "light")
         self.calendars_used = []
 
-        self.features = self.server_params.get("features", {})
+        features = self.server_params.get("features", {})
+
+        ## Temp thing
+        self.old_features = features.get('old_flags', [])
+
+        self.features = FeatureSet(self.server_params.get("features", {}))
 
         ## verify that all old flags are valid
-        for flag in self.features.get('old_flags'):
-            assert flag in compatibility_hints.incompatibility_description
-
-        ## verify that all new compatibility info is valid (TODO: should validate better)
-        for feature in self.server_params.get('features', []):
-            if feature == 'old_flags':
-                continue
-            compatibility_hints.FEATURES.find_feature(feature)
+        for flag in self.old_features:
+            assert flag in incompatibility_description
 
         if self.check_compatibility_flag("unique_calendar_ids"):
             self.testcal_id = "testcalendar-" + str(uuid.uuid4())