pytest-better-report 1.0.0__py3-none-any.whl

pytest_better_report/__init__.py

@@ -0,0 +1,3 @@
+from pytest_better_report.const import EXECUTION_RESULTS_FILENAME, LOGGER_NAME, TEST_RESULTS_FILENAME
+
+__all__ = ["EXECUTION_RESULTS_FILENAME", "LOGGER_NAME", "TEST_RESULTS_FILENAME"]

pytest_better_report/compare.py

@@ -0,0 +1,191 @@
+"""
+CLI tool to compare two better-report JSON log files.
+
+Checks if all pytest_test_name entries are equal, lists missing tests from each file,
+and for matching tests compares their test_status and lists all diffs.
+
+Usage:
+    python better_report_compare.py -a <file_a.json> -b <file_b.json> [--fail-on-diff]
+"""
+
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from python_base_command import BaseCommand, CommandError, CommandParser
+
+PASS_SYMBOL = "✓"
+FAIL_SYMBOL = "✗"
+DIFF_SYMBOL = "≠"
+
+SEP = "─" * 100
+
+
+def _log_missing(missing: list[str], source: str, target: str) -> None:
+    if missing:
+        print(f"\n{FAIL_SYMBOL}  Tests in {source} but MISSING from {target}  ({len(missing)})")
+        for name in missing:
+            print(f"     - {name}")
+    else:
+        print(f"\n{PASS_SYMBOL}  No tests missing from {target}")
+
+
+def _log_status_diffs(status_diffs: list[tuple[str, str, str]]) -> None:
+    if status_diffs:
+        col_w = max(len(name) for name, _, _ in status_diffs)
+        print(f"\n{DIFF_SYMBOL}  Status differences in common tests  ({len(status_diffs)})")
+        print(f"     {'TEST NAME':<{col_w}}  {'STATUS IN A':<12}  STATUS IN B")
+        print("     " + "-" * (col_w + 28))
+        for name, s_a, s_b in status_diffs:
+            print(f"     {name:<{col_w}}  {s_a:<12}  {s_b}")
+    else:
+        print(f"\n{PASS_SYMBOL}  All common tests have identical statuses")
+
+
+@dataclass(frozen=True)
+class ComparisonSummary:
+    file_a: Path
+    file_b: Path
+    total_a: int
+    total_b: int
+    common_count: int
+    only_in_a: list[str]
+    only_in_b: list[str]
+    status_diffs: list[tuple[str, str, str]]
+    test_file_name: str | None = None
+
+    @property
+    def identical(self) -> bool:
+        return not (self.only_in_a or self.only_in_b or self.status_diffs)
+
+
+def _log_summary(summary: ComparisonSummary) -> None:
+    print(f"\n{SEP}")
+    print("  BETTER-REPORT COMPARISON")
+    print(SEP)
+    print(f"  File A : {summary.file_a}")
+    print(f"  File B : {summary.file_b}")
+    if summary.test_file_name:
+        print(f"  Filter : test_file_name = {summary.test_file_name}")
+    print(f"  Tests  : {summary.total_a} in A  |  {summary.total_b} in B  |  {summary.common_count} in common")
+    print(SEP)
+
+    _log_missing(summary.only_in_a, source="A", target="B")
+    _log_missing(summary.only_in_b, source="B", target="A")
+    _log_status_diffs(summary.status_diffs)
+
+    print(f"\n{SEP}")
+    if not summary.identical:
+        print("  RESULT: DIFFERENCES FOUND")
+    else:
+        print("  RESULT: REPORTS ARE IDENTICAL")
+    print(f"{SEP}\n")
+
+
+def load_report(path: Path, test_file_name: str | None = None) -> dict[str, dict]:
+    with open(path) as f:
+        raw = json.load(f)
+    indexed: dict[str, dict] = {}
+    for entry in raw.values():
+        if test_file_name and entry.get("test_file_name") != test_file_name:
+            continue
+        if pytest_name := entry.get("pytest_test_name"):
+            indexed[pytest_name] = entry
+    return indexed
+
+
+def compare_reports(file_a: Path, file_b: Path, test_file_name: str | None = None) -> bool:
+    report_a = load_report(file_a, test_file_name)
+    report_b = load_report(file_b, test_file_name)
+
+    names_a = set(report_a.keys())
+    names_b = set(report_b.keys())
+
+    only_in_a = sorted(names_a - names_b)
+    only_in_b = sorted(names_b - names_a)
+    common = sorted(names_a & names_b)
+
+    status_diffs = [
+        (name, report_a[name]["test_status"], report_b[name]["test_status"])
+        for name in common
+        if report_a[name].get("test_status") != report_b[name].get("test_status")
+    ]
+
+    summary = ComparisonSummary(
+        file_a=file_a,
+        file_b=file_b,
+        total_a=len(names_a),
+        total_b=len(names_b),
+        common_count=len(common),
+        only_in_a=only_in_a,
+        only_in_b=only_in_b,
+        status_diffs=status_diffs,
+        test_file_name=test_file_name,
+    )
+    _log_summary(summary=summary)
+    return summary.identical
+
+
+class Command(BaseCommand):
+    help = "Compare two better-report JSON log files for test coverage and status differences."
+    version = "1.0.0"
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "-a",
+            "--file-a",
+            type=Path,
+            required=True,
+            help="Path to the first better-report JSON file.",
+        )
+        parser.add_argument(
+            "-b",
+            "--file-b",
+            type=Path,
+            required=True,
+            help="Path to the second better-report JSON file.",
+        )
+        parser.add_argument(
+            "--fail-on-diff",
+            action="store_true",
+            default=False,
+            help="Exit with non-zero code if any differences are found.",
+        )
+        parser.add_argument(
+            "--test-file-name",
+            type=str,
+            required=False,
+            default=None,
+            help="Filter comparison to tests belonging to this test_file_name "
+            "(e.g. test_advertiser_services_missing.py).",
+        )
+
+    def handle(self, **kwargs: Any) -> None:
+        file_a: Path = kwargs["file_a"]
+        file_b: Path = kwargs["file_b"]
+        fail_on_diff: bool = kwargs["fail_on_diff"]
+        test_file_name: str | None = kwargs.get("test_file_name")
+
+        for label, path in (("A", file_a), ("B", file_b)):
+            if not path.exists():
+                raise FileNotFoundError(f"File {label} not found: {path}")
+
+        identical = compare_reports(file_a, file_b, test_file_name)
+
+        if fail_on_diff and not identical:
+            raise CommandError("Reports have differences.")
+
+
+def main() -> None:
+    """Entry point: run the compare command from CLI."""
+    print('Starting "Better Report Compare"')
+
+    os.environ["PYTHON_BASE_COMMAND_LOG_FILE"] = "false"
+    Command().run_from_argv(argv=sys.argv)
+
+
+if __name__ == "__main__":
+    main()

