Dynamic library support #18

Still need to add some acceptance tests.

Author: pekkaklarck

src/robotremoteserver.py

@@ -63,7 +63,7 @@ def __init__(self, library, host='127.0.0.1', port=8270, port_file=None,
                             ``Stop Remote Server`` keyword.
         """
         SimpleXMLRPCServer.__init__(self, (host, int(port)), logRequests=False)
-        self._library = RemoteLibrary(library)
+        self._library = RemoteLibraryFactory(library)
         self._allow_stop = allow_stop
         self._shutdown = False
         self._register_functions()
@@ -141,33 +141,48 @@ def get_keyword_documentation(self, name):
         return self._library.get_keyword_documentation(name)
 
 
-class RemoteLibrary(object):
+def RemoteLibraryFactory(library):
+    if inspect.ismodule(library):
+        return StaticRemoteLibrary(library)
+    get_keyword_names = dynamic_method(library, 'get_keyword_names')
+    if not get_keyword_names:
+        return StaticRemoteLibrary(library)
+    run_keyword = dynamic_method(library, 'run_keyword')
+    if not run_keyword:
+        return HybridRemoteLibrary(library, get_keyword_names)
+    return DynamicRemoteLibrary(library, get_keyword_names, run_keyword)
+
+
+def dynamic_method(library, underscore_name):
+    tokens = underscore_name.split('_')
+    camelcase_name = tokens[0] + ''.join(t.title() for t in tokens[1:])
+    for name in underscore_name, camelcase_name:
+        method = getattr(library, name, None)
+        if method and is_function_or_method(method):
+            return method
+    return None
+
+
+def is_function_or_method(item):
+    return inspect.isfunction(item) or inspect.ismethod(item)
+
+
+class StaticRemoteLibrary(object):
 
     def __init__(self, library):
         self._library = library
 
     def get_keyword_names(self):
-        get_kw_names = (getattr(self._library, 'get_keyword_names', None) or
-                        getattr(self._library, 'getKeywordNames', None))
-        if self._is_function_or_method(get_kw_names):
-            names = get_kw_names()
-        else:
-            names = [attr for attr in dir(self._library) if attr[0] != '_' and
-                     self._is_function_or_method(getattr(self._library, attr))]
-        return names
-
-    def _is_function_or_method(self, item):
-        return inspect.isfunction(item) or inspect.ismethod(item)
+        return [name for name, value in inspect.getmembers(self._library)
+                if name[0] != '_' and is_function_or_method(value)]
 
     def run_keyword(self, name, args, kwargs=None):
         kw = self._get_keyword(name)
         return KeywordRunner(kw).run_keyword(args, kwargs)
 
     def _get_keyword(self, name):
         kw = getattr(self._library, name, None)
-        if not self._is_function_or_method(kw):
-            return None
-        return kw
+        return kw if is_function_or_method(kw) else None
 
     def get_keyword_arguments(self, name):
         kw = self._get_keyword(name)
@@ -196,6 +211,45 @@ def get_keyword_documentation(self, name):
         return inspect.getdoc(self._get_keyword(name)) or ''
 
 
+class HybridRemoteLibrary(StaticRemoteLibrary):
+
+    def __init__(self, library, get_keyword_names):
+        StaticRemoteLibrary.__init__(self, library)
+        self.get_keyword_names = get_keyword_names
+
+
+class DynamicRemoteLibrary(HybridRemoteLibrary):
+
+    def __init__(self, library, get_keyword_names, run_keyword):
+        HybridRemoteLibrary.__init__(self, library, get_keyword_names)
+        self._run_keyword = run_keyword
+        self._supports_kwargs = self._get_kwargs_support(run_keyword)
+        self._get_keyword_arguments \
+            = dynamic_method(library, 'get_keyword_arguments')
+        self._get_keyword_documentation \
+            = dynamic_method(library, 'get_keyword_documentation')
+
+    def _get_kwargs_support(self, run_keyword):
+        spec = inspect.getargspec(run_keyword)
+        return len(spec.args) > 3    # self, name, args, kwargs=None
+
+    def run_keyword(self, name, args, kwargs=None):
+        args = [name, args, kwargs]
+        return KeywordRunner(self._run_keyword).run_keyword(args)
+
+    def get_keyword_arguments(self, name):
+        if self._get_keyword_arguments:
+            return self._get_keyword_arguments(name)
+        if self._supports_kwargs:
+            return ['*varargs', '**kwargs']
+        return ['*varargs']
+
+    def get_keyword_documentation(self, name):
+        if self._get_keyword_documentation:
+            return self._get_keyword_documentation(name)
+        return ''
+
+
 class KeywordRunner(object):
 
     def __init__(self, keyword):

test/utest/test_argsdocs.py

@@ -2,7 +2,7 @@
 
 import unittest
 
-from robotremoteserver import RemoteLibrary
+from robotremoteserver import RemoteLibraryFactory
 
 
 class LibraryWithArgsAndDocs:
@@ -59,7 +59,7 @@ def test_intro_doc_from_module(self):
         self._test_doc('__intro__', 'Module doc - used in tests', test_argsdocs)
 
     def _test_doc(self, name, expected, library=LibraryWithArgsAndDocs(None)):
-        library = RemoteLibrary(library)
+        library = RemoteLibraryFactory(library)
         self.assertEquals(library.get_keyword_documentation(name), expected)
 
 
@@ -77,7 +77,7 @@ def test_keyword_args_from_module_keyword(self):
                         test_argsdocs)
 
     def _test_args(self, name, expected, library=LibraryWithArgsAndDocs(None)):
-        library = RemoteLibrary(library)
+        library = RemoteLibraryFactory(library)
         self.assertEquals(library.get_keyword_arguments(name), expected)
 
 

test/utest/test_dynamicargsdocs.py

@@ -0,0 +1,98 @@
+import unittest
+
+from robotremoteserver import RemoteLibraryFactory
+
+
+class OwnArgsAndDocs(object):
+
+    def get_keyword_names(self):
+        return ['keyword']
+
+    def run_keyword(self, name, args, kwargs=None):
+        pass
+
+    def get_keyword_arguments(self, name):
+        return ['a1', 'a2=%s' % name, '*args', '**kwargs']
+
+    def get_keyword_documentation(self, name):
+        return 'The doc for %s' % name
+
+
+class OwnArgsAndDocsWithCamelCaseNames(object):
+
+    def getKeywordNames(self):
+        return ['keyword']
+
+    def runKeyword(self, name, args):
+        pass
+
+    def getKeywordArguments(self, name):
+        return ['a1', 'a2=%s' % name, '*args', '**kwargs']
+
+    def getKeywordDocumentation(self, name):
+        return 'The doc for %s' % name
+
+
+class NoArgsOrDocs(object):
+
+    def get_keyword_names(self):
+        return ['keyword']
+
+    def run_keyword(self, name, args, kwargs=None):
+        pass
+
+
+class NoArgsOrDocsWithoutKwargs(object):
+
+    def get_keyword_names(self):
+        return ['keyword']
+
+    def run_keyword(self, name, args):
+        pass
+
+
+class TestOwnArgsAndDocs(unittest.TestCase):
+
+    def setUp(self):
+        self.lib = RemoteLibraryFactory(OwnArgsAndDocs())
+
+    def test_arguments(self):
+        self.assertEqual(self.lib.get_keyword_arguments('keyword'),
+                         ['a1', 'a2=keyword', '*args', '**kwargs'])
+
+    def test_documentation(self):
+        self.assertEqual(self.lib.get_keyword_documentation('keyword'),
+                         'The doc for keyword')
+
+
+class TestOwnArgsAndDocsWithCamelCaseNames(TestOwnArgsAndDocs):
+
+    def setUp(self):
+        self.lib = RemoteLibraryFactory(OwnArgsAndDocsWithCamelCaseNames())
+
+
+class TestNoArgsOrDocs(unittest.TestCase):
+
+    def setUp(self):
+        self.lib = RemoteLibraryFactory(NoArgsOrDocs())
+
+    def test_arguments(self):
+        self.assertEqual(self.lib.get_keyword_arguments('keyword'),
+                         ['*varargs', '**kwargs'])
+
+    def test_documentation(self):
+        self.assertEqual(self.lib.get_keyword_documentation('keyword'), '')
+
+
+class TestNoArgsOrDocsWithoutKwargs(unittest.TestCase):
+
+    def setUp(self):
+        self.lib = RemoteLibraryFactory(NoArgsOrDocsWithoutKwargs())
+
+    def test_arguments(self):
+        self.assertEqual(self.lib.get_keyword_arguments('keyword'),
+                         ['*varargs'])
+
+
+if __name__ == '__main__':
+    unittest.main()

test/utest/test_robotremoteserver.py

@@ -3,13 +3,13 @@
 import unittest
 import sys
 
-from robotremoteserver import RobotRemoteServer, RemoteLibrary
+from robotremoteserver import RobotRemoteServer, RemoteLibraryFactory
 
 
 class NonServingRemoteServer(RobotRemoteServer):
 
     def __init__(self, library):
-        self._library = RemoteLibrary(library)
+        self._library = RemoteLibraryFactory(library)
 
 
 class StaticLibrary:
@@ -56,6 +56,26 @@ def not_included(self):
         """Not returned by get_keyword_names"""
 
 
+class DynamicLibrary:
+
+    def __init__(self):
+        self.library = StaticLibrary()
+
+    def get_keyword_names(self):
+        return [n for n in dir(self.library) if n.endswith('_keyword')]
+
+    def run_keyword(self, name, args, kwargs=None):
+        kw = getattr(self.library, name)
+        return kw(*args, **kwargs)
+
+    def not_included(self):
+        """Not returned by get_keyword_names"""
+
+    @property
+    def streams(self):
+        return self.library.streams
+
+
 class TestStaticApi(unittest.TestCase):
     library = StaticLibrary()
 
@@ -131,5 +151,9 @@ class TestHybridApi(TestStaticApi):
     library = HybridLibrary()
 
 
+class TestDynamicApi(TestStaticApi):
+    library = DynamicLibrary()
+
+
 if __name__ == '__main__':
     unittest.main()