Merge branch 'master' of https://github.com/robotframework/PythonRemoteServer

Author: pekkaklarck

atest/libs/failing.py

@@ -22,6 +22,21 @@ def failure_deeper(self, rounds=10):
             raise RuntimeError('Finally failing')
         self.failure_deeper(rounds-1)
 
+    def continuable(self, message):
+        self._raise_special(message, continuable=True)
+
+    def fatal(self, message):
+        self._raise_special(message, fatal='yes')
+
+    def not_special(self, message):
+        self._raise_special(message)
+
+    def _raise_special(self, message, continuable=False, fatal=False):
+        special = AssertionError(message)
+        special.ROBOT_CONTINUE_ON_FAILURE = continuable
+        special.ROBOT_EXIT_ON_FAILURE = fatal
+        raise special
+
 
 class MyException(Exception):
     pass

atest/tests/Z_LAST__special_failures.robot

@@ -0,0 +1,28 @@
+*** Settings ***
+Resource          resource.robot
+Suite Setup       Start And Import Remote Library    failing.py
+Suite Teardown    Stop Remote Library
+
+*** Test Cases ***
+Not special
+    [Documentation]  FAIL message
+    Not special    message
+    Fail    This should not be executed
+
+Continuable
+    [Documentation]  FAIL Several failures occurred:\n\n
+    ...    1) message\n\n
+    ...    2) second message\n\n
+    ...    3) third message
+    Continuable    message
+    Continuable    second message
+    Continuable    third message
+
+Fatal
+    [Documentation]  FAIL Execution ends here
+    Fatal    Execution ends here
+    Fail    This should not be executed
+
+Fails due to earlier fatal error
+    [Documentation]  FAIL Test execution stopped due to a fatal error.
+    Fail    This should not be executed

atest/tests/basic_communication.robot

@@ -13,6 +13,7 @@ Passing
 Failing
     [Documentation]    FAIL This is the error we get
     Failing    This is the error we get
+    Fail    This should not be executed
 
 Logging
     [Documentation]    LOG 1 INFO Hello, world! LOG 2 WARN Warning, warning!!

src/robotremoteserver.py

@@ -106,21 +106,33 @@ def get_keyword_names(self):
 
     def run_keyword(self, name, args, kwargs=None):
         args, kwargs = self._handle_binary_args(args, kwargs or {})
-        result = {'status': 'FAIL', 'return': '', 'output': '',
-                  'error': '', 'traceback': ''}
+        result = {'status': 'FAIL'}
         self._intercept_std_streams()
         try:
             return_value = self._get_keyword(name)(*args, **kwargs)
         except:
-            result['error'], result['traceback'] = self._get_error_details()
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            self._add_to_result(result, 'error',
+                                self._get_error_message(exc_type, exc_value))
+            self._add_to_result(result, 'traceback',
+                                self._get_error_traceback(exc_tb))
+            self._add_to_result(result, 'continuable',
+                                self._get_error_attribute(exc_value, 'CONTINUE'),
+                                default=False)
+            self._add_to_result(result, 'fatal',
+                                self._get_error_attribute(exc_value, 'EXIT'),
+                                default=False)
         else:
             try:
-                result['return'] = self._handle_return_value(return_value)
+                self._add_to_result(result, 'return',
+                                    self._handle_return_value(return_value))
             except:
-                result['error'] = self._get_error_message()
+                exc_type, exc_value, _ = sys.exc_info()
+                self._add_to_result(result, 'error',
+                                    self._get_error_message(exc_type, exc_value))
             else:
                 result['status'] = 'PASS'
-        result['output'] = self._restore_std_streams()
+        self._add_to_result(result, 'output', self._restore_std_streams())
         return result
 
     def _handle_binary_args(self, args, kwargs):
@@ -133,6 +145,10 @@ def _handle_binary_arg(self, arg):
             return arg.data
         return arg
 
+    def _add_to_result(self, result, key, value, default=''):
+        if value != default:
+            result[key] = value
+
     def get_keyword_arguments(self, name):
         kw = self._get_keyword(name)
         if not kw:
@@ -167,17 +183,10 @@ def _get_keyword(self, name):
             return kw
         return None
 
-    def _get_error_details(self):
-        exc_type, exc_value, exc_tb = sys.exc_info()
+    def _get_error_message(self, exc_type, exc_value):
         if exc_type in self._fatal_exceptions:
             self._restore_std_streams()
             raise
-        return (self._get_error_message(exc_type, exc_value),
-                self._get_error_traceback(exc_tb))
-
-    def _get_error_message(self, exc_type=None, exc_value=None):
-        if exc_type is None:
-            exc_type, exc_value = sys.exc_info()[:2]
         name = exc_type.__name__
         message = self._get_message_from_exception(exc_value)
         if not message:
@@ -201,6 +210,9 @@ def _get_error_traceback(self, exc_tb):
         trace = ''.join(traceback.format_list(entries))
         return 'Traceback (most recent call last):\n' + trace
 
+    def _get_error_attribute(self, exc_value, name):
+        return bool(getattr(exc_value, 'ROBOT_%s_ON_FAILURE' % name, False))
+
     def _handle_return_value(self, ret):
         if isinstance(ret, basestring):
             return self._handle_binary_result(ret)

utest/test_robotremoteserver.py

@@ -7,32 +7,51 @@
 
 
 class NonServingRemoteServer(RobotRemoteServer):
+
     def __init__(self, library):
         self._library = library
 