pytest_better_report/const.py

@@ -0,0 +1,8 @@
+LOGGER_NAME = "pytest_better_report"
+
+EXECUTION_RESULTS_FILENAME = "execution_results.json"
+TEST_RESULTS_FILENAME = "test_results.json"
+MD_REPORT_FILENAME = "test_report.md"
+OUTPUT_DIR_NAME = "results_output"
+
+REPORTER_PLUGIN_NAME = "better-report-reporter"

pytest_better_report/models/__init__.py

@@ -0,0 +1,5 @@
+from pytest_better_report.models.execution_data import ExecutionData
+from pytest_better_report.models.status import ExecutionStatus
+from pytest_better_report.models.test_data import TestData
+
+__all__ = ["ExecutionStatus", "ExecutionData", "TestData"]

pytest_better_report/models/environment_data.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class EnvironmentData:
+    python_version: str | None
+    platform: str | None

pytest_better_report/models/execution_data.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+from pytest_better_report.models.status import ExecutionStatus
+
+
+@dataclass
+class ExecutionData:
+    execution_status: ExecutionStatus
+    revision: str | None
+    execution_start_time: str | None = None
+    execution_end_time: str | None = None
+    execution_duration_sec: str | None = None
+
+    repo_name: str | None = None
+    pull_request_number: str | None = None
+    merge_request_number: str | None = None
+    pipeline_number: str | None = None
+    commit: str | None = None
+
+    test_list: list | None = None

pytest_better_report/models/status.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class ExecutionStatus(StrEnum):
+    COLLECTED = "collected"
+    STARTED = "started"
+    PENDING = "pending"
+    PASSED = "passed"
+    FAILED = "failed"
+    XFAIL = "xfailed"
+    XPASS = "xpassed"
+    CANCELLED = "cancelled"
+    SKIPPED = "skipped"

pytest_better_report/models/test_data.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+from pytest_better_report.models.status import ExecutionStatus
+
+
+@dataclass
+class TestData:
+    __test__ = False  # a data model, not a test class (stops pytest from trying to collect it)
+
+    test_file_name: str
+    class_test_name: str | None
+    test_name: str
+    pytest_test_name: str
+    test_full_name: str
+    test_full_path: str
+    test_status: ExecutionStatus = ExecutionStatus.COLLECTED
+    test_parameters: dict[str, object] | None = None
+    test_markers: list | None = None
+    test_start_time: str | None = None
+    test_end_time: str | None = None
+    test_duration_sec: float | None = None  # only for the tst itself, not including fixtures
+    exception_message: dict | None = None
+    run_index: int | None = None
+    test_user_properties: dict[str, object] | None = None

