probatio 0.2.0 → 0.5.0

package/dist/mutate/py-pytest-reporter.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""Run pytest and print one Probatio report as a single JSON line.
-
-When PROBATIO_COVERAGE_MAP is set and coverage.py imports, also write a
-per-test line map. A missing coverage module leaves the map unwritten.
-"""
-import json
-import os
-import sys
-
-# The sysmon core on this interpreter drops dynamic context switches.
-os.environ.setdefault("COVERAGE_CORE", "ctrace")
-
-import pytest
-
-
-class Collector:
-    def __init__(self):
-        self.names = []
-        self.failed = []
-
-    def pytest_collectreport(self, report):
-        if not report.failed:
-            return
-        self._add(getattr(report, "nodeid", "") or "pytest", report)
-
-    def pytest_runtest_logreport(self, report):
-        if report.when not in ("setup", "call"):
-            return
-        if report.when == "setup" and not report.failed:
-            return
-        name = report.nodeid
-        if report.when == "call" and name not in self.names:
-            self.names.append(name)
-        if report.failed:
-            self._add(name, report)
-
-    def _add(self, name, report):
-        if any(item["name"] == name for item in self.failed):
-            return
-        location = getattr(report, "location", None) or ("", 0, "")
-        self.failed.append({"name": name, "file": str(location[0] or ""), "line": int(location[1] or 0)})
-
-
-class ContextSwitch:
-    def __init__(self, cov):
-        self.cov = cov
-
-    def pytest_runtest_setup(self, item):
-        self.cov.switch_context(item.nodeid)
-
-
-def start_coverage():
-    dest = os.environ.get("PROBATIO_COVERAGE_MAP")
-    if not dest:
-        return None, None
-    try:
-        import coverage
-    except ImportError:
-        return None, None
-    data_file = dest + ".data"
-    try:
-        cov = coverage.Coverage(cover_pylib=False, data_file=data_file)
-        cov.start()
-        return cov, dest
-    except Exception:
-        return None, None
-
-
-def write_coverage(cov, dest):
-    try:
-        cov.stop()
-        cov.save()
-    except Exception:
-        return
-    try:
-        data = cov.get_data()
-    except Exception:
-        return
-    root = os.path.realpath(os.getcwd())
-    files = {}
-    for filename in data.measured_files():
-        full = os.path.realpath(filename)
-        if not full.startswith(root + os.sep):
-            continue
-        if "/site-packages/" in full or "/node_modules/" in full:
-            continue
-        rel = full[len(root) + 1 :]
-        try:
-            by_line = data.contexts_by_lineno(filename) or {}
-        except Exception:
-            continue
-        lines = {}
-        for lineno, contexts in by_line.items():
-            names = [item for item in contexts if item]
-            if names:
-                lines[str(lineno)] = names
-        if lines:
-            files[rel] = lines
-    with open(dest, "w", encoding="utf-8") as handle:
-        json.dump({"files": files}, handle)
-        handle.write("\n")
-
-
-def main():
-    args = []
-    index = 1
-    while index < len(sys.argv):
-        if sys.argv[index] == "--pattern":
-            args.extend(["-k", sys.argv[index + 1]])
-            index += 2
-            continue
-        args.append(sys.argv[index])
-        index += 1
-    cov, dest = start_coverage()
-    collector = Collector()
-    plugins = [collector]
-    if cov is not None:
-        plugins.append(ContextSwitch(cov))
-    code = 1
-    try:
-        code = pytest.main([*args, "-p", "no:cacheprovider", "--tb=no", "-q"], plugins=plugins) or 0
-    except BaseException:
-        code = 1
-    finally:
-        if cov is not None and dest:
-            write_coverage(cov, dest)
-    names = collector.names or [item["name"] for item in collector.failed]
-    failed = collector.failed
-    # Exit 4 is a usage error (a bad -k expression). No test ran, so this is not a kill.
-    if not names and code != 0:
-        names = []
-        failed = []
-    report = {
-        "tests": len(names),
-        "pass": len(names) - len(failed),
-        "fail": len(failed),
-        "failed": failed,
-        "names": names,
-    }
-    sys.stdout.write(json.dumps(report) + "\n")
-
-
-if __name__ == "__main__":
-    main()

package/dist/mutate/py-reporter.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""Run unittest modules and print one Probatio report as a single JSON line."""
-import importlib.util
-import json
-import os
-import re
-import sys
-import unittest
-from pathlib import Path
-
-
-def load(path: Path):
-    name = f"probatio_{path.stem}"
-    spec = importlib.util.spec_from_file_location(name, path)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"cannot load {path}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def walk(suite):
-    for item in suite:
-        if isinstance(item, unittest.TestSuite):
-            yield from walk(item)
-        else:
-            yield item
-
-
-def parse_args(argv):
-    pattern = None
-    files = []
-    index = 0
-    while index < len(argv):
-        if argv[index] == "--pattern":
-            pattern = argv[index + 1]
-            index += 2
-            continue
-        files.append(argv[index])
-        index += 1
-    return pattern, files
-
-
-def main():
-    pattern, files = parse_args(sys.argv[1:])
-    sys.path.insert(0, str(Path.cwd()))
-    loader = unittest.TestLoader()
-    suite = unittest.TestSuite()
-    compiled = re.compile(pattern) if pattern else None
-    for file in files:
-        loaded = loader.loadTestsFromModule(load(Path(file)))
-        if compiled is None:
-            suite.addTest(loaded)
-        else:
-            for case in walk(loaded):
-                if compiled.fullmatch(case.id()):
-                    suite.addTest(case)
-    cases = [case for case in walk(suite) if case is not None]
-    names = [case.id() for case in cases]
-    with open(os.devnull, "w") as stream:
-        result = unittest.TextTestRunner(stream=stream, verbosity=0).run(suite)
-    failed = []
-    for case, tb in list(result.failures) + list(result.errors):
-        frames = re.findall(r'File "([^"]+)", line (\d+)', tb)
-        file, line = frames[-1] if frames else ("", "0")
-        failed.append({"name": case.id(), "file": file, "line": int(line)})
-    report = {
-        "tests": len(names),
-        "pass": len(names) - len(failed),
-        "fail": len(failed),
-        "failed": failed,
-        "names": names,
-    }
-    sys.stdout.write(json.dumps(report) + "\n")
-
-
-if __name__ == "__main__":
-    main()