Skipping by capability/feature

This change provide a way to skip one or more tests using features names to make it easier to understand why the test is being skipped, specially in the case it is testing new features by avoid the if `list of language` approach. It does not replace the skipped lists implemented for each driver testkit-backend since the skip reason could be different.

The usage of the RunTest message to fetch capabilities was done to keep a simple and backwards compatible way to use the fetch this information.

Author: bigmontz

nutkit/protocol/__init__.py

@@ -1,3 +1,4 @@
 from .requests import *
 from .cypher import *
 from .responses import *
+from .feature import *

nutkit/protocol/feature.py

@@ -0,0 +1,8 @@
+"""
+Enumerate all the capabilities in the drivers
+"""
+from enum import Enum
+
+
+class Feature(Enum):
+    AUTHORIZATION_EXPIRED_TREATMENT = 'AutorizationExpiredTreament'

nutkit/protocol/requests.py

@@ -27,6 +27,13 @@ def __init__(self, test_name):
         self.testName = test_name
 
 
+class GetFeatures:
+    """ Request the backend to the list of features supported by the driver.
+    The backend should respond with FeatureList.
+    """
+    pass
+
+
 class NewDriver:
     """ Request to create a new driver instance on the backend.
     Backend should respond with a Driver response or an Error response.

nutkit/protocol/responses.py

@@ -26,6 +26,15 @@ class RunTest:
     pass
 
 
+class FeatureList:
+    """ Response to GetFeatures indication the features supported
+    by the driver"""
+    def __init__(self, features=None):
+        if features is None:
+            features = []
+        self.features = features
+
+
 class SkipTest:
     """ Response to StartTest indicating that the test should be skipped"""
 

tests/shared.py

@@ -15,6 +15,7 @@
 
 from nutkit import protocol
 from nutkit.backend import Backend
+import warnings
 
 
 def get_backend_host_and_port():
@@ -30,6 +31,62 @@ def new_backend():
     return Backend(host, port)
 
 
+def driver_feature(feature):
+    if not isinstance(feature, protocol.Feature):
+        raise Exception('The argument should be instance of Feature')
+
+    def get_valid_test_case(*args, **kwargs):
+        if not args or not isinstance(args[0], TestkitTestCase):
+            raise Exception('Should only decorate TestkitTestCase methods')
+        return args[0]
+
+    def driver_feature_decorator(func):
+        def wrapper(*args, **kwargs):
+            test_case = get_valid_test_case(*args, **kwargs)
+            if (feature.value not in test_case._driver_features):
+                test_case.skipTest("Needs support for %s" % feature.value)
+            return func(*args, **kwargs)
+        return wrapper
+    return driver_feature_decorator
+
+
+class MemoizedSupplier:
+    """ Momoize the function it annotates.
+    This way the decorated function will always return the
+    same value of the first interaction independent of the
+    supplied params.
+    """
+
+    def __init__(self, func):
+        self._func = func
+        self._memo = None
+
+    def __call__(self, *args, **kwargs):
+        if self._memo is None:
+            self._memo = self._func(*args, **kwargs)
+        return self._memo
+
+
+@MemoizedSupplier
+def get_driver_features(backend):
+    # TODO Remove when dotnet implements the GetFeature message
+    if get_driver_name() in ['dotnet']:
+        warnings.warn("Driver does not implements GetFeatures.")
+        features = ()
+        return features
+
+    try:
+        response = backend.sendAndReceive(protocol.GetFeatures())
+        if not isinstance(response, protocol.FeatureList):
+            raise Exception("Response is not instance of FeatureList")
+        features = tuple(response.features)
+    except Exception as e:
+        warnings.warn("Could not fetch FeatureList: %s" % e)
+        features = ()
+
+    return features
+
+
 def get_driver_name():
     return os.environ['TEST_DRIVER_NAME']
 
@@ -40,6 +97,7 @@ def setUp(self):
         id_ = re.sub(r"^([^\.]+\.)*?tests\.", "", self.id())
         self._backend = new_backend()
         self.addCleanup(self._backend.close)
+        self._driver_features = get_driver_features(self._backend)
         response = self._backend.sendAndReceive(protocol.StartTest(id_))
         if isinstance(response, protocol.SkipTest):
             self.skipTest(response.reason)

tests/stub/authorization.py

@@ -3,6 +3,7 @@
 from tests.shared import (
     get_driver_name,
     TestkitTestCase,
+    driver_feature
 )
 from tests.stub.shared import StubServer
 
@@ -698,6 +699,7 @@ def read_return_1_failure_return_2_succeed_script(self):
         +}
         """
 
+    @driver_feature(types.Feature.AUTHORIZATION_EXPIRED_TREATMENT)
     def test_should_drop_connection_after_AuthorizationExpired(self):
         self._server.start(
             script=self.read_return_1_failure_return_2_succeed_script()
@@ -732,6 +734,7 @@ def test_should_drop_connection_after_AuthorizationExpired(self):
 
         driver.close()
 
+    @driver_feature(types.Feature.AUTHORIZATION_EXPIRED_TREATMENT)
     def test_should_be_able_to_use_current_sessions_after_AuthorizationExpired(self):
         self._server.start(
             script=self.read_return_1_failure_return_2_succeed_script()