merged [master] with [devel]

Author: userzimmermann

.travis.yml

@@ -5,6 +5,7 @@ python:
   - '2.7'
   - '3.3'
   - '3.4'
+  - '3.5'
   - pypy
 
 install:
@@ -14,10 +15,11 @@ install:
   - pip install robotframework-python3
   - pip install zetup[commands] --upgrade
   - pip install pytest --upgrade
-  - pip install tox --upgrade
+  - pip install tox tox-travis --upgrade
   - zetup install
 
 script:
   - zetup test
-  - py.test -v test
+  - py.test -vv robottools
+  - py.test -vv test
   - zetup tox

requirements.robotshell.txt

@@ -1 +1 @@
-ipython >= 4.0 #import IPython
+ipython >= 5.0 #import IPython

robotshell/base.py

@@ -46,15 +46,3 @@ def cell_magics(self):
         """IPython's dict of registered cell magic functions.
         """
         return self.shell.magics_manager.magics['cell']
-
-    @property
-    def in_template(self):
-        """IPython's current input prompt template.
-        """
-        return self.shell.prompt_manager.in_template
-
-    @in_template.setter
-    def in_template(self, value):
-        """Change IPython's current input prompt template to `value`.
-        """
-        self.shell.prompt_manager.in_template = value

robotshell/shell.py

@@ -34,11 +34,16 @@
 import os
 from itertools import chain
 
+# for creating custom IPython input prompts
+from pygments.token import Token
+
 from robot.errors import DataError
 
 from robottools import TestRobot, TestLibraryInspector
 from robottools.testrobot import Keyword
 
+from IPython.terminal.prompts import Prompts
+
 from .base import ShellBase
 from .library import TestLibrary
 from .result import TestResult
@@ -48,7 +53,7 @@
 from .extension import ExtensionMagic
 
 
-class RobotShell(ShellBase):
+class RobotShell(ShellBase, Prompts):
     # To support customization in derived Plugins
     robot_magic_name = 'Robot'
 
@@ -57,6 +62,7 @@ class RobotShell(ShellBase):
 
     def __init__(self, shell, default_robot_name='Default'):
         ShellBase.__init__(self, shell)
+        shell.prompts = self
         self.label = None
 
         for name, value in os.environ.items():
@@ -116,12 +122,21 @@ def Robot(self, name=None, extname=None):
             else:
                 if extname:
                     label += '.' + extname
-        self.in_template = re.sub(
-          r'^(\[%s\]\n)?' % self.label, '[%s]\n' % label, self.in_template)
         self.label = label
 
         return self.robot
 
+    def in_prompt_tokens(self, cli=None):
+        """Creates custom IPython input prompt with
+        ``[Robot.<name>]`` label above.
+
+        * Overrides method from IPython's ``Prompts`` base class.
+        """
+        tokens = super(RobotShell, self).in_prompt_tokens(cli=cli)
+        if not self.label:
+            return tokens
+        return [(Token.Prompt, '[%s]\n' % self.label)] + tokens
+
     def Import(self, libname, args=None, alias=None):
         library = self.robot.Import(libname, args, alias=alias)
         self.register_robot_keyword_magics(alias or libname, library)

robottools/conftest.py

@@ -0,0 +1,33 @@
+from importlib import import_module
+from inspect import getmembers, ismethod
+
+import robot
+
+import pytest
+
+
+@pytest.fixture(params=['String', 'Collections'])
+def stdlibname(request):
+    return request.param
+
+
+@pytest.fixture
+def stdlib(request, stdlibname):
+    try: # Robot < 3.0
+        libmod = import_module(stdlibname)
+    except ImportError:
+        libmod = import_module('robot.libraries.%s' % stdlibname)
+    libcls = getattr(libmod, stdlibname)
+    return libcls()
+
+
+@pytest.fixture
+def stdlib_kwfuncnames(request, stdlib):
+    return [name for name, obj in getmembers(stdlib)
+            if name[0] != '_' and ismethod(obj)]
+
+
+@pytest.fixture
+def BuiltIn_kwfuncnames(request):
+    BuiltIn = stdlib(request, 'BuiltIn')
+    return stdlib_kwfuncnames(request, BuiltIn)

robottools/library/inspector/__init__.py

