diffcone 0.1.0__py3-none-any.whl

diffcone/report.py

@@ -0,0 +1,256 @@
+"""Human-readable and JSON reports for a plan."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from typing import Any
+
+from diffcone.model import SnapshotInfo
+from diffcone.planner import Decision, Plan, Reason
+
+# 2: unresolved_relationships.matched_affected_symbols (was matched_changed_symbols)
+# 3: analysis.evidence (null for a static plan) and the evidence reason rules
+SCHEMA_VERSION = 3
+
+SCOPE_DESCRIPTION = {
+    "granularity": "whole functions, methods, classes and modules",
+    "resolved": [
+        "module-level functions, methods, classes and simple module-level assignments "
+        "(NAME = <expr>, bound once) as symbols",
+        "direct name and attribute references resolvable through module-level "
+        "definitions, import aliases, star imports within source roots, or self/cls",
+        "absolute and relative imports within source roots",
+        "class attribute lookup through the in-scope MRO, including super()",
+        "importlib.import_module / getattr with literal arguments",
+        "transitive dependencies",
+        "manifest-declared entry and lifecycle dependencies",
+    ],
+    "not_resolved": [
+        "type inference and dynamic dispatch on receivers of unknown type",
+        "instance attributes and arbitrary object.method() calls (name-bounded fallback)",
+        "dynamic imports / getattr / eval with non-literal arguments (dynamic fallback)",
+        "code outside the source roots and installed packages (assumed unchanged)",
+    ],
+}
+
+
+def _reason_dict(reason: Reason) -> dict[str, Any]:
+    return {
+        "rule": reason.rule,
+        "conservative": reason.conservative,
+        "detail": reason.detail,
+        "changed_symbol": reason.changed_symbol,
+        "changes": list(reason.changes),
+        "path": [asdict(step) | {"revisions": list(step.revisions)} for step in reason.path],
+    }
+
+
+def _target_dict(decision: Decision) -> dict[str, Any]:
+    t = decision.target
+    return {
+        "runner": t.runner,
+        "runner_id": t.runner_id,
+        "entry_symbol": t.entry_symbol,
+        "lifecycle_dependencies": list(t.lifecycle_dependencies),
+    }
+
+
+def snapshot_to_dict(info: SnapshotInfo) -> dict[str, Any]:
+    return {
+        "revision": info.revision,
+        "commit": info.commit,
+        "kind": info.kind,
+        "uncommitted": not info.committed,
+        "description": info.description,
+    }
+
+
+def to_dict(plan: Plan) -> dict[str, Any]:
+    selected = [d for d in plan.decisions if d.selected]
+    unselected = [d for d in plan.decisions if not d.selected]
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "status": "degraded" if plan.degraded else "complete",
+        # A runner may collect tests that are not targets: the plan is not a
+        # judgement on those, so running only its targets would skip them.
+        "discovery_incomplete": bool(plan.incomplete_discovery),
+        # Dependencies the project stated that the analysis cannot see.
+        "declarations": [
+            {"from": d.source, "to": d.target, "why": d.why} for d in plan.declarations
+        ],
+        "analysis": {
+            "repo": plan.repo,
+            "base": snapshot_to_dict(plan.base),
+            "head": snapshot_to_dict(plan.head),
+            "source_roots": plan.source_roots,
+            "working_tree_analyzed": plan.working_tree_analyzed,
+            "uncommitted_analyzed": plan.uncommitted_analyzed,
+            "scope": SCOPE_DESCRIPTION | {"analyzed": plan.scope_statement},
+            "evidence": plan.evidence,
+            "counts": {
+                "modules_base": len(plan.base_index.modules),
+                "modules_head": len(plan.head_index.modules),
+                "symbols_base": len(plan.base_index.symbols),
+                "symbols_head": len(plan.head_index.symbols),
+                "targets": len(plan.decisions),
+                "selected": len(selected),
+                "unselected": len(unselected),
+            },
+        },
+        "changed_symbols": [
+            {
+                "id": c.id,
+                "kind": c.kind,
+                "changes": list(c.changes),
+                "base_path": c.base.path if c.base else None,
+                "head_path": c.head.path if c.head else None,
+            }
+            for c in plan.changes
+        ],
+        "selected_targets": [
+            _target_dict(d)
+            | {
+                "rules": sorted({r.rule for r in d.reasons}),
+                "conservative": any(r.conservative for r in d.reasons),
+                "affected_dependencies": d.affected_dependencies,
+            }
+            for d in selected
+        ],
+        "unselected_targets": [
+            _target_dict(d) | {"reason": d.unselected_reason} for d in unselected
+        ],
+        "dependency_explanations": [
+            {"runner": d.target.runner, "runner_id": d.target.runner_id}
+            | {"reasons": [_reason_dict(r) for r in d.reasons]}
+            for d in selected
+        ],
+        "unresolved_relationships": [
+            {
+                "symbol": u.symbol,
+                "kind": u.kind,
+                "name": u.name,
+                "detail": u.detail,
+                "revisions": list(u.revisions),
+                "matched_affected_symbols": list(u.matched_affected_symbols),
+            }
+            for u in plan.unresolved
+        ],
+        "fallback_decisions": [
+            {"rule": f.rule, "scope": f.scope, "target": f.target, "detail": f.detail}
+            for f in plan.fallbacks
+        ],
+        "analysis_errors": [
+            {"revision": e.revision, "path": e.path, "message": e.message} for e in plan.errors
+        ],
+        "discovery": [
+            {
+                "runner": d.runner,
+                "targets": len(d.targets),
+                "config": d.config,
+                "notes": [{"kind": n.kind, "detail": n.detail} for n in d.notes],
+            }
+            for d in plan.discovery
+        ],
+    }
+
+
+def to_json(plan: Plan, indent: int | None = 2) -> str:
+    return json.dumps(to_dict(plan), indent=indent, sort_keys=False) + "\n"
+
+
+def _format_path(reason: Reason) -> str:
+    if not reason.path:
+        return ""
+    parts = [reason.path[0].source]
+    for step in reason.path:
+        parts.append(f"-[{step.kind}{':' + step.detail if step.detail else ''}]-> {step.target}")
+    return " ".join(parts)
+
+
+def to_text(plan: Plan) -> str:
+    lines: list[str] = []
+    lines.append(f"diffcone plan: {plan.base.revision} -> {plan.head.revision}")
+    lines.append(f"source roots: {', '.join(plan.source_roots)}")
+    lines.append(f"base: {plan.base.description}")
+    lines.append(f"head: {plan.head.description}")
+    lines.append(f"scope: {plan.scope_statement}")
+    lines.append(f"status: {'DEGRADED' if plan.degraded else 'complete'}")
+    if plan.evidence is not None:
+        ev = plan.evidence
+        lines.append(
+            f"evidence: {ev['tests']} tests recorded at {ev['commit'][:12]} "
+            f"(environment {ev['environment_hash']}, PYTHONHASHSEED={ev['hash_seed']}); "
+            f"planned {', '.join(ev['planned'])}"
+        )
+        if ev["changes_outside_range"]:
+            lines.append(
+                f"  {len(ev['changes_outside_range'])} change(s) since the evidence lie outside "
+                "base..head and were planned too"
+            )
+    if plan.declarations:
+        lines.append(f"declared dependencies ({len(plan.declarations)}):")
+        for d in plan.declarations:
+            lines.append(f"  {d.source} -> {d.target}" + (f"  ({d.why})" if d.why else ""))
+    if plan.incomplete_discovery:
+        lines.append(
+            f"discovery INCOMPLETE: {len(plan.incomplete_discovery)} place(s) where a runner "
+            "may collect tests that are not targets (see the notes below)"
+        )
+    lines.append("")
+    lines.append(f"changed symbols ({len(plan.changes)}):")
+    for c in plan.changes or []:
+        lines.append(f"  {c.id} [{c.kind}] {', '.join(c.changes)}")
+    if not plan.changes:
+        lines.append("  (none)")
+    lines.append("")
+    selected = plan.selected
+    lines.append(f"selected targets ({len(selected)}):")
+    for d in selected:
+        flag = " (conservative)" if any(r.conservative for r in d.reasons) else ""
+        lines.append(f"  {d.target.runner}: {d.target.runner_id}{flag}")
+        for r in d.reasons:
+            path = _format_path(r)
+            lines.append(f"    - {r.rule}: {r.detail}")
+            if path:
+                lines.append(f"      {path}")
+    if not selected:
+        lines.append("  (none)")
+    lines.append("")
+    unselected = plan.unselected
+    lines.append(f"unselected targets ({len(unselected)}):")
+    for d in unselected:
+        lines.append(f"  {d.target.runner}: {d.target.runner_id}")
+    if not unselected:
+        lines.append("  (none)")
+    matched = [u for u in plan.unresolved if u.matched_affected_symbols]
+    dynamic = [u for u in plan.unresolved if u.kind == "dynamic"]
+    lines.append("")
+    lines.append(
+        f"unresolved relationships: {len(plan.unresolved)} "
+        f"({len(matched)} matching an affected symbol, {len(dynamic)} dynamic)"
+    )
+    for u in matched:
+        lines.append(
+            f"  {u.symbol}: {u.kind} {u.detail!r} may refer to "
+            f"{', '.join(u.matched_affected_symbols)}"
+        )
+    for u in dynamic:
+        lines.append(f"  {u.symbol}: dynamic {u.detail}")
+    if plan.fallbacks:
+        lines.append("")
+        lines.append(f"fallback decisions ({len(plan.fallbacks)}):")
+        for f in plan.fallbacks:
+            where = f" [{f.target}]" if f.target else ""
+            lines.append(f"  {f.rule} ({f.scope}){where}: {f.detail}")
+    if plan.errors:
+        lines.append("")
+        lines.append(f"analysis errors ({len(plan.errors)}):")
+        for e in plan.errors:
+            lines.append(f"  {e.revision}:{e.path}: {e.message}")
+    for d in plan.discovery:
+        lines.append("")
+        lines.append(f"discovery ({d.runner}): {len(d.targets)} target(s), {len(d.notes)} note(s)")
+        for n in d.notes:
+            lines.append(f"  {n.kind}: {n.detail}")
+    return "\n".join(lines) + "\n"

diffcone/selection.py

@@ -0,0 +1,133 @@
+"""Keep only the tests ``diffcone run`` selected: a pytest plugin.
+
+``run`` used to name the selected tests on pytest's command line. pytest
+imports the conftests of command-line paths while it parses its
+configuration, and there a conftest that skips at module level
+(``pytest.importorskip("tables")`` in pandas' ``tests/io/pytables``) raises
+``Skipped`` past pytest's handler and kills the session; collected the
+ordinary way, the same conftest skips its directory. So pytest collects from
+its own starting points, as a full run does, and this plugin deselects every
+item whose test is not selected.
+
+Loaded into the project's process as ``-p diffcone_select`` (a link to this
+file, as with the recorder), so it imports nothing of diffcone. Settings, from
+the environment:
+
+* ``DIFFCONE_SELECT``: a directory holding ``selected``, one selected test per
+  line (``path::Class::test``, parameter cases folded), and ``targets``, every
+  target of the plan; each process writes ``missing-<pid>`` there, the
+  selected tests it did not collect, leaving out those under a directory or
+  module that skipped at collection, and ``unknown-<pid>``, the collected
+  tests that are no target at all: those are kept and run, since the plan
+  cannot say whether a change reaches them (a plugin's own collection, an
+  option discovery did not see);
+* ``DIFFCONE_COLLECT_ROOT``: the repository, which those paths are relative
+  to (pytest's own node ids are relative to its rootdir, which may differ);
+* ``DIFFCONE_OUTCOMES``: a directory; each process writes ``outcomes-<pid>``,
+  one ``nodeid<TAB>OUTCOME`` line per report (``PASSED``, ``FAILED``,
+  ``SKIPPED``, ``XFAIL``, ``XPASS``, ``ERROR``), as ``validate`` reads them:
+  pytest's console output depends on the project's verbosity options.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+
+import pytest
+
+DIRECTORY = os.environ.get("DIFFCONE_SELECT")
+OUTCOMES = os.environ.get("DIFFCONE_OUTCOMES")
+_ROOT = os.environ.get("DIFFCONE_COLLECT_ROOT") or os.getcwd()
+# The repository as given and with symlinks resolved: pytest reports paths
+# under whichever its rootdir is, and a linked or relative ``--repo`` differs.
+ROOTS = tuple(dict.fromkeys([os.path.realpath(_ROOT), os.path.abspath(_ROOT)]))
+skipped: list[str] = []  # repository-relative paths of collectors that skipped
+
+
+def _relative(where) -> str:
+    path = os.path.abspath(str(where))
+    for root in ROOTS:
+        if path.startswith(root + os.sep):
+            return os.path.relpath(path, root).replace(os.sep, "/")
+    return os.path.relpath(os.path.realpath(path), ROOTS[0]).replace(os.sep, "/")
+
+
+def _key(item) -> str:
+    """The item's test as diffcone names it: the file relative to the
+    repository, then the rest of the node id without the parameter case."""
+    path = _relative(getattr(item, "path", None) or item.fspath)  # ``path`` from pytest 7
+    if "::" not in item.nodeid:
+        return path
+    rest = re.sub(r"\[.*\]$", "", item.nodeid.split("::", 1)[1])
+    return path + "::" + rest
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_make_collect_report(collector):
+    outcome = yield
+    if DIRECTORY and outcome.get_result().skipped:
+        skipped.append(_relative(getattr(collector, "path", None) or collector.fspath))
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_collection_modifyitems(session, config, items):
+    # First, so that a test the project's own options (-m, -k) deselect is
+    # still counted as collected.
+    if not DIRECTORY:
+        return
+    with open(os.path.join(DIRECTORY, "selected"), encoding="utf-8") as f:
+        wanted = {line for line in f.read().splitlines() if line}
+    targets_file = os.path.join(DIRECTORY, "targets")
+    known: set[str] | None = None
+    if os.path.exists(targets_file):
+        with open(targets_file, encoding="utf-8") as f:
+            known = {line for line in f.read().splitlines() if line}
+    keep, drop, found, unknown = [], [], set(), set()
+    for item in items:
+        key = _key(item)
+        if key in wanted:
+            keep.append(item)
+            found.add(key)
+        elif known is not None and key not in known:
+            keep.append(item)
+            unknown.add(key)
+        else:
+            drop.append(item)
+    with open(os.path.join(DIRECTORY, f"unknown-{os.getpid()}"), "w", encoding="utf-8") as f:
+        f.write("\n".join(sorted(unknown)))
+    if drop:
+        config.hook.pytest_deselected(items=drop)
+        items[:] = keep
+    with open(os.path.join(DIRECTORY, f"missing-{os.getpid()}"), "w", encoding="utf-8") as f:
+        f.write(
+            "\n".join(
+                sorted(
+                    test
+                    for test in wanted - found
+                    if not any(
+                        test.split("::", 1)[0] == s or test.startswith(s + "/") for s in skipped
+                    )
+                )
+            )
+        )
+
+
+def pytest_runtest_logreport(report):
+    if not OUTCOMES:
+        return
+    outcome = None
+    xfail = hasattr(report, "wasxfail")
+    if report.when == "call":
+        if xfail:
+            outcome = "XPASS" if report.passed else "XFAIL"
+        else:
+            outcome = report.outcome.upper()
+    elif report.failed:
+        outcome = "ERROR"  # in setup or teardown
+    elif report.when == "setup" and report.skipped:
+        outcome = "XFAIL" if xfail else "SKIPPED"
+    if outcome is not None:
+        path = os.path.join(OUTCOMES, f"outcomes-{os.getpid()}")
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(f"{report.nodeid}\t{outcome}\n")