added integration tests for RemoteRobot and TestRobot

--HG--
branch : dev

Author: userzimmermann

test/remote/conftest.py

@@ -0,0 +1,43 @@
+import sys
+from textwrap import dedent
+from subprocess import Popen
+
+from robottools import TestRobot
+from robottools.remote import RemoteRobot
+
+import pytest
+
+
+# the libraries to load in the RemoteRobot instance
+# created in an external python process via process fixture
+REMOTE_LIBRARIES = [
+    'BuiltIn',
+    'ToolsLibrary',
+]
+ALLOWED_REMOTE_IMPORTS = [
+    'Collections',
+]
+
+
+@pytest.fixture(scope='module')
+def process(request):
+    """Creates an external python process with a ``RemoteRobot`` instance
+    loading all libraries defined in ``REMOTE_LIBRARIES``.
+    """
+    return Popen([
+        sys.executable, '-c', dedent("""
+        __import__('robottools.remote').remote.RemoteRobot(
+            [%s], allow_import=[%s]
+        )""") % (', '.join(map(repr, REMOTE_LIBRARIES)),
+                 ', '.join(map(repr, ALLOWED_REMOTE_IMPORTS)))])
+
+
+@pytest.fixture(scope='module')
+def robot_Remote(request):
+    """Creates a ``TestRobot`` instance loading ``Remote`` library,
+    which automatically connects to the external ``RemoteRobot`` instance
+    created in ``process`` fixture.
+    """
+    robot = TestRobot('Test')
+    robot.Import('Remote')
+    return robot

test/remote/test_remote.py

@@ -0,0 +1,76 @@
+from six import text_type as unicode
+from time import sleep
+
+from decorator import decorate
+
+from robottools import TestRobot
+
+import pytest
+
+
+def check_process(func):
+    """Decorator for ``TestRemoteRobot.test_...`` methods
+    to check if the external ``RemoteRobot`` process is still running,
+    which is passed to every test method as ``process`` fixture.
+    """
+    def caller(func, self, process, *args, **kwargs):
+        # polling returns None as long as process is running
+        assert process.poll() is None, \
+            "RemoteRobot process is not running (anymore)."
+        return func(self, process, *args, **kwargs)
+
+    return decorate(func, caller)
+
+
+class TestRemoteRobot(object):
+    """Integration tests for ``RemoteRobot`` and ``TestRobot``.
+    """
+    @check_process
+    def test_bool_result(self, process, robot_Remote):
+        for value in [True, 1, 2.3, b'four', u'five', [5], {'six': 7}]:
+            assert robot_Remote.ConvertToBool(value) is True
+        for value in [False, 0, 0.0, b'', u'', [], {}]:
+            assert robot_Remote.ConvertToBool('') is False
+
+    @check_process
+    def test_int_result(self, process, robot_Remote):
+        for value in [1, 2.3, '4', u'5']:
+            result = robot_Remote.ConvertToInteger(value)
+            assert isinstance(result, int)
+            assert result == int(value)
+
+    @check_process
+    def test_float_result(self, process, robot_Remote):
+        for value in [1, 2.3, '4.5', u'6.7']:
+            result = robot_Remote.ConvertToNumber(value)
+            assert isinstance(result, float)
+            assert result == float(value)
+
+    @check_process
+    def test_bytes_result(self, process, robot_Remote):
+        for value in [b'bytes', u'bytes']:
+            result = robot_Remote.ConvertToBytes(value)
+            assert isinstance(result, bytes)
+            assert result == b'bytes'
+
+    @check_process
+    def test_string_result(self, process, robot_Remote):
+        for value in [1, 2.3, 'four', u'five']:
+            result = robot_Remote.ConvertToString(value)
+            assert isinstance(result, unicode)
+            assert result == unicode(value)
+
+    @check_process
+    def test_ImportRemoteLibrary(self, process, robot_Remote):
+        assert not hasattr(robot_Remote, 'CopyList')
+        robot_Remote.ImportRemoteLibrary('Collections')
+        robot = TestRobot('New')
+        robot.Import('Remote')
+        assert robot.CopyList
+
+    @check_process
+    def test_StopRemoteServer(self, process, robot_Remote):
+        assert robot_Remote.StopRemoteServer() is True
+        process.wait()
+        # polling returns None as long as process is running
+        assert process.poll() is not None