Python terminal.TerminalReporter类代码示例

 def pytest_collectreport(self, report):
     TerminalReporter.pytest_collectreport(self, report)
     if report.location[0]:
         self.paths_left.append(os.path.join(os.getcwd(), report.location[0]))
     if report.failed:
         self.rewrite("")
         self.print_failure(report)

 def __init__(self, reporter):
     TerminalReporter.__init__(self, reporter.config)
     self.writer = self._tw
     self.tests_count = 0
     self.reports = []
     self.skipped = []
     self.failed = []
     self.result = StreamResultToBytes(self.writer._file)

 def test_internalerror(self, testdir, linecomp):
     modcol = testdir.getmodulecol("def test_one(): pass")
     rep = TerminalReporter(modcol.config, file=linecomp.stringio)
     excinfo = pytest.raises(ValueError, "raise ValueError('hello')")
     rep.pytest_internalerror(excinfo.getrepr())
     linecomp.assert_contains_lines([
         "INTERNALERROR> *ValueError*hello*"
     ])

    def pytest_runtest_logreport(self, report):
        rep = report
        res = self.config.hook.pytest_report_teststatus(report=rep)
        cat, letter, word = res

        if not letter and not word:
            # probably passed setup/teardown
            return

        if isinstance(word, tuple):
            word, word_markup = word
        else:
            if rep.passed:
                word_markup = {'green': True}
            elif rep.failed:
                word_markup = {'red': True}
            elif rep.skipped:
                word_markup = {'yellow': True}
        feature_markup = {'blue': True}
        scenario_markup = word_markup

        if self.verbosity <= 0:
            return TerminalReporter.pytest_runtest_logreport(self, rep)
        elif self.verbosity == 1:
            if hasattr(report, 'scenario'):
                self.ensure_newline()
                self._tw.write('Feature: ', **feature_markup)
                self._tw.write(report.scenario['feature']['name'], **feature_markup)
                self._tw.write('\n')
                self._tw.write('    Scenario: ', **scenario_markup)
                self._tw.write(report.scenario['name'], **scenario_markup)
                self._tw.write(' ')
                self._tw.write(word, **word_markup)
                self._tw.write('\n')
            else:
                return TerminalReporter.pytest_runtest_logreport(self, rep)
        elif self.verbosity > 1:
            if hasattr(report, 'scenario'):
                self.ensure_newline()
                self._tw.write('Feature: ', **feature_markup)
                self._tw.write(report.scenario['feature']['name'], **feature_markup)
                self._tw.write('\n')
                self._tw.write('    Scenario: ', **scenario_markup)
                self._tw.write(report.scenario['name'], **scenario_markup)
                self._tw.write('\n')
                for step in report.scenario['steps']:
                    if self.config.option.expand:
                        step_name = self._format_step_name(step['name'], **report.scenario['example_kwargs'])
                    else:
                        step_name = step['name']
                    self._tw.write('        {} {}\n'.format(step['keyword'],
                                                            step_name), **scenario_markup)
                self._tw.write('    ' + word, **word_markup)
                self._tw.write('\n\n')
            else:
                return TerminalReporter.pytest_runtest_logreport(self, rep)
        self.stats.setdefault(cat, []).append(rep)

 def test_writeline(self, testdir, linecomp):
     modcol = testdir.getmodulecol("def test_one(): pass")
     rep = TerminalReporter(modcol.config, file=linecomp.stringio)
     rep.write_fspath_result(modcol.nodeid, ".")
     rep.write_line("hello world")
     lines = linecomp.stringio.getvalue().split('\n')
     assert not lines[0]
     assert lines[1].endswith(modcol.name + " .")
     assert lines[2] == "hello world"

 def test_rewrite(self, testdir, monkeypatch):
     config = testdir.parseconfig()
     f = py.io.TextIO()
     monkeypatch.setattr(f, "isatty", lambda *args: True)
     tr = TerminalReporter(config, f)
     tr._tw.fullwidth = 10
     tr.write("hello")
     tr.rewrite("hey", erase=True)
     assert f.getvalue() == "hello" + "\r" + "hey" + (6 * " ")

    def pytest_collectreport(self, report):
        """Report failure during colltion.

        :type report: :py:class:_pytest.runner.CollectReport
        """
        TerminalReporter.pytest_collectreport(self, report)

        if report.failed:
            self.report_failure(report, when='collect')

 def test_rewrite(self, testdir, monkeypatch):
     config = testdir.parseconfig()
     f = py.io.TextIO()
     monkeypatch.setattr(f, 'isatty', lambda *args: True)
     tr = TerminalReporter(config, f)
     tr.writer.fullwidth = 10
     tr.write('hello')
     tr.rewrite('hey', erase=True)
     assert f.getvalue() == 'hello' + '\r' + 'hey' + (7 * ' ')

 def __init__(self, reporter):
     TerminalReporter.__init__(self, reporter.config)
     self.writer = self._tw
     self.paths_left = []
     self.tests_count = 0
     self.tests_taken = 0
     self.reports = []
     self.unreported_errors = []
     self.progress_blocks = []
     self.reset_tracked_lines()

 def test_writeline(self, testdir, linecomp):
     modcol = testdir.getmodulecol("def test_one(): pass")
     stringio = py.io.TextIO()
     rep = TerminalReporter(modcol.config, file=linecomp.stringio)
     rep.write_fspath_result(py.path.local("xy.py"), '.')
     rep.write_line("hello world")
     lines = linecomp.stringio.getvalue().split('\n')
     assert not lines[0]
     assert lines[1].endswith("xy.py .")
     assert lines[2] == "hello world"

 def __init__(self, reporter):
     TerminalReporter.__init__(self, reporter.config)
     self.writer = self._tw
     self.paths_left = []
     self.tests_count = 0
     self.tests_taken = 0
     self.current_line = ''
     self.currentfspath2 = ''
     self.time_taken = {}
     self.reports = []
     self.unreported_errors = []

 def __init__(self, reporter):
     #pytest_collectreport = self.pytest_collectreport
     TerminalReporter.__init__(self, reporter.config)
     self.writer = self._tw
     self.eta_logger = EtaLogger()
     self.paths_left = []
     self.tests_count = 0
     self.tests_taken = 0
     self.current_line = u''
     self.currentfspath2 = ''
     self.time_taken = {}
     self.reports = []
     self.unreported_errors = []