pytest_better_report/plugin.py

@@ -0,0 +1,324 @@
+"""Structured JSON (and optional Markdown) reporting of a pytest run: ``--better-report``.
+
+Without ``--better-report`` the reporter is never registered, so none of its hooks run.
+
+How results are recorded:
+- A test's status is decided from pytest's **final** reports (``pytest_runtest_logreport``), after every plugin has
+  finished changing them (e.g. one that converts failures into skips), so the result doesn't depend on plugin
+  load order.
+- The exception details come from the raw call information, captured in a plain ``pytest_runtest_makereport``
+  wrapper. It never reads or decides the outcome there, only the exception, so its order doesn't matter either.
+- All state lives on a reporter object created for each run, so nothing leaks between runs in the same process.
+"""
+
+import json
+import platform
+import sys
+from collections.abc import Generator
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import pytest
+from custom_python_logger import get_logger
+from python_base_toolkit.utils.data_serialization import default_serialize
+
+from pytest_better_report.const import (
+    EXECUTION_RESULTS_FILENAME,
+    LOGGER_NAME,
+    MD_REPORT_FILENAME,
+    OUTPUT_DIR_NAME,
+    REPORTER_PLUGIN_NAME,
+    TEST_RESULTS_FILENAME,
+)
+from pytest_better_report.models import ExecutionData, ExecutionStatus, TestData
+from pytest_better_report.models.environment_data import EnvironmentData
+from pytest_better_report.utils.create_report import generate_md_report
+from pytest_better_report.utils.helper import save_as_json, save_as_markdown
+from pytest_better_report.utils.pytest_helper import (
+    get_pytest_test_name,
+    get_test_full_name,
+    get_test_full_path,
+    get_test_name_without_parameters,
+)
+
+logger = get_logger(f"{LOGGER_NAME}.better_report")
+
+_PASSING_STATUSES = (
+    ExecutionStatus.COLLECTED,
+    ExecutionStatus.PASSED,
+    ExecutionStatus.SKIPPED,
+    ExecutionStatus.XFAIL,
+)
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    parser.addoption(
+        "--better-report",
+        action="store_true",
+        default=False,
+        help="Enable the pytest-better-report plugin",
+    )
+    parser.addoption(
+        "--output-dir",
+        type=Path,
+        action="store",
+        default=None,
+        help="Directory to save the results and reports",
+    )
+    parser.addoption("--traceback", action="store_true", default=False, help="Enable detailed traceback in the report")
+    parser.addoption(
+        "--md-report", action="store_true", default=False, help="Generate a markdown report of the test results"
+    )
+    parser.addoption("--repo-name", action="store", default=None, help="Git Repository Name")
+    parser.addoption("--pr-number", action="store", default=None, help="Pull Request Number")
+    parser.addoption("--mr-number", action="store", default=None, help="Merge Request Number")
+    parser.addoption("--pipeline-number", action="store", default=None, help="CI Pipeline Number")
+    parser.addoption(
+        "--commit",
+        action="store",
+        default=None,
+        help="Commit Hash (SHA-1) of the repository at the time of test execution",
+    )
+    parser.addoption(
+        "--add-parameters",
+        action="store_true",
+        default=None,
+        help='Add the test parameters as fields to the "test_results.json" file',
+    )
+    parser.addoption(
+        "--pytest-command",
+        action="store_true",
+        default=None,
+        help='Add the detailed information about the pytest command-line to the "execution_results.json" file',
+    )
+    parser.addoption(
+        "--pytest-xfail-strict",
+        action="store_true",
+        default=False,
+        help="Enable strict xfail handling, treating unexpected passes as failures, if set to True "
+        '"execution status" will be "failed" when there is at least one xpass test',
+    )
+    parser.addoption(
+        "--result-each-test",
+        action="store_true",
+        default=False,
+        help="Print the pytest result for each test after its execution",
+    )
+    parser.addoption(
+        "--log-collected-tests",
+        action="store_true",
+        default=False,
+        help="Log all collected tests at the start of the test session",
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config: pytest.Config) -> None:
+    if not config.getoption("--better-report"):
+        return
+
+    if config.option.output_dir:
+        config.option.output_dir = config.option.output_dir / OUTPUT_DIR_NAME
+    else:
+        config.option.output_dir = Path(OUTPUT_DIR_NAME)
+
+    config.pluginmanager.register(BetterReporter(config=config), REPORTER_PLUGIN_NAME)
+
+
+def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
+    # Gated by its own flag, independent of --better-report (as it always was).
+    if not config.getoption("--log-collected-tests"):
+        return
+
+    for item in items:
+        logger.debug(f"Collected test: {get_test_full_name(item=item)}")
+
+
+def _iso(timestamp: float) -> str:
+    return datetime.fromtimestamp(timestamp, UTC).isoformat()
+
+
+def _status_from_report(report: pytest.TestReport) -> ExecutionStatus | None:
+    """The status a single phase report implies, or None if it doesn't change the test's status."""
+    if hasattr(report, "wasxfail") and report.skipped:
+        return ExecutionStatus.XFAIL
+    if hasattr(report, "wasxfail") and report.passed:
+        return ExecutionStatus.XPASS
+    if report.failed:
+        return ExecutionStatus.FAILED
+    if report.skipped:
+        return ExecutionStatus.SKIPPED
+    if report.when == "call" and report.passed:
+        return ExecutionStatus.PASSED
+    return None
+
+
+class BetterReporter:
+    """Registered only when ``--better-report`` is set; one instance per run holds all of the run's state."""
+
+    def __init__(self, config: pytest.Config) -> None:
+        self._config = config
+        self.execution_results: dict[str, Any] = {}
+        self.test_results: dict[str, TestData] = {}
+        self._full_names: dict[str, str] = {}  # nodeid -> key in test_results
+        self._setup_stop: dict[str, float] = {}
+        self._tests_started = False
+
+    def _get_test_data(self, nodeid: str) -> TestData | None:
+        if (full_name := self._full_names.get(nodeid)) is None:
+            return None
+        return self.test_results.get(full_name)
+
+    def pytest_sessionstart(self, session: pytest.Session) -> None:
+        logger.info("Better report plugin enabled.")
+        logger.info(f"Output directory set to: {session.config.option.output_dir}")
+
+        self.execution_results["environment_info"] = EnvironmentData(
+            python_version=platform.python_version(),
+            platform=platform.platform(),
+        )
+        self.execution_results["execution_info"] = ExecutionData(
+            execution_status=ExecutionStatus.STARTED,
+            revision=datetime.now(UTC).strftime("%Y%m%d%H%M%S%f"),
+            execution_start_time=datetime.now(UTC).isoformat(),
+            repo_name=session.config.getoption("--repo-name", None),
+            pull_request_number=session.config.getoption("--pr-number", None),
+            merge_request_number=session.config.getoption("--mr-number", None),
+            pipeline_number=session.config.getoption("--pipeline-number", None),
+            commit=session.config.getoption("--commit", None),
+        )
+        if session.config.getoption("--pytest-command"):
+            self.execution_results["pytest_command"] = {
+                "real_cli": sys.argv,
+                "ini_addopts": session.config.getini("addopts"),
+                "raw_args": session.config.invocation_params.args,
+            }
+
+    def pytest_collection_finish(self, session: pytest.Session) -> None:
+        add_parameters = session.config.getoption("--add-parameters")
+        for item in session.items:
+            test_full_name = get_test_full_name(item=item)
+            has_callspec_params = bool(getattr(item, "callspec", None) and getattr(item.callspec, "params", None))
+            self._full_names[item.nodeid] = test_full_name
+            self.test_results[test_full_name] = TestData(
+                class_test_name=item.cls.__name__ if item.cls else None,
+                test_name=get_test_name_without_parameters(item=item),
+                pytest_test_name=get_pytest_test_name(item=item),
+                test_full_name=test_full_name,
+                test_full_path=get_test_full_path(item=item),
+                test_file_name=item.path.name,
+                test_parameters=item.callspec.params if has_callspec_params else None,
+                test_markers=[marker.name for marker in item.iter_markers() if not marker.args],
+                test_status=ExecutionStatus.COLLECTED,
+                test_start_time=None,
+                run_index=len(self.test_results) + 1,
+            )
+            if has_callspec_params and add_parameters:
+                self.test_results[test_full_name].__dict__.update(**item.callspec.params)
+        logger.debug(
+            f"Tests to be executed: \n{json.dumps(list(self.test_results.keys()), indent=4, default=default_serialize)}"
+        )
+
+    # Not tryfirst, and it never reads report.outcome: it only captures the raw exception of each phase.
+    @pytest.hookimpl(wrapper=True)
+    def pytest_runtest_makereport(
+        self, item: pytest.Item, call: pytest.CallInfo[None]
+    ) -> Generator[None, pytest.TestReport, pytest.TestReport]:
+        report = yield
+        if (test_item := self._get_test_data(item.nodeid)) is None:
+            return report
+
+        if call.excinfo is None:
+            if call.when == "call":
+                test_item.exception_message = None
+            return report
+
+        # The first failing phase wins: a teardown error doesn't hide the call's failure.
+        if call.when != "teardown" or test_item.exception_message is None:
+            test_item.exception_message = _exception_message(
+                call=call, with_traceback=item.config.getoption("--traceback")
+            )
+        return report
+
+    def pytest_runtest_logreport(self, report: pytest.TestReport) -> None:
+        if (test_item := self._get_test_data(report.nodeid)) is None:
+            logger.warning(f"Test {report.nodeid} missing in test_results")
+            return
+
+        if report.when == "setup":
+            self._tests_started = True
+            self._setup_stop[report.nodeid] = report.stop
+            test_item.test_start_time = _iso(report.stop)
+
+        if (status := _status_from_report(report)) is not None:
+            test_item.test_status = status
+
+        if report.when != "teardown":
+            return
+
+        test_item.test_end_time = _iso(report.start)
+        if (setup_stop := self._setup_stop.pop(report.nodeid, None)) is not None:
+            test_item.test_duration_sec = report.start - setup_stop
+        if report.user_properties:
+            test_item.test_user_properties = dict(report.user_properties)
+
+        if self._config.getoption("--result-each-test"):
+            logger.debug(f"Test Results: \n{json.dumps(test_item, indent=4, default=default_serialize)}")
+
+    def pytest_sessionfinish(self, session: pytest.Session, exitstatus: int) -> None:
+        if session.config.option.collectonly or not self._tests_started:
+            return
+
+        self._finalize_execution_info(config=session.config)
+        output_dir: Path = session.config.option.output_dir
+        output_dir.mkdir(parents=True, exist_ok=True)
+        save_as_json(
+            path=output_dir / EXECUTION_RESULTS_FILENAME, data=self.execution_results, default=default_serialize
+        )
+        save_as_json(path=output_dir / TEST_RESULTS_FILENAME, data=self.test_results, default=default_serialize)
+        logger.info(f"Better report: Execution results saved to {output_dir / EXECUTION_RESULTS_FILENAME}")
+        logger.info(f"Better report: Test results saved to {output_dir / TEST_RESULTS_FILENAME}")
+
+        logger.info(f"Test session finished with exit status: {exitstatus}")
+        if exitstatus != 0:
+            failed_tests = [v for v in self.test_results.values() if v.test_status == ExecutionStatus.FAILED]
+            logger.debug(f"Failed tests: {json.dumps(failed_tests, indent=4, default=default_serialize)}")
+
+        if session.config.getoption("--md-report"):
+            res_md = generate_md_report(report=json.loads(json.dumps(self.test_results, default=default_serialize)))
+            save_as_markdown(path=output_dir / MD_REPORT_FILENAME, data=res_md)
+
+    def _finalize_execution_info(self, config: pytest.Config) -> None:
+        exec_info: ExecutionData = self.execution_results["execution_info"]
+        exec_info.execution_end_time = datetime.now(UTC).isoformat()
+        start = datetime.fromisoformat(exec_info.execution_start_time)
+        end = datetime.fromisoformat(exec_info.execution_end_time)
+        exec_info.execution_duration_sec = (end - start).total_seconds()
+
+        passing_statuses = list(_PASSING_STATUSES)
+        if not config.getoption("--pytest-xfail-strict"):
+            passing_statuses.append(ExecutionStatus.XPASS)
+        all_passed = all(t.test_status in passing_statuses for t in self.test_results.values())
+        exec_info.execution_status = ExecutionStatus.PASSED if all_passed else ExecutionStatus.FAILED
+        exec_info.test_list = list(self.test_results.keys())
+
+
+def _exception_message(call: pytest.CallInfo[None], with_traceback: bool) -> dict[str, Any]:
+    excinfo = call.excinfo
+    message = str(excinfo.value).split("\nassert", maxsplit=1)[0]
+    # A test can raise with a JSON object as its message to record structured data; anything else is plain text.
+    try:
+        parsed = json.loads(message)
+    except json.JSONDecodeError:
+        parsed = None
+    exception_message: dict[str, Any] = (
+        parsed if isinstance(parsed, dict) else {"exception_type": excinfo.typename, "message": message}
+    )
+
+    if with_traceback:
+        exception_message["traceback"] = {
+            "repr_crash": excinfo.getrepr().reprcrash,
+            "traceback": [str(frame.path) for frame in excinfo.traceback],
+        }
+    return exception_message