+
 class StaticLibrary:
+
     def passing_keyword(self):
         pass
-    def failing_keyword(self, exception, message='Hello, world!'):
-        raise exception(message)
+
+    def failing_keyword(self, exception=AssertionError, message='Hello, world!',
+                        **kwargs):
+        err = exception(message)
+        for name, value in kwargs.items():
+            setattr(err, name, value)
+        raise err
+
+    def returning_keyword(self, value):
+        return value
+
     def logging_keyword(self, stdout, stderr):
         if stdout:
             sys.stdout.write(stdout)
         if stderr:
             sys.stderr.write(stderr)
         self.streams = (sys.stdout, sys.stderr)
+
     def _not_included(self):
         """Starts with an underscore"""
+
     not_included = "Not a method or function"
     not_included_2 = NonServingRemoteServer  # Callable but not method/function
 
+
 class HybridLibrary:
+
     def __init__(self):
         self.library = StaticLibrary()
+
     def get_keyword_names(self):
         return [n for n in dir(self.library) if n.endswith('_keyword')]
+
     def __getattr__(self, name):
         return getattr(self.library, name)
+
     def not_included(self):
         """Not returned by get_keyword_names"""
 
@@ -46,43 +65,65 @@ def setUp(self):
     def test_get_keyword_names(self):
         self.assertEquals(self.server.get_keyword_names(),
                           ['failing_keyword', 'logging_keyword',
-                           'passing_keyword', 'stop_remote_server'])
+                           'passing_keyword', 'returning_keyword',
+                           'stop_remote_server'])
 
     def test_run_passing_keyword(self):
-        self.assertEquals(self.server.run_keyword('passing_keyword', []),
-                          {'status': 'PASS', 'output': '', 'traceback': '',
-                           'return': '', 'error': ''})
+        self.assertEquals(self._run('passing_keyword'), {'status': 'PASS'})
+
+    def test_returning_keyword(self):
+        for ret in 'Hello, world!', 42, True:
+            self.assertEquals(self._run('returning_keyword', ret),
+                              {'status': 'PASS', 'return': ret})
 
     def test_run_failing_keyword(self):
-        ret = self.server.run_keyword('failing_keyword', [ValueError])
-        self.assertEquals(ret['status'], 'FAIL')
-        self.assertEquals(ret['error'], 'ValueError: Hello, world!')
+        ret = self._run('failing_keyword', ValueError)
+        self._verify_failed(ret, 'ValueError: Hello, world!')
 
     def test_strip_generic_exception_names_from_error_messages(self):
         for exception in AssertionError, Exception, RuntimeError:
-            ret = self.server.run_keyword('failing_keyword', [exception])
-            self.assertEquals(ret['status'], 'FAIL')
-            self.assertEquals(ret['error'], 'Hello, world!')
+            ret = self._run('failing_keyword', exception)
+            self._verify_failed(ret, 'Hello, world!')
 
     def test_return_only_exception_name_if_no_error_message(self):
         for exception in AssertionError, ValueError:
-            ret = self.server.run_keyword('failing_keyword', [exception, ''])
-            self.assertEquals(ret['status'], 'FAIL')
-            self.assertEquals(ret['error'], exception.__name__)
+            ret = self._run('failing_keyword', exception, '')
+            self._verify_failed(ret, exception.__name__)
+
+    def test_continuable_error(self):
+        ret = self._run('failing_keyword', ROBOT_CONTINUE_ON_FAILURE=True)
+        self._verify_failed(ret, continuable=True)
+
+    def test_fatal_error(self):
+        ret = self._run('failing_keyword', ROBOT_EXIT_ON_FAILURE='yes please')
+        self._verify_failed(ret, fatal=True)
 
     def test_logging_to_stdout(self):
-        ret = self.server.run_keyword('logging_keyword', ['out', ''])
-        self.assertEquals(ret['output'], 'out')
-        self.assertTrue(all(s.closed for s in self.library.streams))
+        ret = self._run('logging_keyword', 'out', '')
+        self._verify_logged(ret, 'out')
 
     def test_logging_to_stderr(self):
-        ret = self.server.run_keyword('logging_keyword', ['', 'err'])
-        self.assertEquals(ret['output'], 'err')
-        self.assertTrue(all(s.closed for s in self.library.streams))
+        ret = self._run('logging_keyword', '', 'err')
+        self._verify_logged(ret, 'err')
 
     def test_logging_to_stdout_and_stderr(self):
-        ret = self.server.run_keyword('logging_keyword', ['out', 'err'])
-        self.assertEquals(ret['output'], 'out\n*INFO* err')
+        ret = self._run('logging_keyword', 'out', 'err')
+        self._verify_logged(ret, 'out\n*INFO* err')
+
+    def _run(self, kw, *args, **kwargs):
+        return self.server.run_keyword(kw, args, kwargs)
+
+    def _verify_failed(self, ret, error='Hello, world!', continuable=False,
+                       fatal=False):
+        ret.pop('traceback')
+        if continuable:
+            self.assertEquals(ret.pop('continuable'), True)
+        if fatal:
+            self.assertEquals(ret.pop('fatal'), True)
+        self.assertEquals(ret, {'error': error, 'status': 'FAIL'})
+
+    def _verify_logged(self, ret, output):
+        self.assertEquals(ret, {'output': output, 'status': 'PASS'})
         self.assertTrue(all(s.closed for s in self.library.streams))