Return only needed information back to Robot.

Fixes #12.

Unit test changes unfortunately contain also general cleanup. Should have
done that separataly, but don't think separating changes is worth the effort
anymore.

Author: spooning

src/robotremoteserver.py

@@ -106,26 +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:
             exc_type, exc_value, exc_tb = sys.exc_info()
-            result['error'] = self._get_error_message(exc_type, exc_value)
-            result['traceback'] = self._get_error_traceback(exc_tb)
-            result['continuable'] = self._get_error_attribute(exc_value, 'CONTINUE')
-            result['fatal'] = self._get_error_attribute(exc_value, 'EXIT')
+            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:
                 exc_type, exc_value, _ = sys.exc_info()
-                result['error'] = self._get_error_message(exc_type, exc_value)
+                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):
@@ -136,6 +143,10 @@ def _handle_binary_args(self, args, kwargs):
     def _handle_binary_arg(self, arg):
         return arg if not isinstance(arg, Binary) else str(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:

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))