pytest_better_report/utils/create_report.py

@@ -0,0 +1,38 @@
+import json
+
+
+def _format_message(exception_message: dict | None) -> str:
+    if not exception_message:
+        return "-"
+    if "message" in exception_message:
+        return str(exception_message["message"])
+    # A test raised with a JSON object as its message: show the object itself (without the traceback).
+    return json.dumps({key: value for key, value in exception_message.items() if key != "traceback"})
+
+
+def generate_md_report(report: dict) -> str:
+    status_icons = {
+        "passed": "✅",
+        "failed": "❌",
+        "xpassed": "✅",
+        "xfailed": "❌",
+        "skipped": "⏭️",
+        "collected": "📋",
+    }
+    rows = ["| No. | Test Name | Status | Duration | Message |", "|:---:|-----------|:------:|:--------:|---------|"]
+    stats = dict.fromkeys(status_icons, 0)
+    for index, test in enumerate(report.values(), start=1):
+        status = test["test_status"]
+        stats[status] = stats.get(status, 0) + 1  # an unexpected status is counted, not a KeyError
+        name = test["test_full_name"]
+        icon = status_icons.get(status, status)
+        duration_sec = test["test_duration_sec"]
+        duration = f"{duration_sec:.2f}s" if duration_sec is not None else "-"
+        msg = _format_message(exception_message=test["exception_message"])
+        rows.append(f"|{index}| `{name}` | {icon} {status} | {duration} | `{msg}` |")
+
+    total_summary = f"\n🧪 Total: {len(report)}   |   " + "   |   ".join(
+        f"{icon} {k.capitalize()}: {v}" for k, v in stats.items() for icon in (status_icons.get(k, ""),)
+    )
+
+    return "## ✅ Test Report Summary\n\n" + "\n".join(rows) + f"\n<br> \n\n### Summary: <br> \n{total_summary}"

