def __init__(self, node):
Message.__init__(self,
node.text,
level=node.get_attr('level', 'INFO'),
html=node.get_attr('html', 'no') == 'yes',
timestamp=node.get_attr('timestamp', 'N/A'),
linkable=node.get_attr('linkable', 'no') == 'yes')
def write(self, msg, level, html=False):
with self.lock:
thread = threading.currentThread().getName()
if thread in self.LOGGING_THREADS:
LOGGER.log_message(Message(msg, level, html))
else:
message = Message(msg, level, html)
self._messages.setdefault(thread, []).append(message)
def wait_to_date(date_stamp):
date = parse(date_stamp)
LOGGER.log_message(Message("date: {}".format(date.isoformat()), "INFO"))
now = get_now()
LOGGER.log_message(Message("now: {}".format(now.isoformat()), "INFO"))
wait_seconds = (date - now).total_seconds()
wait_seconds += 2
if wait_seconds < 0:
return 0
return wait_seconds
def output_error_in_robot_log(self, e):
import robot, traceback
if ROBOT_VERSION >= '2.1':
syslog = robot.output.LOGGER
from robot.output.loggerhelper import Message
syslog.message(
Message("%s:%s" % ('Import Keyword Error', e.message),
'ERROR'))
syslog.message(Message(traceback.format_exc(), 'ERROR'))
else:
syslog = robot.output.SYSLOG
syslog.error("*ERROR* %s:%s" % ('Import Keyword Error', e.message))
syslog.error(traceback.format_exc())
def log_object_data(data,
file_name=None,
format="yaml",
update=False,
artifact=False):
"""Log object data in pretty format (JSON or YAML)
Two output formats are supported: "yaml" and "json".
If a file name is specified, the output is written into that file.
If you would like to get similar output everywhere,
use the following snippet somewhere in your code
before actually using Munch. For instance,
put it into your __init__.py, or, if you use zc.buildout,
specify it in "initialization" setting of zc.recipe.egg.
from munch import Munch
Munch.__str__ = lambda self: Munch.toYAML(self, allow_unicode=True,
default_flow_style=False)
Munch.__repr__ = Munch.__str__
"""
if not isinstance(data, Munch):
data = munchify(data)
if file_name:
if artifact:
file_path = os.path.join(os.path.dirname(__file__), 'data',
file_name + '.' + format)
else:
output_dir = BuiltIn().get_variable_value("${OUTPUT_DIR}")
file_path = os.path.join(output_dir, file_name + '.' + format)
if update:
try:
with open(file_path, "r+") as file_obj:
new_data = data.copy()
data = munch_from_object(file_obj.read(), format)
data.update(new_data)
file_obj.seek(0)
file_obj.truncate()
except IOError as e:
LOGGER.log_message(Message(e, "INFO"))
LOGGER.log_message(
Message("Nothing to update, "
"creating new file.", "INFO"))
data_obj = munch_to_object(data, format)
with open(file_path, "w") as file_obj:
file_obj.write(data_obj)
data_obj = munch_to_object(data, format)
LOGGER.log_message(Message(data_obj.decode('utf-8'), "INFO"))
def prepare_test_tender_data(procedure_intervals, tender_parameters):
# Get actual intervals by mode name
mode = tender_parameters['mode']
if mode in procedure_intervals:
intervals = procedure_intervals[mode]
else:
intervals = procedure_intervals['default']
LOGGER.log_message(Message(intervals))
tender_parameters['intervals'] = intervals
# Set acceleration value for certain modes
assert isinstance(intervals['accelerator'], int), \
"Accelerator should be an 'int', " \
"not '{}'".format(type(intervals['accelerator']).__name__)
assert intervals['accelerator'] >= 0, \
"Accelerator should not be less than 0"
if mode == 'negotiation':
return munchify({'data': test_tender_data_limited(tender_parameters)})
elif mode == 'negotiation.quick':
return munchify({'data': test_tender_data_limited(tender_parameters)})
elif mode == 'openeu':
return munchify({'data': test_tender_data_openeu(tender_parameters)})
elif mode == 'openua':
return munchify({'data': test_tender_data_openua(tender_parameters)})
elif mode == 'open_competitive_dialogue':
return munchify(
{'data': test_tender_data_competitive_dialogue(tender_parameters)})
elif mode == 'reporting':
return munchify({'data': test_tender_data_limited(tender_parameters)})
elif mode == 'belowThreshold':
return munchify({'data': test_tender_data(tender_parameters)})
raise ValueError("Invalid mode for prepare_test_tender_data")
def output_error_in_robot_log(self, e):
import traceback
from robot.output import LOGGER
from robot import version
ROBOT_VERSION = version.get_version()
if ROBOT_VERSION >= '2.1':
syslog = LOGGER
from robot.output.loggerhelper import Message
syslog.message(
Message("%s:%s" % ('Import Keyword Error', e.message),
'ERROR'))
syslog.message(Message(traceback.format_exc(), 'ERROR'))
else:
syslog = LOGGER
syslog.error("*ERROR* %s:%s" % ('Import Keyword Error', e.message))
syslog.error(traceback.format_exc())
def prepare_test_tender_data(procedure_intervals,
tender_parameters,
submissionMethodDetails,
accelerator,
funders,
plan_data):
# Get actual intervals by mode name
mode = tender_parameters['mode']
if mode in procedure_intervals:
intervals = procedure_intervals[mode]
else:
intervals = procedure_intervals['default']
LOGGER.log_message(Message(intervals))
tender_parameters['intervals'] = intervals
# Set acceleration value for certain modes
assert isinstance(intervals['accelerator'], int), \
"Accelerator should be an 'int', " \
"not '{}'".format(type(intervals['accelerator']).__name__)
assert intervals['accelerator'] >= 0, \
"Accelerator should not be less than 0"
if mode == 'negotiation':
return munchify({'data': test_tender_data_limited(tender_parameters, plan_data)})
elif mode == 'negotiation.quick':
return munchify({'data': test_tender_data_limited(tender_parameters, plan_data)})
elif mode == 'openeu':
return munchify({'data': test_tender_data_openeu(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'openua':
return munchify({'data': test_tender_data_openua(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'openua_defense':
return munchify({'data': test_tender_data_openua_defense(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'open_competitive_dialogue':
return munchify({'data': test_tender_data_competitive_dialogue(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'reporting':
return munchify({'data': test_tender_data_limited(tender_parameters, plan_data)})
elif mode == 'open_framework':
return munchify({'data': test_tender_data_framework_agreement(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'belowThreshold':
return munchify({'data': test_tender_data(
tender_parameters,
plan_data,
submissionMethodDetails=submissionMethodDetails,
funders=funders,
accelerator=accelerator,
)})
elif mode == 'open_esco':
return munchify({'data': test_tender_data_esco(
tender_parameters, submissionMethodDetails, plan_data)})
elif mode == 'priceQuotation':
return munchify({'data': test_tender_data_pq(tender_parameters, submissionMethodDetails, plan_data)})
# The previous line needs an explicit keyword argument because,
# unlike previous functions, this one has three arguments.
raise ValueError("Invalid mode for prepare_test_tender_data")
def compare_date(left, right, accuracy="minute", absolute_delta=True):
'''Compares dates with specified accuracy
Before comparison dates are parsed into datetime.datetime format
and localized.
:param left: First date
:param right: Second date
:param accuracy: Max difference between dates to consider them equal
Default value - "minute"
Possible values - "day", "hour", "minute" or float value
of seconds
:param absolute_delta: Type of comparison. If set to True, then no matter which date order. If set to
False then right must be lower then left for accuracy value.
Default value - True
Possible values - True and False or something what can be casted into them
:returns: Boolean value
:error: ValueError when there is problem with converting accuracy
into float value. When it will be catched warning will be
given and accuracy will be set to 60.
'''
left = parse(left)
right = parse(right)
if left.tzinfo is None:
left = TZ.localize(left)
if right.tzinfo is None:
right = TZ.localize(right)
delta = (left - right).total_seconds()
if accuracy == "day":
accuracy = 24 * 60 * 60 - 1
elif accuracy == "hour":
accuracy = 60 * 60 - 1
elif accuracy == "minute":
accuracy = 60 - 1
else:
try:
accuracy = float(accuracy)
except ValueError:
LOGGER.log_message(
Message(
"Could not convert from {} to float. Accuracy is set to 60 seconds."
.format(accuracy), "WARN"))
accuracy = 60
if absolute_delta:
delta = abs(delta)
if delta > accuracy:
return False
return True
def log_object_data(data, file_name="", format="yaml"):
if not isinstance(data, Munch):
data = munchify(data)
if format == 'json':
data = data.toJSON(indent=2)
else:
data = data.toYAML(allow_unicode=True, default_flow_style=False)
format = 'yaml'
LOGGER.log_message(Message(data, "INFO"))
if file_name:
output_dir = BuiltIn().get_variable_value("${OUTPUT_DIR}")
with open(os.path.join(output_dir, file_name + '.' + format), "w") as file_obj:
file_obj.write(data)
def get_intervals(procedure_intervals, tender_parameters):
# Get actual intervals by mode name
mode = tender_parameters['mode']
if mode in procedure_intervals:
intervals = procedure_intervals[mode]
else:
intervals = procedure_intervals['default']
LOGGER.log_message(Message(intervals))
tender_parameters['intervals'] = intervals
# Set acceleration value for certain modes
assert isinstance(intervals['accelerator'], int), \
"Accelerator should be an 'int', " \
"not '{}'".format(type(intervals['accelerator']).__name__)
assert intervals['accelerator'] >= 0, \
"Accelerator should not be less than 0"
return tender_parameters
def prepare_test_tender_data(procedure_intervals, tender_parameters,
submissionMethodDetails):
# Get actual intervals by mode name
mode = tender_parameters['mode']
if mode in procedure_intervals:
intervals = procedure_intervals[mode]
else:
intervals = procedure_intervals['default']
LOGGER.log_message(Message(intervals))
tender_parameters['intervals'] = intervals
# Set acceleration value for certain modes
assert isinstance(intervals['accelerator'], int), \
"Accelerator should be an 'int', " \
"not '{}'".format(type(intervals['accelerator']).__name__)
assert intervals['accelerator'] >= 0, \
"Accelerator should not be less than 0"
if mode == 'belowThreshold':
return munchify({
'data':
test_tender_data(tender_parameters,
submissionMethodDetails=submissionMethodDetails)
})
elif mode == 'dgfFinancialAssets':
return munchify({
'data':
test_tender_data_dgf_financial(tender_parameters,
submissionMethodDetails)
})
elif mode == 'dgfOtherAssets':
return munchify({
'data':
test_tender_data_dgf_other(tender_parameters,
submissionMethodDetails)
})
elif mode == 'dgfInsider':
return munchify({
'data':
test_tender_data_dgf_insider(tender_parameters,
submissionMethodDetails)
})
raise ValueError("Invalid mode for prepare_test_tender_data")
def run_keyword_and_ignore_keyword_definations(name, *args):
"""Runs the given keyword with given arguments and returns the status as a Boolean value.
This keyword returns `True` if the keyword that is executed succeeds and
`False` if it fails. This is useful, for example, in combination with
`Run Keyword If`. If you are interested in the error message or return
value, use `Run Keyword And Ignore Error` instead.
The keyword name and arguments work as in `Run Keyword`.
Example:
| ${passed} = | `Run Keyword And Return Status` | Keyword | args |
| `Run Keyword If` | ${passed} | Another keyword |
New in Robot Framework 2.7.6.
"""
try:
status, _ = BuiltIn().run_keyword_and_ignore_error(name, *args)
except HandlerExecutionFailed, e:
LOGGER.log_message(Message("Keyword {} not implemented", "ERROR"))
return "FAIL", ""
def prepare_test_tender_data(procedure_intervals, mode):
# Get actual intervals by mode name
if mode in procedure_intervals:
intervals = procedure_intervals[mode]
else:
intervals = procedure_intervals['default']
LOGGER.log_message(Message(intervals))
# Set acceleration value for certain modes
if mode in ['openua', 'openeu']:
assert isinstance(intervals['accelerator'], int), \
"Accelerator should be an 'int', " \
"not '{}'".format(type(intervals['accelerator']).__name__)
assert intervals['accelerator'] >= 0, \
"Accelerator should not be less than 0"
else:
assert 'accelerator' not in intervals.keys(), \
"Accelerator is not available for mode '{0}'".format(mode)
if mode == 'single':
return munchify({'data': test_tender_data(intervals)})
elif mode == 'multi':
return munchify({'data': test_tender_data_multiple_items(intervals)})
elif mode == 'reporting':
return munchify(
{'data': test_tender_data_limited(intervals, 'reporting')})
elif mode == 'negotiation':
return munchify(
{'data': test_tender_data_limited(intervals, 'negotiation')})
elif mode == 'negotiation.quick':
return munchify(
{'data': test_tender_data_limited(intervals, 'negotiation.quick')})
elif mode == 'openua':
return munchify({'data': test_tender_data_openua(intervals)})
elif mode == 'openeu':
return munchify({'data': test_tender_data_openeu(intervals)})
raise ValueError("Invalid mode for prepare_test_tender_data")
def _log_messages_by_thread(self, name, html=False):
msg = 'Run Thread %s' % name
LOGGER.log_message(Message(msg, 'INFO', html))
for message in self._messages.pop(name, []):
LOGGER.log_message(message)
def log_object_data(data):
if not isinstance(data, Munch):
data = munchify(data)
LOGGER.log_message(
Message(data.toYAML(allow_unicode=True, default_flow_style=False),
"INFO"))
def test_string_message(self):
assert_equal(Message('my message').message, 'my message')
def emit(self, record):
msg = record.getMessage()
lvl = self.mapping[record.levelname]
LOGGER.log_message(Message(msg, lvl))
def test_callable_message(self):
assert_equal(Message(lambda: 'my message').message, 'my message')
def emit(self, record):
message = self.format(record)
level = MAP.get(record.levelname, record.levelname)
LOGGER.log_message(Message(message, level, False))
def __init__(self, node):
Message.__init__(self, node.text,
level=node.get('level', 'INFO'),
html=node.get('html', 'no') == 'yes',
timestamp=node.get('timestamp', 'N/A'),
linkable=node.get('linkable', 'no') == 'yes')
