Commit 9b68f40

import os

import sys

class ExampleRemoteLibrary:

"""Example library to be used with Robot Framework's remote server.

def __init__(self):

"""Also this doc should be in shown in library doc."""

def count_items_in_directory(self, path):

"""Returns the number of items in the directory specified by `path`."""

return len([i for i in os.listdir(path) if not i.startswith('.')])

def strings_should_be_equal(self, str1, str2):

print "Comparing '%s' to '%s'" % (str1, str2)

if str1 != str2:

raise AssertionError("Given strings are not equal")

if __name__ == '__main__':

from robotremoteserver import RobotRemoteServer

RobotRemoteServer(ExampleRemoteLibrary(), *sys.argv[1:])

*** Settings ***

Library Remote http://localhost:${PORT}

*** Variables ***

${PORT} 8270

*** Test Cases ***

Count Items in Directory

${items1} = Count Items In Directory ${CURDIR}

${items2} = Count Items In Directory ${TEMPDIR}

Log ${items1} items in '${CURDIR}' and ${items2} items in '${TEMPDIR}'

Failing Example

Strings Should Be Equal Hello Hello

Strings Should Be Equal not equal

import sys

import inspect

import traceback

from StringIO import StringIO

from SimpleXMLRPCServer import SimpleXMLRPCServer

try:

import signal

except ImportError:

signal = None

class RobotRemoteServer(SimpleXMLRPCServer):

allow_reuse_address = True

def __init__(self, library, host='localhost', port=8270, allow_stop=True):

SimpleXMLRPCServer.__init__(self, (host, int(port)), logRequests=False)

self._library = library

self._allow_stop = allow_stop

self._register_functions()

self._register_signal_handlers()

self._log('Robot Framework remote server starting at %s:%s'

% (host, port))

self.serve_forever()

def _register_functions(self):

self.register_function(self.get_keyword_names)

self.register_function(self.run_keyword)

self.register_function(self.get_keyword_arguments)

self.register_function(self.get_keyword_documentation)

self.register_function(self.stop_remote_server)

def _register_signal_handlers(self):

def stop_with_signal(signum, frame):

self._allow_stop = True

self.stop_remote_server()

if hasattr(signal, 'SIGHUP'):

signal.signal(signal.SIGHUP, stop_with_signal)

if hasattr(signal, 'SIGINT'):

signal.signal(signal.SIGINT, stop_with_signal)

def serve_forever(self):

self._shutdown = False

while not self._shutdown:

self.handle_request()

def stop_remote_server(self):

prefix = 'Robot Framework remote server at %s:%s ' % self.server_address

if self._allow_stop:

self._log(prefix + 'stopping')

self._shutdown = True

else:

self._log(prefix + 'does not allow stopping', 'WARN')

return True

def get_keyword_names(self):

get_kw_names = getattr(self._library, 'get_keyword_names', None) or \

getattr(self._library, 'getKeywordNames', None)

if inspect.isroutine(get_kw_names):

names = get_kw_names()

else:

names = [attr for attr in dir(self._library) if attr[0] != '_'

and inspect.isroutine(getattr(self._library, attr))]

return names + ['stop_remote_server']

def run_keyword(self, name, args):

result = {'status': 'PASS', 'return': '', 'output': '',

'error': '', 'traceback': ''}

self._intercept_stdout()

try:

return_value = self._get_keyword(name)(*args)

except:

result['status'] = 'FAIL'

result['error'], result['traceback'] = self._get_error_details()

else:

result['return'] = self._handle_return_value(return_value)

result['output'] = self._restore_stdout()

return result

def get_keyword_arguments(self, name):

kw = self._get_keyword(name)

if not kw:

return []

return self._arguments_from_kw(kw)

def _arguments_from_kw(self, kw):

args, varargs, _, defaults = inspect.getargspec(kw)

if inspect.ismethod(kw):

args = args[1:] # drop 'self'

if defaults:

args, names = args[:-len(defaults)], args[-len(defaults):]

args += ['%s=%s' % (n, d) for n, d in zip(names, defaults)]

if varargs:

args.append('*%s' % varargs)

return args

def get_keyword_documentation(self, name):

if name == '__intro__':

return inspect.getdoc(self._library) or ''

if name == '__init__' and inspect.ismodule(self._library):

return ''

return inspect.getdoc(self._get_keyword(name)) or ''

def _get_keyword(self, name):

if name == 'stop_remote_server':

return self.stop_remote_server

kw = getattr(self._library, name, None)

if inspect.isroutine(kw):

return kw

return None

def _get_error_details(self):

exc_type, exc_value, exc_tb = sys.exc_info()

if exc_type in (SystemExit, KeyboardInterrupt):

self._restore_stdout()

raise

return (self._get_error_message(exc_type, exc_value),

self._get_error_traceback(exc_tb))

def _get_error_message(self, exc_type, exc_value):

name = exc_type.__name__

message = str(exc_value)

if not message:

return name

if name in ('AssertionError', 'RuntimeError', 'Exception'):

return message

return '%s: %s' % (name, message)

def _get_error_traceback(self, exc_tb):

# Latest entry originates from this class so it can be removed

entries = traceback.extract_tb(exc_tb)[1:]

trace = ''.join(traceback.format_list(entries))

return 'Traceback (most recent call last):\n' + trace

def _handle_return_value(self, ret):

if isinstance(ret, (basestring, int, long, float)):

return ret

if isinstance(ret, (tuple, list)):

return [self._handle_return_value(item) for item in ret]

if isinstance(ret, dict):

return dict([(self._str(key), self._handle_return_value(value))

for key, value in ret.items()])

return self._str(ret)

def _str(self, item):

if item is None:

return ''

return str(item)

def _intercept_stdout(self):

# TODO: What about stderr?

sys.stdout = StringIO()

def _restore_stdout(self):

output = sys.stdout.getvalue()

sys.stdout.close()

sys.stdout = sys.__stdout__

return output

def _log(self, msg, level=None):

if level:

msg = '*%s* %s' % (level.upper(), msg)

print msg

*** Settings ***

Default Tags python ruby

Library Remote localhost:${PORT}

*** Variables ***

${PORT} 8270

*** Test Cases ***

No Arguments

Arguments Should Be Accepted no arguments No Arguments

Required Arguments

Arguments Should Be Accepted some argument One Argument some argument

Arguments Should Be Accepted first argument second argument Two Arguments first argument second argument

Arguments Should Be Accepted 1 2 3 4 5 6 7 Seven Arguments 1 2 3 4 5

... 6 7

Arguments With Default Values

Arguments Should Be Accepted one two three Arguments With Default Values one two three

Arguments Should Be Accepted one two 3 Arguments With Default Values one two

Arguments Should Be Accepted one 2 3 Arguments With Default Values one

Variable Number Of Arguments

Arguments Should Be Accepted ${EMPTY} Variable Number Of Arguments

Arguments Should Be Accepted One argument Variable Number Of Arguments One argument

Arguments Should Be Accepted Three arguments now Variable Number Of Arguments Three arguments now

Arguments Should Be Accepted 1 2 3 4 5 6 7 8 9 10 Variable Number Of Arguments 1 2 3 4 5

... 6 7 8 9 10

Required Arguments, Default Values and Varargs

Arguments Should Be Accepted Hello world Required Defaults And Varargs Hello

Arguments Should Be Accepted Hi tellus Required Defaults And Varargs Hi tellus

Arguments Should Be Accepted Hello again world Required Defaults And Varargs Hello again world

Arguments Should Be Accepted Hi for the last time tellus Required Defaults And Varargs Hi for the last time

... tellus

Using Arguments When No Accepted

[Documentation] FAIL Keyword 'Remote.No Arguments' expected 0 arguments, got 1.

No Arguments not allowed

Too Few Arguments When Using Only Required Args

[Documentation] FAIL Keyword 'Remote.One Argument' expected 1 argument, got 0.

One Argument

Too Many Arguments When Using Only Required Args

[Documentation] FAIL Keyword 'Remote.Two Arguments' expected 2 arguments, got 3.

Two Arguments too many arguments

Too Few Arguments When Using Default Values

[Documentation] FAIL Keyword 'Remote.Arguments With Default Values' expected 1 to 3 arguments, got 0.

[Tags] python

Arguments With Default Values

Too Many Arguments When Using Default Values

[Documentation] FAIL Keyword 'Remote.Arguments With Default Values' expected 1 to 3 arguments, got 5.

[Tags] python

Arguments With Default Values this is way too much

Too Few Arguments When Using Default Values

[Documentation] With Ruby it is not possible to get maximum argument count when using default values. FAIL Keyword 'Remote.Arguments With Default Values' expected at least 1 argument, got 0.

[Tags] ruby

Arguments With Default Values

Too Many Arguments When Using Default Values

[Documentation] With Ruby it is not possible to get maximum argument count when using default values. This error comes from Ruby. FAIL wrong number of arguments (5 for 3)

[Tags] ruby

Arguments With Default Values this is way too much

Too Few Arguments When Using Varargs

[Documentation] FAIL Keyword 'Remote.Required Defaults And Varargs' expected at least 1 argument, got 0.

Required Defaults And Varargs

*** Keywords ***

Arguments Should Be Accepted

[Arguments] ${expected} ${keyword} @{arguments}

${actual} = Run Keyword ${keyword} @{arguments}

Should Be Equal ${actual} ${expected}