def get_assertion_details(self, entry):
raised_exc = entry.raised_exception
expected_exceptions = ", ".join(
[exc.__name__ for exc in entry.expected_exceptions])
label = ("not instance of" if isinstance(
entry, assertions.ExceptionNotRaised) else "instance of")
msg = "{} {} {}".format(type(raised_exc), label, expected_exceptions)
if entry.func:
msg += "{} Function: {}".format(
os.linesep,
str(entry.func)
if entry.passed else Color.red(str(entry.func)),
)
if entry.pattern:
msg += "{} Pattern: {}".format(
os.linesep,
entry.pattern if entry.passed else Color.red(entry.pattern),
)
msg += "{} Exception message: {}".format(os.linesep,
entry.raised_exception)
return msg
def get_assertion_details(self, entry):
"""
Render the message if there is any, then render XMLTagComparison items.
"""
result = []
result.append("xpath: {}".format(entry.xpath))
if entry.namespaces:
result.append("Namespaces: {}".format(entry.namespaces))
if entry.message:
result.append(
entry.message if entry.passed else Color.red(entry.message))
if entry.data:
result.append("Tags:")
for tag_comp in entry.data:
template = " {actual} {operator} {expected}"
common = dict(actual=tag_comp.tag,
expected=tag_comp.comparison_value)
if tag_comp.passed:
result.append(template.format(operator="==", **common))
else:
result.append(
Color.red(template.format(operator="!=", **common)))
return os.linesep.join(result)
def get_assertion_details(self, entry):
"""
Use a format like `1 == 2`, highlighting
failing comparisons in red.
"""
msg = "{} {} {}".format(entry.first, entry.label, entry.second)
return msg if entry else Color.red(msg)
def get_assertion_details(self, entry):
"""Return row by row match results in tabular format"""
if entry.message:
result = (
Color.red(entry.message) if not entry.passed else entry.message
)
else:
result = ""
row_data = [
self.get_row_data(
row_comparison,
entry.display_columns,
display_index=entry.report_fails_only,
)
for row_comparison in entry.data
]
columns = (
["row"] + list(entry.display_columns)
if entry.report_fails_only
else entry.display_columns
)
ascii_table = (
AsciiTable([columns] + row_data).table if row_data else ""
)
return "{}{}{}".format(
result, os.linesep if result and ascii_table else "", ascii_table
)
def get_row_data(
self,
row_comparison,
columns,
include_columns=None,
exclude_columns=None,
display_index=False,
):
"""Return single row data to be printed"""
result = []
for idx, column in enumerate(columns):
actual = row_comparison.data[idx]
other, matched = row_comparison.get_comparison_value(column, idx)
value_limit = int((constants.CELL_STRING_LENGTH - 4) / 2)
other, actual = format_cell_data(data=[other, actual],
limit=value_limit)
include_columns = include_columns or columns
exclude_columns = exclude_columns or []
if (column not in include_columns) or (column in exclude_columns):
result.append("{} .. {}".format(actual, other))
elif matched:
result.append(Color.green("{} == {}".format(actual, other)))
else:
result.append(Color.red("{} != {}".format(actual, other)))
if display_index:
result = [row_comparison.idx] + result
return result
def get_assertion_details(self, entry):
"""Return `has_keys` & `absent_keys` context"""
msg = ""
if entry.has_keys:
msg += "Existence check: {}".format(entry.has_keys)
if entry.has_keys_diff:
msg += "{}\tMissing keys: {}".format(
os.linesep, Color.red(list(entry.has_keys_diff)))
if entry.absent_keys:
if msg:
msg += os.linesep
msg += "Absence check: {}".format(entry.absent_keys)
if entry.absent_keys_diff:
msg += "{}\tKey should be absent: {}".format(
os.linesep, Color.red(list(entry.absent_keys_diff)))
return msg
def get_assertion_details(self, entry):
"""
Use a format like `99 ~= 100 (with rel_tol=0.1, abs_tol=0.0)`,
highlighting failing comparisons in red.
"""
msg = '{} {} {} (rel_tol: {}, abs_tol: {})'.format(
entry.first, entry.label, entry.second, entry.rel_tol,
entry.abs_tol)
return msg if entry else Color.red(msg)
def log_test_status(self, name, passed, indent=0, level=TEST_INFO):
"""Shortcut to log a pass/fail status for a test."""
pass_label = Color.green('Pass') if passed else Color.red('Fail')
indent_str = indent * ' '
msg = self._TEST_STATUS_FORMAT
self._custom_log(
level,
msg,
{'name': name, 'pass_label': pass_label, 'indent': indent_str})
def _print_test_result(self, task_result):
if not isinstance(task_result.result, RunnableResult) or\
not hasattr(task_result.result, 'report'):
return
# Currently prints report top level result and not details.
name = task_result.result.report.name
if task_result.result.report.passed is True:
self.logger.test_info('{} -> {}'.format(name, Color.green('Pass')))
else:
self.logger.test_info('{} -> {}'.format(name, Color.red('Fail')))
def _print_test_result(self, task_result):
if (not isinstance(task_result.result, entity.RunnableResult)) or (
not hasattr(task_result.result, "report")):
return
# Currently prints report top level result and not details.
name = task_result.result.report.name
if task_result.result.report.passed is True:
self.logger.test_info("{} -> {}".format(name, Color.green("Pass")))
else:
self.logger.test_info("{} -> {}".format(name, Color.red("Fail")))
def get_assertion_details(self, entry):
result = []
if not entry.passed:
result.append(Color.red("*** a.text ***" + os.linesep))
for line in self._get_truncated_lines(
entry.first, n=constants.NUM_DISPLAYED_ROWS
):
result.append(" {}".format(line))
if not (result[-1].endswith(os.linesep) or result[-1][-1] == "\n"):
result[-1] += os.linesep
result.append(Color.red("*** b.text ***" + os.linesep))
for line in self._get_truncated_lines(
entry.second, n=constants.NUM_DISPLAYED_ROWS
):
result.append(" {}".format(line))
if not (result[-1].endswith(os.linesep) or result[-1][-1] == "\n"):
result[-1] += os.linesep
options = ""
options += "-b " if entry.ignore_space_change else ""
options += "-w " if entry.ignore_whitespaces else ""
options += "-B " if entry.ignore_blank_lines else ""
options += "-u " if entry.unified else ""
options += "-c " if entry.context and not entry.unified else ""
options = " ( " + options + ")" if options else ""
if entry.passed:
result.append("No difference found{}".format(options))
else:
result.append(
Color.red("Differences{}:{}".format(options, os.linesep))
)
for line in self._get_truncated_lines(
entry.delta, n=constants.NUM_DISPLAYED_ROWS * 5
):
result.append(" {}".format(line))
result[-1] = re.sub(r"[\r\n]+$", "", result[-1])
return "".join(result)
def get_assertion_details(self, entry):
result = []
if not entry.passed:
result.append(Color.red('*** a.text ***' + os.linesep))
for line in self._get_truncated_lines(
entry.first, n=constants.NUM_DISPLAYED_ROWS):
result.append(' {}'.format(line))
if not (result[-1].endswith(os.linesep) or result[-1][-1] == '\n'):
result[-1] += os.linesep
result.append(Color.red('*** b.text ***' + os.linesep))
for line in self._get_truncated_lines(
entry.second, n=constants.NUM_DISPLAYED_ROWS):
result.append(' {}'.format(line))
if not (result[-1].endswith(os.linesep) or result[-1][-1] == '\n'):
result[-1] += os.linesep
options = ''
options += '-b ' if entry.ignore_space_change else ''
options += '-w ' if entry.ignore_whitespaces else ''
options += '-B ' if entry.ignore_blank_lines else ''
options += '-u ' if entry.unified else ''
options += '-c ' if entry.context and not entry.unified else ''
options = ' ( ' + options + ')' if options else ''
if entry.passed:
result.append('No difference found{}'.format(options))
else:
result.append(
Color.red('Differences{}:{}'.format(options, os.linesep))
)
for line in self._get_truncated_lines(
entry.delta, n=constants.NUM_DISPLAYED_ROWS*5):
result.append(' {}'.format(line))
result[-1] = re.sub(r'[\r\n]+$', '', result[-1])
return ''.join(result)
def get_assertion_details(self, entry):
result = [
'{} - excluded'.format(slice_comp.slice)
for slice_comp in entry.data
]
actual = [entry.actual[i] for i in entry.included_indices]
expected = [entry.expected[i] for i in entry.included_indices]
result.extend([
'{}: {}'.format(title, data if entry.passed else Color.red(data))
for title, data in (('Compared indices',
list(entry.included_indices)),
('Actual', actual), ('Expected', expected))
])
return os.linesep.join(result)
def get_assertion_details(self, entry):
result = []
for slice_comp in entry.data:
result.append("{}".format(slice_comp.slice if slice_comp.
passed else Color.red(slice_comp.slice)))
# Display mismatched indexes if slice has
# a step, for easier debugging
if slice_comp.mismatch_indices:
result.append(" Mismatched indices: {}".format(
slice_comp.mismatch_indices))
result.append(" Actual:\t{}".format(slice_comp.actual))
result.append(" Expected:\t{}".format(slice_comp.expected))
return os.linesep.join(result)
def get_assertion_details(self, entry):
"""Return row by row match results in tabular format"""
if entry.message:
message = Color.red(entry.message) \
if not entry.passed else entry.message
result = '{}{}'.format(message, os.linesep)
else:
result = ''
display_index = entry.fail_limit > 0
row_data = [
self.get_row_data(row_comparison,
entry.display_columns,
display_index=display_index)
for row_comparison in entry.data
]
columns = ['row'] + list(entry.display_columns) \
if display_index else entry.display_columns
return '{}{}'.format(result, AsciiTable([columns] + row_data).table)
def log_test_status(self, name, status, indent=0, level=TEST_INFO):
"""Shortcut to log a pass/fail status for a test."""
if Status.STATUS_CATEGORY[status] == Status.PASSED:
pass_label = Color.green(status.title())
elif Status.STATUS_CATEGORY[status] in [Status.FAILED, Status.ERROR]:
pass_label = Color.red(status.title())
elif Status.STATUS_CATEGORY[status] == Status.UNSTABLE:
pass_label = Color.yellow(status.title())
else: # unknown
pass_label = status
indent_str = indent * " "
msg = self._TEST_STATUS_FORMAT
self._custom_log(
level,
msg,
{
"name": name,
"pass_label": pass_label,
"indent": indent_str
},
)
def get_assertion_details(self, entry):
"""Return row by row match results in tabular format"""
if entry.message:
result = Color.red(entry.message) \
if not entry.passed else entry.message
else:
result = ''
row_data = [
self.get_row_data(row_comparison,
entry.display_columns,
display_index=entry.report_fails_only)
for row_comparison in entry.data
]
columns = ['row'] + list(entry.display_columns) \
if entry.report_fails_only else entry.display_columns
ascii_table = AsciiTable([columns] + row_data).table \
if row_data else ''
return '{}{}{}'.format(result,
os.linesep if result and ascii_table else '',
ascii_table)
def get_header_text(self, entry):
"""Always return text in red as it is an explicit failure."""
return Color.red(entry.description)
def pass_label(self, entry):
return Color.green("Pass") if entry else Color.red("Fail")
def pass_label(self, entry):
return Color.green('Pass') if entry else Color.red('Fail')
def get_test_status_message(name, passed):
pass_label = Color.green('Pass') if passed else Color.red('Fail')
return TEST_STATUS_FORMAT.format(name=name, pass_label=pass_label)