changed TestRobot's Handler wrapping for compatibility with RFW<3.0

--HG--
branch : dev

Author: userzimmermann

robottools/testrobot/context.py

@@ -29,7 +29,6 @@
 from robot.running.namespace import Importer
 
 from .keyword import Keyword
-from .handler import Handler
 
 
 class Context(object):
@@ -89,9 +88,6 @@ def get_handler(self, name):
     def get_runner(self, name):
         handler = self.get_handler(name)
         runner = handler.create_runner(name)
-        # wrap the handler for Pythonic args/kwargs handling
-        # as needed by .keyword.Keyword.__call__
-        runner._handler = Handler(runner._handler)
         return runner
 
     def start_keyword(self, keyword):

robottools/testrobot/handler.py

@@ -26,25 +26,29 @@
 """
 __all__ = ['Handler']
 
-from moretools import isstring, dictitems
+from six import with_metaclass
 
+from moretools import isstring, isdict, dictitems
 
-class Handler(object):
-    """A wrapper for instances of classes from ``robot.running.handlers``,
-    implementing a custom :meth:`.resolve_arguments`,
-    which supports passing arbitrary python objects
-    as keyword argument values.
-    """
-    def __init__(self, handler):
-        """Create with the `handler` instance to wrap.
-        """
-        self._handler = handler
 
-    def __getattr__(self, name):
-        return getattr(self._handler, name)
+class HandlerMeta(type):
+
+    def __getitem__(cls, handlercls):
+        return type('Handler', (cls, handlercls), {
+            '_resolve_arguments': handlercls.resolve_arguments,
+        })
 
+
+class Handler(with_metaclass(HandlerMeta, object)):
+    """A wrapper base class for instances of classes
+    from ``robot.running.handlers``.
+
+    * Implements a custom :meth:`.resolve_arguments`,
+      which supports passing arbitrary python objects
+      as keyword argument values.
+    """
     # HACK
-    def resolve_arguments(self, args_and_kwargs, variables):
+    def resolve_arguments(self, args_and_kwargs, variables=None):
         """More Pythonic argument handling for interactive
         :class:`robottools.testrobot.keyword.Keyword` calls.
 
@@ -77,13 +81,19 @@ def resolve_arguments(self, args_and_kwargs, variables):
             if not isstring(value):
                 value = repr(value)
             rfwargs.append(u'%s=%s' % (name, value))
-        posargs, rfwkwargslist \
-            = self._handler.resolve_arguments(rfwargs, variables)
+        posargs, rfwkwargs = self._resolve_arguments(rfwargs, variables)
         # and replace values with original non-string objects after resolving
         kwargslist = []
-        for name, rfwvalue in rfwkwargslist:
+        if isdict(rfwkwargs):
+            # ==> RFW < 3.0
+            rfwkwargs = dictitems(rfwkwargs)
+        for name, rfwvalue in rfwkwargs:
             value = kwargs[name]
             if isstring(value):
                 value = rfwvalue
-            kwargslist.append(value)
+            kwargslist.append((name, value))
+        if hasattr(self, 'run'):
+            # ==> RFW < 3.0
+            return posargs, dict(kwargslist)
+        # RFW >= 3.0
         return posargs, kwargslist

robottools/testrobot/keyword.py

@@ -42,6 +42,8 @@
 
 from robottools.library.inspector.keyword import KeywordInspector
 
+from .handler import Handler
+
 
 def debug_fail(context, exc_info=None):
     """Handles a Keyword FAIL in debugging mode
@@ -125,6 +127,8 @@ def __exit__(self, *exc):
 class Keyword(KeywordInspector):
     def __init__(self, handler, context, debug=False):
         KeywordInspector.__init__(self, handler)
+        if not isinstance(handler, Handler):
+            handler.__class__ = Handler[handler.__class__]
         self._context = context
         self._debug = debug