pytest_better_report/utils/helper.py

@@ -0,0 +1,44 @@
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+from custom_python_logger import get_logger
+from python_base_toolkit.utils.data_serialization import default_serialize
+
+from pytest_better_report.const import LOGGER_NAME
+
+logger = get_logger(f"{LOGGER_NAME}")
+
+
+def get_project_root(marker: str = ".git") -> Path | None:
+    path = Path(__file__).resolve()
+    for parent in path.parents:
+        if (parent / marker).exists():
+            return parent
+    return None
+
+
+def serialize_data(obj: object) -> object:  # default_serialize
+    return default_serialize(obj=obj)
+
+
+def open_json(path: Path) -> dict:
+    with open(path, encoding="utf-8") as json_file:
+        return json.load(json_file)
+
+
+def save_as_json(path: Path, data: dict, default: Callable | None = None) -> None:
+    if not path.parent.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(path, "w", encoding="utf-8") as json_file:
+        text = json.dumps(data, indent=4, default=default) if default else json.dumps(data, indent=4)
+        json_file.write(text)
+
+
+def save_as_markdown(path: Path, data: str) -> None:
+    if not path.parent.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(path, "w", encoding="utf-8") as md_file:
+        md_file.write(data)

pytest_better_report/utils/pytest_helper.py

