# Copyright 2008-2015 Nokia Networks
# Copyright 2016- Robot Framework Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from robot.model import BodyItem
from robot.utils import is_list_like, is_dict_like, is_string, safe_str
[docs]class ListenerArguments:
def __init__(self, arguments):
self._arguments = arguments
self._version2 = None
self._version3 = None
[docs] def get_arguments(self, version):
if version == 2:
if self._version2 is None:
self._version2 = self._get_version2_arguments(*self._arguments)
return self._version2
else:
if self._version3 is None:
self._version3 = self._get_version3_arguments(*self._arguments)
return self._version3
def _get_version2_arguments(self, *arguments):
return arguments
def _get_version3_arguments(self, *arguments):
return arguments
[docs] @classmethod
def by_method_name(cls, name, arguments):
Arguments = {'start_suite': StartSuiteArguments,
'end_suite': EndSuiteArguments,
'start_test': StartTestArguments,
'end_test': EndTestArguments,
'start_keyword': StartKeywordArguments,
'end_keyword': EndKeywordArguments,
'log_message': MessageArguments,
'message': MessageArguments}.get(name, ListenerArguments)
return Arguments(arguments)
[docs]class MessageArguments(ListenerArguments):
def _get_version2_arguments(self, msg):
attributes = {'timestamp': msg.timestamp,
'message': msg.message,
'level': msg.level,
'html': 'yes' if msg.html else 'no'}
return attributes,
def _get_version3_arguments(self, msg):
return msg,
class _ListenerArgumentsFromItem(ListenerArguments):
_attribute_names = None
def _get_version2_arguments(self, item):
attributes = dict((name, self._get_attribute_value(item, name))
for name in self._attribute_names)
attributes.update(self._get_extra_attributes(item))
return item.name or '', attributes
def _get_attribute_value(self, item, name):
value = getattr(item, name)
if value is None:
return ''
return self._take_copy_of_mutable_value(value)
def _take_copy_of_mutable_value(self, value):
if is_dict_like(value):
return dict(value)
if is_list_like(value):
return list(value)
return value
def _get_extra_attributes(self, item):
return {}
def _get_version3_arguments(self, item):
return item.data, item.result
[docs]class StartSuiteArguments(_ListenerArgumentsFromItem):
_attribute_names = ('id', 'longname', 'doc', 'metadata', 'starttime')
def _get_extra_attributes(self, suite):
return {'tests': [t.name for t in suite.tests],
'suites': [s.name for s in suite.suites],
'totaltests': suite.test_count,
'source': str(suite.source or '')}
[docs]class EndSuiteArguments(StartSuiteArguments):
_attribute_names = ('id', 'longname', 'doc', 'metadata', 'starttime',
'endtime', 'elapsedtime', 'status', 'message')
def _get_extra_attributes(self, suite):
attrs = super()._get_extra_attributes(suite)
attrs['statistics'] = suite.stat_message
return attrs
[docs]class StartTestArguments(_ListenerArgumentsFromItem):
_attribute_names = ('id', 'longname', 'doc', 'tags', 'lineno', 'starttime')
def _get_extra_attributes(self, test):
return {'source': str(test.source or ''),
'template': test.template or '',
'originalname': test.data.name}
[docs]class EndTestArguments(StartTestArguments):
_attribute_names = ('id', 'longname', 'doc', 'tags', 'lineno', 'starttime',
'endtime', 'elapsedtime', 'status', 'message')
[docs]class StartKeywordArguments(_ListenerArgumentsFromItem):
_attribute_names = ('doc', 'assign', 'tags', 'lineno', 'type', 'status', 'starttime')
_type_attributes = {
BodyItem.FOR: ('variables', 'flavor', 'values'),
BodyItem.IF: ('condition',),
BodyItem.ELSE_IF: ('condition',),
BodyItem.EXCEPT: ('patterns', 'pattern_type', 'variable'),
BodyItem.WHILE: ('condition', 'limit', 'on_limit_message'),
BodyItem.RETURN: ('values',),
BodyItem.ITERATION: ('variables',)
}
_for_flavor_attributes = {
'IN ENUMERATE': ('start',),
'IN ZIP': ('mode', 'fill')
}
def _get_extra_attributes(self, kw):
attrs = {'kwname': kw.kwname or '',
'libname': kw.libname or '',
'args': [a if is_string(a) else safe_str(a) for a in kw.args],
'source': str(kw.source or '')}
if kw.type in self._type_attributes:
for name in self._type_attributes[kw.type]:
if hasattr(kw, name):
attrs[name] = self._get_attribute_value(kw, name)
if kw.type == BodyItem.FOR:
for name in self._for_flavor_attributes.get(kw.flavor, ()):
attrs[name] = self._get_attribute_value(kw, name)
return attrs
[docs]class EndKeywordArguments(StartKeywordArguments):
_attribute_names = ('doc', 'assign', 'tags', 'lineno', 'type', 'status',
'starttime', 'endtime', 'elapsedtime')