def highlight_code(code, style="default") -> str:
"""Apply syntax highlighting to the string of python `code`.
Args:
code (str): The string of python code to be styled.
style (:obj:`str`, optional): The style to apply.
The name of the syntax highlighting style to apply to the `code`.
Defaults to "default". The "default" style is the same syntax
highlighting style used by default in ipython and jupyter notebooks.
Any style must be listed among the available syntax highlighting
styles from the `pygments` package. See `get_all_styles()`.
Returns:
str: A string of python code that has been syntax highlighted.
"""
assert style in get_all_styles()
highlighted_code = pygments.highlight(
code, lexers.PythonLexer(), formatters.Terminal256Formatter(style=style),
)
return highlighted_code
def main(argv):
if len(argv) != 2:
sys.exit('Expected exactly 1 argument, got: %s' % (len(argv) - 1))
debug_file = argv[-1]
with open(debug_file) as f:
debug_info = json.load(f)
rxerr_argv = debug_info.get('argv')
if rxerr_argv:
print('Command:', ' '.join(shlex.quote(arg) for arg in rxerr_argv), '\n')
is_first = False
for f, failure in debug_info.get('failures', {}).items():
if not is_first:
print('\n')
is_first = False
print('File:', f)
try:
source = failure['content']
except KeyError:
pass
else:
with tempfile.NamedTemporaryFile(
mode='w', encoding='utf-8', suffix='.py', delete=False) as out_f:
out_f.write(source)
print('Content:', out_f.name)
try:
tb = failure['traceback']
except KeyError:
pass
else:
lexer = lexers.PythonTracebackLexer() # pytype: disable=module-attr
formatter = formatters.Terminal256Formatter() # pytype: disable=module-attr
print(pygments.highlight(tb, lexer, formatter))
def format(self, record):
formatted_json = super(CustomJsonFormatter, self).format(record)
if self.coloured_logging:
from logging import LogRecord
from pygments import highlight, lexers, formatters
if isinstance(record, LogRecord):
colorful_json = highlight(
formatted_json, lexers.JsonLexer(),
formatters.Terminal256Formatter(style=level_style_dict.get(
record.levelname, 'default')))
else:
colorful_json = highlight(formatted_json, lexers.JsonLexer(),
formatters.Terminal256Formatter())
return colorful_json
else:
return formatted_json
def json_print(obj, sort_keys=False, color=False, bgcolor=None):
jsonstr = json_dumps(obj, sort_keys)
# from pygments.styles import get_all_styles
# styles = list(get_all_styles())
if color:
if bgcolor is not None:
jsonstr = bgcolor + jsonstr + '\033[0m'
else:
term = formatters.Terminal256Formatter(style='fruity')
jsonstr = highlight(jsonstr, lexers.JsonLexer(), term)
print(jsonstr)
def json_output_formatter(parsed_json):
"""
Applies syntax highlighting to output
:params parsed_json: (dict) JSON response requests response.json()
:returns: (str) syntax highlighted text
"""
formatted_json = json.dumps(parsed_json,
sort_keys=True,
ensure_ascii=False,
indent=4)
output_style = get_style_by_name('emacs')
colorful_json = highlight(
formatted_json, lexers.JsonLexer(),
formatters.Terminal256Formatter(style=output_style))
return colorful_json
def hprint(j_data):
""" Utility function to print formatted + highlighted JSON to
console
Args:
j_data (dict): The json to print
"""
if not isinstance(j_data, dict):
raise Exception('trying to print a non-json object', type(j_data))
formatted_json = json.dumps(j_data, sort_keys=True, indent=4)
colorful_json = highlight(formatted_json, lexers.JsonLexer(),
formatters.Terminal256Formatter())
print(colorful_json)
def output(self, outdata, tablefmt):
# log.debugv(f"data passed to output():\n{pprint(outdata, indent=4)}")
if tablefmt == "json":
# from pygments import highlight, lexers, formatters
json_data = json.dumps(outdata, sort_keys=True, indent=2)
table_data = highlight(
bytes(json_data, 'UTF-8'), lexers.JsonLexer(),
formatters.Terminal256Formatter(style='solarized-dark'))
elif tablefmt == "csv":
table_data = "\n".join([
",".join([
k if outdata.index(d) == 0 else str(v)
for k, v in d.items() if k not in CUST_KEYS
]) for d in outdata
])
elif tablefmt in ["yml", "yaml"]:
table_data = highlight(
bytes(yaml.dump(
outdata,
sort_keys=True,
), 'UTF-8'), lexers.YamlLexer(),
formatters.Terminal256Formatter(style='solarized-dark'))
else:
customer_id = customer_name = ""
outdata = self.listify(outdata)
if outdata and isinstance(outdata, list) and isinstance(
outdata[0], dict):
customer_id = outdata[0].get("customer_id", "")
customer_name = outdata[0].get("customer_name", "")
outdata = [{k: v
for k, v in d.items() if k not in CUST_KEYS}
for d in outdata]
table_data = tabulate(outdata, headers="keys", tablefmt=tablefmt)
table_data = f"--\n{'Customer ID:':15}{customer_id}\n{'Customer Name:':15} {customer_name}\n--\n{table_data}"
return table_data
def wrapper(*args, **kwargs):
"""Pretty-print container types and syntax-highlight command results."""
out = f(*args, **kwargs)
printable = repr(out)
lexer = lexers.PythonLexer()
try:
serialized = json.loads(out)
except ValueError:
pass
else:
if isinstance(serialized, collections.abc.Container):
printable = json.dumps(serialized, indent=2)
lexer = lexers.JsonLexer()
printable = highlight(
printable, lexer,
formatters.Terminal256Formatter(style=MonokaiStyle))
return printable
def highlight_code(code, language, style, format):
block = code.split('\n')
if language is not None:
lexer = lexers.get_lexer_by_name(language)
else:
try:
lexer = lexers.guess_lexer('\n'.join(block))
except Exception:
lexer = lexers.special.TextLexer()
if style is None or format == 'none':
f = formatters.NullFormatter()
elif format == 'color':
f = formatters.TerminalFormatter(style=style)
elif format == 'color256':
f = formatters.Terminal256Formatter(style=style)
return highlight('\n'.join(block), lexer, f)
def __print_vars(self, e_vars, pre_middle_var, pre_last_var):
e_line = ''
e_vars_keys = []
for v in e_vars:
e_vars_keys.append(v)
if e_vars_keys:
e_vars_keys.sort()
last_key = e_vars_keys[-1]
longest_key = self.C(e_vars_keys[0]).__len__()
for v in e_vars_keys:
if self.C(v).__len__() > longest_key:
longest_key = self.C(v).__len__()
for v in e_vars_keys:
if v == last_key:
e_line += pre_last_var
else:
e_line += pre_middle_var
var_line = '╴%%-%ds = %%s\n' % longest_key
if isinstance(e_vars[v], dict):
if self.color.use_colors:
from pygments import highlight, lexers, formatters
var_dict = highlight(
json.dumps(e_vars[v], sort_keys=True, indent=2),
lexers.JsonLexer(),
formatters.Terminal256Formatter(style='vim'))
var_dict = var_dict.replace("\n", "\n │ │ ")
else:
var_dict = json.dumps(e_vars[v],
sort_keys=True,
indent=2).replace(
"\n", "\n │ │ ")
e_line += var_line % (self.C(v), var_dict)
else:
e_line += var_line % (self.C(v), e_vars[v])
return e_line
def wrapper(*args, **kwargs):
"""Pretty-print container types and syntax-highlight command results."""
from .prompt import g
out = f(*args, **kwargs)
if out is None:
return
if g.style is None:
return out
printable = repr(out)
lexer = lexers.PythonLexer()
try:
serialized = json.loads(out)
except ValueError:
pass
else:
if isinstance(serialized, (tuple, list, dict)):
printable = json.dumps(serialized, indent=2)
lexer = lexers.JsonLexer()
printable = highlight(
printable,
lexer,
formatters.Terminal256Formatter(style=g.style))
return printable
def log_info_dict_json(data_str, colored=True):
data_str = json.dumps(data_str, indent=4, sort_keys=True)
if colored and os.name != "nt":
data_str = highlight(data_str, lexers.JsonLexer(),
formatters.Terminal256Formatter(style="monokai"))
logger.info(data_str)
def _output_result(self, result):
cmd_str = ' '.join(["crossbar", "shell"] + sys.argv[1:])
if self._output_format in [
Application.OUTPUT_FORMAT_JSON,
Application.OUTPUT_FORMAT_JSON_COLORED
]:
json_str = json.dumps(result.result,
separators=(', ', ': '),
sort_keys=False,
indent=4,
ensure_ascii=False)
if self._output_format == Application.OUTPUT_FORMAT_JSON_COLORED:
console_str = highlight(
json_str, lexers.JsonLexer(),
formatters.Terminal256Formatter(style=self._output_style))
else:
console_str = json_str
elif self._output_format in [
Application.OUTPUT_FORMAT_YAML,
Application.OUTPUT_FORMAT_YAML_COLORED
]:
yaml_str = yaml.safe_dump(result.result)
if self._output_format == Application.OUTPUT_FORMAT_YAML_COLORED:
console_str = highlight(
yaml_str, lexers.YamlLexer(),
formatters.Terminal256Formatter(style=self._output_style))
else:
console_str = yaml_str
elif self._output_format == Application.OUTPUT_FORMAT_PLAIN:
console_str = '{}'.format(result)
else:
# should not arrive here
raise Exception(
'internal error: unprocessed value "{}" for output format'.
format(self._output_format))
# output command metadata (such as runtime)
if self._output_verbosity == Application.OUTPUT_VERBOSITY_SILENT:
pass
else:
# output result of command
click.echo(console_str)
if self._output_verbosity == Application.OUTPUT_VERBOSITY_RESULT_ONLY or self._output_format == Application.OUTPUT_FORMAT_PLAIN:
pass
elif self._output_verbosity == Application.OUTPUT_VERBOSITY_NORMAL:
if result.duration:
click.echo(
style_finished_line(
'Finished command in {} ms: {}'.format(
result.duration, cmd_str)))
else:
click.echo(
style_finished_line(
'Finished command successfully: {}'.format(
cmd_str)))
elif self._output_verbosity == Application.OUTPUT_VERBOSITY_EXTENDED:
if result.duration:
click.echo(
style_finished_line(
'Finished command in {} ms on {}: {}'.format(
result.duration, localnow(), cmd_str)))
else:
click.echo(
style_finished_line(
'Finished successfully on {}: {}'.format(
localnow(), cmd_str)))
else:
# should not arrive here
raise Exception('internal error')
def output(
self,
outdata: Union[List[str], Dict[str, Any]],
tablefmt: str = "rich",
title: str = None,
caption: str = None,
account: str = None,
config=None,
ok_status: Union[int, List[int], Tuple[int, str],
List[Tuple[int, str]]] = None,
) -> str:
# log.debugv(f"data passed to output():\n{pprint(outdata, indent=4)}")
def _do_subtables(data: list, tablefmt: str = "rich"):
out = []
for inner_dict in data: # the object: switch/vlan etc dict
for key, val in inner_dict.items():
if not isinstance(val, (list, dict, tuple)):
if val is None:
inner_dict[key] = ''
elif isinstance(val,
str) and val.lower() in ['up', 'down']:
color = 'red' if val.lower() == 'down' else 'green'
if tablefmt == 'rich':
inner_dict[
key] = f'[b {color}]{val.title()}[/b {color}]'
else:
inner_dict[key] = typer.style(val.title(),
fg=color)
else:
if tablefmt == 'rich':
inner_dict[key] = Text(str(val), style=None)
else:
inner_dict[key] = str(val)
else:
val = self.listify(val)
if val and tablefmt == "rich" and hasattr(
val[0], 'keys'):
inner_table = Table(
*(k for k in val[0].keys()),
show_header=True,
# padding=(0, 0),
pad_edge=False,
collapse_padding=True,
show_edge=False,
header_style="bold cyan",
box=SIMPLE)
_ = [
inner_table.add_row(*[
self.do_pretty(kk, str(vv))
for kk, vv in v.items()
]) for v in val
]
with console.capture():
console.print(inner_table)
inner_dict[key] = console.export_text()
elif val and tablefmt == "tabulate" and hasattr(
val[0], 'keys'):
inner_table = tabulate(val,
headers="keys",
tablefmt=tablefmt)
inner_dict[key] = inner_table
else:
if all(isinstance(v, str) for v in val):
inner_dict[key] = ", ".join(val)
out.append(inner_dict)
return out
raw_data = outdata
_lexer = table_data = None
if config and config.sanitize and raw_data and all(
isinstance(x, dict) for x in raw_data):
redact = [
"mac", "serial", "neighborMac", "neighborSerial",
"neighborPortMac", "longitude", "latitude"
]
outdata = [{
k: d[k] if k not in redact else "--redacted--"
for k in d
} for d in raw_data]
# -- // List[str, ...] \\ -- Bypass all formatters, (config file output, etc...)
if outdata and all(isinstance(x, str) for x in outdata):
tablefmt = "strings"
# -- convert List[dict] --> Dict[dev_name: dict] for yaml/json outputs
if tablefmt in ['json', 'yaml', 'yml']:
outdata = self.listify(outdata)
if outdata and 'name' in outdata[0]:
outdata: Dict[str, Dict[str, Any]] = {
item['name']:
{k: v
for k, v in item.items() if k != 'name'}
for item in outdata
}
if tablefmt == "json":
raw_data = json.dumps(outdata, indent=4)
_lexer = lexers.JsonLexer
elif tablefmt in ["yml", "yaml"]:
raw_data = yaml.dump(outdata, sort_keys=False)
_lexer = lexers.YamlLexer
elif tablefmt == "csv":
raw_data = table_data = "\n".join([
",".join([
k if outdata.index(d) == 0 else str(v)
for k, v in d.items() if k not in CUST_KEYS
]) for d in outdata
])
elif tablefmt == "rich":
from rich.console import Console
from rich.table import Table
from rich.box import HORIZONTALS, SIMPLE
from rich.text import Text
from centralcli import constants
console = Console(record=True)
customer_id, customer_name = "", ""
# outdata = self.listify(outdata)
# -- // List[dict, ...] \\ --
if outdata and all(isinstance(x, dict) for x in outdata):
customer_id = outdata[0].get("customer_id", "")
customer_name = outdata[0].get("customer_name", "")
outdata = [{k: v
for k, v in d.items() if k not in CUST_KEYS}
for d in outdata]
table = Table(
# show_edge=False,
show_header=True,
title=title,
header_style='magenta',
show_lines=False,
box=HORIZONTALS,
row_styles=['none', 'dark_sea_green'])
fold_cols = ['description']
_min_max = {'min': 10, 'max': 30}
set_width_cols = {'name': _min_max, 'model': _min_max}
full_cols = [
'mac', 'serial', 'ip', 'public ip', 'version', 'radio',
'id'
]
for k in outdata[0].keys():
if k in fold_cols:
table.add_column(k,
overflow='fold',
max_width=115,
justify='left')
elif k in set_width_cols:
table.add_column(k,
min_width=set_width_cols[k]['min'],
max_width=set_width_cols[k]['max'],
justify='left')
elif k in full_cols:
table.add_column(k, no_wrap=True, justify='left')
else:
table.add_column(k, justify='left')
formatted = _do_subtables(outdata)
[
table.add_row(*list(in_dict.values()))
for in_dict in formatted
]
if title:
table.title = f'[italic cornflower_blue]{constants.what_to_pretty(title)}'
if account or caption:
table.caption_justify = 'left'
table.caption = '' if not account else f'[italic dark_olive_green2] Account: {account}'
if caption:
table.caption = f"[italic dark_olive_green2]{table.caption} {caption}"
data_header = f"--\n{'Customer ID:':15}{customer_id}\n{'Customer Name:':15} {customer_name}\n--\n"
with console.capture():
console.print(table)
raw_data = console.export_text(clear=False)
table_data = console.export_text(styles=True)
raw_data = f"{data_header}{raw_data}" if customer_id else f"{raw_data}"
table_data = f"{data_header}{table_data}" if customer_id else f"{table_data}"
elif tablefmt == "tabulate":
customer_id = customer_name = ""
outdata = self.listify(outdata)
# -- // List[dict, ...] \\ --
if outdata and all(isinstance(x, dict) for x in outdata):
customer_id = outdata[0].get("customer_id", "")
customer_name = outdata[0].get("customer_name", "")
outdata = [{k: v
for k, v in d.items() if k not in CUST_KEYS}
for d in outdata]
raw_data = outdata
outdata = _do_subtables(outdata, tablefmt=tablefmt)
# outdata = [dict((k, v) for k, v in zip(outdata[0].keys(), val)) for val in outdata]
table_data = tabulate(outdata,
headers="keys",
tablefmt=tablefmt)
td = table_data.splitlines(keepends=True)
table_data = f"{typer.style(td[0], fg='cyan')}{''.join(td[1:])}"
data_header = f"--\n{'Customer ID:':15}{customer_id}\n" \
f"{'Customer Name:':15} {customer_name}\n--\n"
table_data = f"{data_header}{table_data}" if customer_id else f"{table_data}"
raw_data = f"{data_header}{raw_data}" if customer_id else f"{raw_data}"
else: # strings output No formatting
# -- // List[str, ...] \\ --
if len(outdata) == 1:
if "\n" not in outdata[0]:
# we can format green as only success output is sent through formatter.
table_data = typer.style(f" {outdata[0]}", fg="green")
raw_data = outdata[0]
else: # template / config file output
# get rid of double nl @ EoF (configs)
raw_data = table_data = "{}\n".format(
'\n'.join(outdata).rstrip('\n'))
else:
raw_data = table_data = '\n'.join(outdata)
# Not sure what hit's this, but it was created so something must
log.debug("List[str] else hit")
if _lexer and raw_data:
table_data = highlight(
bytes(raw_data, 'UTF-8'), _lexer(),
formatters.Terminal256Formatter(style='solarized-dark'))
return self.Output(rawdata=raw_data,
prettydata=table_data,
config=config)
async def run_command(self, cmd):
try:
result = await cmd.run(self.session)
except Exception as e:
print(e)
if self._output_format in [
Application.OUTPUT_FORMAT_JSON,
Application.OUTPUT_FORMAT_JSON_COLORED
]:
json_str = json.dumps(result.result,
separators=(', ', ': '),
sort_keys=True,
indent=4,
ensure_ascii=False)
if self._output_format == Application.OUTPUT_FORMAT_JSON_COLORED:
console_str = highlight(
json_str, lexers.JsonLexer(),
formatters.Terminal256Formatter(style=self._output_style))
else:
console_str = json_str
elif self._output_format in [
Application.OUTPUT_FORMAT_YAML,
Application.OUTPUT_FORMAT_YAML_COLORED
]:
yaml_str = yaml.safe_dump(result.result)
if self._output_format == Application.OUTPUT_FORMAT_YAML_COLORED:
console_str = highlight(
yaml_str, lexers.YamlLexer(),
formatters.Terminal256Formatter(style=self._output_style))
else:
console_str = yaml_str
elif self._output_format == Application.OUTPUT_FORMAT_PLAIN:
#console_str = u'{}'.format(pprint.pformat(result.result))
console_str = u'{}'.format(result)
else:
# should not arrive here
raise Exception(
'internal error: unprocessed value "{}" for output format'.
format(self._output_format))
# output command metadata (such as runtime)
if self._output_verbosity == Application.OUTPUT_VERBOSITY_SILENT:
pass
else:
# output result of command
click.echo(console_str)
if self._output_verbosity == Application.OUTPUT_VERBOSITY_RESULT_ONLY or self._output_format == Application.OUTPUT_FORMAT_PLAIN:
pass
elif self._output_verbosity == Application.OUTPUT_VERBOSITY_NORMAL:
if result.duration:
click.echo(
style_finished_line(u'Finished in {} ms.'.format(
result.duration)))
else:
click.echo(style_finished_line(u'Finished successfully.'))
elif self._output_verbosity == Application.OUTPUT_VERBOSITY_EXTENDED:
if result.duration:
click.echo(
style_finished_line(u'Finished in {} ms on {}.'.format(
result.duration, localnow())))
else:
click.echo(
style_finished_line(
u'Finished successfully on {}.'.format(
localnow())))
else:
# should not arrive here
raise Exception('internal error')
import sqlparse
from django.utils.log import ServerFormatter
from pygments import formatters, highlight, lexers
TIME_CRIT = 0.2
TIME_WARN = 0.05
TIME_FORMAT = u'\x1b[0;30;{bgcolor}m {duration:.3f}s \x1b[0m\n{msg}'
LEXER = lexers.SqlLexer()
FORMATTER = formatters.Terminal256Formatter(style='monokai')
class SqlFormatter(ServerFormatter):
def format(self, record):
try:
sql = record.sql.strip()
duration = record.duration
except AttributeError:
return super(SqlFormatter, self).format(record)
sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
bg_color = 41 if duration > TIME_CRIT else 43 if duration > TIME_WARN else 42
return TIME_FORMAT.format(bgcolor=bg_color,
duration=duration,
msg=highlight(sql, LEXER, FORMATTER))
class ColourTextTestResult(result.TestResult):
"""
A test result class that prints colour formatted text results to a stream.
Based on https://github.com/python/cpython/blob/3.3/Lib/unittest/runner.py
"""
formatter = formatters.Terminal256Formatter()
lexer = Lexer()
separator1 = '=' * 70
separator2 = '-' * 70
indent = ' ' * 4
_terminal = Terminal()
colours = {
None: text_type,
'error': _terminal.bold_red,
'expected': _terminal.blue,
'fail': _terminal.bold_yellow,
'skip': text_type,
'success': _terminal.green,
'title': _terminal.blue,
'unexpected': _terminal.bold_red,
}
_test_class = None
def __init__(self, stream, descriptions, verbosity):
super(ColourTextTestResult, self).__init__(stream, descriptions,
verbosity)
self.stream = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
self.descriptions = descriptions
def getShortDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return self.indent + doc_first_line
return self.indent + test._testMethodName
def getLongDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
return str(test)
def getClassDescription(self, test):
test_class = test.__class__
doc = test_class.__doc__
if self.descriptions and doc:
return doc.strip().split('\n')[0].strip()
return strclass(test_class)
def startTest(self, test):
super(ColourTextTestResult, self).startTest(test)
if self.showAll:
if self._test_class != test.__class__:
self._test_class = test.__class__
title = self.getClassDescription(test)
self.stream.writeln(self.colours['title'](title))
self.stream.write(self.getShortDescription(test))
self.stream.write(' ... ')
self.stream.flush()
def printResult(self, short, extended, colour_key=None):
colour = self.colours[colour_key]
if self.showAll:
self.stream.writeln(colour(extended))
elif self.dots:
self.stream.write(colour(short))
self.stream.flush()
def addSuccess(self, test):
super(ColourTextTestResult, self).addSuccess(test)
self.printResult('.', 'ok', 'success')
def addError(self, test, err):
super(ColourTextTestResult, self).addError(test, err)
self.printResult('E', 'ERROR', 'error')
def addFailure(self, test, err):
super(ColourTextTestResult, self).addFailure(test, err)
self.printResult('F', 'FAIL', 'fail')
def addSkip(self, test, reason):
super(ColourTextTestResult, self).addSkip(test, reason)
self.printResult('s', 'skipped {0!r}'.format(reason), 'skip')
def addExpectedFailure(self, test, err):
super(ColourTextTestResult, self).addExpectedFailure(test, err)
self.printResult('x', 'expected failure', 'expected')
def addUnexpectedSuccess(self, test):
super(ColourTextTestResult, self).addUnexpectedSuccess(test)
self.printResult('u', 'unexpected success', 'unexpected')
def printErrors(self):
if self.dots or self.showAll:
self.stream.writeln()
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)
def printErrorList(self, flavour, errors):
colour = self.colours[flavour.lower()]
for test, err in errors:
self.stream.writeln(self.separator1)
title = '%s: %s' % (flavour, self.getLongDescription(test))
self.stream.writeln(colour(title))
self.stream.writeln(self.separator2)
self.stream.writeln(highlight(err, self.lexer, self.formatter))
class SSTTextTestResult(unittest.TestResult):
""" A superclass to support SST required testing, this is a modified version
of unittestTextTestResult from python 2.7 modified for SST's needs.
"""
separator1 = '=' * 70
separator2 = '-' * 70
indent = ' ' * 4
_test_class = None
if blessings_loaded:
_terminal = Terminal()
colours = {
None: text_type,
'error': _terminal.bold_yellow,
'expected': _terminal.green,
'fail': _terminal.bold_red,
'skip': _terminal.bold_blue,
'success': _terminal.green,
'title': _terminal.magenta,
'unexpected': _terminal.bold_red,
}
else:
colours = {
None: text_type
}
if pygments_loaded:
formatter = formatters.Terminal256Formatter()
lexer = Lexer()
def __init__(self, stream, descriptions, verbosity, no_colour_output=False):
super(SSTTextTestResult, self).__init__(stream, descriptions, verbosity)
self.testsuitesresultsdict = SSTTestSuitesResultsDict()
self._test_name = "undefined_testname"
self._testcase_name = "undefined_testcasename"
self._testsuite_name = "undefined_testsuitename"
self._junit_test_case = None
self.stream = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
self.descriptions = descriptions
if blessings_loaded:
self.no_colour_output = no_colour_output
else:
self.no_colour_output = True
def getShortDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
else:
return str(test)
def getLongDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
return str(test)
def getClassDescription(self, test):
test_class = test.__class__
doc = test_class.__doc__
if self.descriptions and doc:
return doc.strip().split('\n')[0].strip()
return strclass(test_class)
###
def startTest(self, test):
super(SSTTextTestResult, self).startTest(test)
#log_forced("DEBUG - startTest: Test = {0}\n".format(test))
if self.showAll:
if not test_engine_globals.TESTENGINE_CONCURRENTMODE:
if self._test_class != test.__class__:
self._test_class = test.__class__
title = self.getClassDescription(test)
if self.no_colour_output:
self.stream.writeln(self.colours[None](title))
else:
self.stream.writeln(self.colours['title'](title))
self.stream.flush()
self._test_name = "undefined_testname"
_testname = getattr(test, 'testname', None)
if _testname is not None:
self._test_name = test.testname
if self._is_test_of_type_ssttestcase(test):
self._testcase_name = test.get_testcase_name()
self._testsuite_name = test.get_testsuite_name()
else:
self._testcase_name = "FailedTest"
self._testsuite_name = "FailedTest"
timestamp = datetime.utcnow().strftime("%Y_%m%d_%H:%M:%S.%f utc")
self._junit_test_case = JUnitTestCase(self._test_name,
self._testcase_name,
timestamp=timestamp)
def stopTest(self, test):
super(SSTTextTestResult, self).stopTest(test)
#log_forced("DEBUG - stopTest: Test = {0}\n".format(test))
testruntime = 0
if self._is_test_of_type_ssttestcase(test):
testruntime = test.get_test_runtime_sec()
self._junit_test_case.junit_add_elapsed_sec(testruntime)
if not self._is_test_of_type_ssttestcase(test):
return
if not test_engine_globals.TESTENGINE_CONCURRENTMODE:
test_engine_globals.TESTRUN_JUNIT_TESTCASE_DICTLISTS['singlethread'].\
append(self._junit_test_case)
else:
test_engine_globals.TESTRUN_JUNIT_TESTCASE_DICTLISTS[self._testsuite_name].\
append(self._junit_test_case)
###
def get_testsuites_results_dict(self):
""" Return the test suites results dict """
return self.testsuitesresultsdict
###
def printResult(self, test, short, extended, colour_key=None, showruntime=True):
if self.no_colour_output:
colour = self.colours[None]
else:
colour = self.colours[colour_key]
if self.showAll:
self.stream.write(self.indent)
self.stream.write(colour(extended))
self.stream.write(" -- ")
self.stream.write(self.getShortDescription(test))
testruntime = 0
if self._is_test_of_type_ssttestcase(test):
testruntime = test.get_test_runtime_sec()
if showruntime:
self.stream.writeln(" [{0:.3f}s]".format(testruntime))
else:
self.stream.writeln(" ".format(testruntime))
self.stream.flush()
elif self.dots:
self.stream.write(colour(short))
self.stream.flush()
###
def addSuccess(self, test):
super(SSTTextTestResult, self).addSuccess(test)
#log_forced("DEBUG - addSuccess: Test = {0}\n".format(test))
self.printResult(test, '.', 'PASS', 'success')
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_success(test)
def addError(self, test, err):
super(SSTTextTestResult, self).addError(test, err)
#log_forced("DEBUG - addError: Test = {0}, err = {1}\n".format(test, err))
self.printResult(test, 'E', 'ERROR', 'error')
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_error(test)
_junit_test_case = getattr(self, '_junit_test_case', None)
if _junit_test_case is not None:
err_msg = self._get_err_info(err)
_junit_test_case.junit_add_error_info(err_msg)
def addFailure(self, test, err):
super(SSTTextTestResult, self).addFailure(test, err)
#log_forced("DEBUG - addFailure: Test = {0}, err = {1}\n".format(test, err))
self.printResult(test, 'F', 'FAIL', 'fail')
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_failure(test)
_junit_test_case = getattr(self, '_junit_test_case', None)
if _junit_test_case is not None:
err_msg = self._get_err_info(err)
_junit_test_case.junit_add_failure_info(err_msg)
def addSkip(self, test, reason):
super(SSTTextTestResult, self).addSkip(test, reason)
#log_forced("DEBUG - addSkip: Test = {0}, reason = {1}\n".format(test, reason))
self.printResult(test, 's', 'SKIPPED: {0!r}'.format(reason), 'skip', showruntime=False)
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_skip(test)
_junit_test_case = getattr(self, '_junit_test_case', None)
if _junit_test_case is not None:
_junit_test_case.junit_add_skipped_info(reason)
def addExpectedFailure(self, test, err):
# NOTE: This is not a failure, but an identified pass
# since we are expecting a failure
super(SSTTextTestResult, self).addExpectedFailure(test, err)
#log_forced("DEBUG - addExpectedFailure: Test = {0}, err = {1}\n".format(test, err))
self.printResult(test, 'x', 'EXPECTED FAILURE', 'expected')
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_expected_failure(test)
def addUnexpectedSuccess(self, test):
# NOTE: This is a failure, since we passed, but were expecting a failure
super(SSTTextTestResult, self).addUnexpectedSuccess(test)
#log_forced("DEBUG - addUnexpectedSuccess: Test = {0}\n".format(test))
self.printResult(test, 'u', 'UNEXPECTED SUCCESS', 'unexpected')
if not self._is_test_of_type_ssttestcase(test):
return
self.testsuitesresultsdict.add_unexpected_success(test)
_junit_test_case = getattr(self, '_junit_test_case', None)
if _junit_test_case is not None:
_junit_test_case.junit_add_failure_info("RECEIVED SUCCESS WHEN EXPECTING A FAILURE")
###
def printErrors(self):
if self.dots or self.showAll:
self.stream.writeln()
log("=" * 70)
log("=== TESTS FINISHED " + ("=" * 51))
log("=" * 70 + "\n")
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)
def printErrorList(self, flavour, errors):
if self.no_colour_output:
colour = self.colours[None]
else:
colour = self.colours[flavour.lower()]
for test, err in errors:
self.stream.writeln(self.separator1)
title = '%s: %s' % (flavour, self.getLongDescription(test))
self.stream.writeln(colour(title))
self.stream.writeln(self.separator2)
if pygments_loaded:
self.stream.writeln(highlight(err, self.lexer, self.formatter))
else:
self.stream.writeln(err)
####
def _get_err_info(self, err):
"""Converts a sys.exc_info() into a string."""
exctype, value, tback = err
msg_lines = traceback.format_exception_only(exctype, value)
msg_lines = [x.replace('\n', ' ') for x in msg_lines]
return ''.join(msg_lines)
####
def _is_test_of_type_ssttestcase(self, test):
""" Detirmine if this is is within a valid SSTTestCase object by
checking if a unique SSTTestCase function exists
return: True if this is a test within a valid SSTTestCase object
"""
return getattr(test, 'get_testcase_name', None) is not None
