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