@@ -0,0 +1,28 @@
+from _pytest.python import Function
+
+
+def get_test_path_without_parameters(item: Function) -> str:
+    """Get the test name without parameters."""
+    return item.nodeid.split("[")[0]
+
+
+def get_test_name_without_parameters(item: Function) -> str:
+    """Get the test name without parameters."""
+    return item.nodeid.split(".py::")[-1].split("[")[0]
+
+
+def get_pytest_test_name(item: Function) -> str:
+    """Get the test name without parameters."""
+    return item.nodeid.split(".py::")[-1]
+
+
+def get_test_full_name(item: Function) -> str:
+    """Get the full name of the test, including parameters if available."""
+    test_name = get_test_name_without_parameters(item=item)
+    return f"{test_name}[{item.callspec.params}]" if getattr(item, "callspec", None) else test_name
+
+
+def get_test_full_path(item: Function) -> str:
+    """Get the full name of the test, including parameters if available."""
+    test_name = get_test_path_without_parameters(item=item)
+    return f"{test_name}[{item.callspec.params}]" if getattr(item, "callspec", None) else test_name

pytest_better_report-1.0.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: pytest-better-report
+Version: 1.0.0
+Summary: A pytest plugin that writes structured JSON (and optional Markdown) reports of every run, with CI metadata and a CLI to compare two runs.
+Author: Avi Zaguri
+License: MIT
+Project-URL: Homepage, https://github.com/aviz92/pytest-better-report
+Project-URL: Repository, https://github.com/aviz92/pytest-better-report
+Project-URL: Issues, https://github.com/aviz92/pytest-better-report/issues
+Keywords: pytest,plugin,testing,report,json,markdown,ci
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: custom-python-logger>=4.1.0
+Requires-Dist: pytest>=9.2.0
+Requires-Dist: python-base-command>=0.1.8
+Requires-Dist: python-base-toolkit>=1.1.2
+Dynamic: license-file
+
+![PyPI version](https://img.shields.io/pypi/v/pytest-better-report)
+![Python](https://img.shields.io/badge/python->=3.12-blue)
+![Development Status](https://img.shields.io/badge/status-stable-green)
+![Maintenance](https://img.shields.io/maintenance/yes/2026)
+![PyPI](https://img.shields.io/pypi/dm/pytest-better-report)
+![License](https://img.shields.io/pypi/l/pytest-better-report)
+
+---
+
+# 💡 pytest-better-report
+A pytest plugin that writes a structured report of every run: a JSON file per test, a JSON file for the run with CI
+metadata (repo, PR/MR, pipeline, commit), and an optional Markdown summary. Includes a CLI to compare two runs.
+
+---
+
+## 📦 Installation
+```bash
+uv add pytest-better-report
+```
+
+---
+
+## 🚀 Features
+  - ✅ **Structured JSON** — `test_results.json` (one entry per test) and `execution_results.json` (the run)
+  - ✅ **CI traceability** — repo name, PR / MR number, pipeline number and commit in the run report
+  - ✅ **Markdown summary** — a table of every test with status, duration and message
+  - ✅ **Structured failure data** — raise with a JSON object as the message to record it as data
+  - ✅ **Compare two runs** — `better_report_compare` lists missing tests and status differences
+  - ✅ **Plays well with other plugins** — statuses come from pytest's final reports, whatever the plugin order
+  - ✅ **Zero footprint without the flag** — nothing is registered, no hook runs
+
+---
+
+## 🛠️ How to Use
+```bash
+pytest --better-report --md-report --pr-number=123 --commit="$GIT_SHA"
+```
+Files are written to `results_output/` (or `<output-dir>/results_output/`):
+
+| File | Content |
+|---|---|
+| `test_results.json` | One entry per test: name, file, class, parameters, markers, status, times, exception, user properties |
+| `execution_results.json` | The run: status, start / end / duration, CI metadata, environment, optionally the pytest command |
+| `test_report.md` | With `--md-report`: a table of all tests and a summary by status |
+
+---
+
+## ⚙️ Flags
+| Flag | Description |
+|---|---|
+| `--better-report` | Enable the report |
+| `--output-dir=DIR` | Write the files to `DIR/results_output/` |
+| `--md-report` | Also write `test_report.md` |
+| `--traceback` | Add the crash location and traceback frames to each exception |
+| `--repo-name`, `--pr-number`, `--mr-number`, `--pipeline-number`, `--commit` | CI metadata for `execution_results.json` |
+| `--add-parameters` | Add each test parameter as its own field in `test_results.json` |
+| `--pytest-command` | Record the pytest command line in `execution_results.json` |
+| `--pytest-xfail-strict` | Treat an unexpected pass (XPASS) as a failure of the run |
+| `--result-each-test` | Log each test's result after it runs |
+| `--log-collected-tests` | Log every collected test at the start (works without `--better-report` too) |
+
+---
+
+## 📊 Statuses
+Each test gets one status in `test_results.json`.
+The run as a whole gets `execution_info.execution_status` in `execution_results.json`: `failed` if **at least one**
+test has a status marked "Yes" in the last column, otherwise `passed`.
+
+This is the report's own verdict on the run, written into the file. It is separate from pytest's exit code, which this
+plugin doesn't change.
+
+| Test status | Meaning | Makes `execution_status` = `failed` |
+|---|---|---|
+| `passed` | Passed | No |
+| `failed` | Failed or errored in setup, call or teardown | Yes |
+| `skipped` | Skipped (marker, fixture, or a plugin that converted the outcome) | No |
+| `xfailed` | Expected failure | No |
+| `xpassed` | Unexpected pass | Only with `--pytest-xfail-strict` |
+| `collected` | Collected but not run (e.g. the run stopped early) | No |
+
+---
+
+## ▶️ Usage Examples
+### Record structured failure data
+```python
+import json
+
+def test_api():
+    response = call_api()
+    if response.status != 200:
+        raise AssertionError(json.dumps({"status": response.status, "body": response.text}))
+```
+The exception is recorded as `{"status": ..., "body": ...}` instead of plain text.
+
+### Compare two runs
+```bash
+better_report_compare -a main/test_results.json -b branch/test_results.json --fail-on-diff
+```
+Lists tests missing from either side and tests whose status changed; exits non-zero with `--fail-on-diff` when
+there are differences. `--test-file-name` limits the comparison to one test file.
+
+---
+
+## 🔁 Migrating from pytest-plugins
+This plugin was previously `better_report` in `pytest-plugins`. Flags, file names and the JSON schema are unchanged.
+Both register the same options, so don't install them together until you're on a `pytest-plugins` release without it.
+Differences you may notice:
+- A test that errors in teardown is now `failed` (it was reported as passed).
+- The `failed-skipped` status no longer exists; converted failures are `skipped`, with the reason in `test_user_properties`.
+- The logger is named `pytest_better_report`.
+
+---
+
+## 🤝 Contributing
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-addition`
+3. Make your changes
+4. Commit your changes: `git commit -m 'Add my addition'`
+5. Push to the branch: `git push origin feature/my-addition`
+6. Open a Pull Request
+
+Additions that promote clean, productive, and maintainable development are always welcome.
+
+---
+
+## 📄 License
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+## 🙏 Thanks
+Thanks for exploring this repository! <br>
+Happy coding!
+
+[![GitHub](https://img.shields.io/badge/GitHub-aviz92-181717?logo=github)](https://github.com/aviz92)
+&nbsp; [![PyPI](https://img.shields.io/badge/PyPI-aviz-3775A9?logo=pypi)](https://pypi.org/user/aviz/)
+&nbsp; [![Blog](https://img.shields.io/badge/Blog-aviz92.github.io-0066CC?logo=googlechrome)](https://aviz92.github.io/)
+&nbsp; [![LinkedIn](https://img.shields.io/badge/LinkedIn-avi--zaguri-0A66C2?logo=linkedin)](https://www.linkedin.com/in/avi-zaguri-41869b11b)

pytest_better_report-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+pytest_better_report/__init__.py,sha256=6CjdXPlwznDcEFpfDMEH7KZGveNvziuEb5MRSMziplA,184
+pytest_better_report/compare.py,sha256=pj4ynKT0zsRaJONueY81MiummdoJoLFR7WaNYwmz7q4,6003
+pytest_better_report/const.py,sha256=Uv8geS601qFxIMiiJvo5_2QVibG_NmUQVjtXQ75S26k,258
+pytest_better_report/plugin.py,sha256=XoXO9O9hJvPr_T0SPnEm64C9wR8wiEMLz3cywXsKfgw,14170
+pytest_better_report/models/__init__.py,sha256=X6GwVDzXndlui_5sDNfwnkty8saeltmf-hy3GYr_fVw,251
+pytest_better_report/models/environment_data.py,sha256=OMezmiFttnpwQKY53YSlfdRXncChO7jzUhXQVWEsPz4,126
+pytest_better_report/models/execution_data.py,sha256=IyTGdNg1ahehNyO8CoraDRxutUqQkGfJqXRFcoMYSMU,552
+pytest_better_report/models/status.py,sha256=RXKkfy4zJQufOlQZjcbJLbxDwVEQ9KDr8CepVU0Dh6Y,275
+pytest_better_report/models/test_data.py,sha256=xJriKroMEy4kgVr2ywtbzCxN0GLtNybnxY-Rt8mOe6Y,827
+pytest_better_report/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_better_report/utils/create_report.py,sha256=JDlL5I2T3JxTHaIalUwKq2WbTQ9ur36vVNUFX9vVqgc,1726
+pytest_better_report/utils/helper.py,sha256=YI4E0fHZFzPZy-Mf4-gUKfBS4KczUzP2JNXr5iUGbjc,1314
+pytest_better_report/utils/pytest_helper.py,sha256=Nkzz8p8277GgYpv47TJeN1381WXoF24Mph0Uf-937_g,1062
+pytest_better_report-1.0.0.dist-info/licenses/LICENSE,sha256=cSikHY6SZFsPZSBizCDAJ0-Bjjzxt-JtX6TVbKxwimo,1067
+pytest_better_report-1.0.0.dist-info/METADATA,sha256=s-n0txzFp0k7FGxJwiUJ-WUhIk2D76AZKjTtvC-u4NI,6963
+pytest_better_report-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pytest_better_report-1.0.0.dist-info/entry_points.txt,sha256=CSkW_An0_xj_uVsqD8XYDc-4h-1VgHuW38nRqadqdDw,132
+pytest_better_report-1.0.0.dist-info/top_level.txt,sha256=Q6-6WF0ZWDa2MrrIs7gcl15WBMl6GXspjFb36n3ipBY,21
+pytest_better_report-1.0.0.dist-info/RECORD,,

pytest_better_report-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_better_report-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+better_report_compare = pytest_better_report.compare:main
+
+[pytest11]
+better_report = pytest_better_report.plugin

pytest_better_report-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Avi Zaguri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_better_report-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_better_report