def perform_collect_and_run(session):
    """Collect and run tests streaming from the redis queue."""
    # This mimics the internal pytest collect loop, but shortened
    # while running tests as soon as they are found.
    term = TerminalReporter(session.config)

    redis_connection = get_redis_connection(session.config)

    redis_list = populate_test_generator(session,
                                         redis_connection)


    default_verbosity = session.config.option.verbose
    hook = session.config.hook
    session._initialpaths = set()
    session._initialparts = []
    session._notfound = []
    session.items = []
    for arg in redis_list:
        term.write(os.linesep)
        parts = session._parsearg(arg)
        session._initialparts.append(parts)
        session._initialpaths.add(parts[0])
        arg = "::".join(map(str, parts))
        session.trace("processing argument", arg)
        session.trace.root.indent += 1
        try:
            for x in session._collect(arg):
                items = session.genitems(x)
                new_items = []
                for item in items:
                    new_items.append(item)

                # HACK ATTACK: This little hack lets us remove the
                # 'collected' and 'collecting' messages while still
                # keeping the default verbosity for the rest of the
                # run...
                session.config.option.verbose = -1
                hook.pytest_collection_modifyitems(session=session,
                                                   config=session.config,
                                                   items=new_items)
                session.config.option.verbose = default_verbosity
                for item in new_items:
                    session.items.append(item)
                    _pytest.runner.pytest_runtest_protocol(item, None)
        except NoMatch:
            # we are inside a make_report hook so
            # we cannot directly pass through the exception
            raise pytest.UsageError("Could not find" + arg)
        session.trace.root.indent -= 1
    return session.items

    def summary_errors(self):
      reports = self.getreports('error')
      if not reports:
        return
      for rep in self.stats['error']:
        name = rep.nodeid.split("/")[-1]
        location = None
        if hasattr(rep, 'location'):
          location, lineno, domain = rep.location

        messages.testSuiteStarted(name, location=fspath_to_url(location))
        messages.testStarted("<noname>", location=fspath_to_url(location))
        TerminalReporter.summary_errors(self)
        messages.testError("<noname>")
        messages.testSuiteFinished(name)

def redis_test_generator(config, redis_connection, redis_list_key,
                         backup_list_key=None):
    """A generator that pops and returns test paths from the redis list key."""
    term = TerminalReporter(config)

    val = retrieve_test_from_redis(redis_connection,
                                   redis_list_key,
                                   backup_list_key)

    if val is None:
        term.write("No items in redis list '%s'\n" % redis_list_key)

    while val is not None:
        yield val
        val = retrieve_test_from_redis(redis_connection,
                                       redis_list_key,
                                       backup_list_key)