golden hour

/opt/cloudlinux/venv/lib/python3.11/site-packages/tap

File/Folder	Size	Actions
__init__.py	85 B
__main__.py	48 B
__pycache__	-
adapter.py	1.47 KB
directive.py	1.75 KB
formatter.py	762 B
line.py	4.56 KB
loader.py	2.87 KB
main.py	2.07 KB
parser.py	6.63 KB
rules.py	3.3 KB
runner.py	4.95 KB
tests	-
tracker.py	7.4 KB

Edit: runner.py

import os
import sys
from unittest import TextTestResult, TextTestRunner
from unittest.runner import _WritelnDecorator

from tap import formatter
from tap.tracker import Tracker

class TAPTestResult(TextTestResult):
    FORMAT = None

def __init__(self, stream, descriptions, verbosity):
        super().__init__(stream, descriptions, verbosity)

def addSubTest(self, test, subtest, err):
        super().addSubTest(test, subtest, err)
        if err is not None:
            diagnostics = formatter.format_exception(err)
            self.tracker.add_not_ok(
                self._cls_name(test),
                self._description(subtest),
                diagnostics=diagnostics,
            )
        else:
            self.tracker.add_ok(self._cls_name(test), self._description(subtest))

def stopTestRun(self):  # pragma: no cover
        """Once the test run is complete, generate each of the TAP files."""
        super().stopTestRun()
        self.tracker.generate_tap_reports()

def addError(self, test, err):
        super().addError(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test), self._description(test), diagnostics=diagnostics
        )

def addFailure(self, test, err):
        super().addFailure(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test), self._description(test), diagnostics=diagnostics
        )

def addSuccess(self, test):
        super().addSuccess(test)
        self.tracker.add_ok(self._cls_name(test), self._description(test))

def addSkip(self, test, reason):
        super().addSkip(test, reason)
        self.tracker.add_skip(self._cls_name(test), self._description(test), reason)

def addExpectedFailure(self, test, err):
        super().addExpectedFailure(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test),
            self._description(test),
            "TODO {}".format("(expected failure)"),
            diagnostics=diagnostics,
        )

def addUnexpectedSuccess(self, test):
        super().addUnexpectedSuccess(test)
        self.tracker.add_ok(
            self._cls_name(test),
            self._description(test),
            "TODO {}".format("(unexpected success)"),
        )

def _cls_name(self, test):
        return test.__class__.__name__

def _description(self, test):
        if self.FORMAT:
            try:
                return self.FORMAT.format(
                    method_name=str(test),
                    short_description=test.shortDescription() or "",
                )
            except KeyError:
                sys.exit(
                    f"Bad format string: {self.FORMAT}\n"
                    "Replacement options are: {short_description} and "
                    "{method_name}"
                )

return test.shortDescription() or str(test)

# TODO: 2016-7-30 mblayman - Since the 2.6 signature is no longer relevant,
# check the possibility of removing the module level scope.

# Module level state stinks, but this is the only way to keep compatibility
# with Python 2.6. The best place for the tracker is as an instance variable
# on the runner, but __init__ is so different that it is not easy to create
# a runner that satisfies every supported Python version.
_tracker = Tracker()

class TAPTestRunner(TextTestRunner):
    """A test runner that will behave exactly like TextTestRunner and will
    additionally generate TAP files for each test case"""

resultclass = TAPTestResult

def set_stream(self, streaming):
        """Set the streaming boolean option to stream TAP directly to stdout.

The test runner default output will be suppressed in favor of TAP.
        """
        self.stream = _WritelnDecorator(open(os.devnull, "w"))  # noqa: SIM115
        _tracker.streaming = streaming
        _tracker.stream = sys.stdout

def _makeResult(self):  # pragma: no cover
        result = self.resultclass(self.stream, self.descriptions, self.verbosity)
        result.tracker = _tracker
        return result

@classmethod
    def set_outdir(cls, outdir):
        """Set the output directory so that TAP files are written to the
        specified outdir location.
        """
        # Blame the lack of unittest extensibility for this hacky method.
        _tracker.outdir = outdir

@classmethod
    def set_combined(cls, combined):
        """Set the tracker to use a single output file."""
        _tracker.combined = combined

@classmethod
    def set_header(cls, header):
        """Set the header display flag."""
        _tracker.header = header

@classmethod
    def set_format(cls, fmt):
        """Set the format of each test line.

The format string can use:
        * {method_name}: The test method name
        * {short_description}: The test's docstring short description
        """
        TAPTestResult.FORMAT = fmt