@@ -21,15 +21,17 @@
 
 .. moduleauthor:: Stefan Zimmermann <[email protected]>
 """
-from six import with_metaclass
-
 __all__ = [
   'ROBOT_LIBRARIES',
   'TestLibraryImportError', 'TestLibraryInspector',
   # From .multi:
   'MultiTestLibraryInspector',
   ]
 
+from six import with_metaclass
+from itertools import chain
+
+import zetup
 from moretools import camelize
 
 from path import Path
@@ -55,10 +57,11 @@
 
 
 class TestLibraryImportError(ImportError):
-  pass
+    pass
+
 
+class TestLibraryInspectorMeta(zetup.meta):
 
-class TestLibraryInspectorMeta(type):
     def __getattr__(self, libname):
         try:
             return TestLibraryInspector(libname)
@@ -70,8 +73,9 @@ def __dir__(self):
 
 
 class TestLibraryInspector(
-  with_metaclass(TestLibraryInspectorMeta, object)
+  with_metaclass(TestLibraryInspectorMeta, zetup.object)
   ):
+
     def __init__(self, lib, *args):
         if isinstance(lib, TestLibraryInspector):
             self._library = lib._library
@@ -122,7 +126,14 @@ def __getattr__(self, name):
             raise AttributeError(str(e))
 
     def __dir__(self):
-        return list(map(camelize, self._library.handlers.keys()))
+        if hasattr(self._library.handlers, 'keys'):
+            # Robot < 3.0
+            kwnames = self._library.handlers.keys()
+        else:
+            kwnames = (h.name for h in self._library.handlers)
+        return list(chain(
+            super(TestLibraryInspector, self).__dir__(),
+            map(camelize, kwnames)))
 
     def __str__(self):
         return self._library.name

robottools/library/inspector/conftest.py

@@ -0,0 +1,8 @@
+from robottools import TestLibraryInspector
+
+import pytest
+
+
+@pytest.fixture
+def inspector(request, stdlibname):
+    return TestLibraryInspector(stdlibname)

robottools/library/inspector/keyword.py

@@ -27,6 +27,7 @@
 
 
 class KeywordInspector(object):
+
     def __init__(self, handler):
         self._handler = handler
 
@@ -38,6 +39,10 @@ def __doc__(self):
     def arguments(self):
         return KeywordArgumentsInspector(self._handler.arguments)
 
+    def __eq__(self, other):
+        return isinstance(other, KeywordInspector) and \
+            self._handler == other._handler
+
     def __getattr__(self, name):
         return getattr(self._handler, name)
 

robottools/library/inspector/test_inspector.py

@@ -0,0 +1,83 @@
+from inspect import getmembers, ismethod
+from itertools import chain
+from six.moves import zip
+
+from moretools import camelize, isidentifier
+
+from robot.utils import normalize
+from robot.errors import DataError
+
+import robottools.library.inspector
+from robottools import TestLibraryInspector, TestLibraryImportError
+
+import pytest
+
+
+class TestInspector(object):
+    """Tests for :class:`robottools.TestLibraryInspector`.
+    """
+    def test_class(self):
+        assert TestLibraryInspector \
+            is robottools.library.inspector.TestLibraryInspector
+        assert type(TestLibraryInspector) \
+            is robottools.library.inspector.TestLibraryInspectorMeta
+
+    def test__init__(self, stdlibname, stdlib):
+        inspector = TestLibraryInspector(stdlibname)
+        assert type(inspector._library.get_instance()) is type(stdlib)
+
+    def test_name(self, inspector, stdlibname):
+        assert inspector.name == stdlibname
+
+    def test__iter__(self, inspector, stdlib, stdlib_kwfuncnames):
+        kwnames = [camelize(n, joiner=' ') for n in stdlib_kwfuncnames]
+        for keyword in iter(inspector):
+            assert isinstance(
+                keyword, robottools.library.inspector.KeywordInspector)
+            kwnames.remove(keyword.name)
+        assert not kwnames
+
+    def test__dir__(self, inspector, stdlib):
+        # filter keyword methods from directly instantiated stdlib
+        kwfuncnames = [name for name, obj in getmembers(stdlib)
+                       if name[0] != '_' and ismethod(obj)]
+        # and check if __dir__ contains their camelized names
+        assert set(dir(inspector)) \
+            == set(chain(map(camelize, kwfuncnames),
+                         # as well as all other members
+                         super(TestLibraryInspector, inspector).__dir__()))
+
+    def test__getattr__(self, inspector, stdlib):
+        # filter keyword methods from directly instantiated stdlib
+        kwfuncnames = [name for name, obj in getmembers(stdlib)
+                       if name[0] != '_' and ismethod(obj)]
+        # and check that __getattr__ works with with keyword method names
+        # as well as with normalized and camelized keyword names
+        for name, normalized, camelized in zip(
+                kwfuncnames, map(normalize, kwfuncnames),
+                map(camelize, kwfuncnames)
+        ):
+            keyword, from_normalized, from_camelized = (
+                getattr(inspector, n)
+                for n in [name, normalized, camelized])
+            assert keyword == from_normalized == from_camelized
+            for keyword in [keyword, from_normalized, from_camelized]:
+                assert isinstance(
+                    keyword, robottools.library.inspector.KeywordInspector)
+                assert keyword.name == camelize(name, joiner=' ')
+
+    def test__getattr__error(self, inspector):
+        with pytest.raises(AttributeError) as exc:
+            getattr(inspector, 'Invalid')
+        # and check that exception message contains
+        # RFW's original exception message
+        with pytest.raises(DataError) as robot_exc:
+            if hasattr(inspector._library, 'get_handler'):
+                # robot < 2.9
+                inspector._library.get_handler('Invalid')
+            else:
+                inspector._library.handlers['Invalid']
+        assert str(robot_exc.value) in str(exc.value)
+
+    def test__repr__(self, inspector, stdlibname):
+        assert repr(inspector) == "[Library] %s" % stdlibname

robottools/remote/__init__.py

@@ -120,14 +120,12 @@ def _get_keyword(self, name):
         except KeyError:
             try:
                 # find in extra RemoteRobot Keywords
-                keyword = self.keywords[name]
+                return self.keywords[name]
             except KeyError:
                 return None
-            else:
-                # use Keyword's debug mode
-                # to pass exceptions to RobotRemoteServer base
-                return keyword.debug
         # make sure that self[name] is not a Library
+        # and return TestRobot Keywords in debug mode
+        # to get actual exceptions from Keyword functions
         return keyword.debug if isinstance(keyword, Keyword) else None
 
     def _arguments_from_kw(self, keyword):