pytest-digline 0.2.0__tar.gz → 0.2.2__tar.gz

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pytest-digline
-Version: 0.2.0
+Version: 0.2.2
 Summary: Gate a pytest run on a digline comparison: one row per check, against the baseline committed in your repo.
 Project-URL: Homepage, https://digline.dev/
 Project-URL: Documentation, https://digline.dev/product/pytest/
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: digline>=0.19.0
+Requires-Dist: digline>=0.20.0
 Requires-Dist: pytest>=8.0
 Description-Content-Type: text/markdown
 
@@ -84,6 +84,11 @@ for either. The distinction survives in the report — `F` and `E` are counted
 separately, `-rE` lists the errored rows — and in `--junit-xml`. A job that
 needs `1` versus `2` runs `digline compare`, which is one command away.
 
+One exit code it does carry: a **refusal**. When digline declines the request
+— no baseline, a document it refuses, a comparison across tenants or across
+the projection — the session stops as pytest's usage error, exit `4`, and the
+message names the refusal, as `digline compare` names it and exits `64`.
+
 ## Naming a suite
 
 Nothing is discovered by convention: a suite is a file that *executes*, and a

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/README.md

@@ -61,6 +61,11 @@ for either. The distinction survives in the report — `F` and `E` are counted
 separately, `-rE` lists the errored rows — and in `--junit-xml`. A job that
 needs `1` versus `2` runs `digline compare`, which is one command away.
 
+One exit code it does carry: a **refusal**. When digline declines the request
+— no baseline, a document it refuses, a comparison across tenants or across
+the projection — the session stops as pytest's usage error, exit `4`, and the
+message names the refusal, as `digline compare` names it and exits `64`.
+
 ## Naming a suite
 
 Nothing is discovered by convention: a suite is a file that *executes*, and a

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-digline"
-version = "0.2.0"
+version = "0.2.2"
 description = "Gate a pytest run on a digline comparison: one row per check, against the baseline committed in your repo."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -38,7 +38,11 @@ dependencies = [
     # and reads `AssertionDelta.calibration` so a calibration case that moved
     # inside its band never fails a row. A calibration case outside its band is
     # the plugin's ERROR state, with the report's sentence. (ADR 0024 §4.7)
-    "digline>=0.19.0",
+    #
+    # 0.20.0, a fourth time, for a name the gate sees: the plugin catches
+    # `digline.host.REFUSALS`, which arrived there, and turns every refusal into
+    # pytest's usage error rather than an INTERNALERROR.
+    "digline>=0.20.0",
     # A floor and no cap, unlike `digline-mcp`'s `mcp<3`. That cap records a
     # rename that actually happened; pytest has not moved the `pytest11` entry
     # point in a decade, and a cap here would fight the one dependency the user

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/src/pytest_digline/plugin.py

@@ -39,7 +39,7 @@ import pytest
 if TYPE_CHECKING:
     from digline.core import AssertionDelta, Comparison, ScaleLost, Verdict
     from digline.run import Suite
-    from digline.store import FileResultStore
+    from digline.store import ResultStore
 
 # **digline is imported inside the hooks, not here**, and the reason is
 # measured rather than tidy-minded.
@@ -76,6 +76,7 @@ RUN_SCOPE = "<run>"
 #: Set by `pytest_collection_modifyitems`, read by `pytest_terminal_summary`.
 #: On the config's stash rather than a module global: a module global is shared
 #: by every `Config` in the process, and `pytester` runs several in one.
+#: Each suite's headline, followed by its `latest` note when there is one.
 HEADLINES: pytest.StashKey[list[str]] = pytest.StashKey()
 
 
@@ -204,6 +205,8 @@ def pytest_collection_modifyitems(
         node = _child(session, DiglineSuite, path=opened.path, opened=opened)
         items.extend(node.collect())
         config.stash[HEADLINES].append(opened.headline)
+        if opened.note:
+            config.stash[HEADLINES].append(f"note: {opened.note}")
 
 
 def _child[N: pytest.Item | pytest.File](
@@ -242,6 +245,11 @@ class _Opened:
     #: The calibration cases of the run that left their band, read off the run
     #: by the report's own function. (ADR 0024 §4.7)
     lost: Sequence[ScaleLost] = ()
+    #: What resolving `latest` stepped over, or empty. Its sharpest case is a
+    #: baseline promoted from a run newer than the one compared: every row is
+    #: then an older run held against a newer reference, and a red there is
+    #: not a regression. (#433)
+    note: str = ""
 
 
 def _open(spec: str, config: pytest.Config) -> _Opened:
@@ -253,14 +261,24 @@ def _open(spec: str, config: pytest.Config) -> _Opened:
     purpose: a suite with no baseline yet, or a path with a typo, must not
     collect zero rows and let a green run mean "nothing to check". That is the
     vacuously green assertion fixed decision 3 refuses.
+
+    **Every refusal in `digline.host.REFUSALS` takes the same road**, by
+    naming the tuple rather than its members, as `digline-mcp` does: a
+    document the store refuses, a comparison across tenants or across the
+    projection. Each is digline declining the request, and before this each
+    one reached pytest as `INTERNALERROR` and exit 3, which reads as a crash of
+    pytest or of this plugin. The class is named in the message, as the CLI
+    names it. (Delta-pass over 0.25.1)
     """
-    from digline.host import UsageError
+    from digline.host import REFUSALS, UsageError
 
     root = Path(config.getoption("digline_root") or config.rootpath)
     try:
         return _opened(spec, root, run_first=bool(config.getoption("digline_run")))
     except UsageError as exc:
         raise pytest.UsageError(f"digline: {exc}") from exc
+    except REFUSALS as exc:
+        raise pytest.UsageError(f"digline: {type(exc).__name__}: {exc}") from exc
 
 
 def _opened(spec: str, root: Path, *, run_first: bool) -> _Opened:
@@ -276,8 +294,8 @@ def _opened(spec: str, root: Path, *, run_first: bool) -> _Opened:
     if run_first:
         _measure(suite, loaded, spec, path, store, root=root)
 
-    key = resolve_key(store, suite, "latest").key
-    run = read_run(store, suite, key)
+    resolved = resolve_key(store, suite, "latest")
+    run = read_run(store, suite, resolved.key)
     baseline = need_baseline(store, suite)
     comparison = compare(run, baseline)
     head = headline(comparison, run, baseline, locale=LOCALE)
@@ -289,6 +307,7 @@ def _opened(spec: str, root: Path, *, run_first: bool) -> _Opened:
         headline=head.sentence,
         reasons_available=head.reasons_available,
         lost=scale_lost(run),
+        note=resolved.note,
     )
 
 
@@ -297,7 +316,7 @@ def _measure(
     loaded: Any,
     spec: str,
     path: Path,
-    store: FileResultStore,
+    store: ResultStore,
     *,
     root: Path,
 ) -> None:
@@ -655,6 +674,10 @@ def pytest_terminal_summary(
     It is `headline().sentence`, byte for byte the sentence `digline compare`
     prints and the report shows, because a gate and a document must never say
     two different things about one run.
+
+    Under it, the note `latest` left, as `note: …`, the line `digline compare`
+    prints on stderr. Here and not as a warning: under `-W error` a warning
+    fails the session, and a note is not a verdict. (#433)
     """
     none: list[str] = []
     sentences = config.stash.get(HEADLINES, none)

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/tests/_cycle.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from digline.core import key_of
 from digline.host import load_suite, load_target, read_artifacts, utc_now_iso
 from digline.run import execute
 from digline.store import FileResultStore
@@ -36,7 +37,17 @@ def cycle(path: Path, root: Path, *, promote: bool) -> str:
     store = FileResultStore(str(root))
     ref = store.write_run(run)
     if promote:
+        # Whatever is there now: a cycle that promotes is standing in for a
+        # person who has just compared against it.
+        current = store.read_baseline(suite.tenant, suite.name)
         store.promote_baseline(
-            ref, suite.config_hash(), promoted_at="2026-01-02T09:00:00+00:00"
+            ref,
+            suite.config_hash(),
+            expected_baseline=(
+                None
+                if current is None
+                else key_of(current.created_at, current.config_hash)
+            ),
+            promoted_at="2026-01-02T09:00:00+00:00",
         )
     return ref.key

{pytest_digline-0.2.0 → pytest_digline-0.2.2}/tests/test_message.py

@@ -141,3 +141,57 @@ def test_a_suite_that_does_not_exist_refuses_by_name(
     result = pytester.runpytest_subprocess("--digline-suite", "nope/suite.py")
     assert result.ret == pytest.ExitCode.USAGE_ERROR
     result.stderr.fnmatch_lines(["*no such file*"])
+
+
+def _rewrite_baseline(root: Path, edit: Callable[[str], str]) -> None:
+    (stored,) = root.glob(".digline/*/baselines/*.json")
+    stored.write_text(edit(stored.read_text(encoding="utf-8")), encoding="utf-8")
+
+
+def _projected(document: str) -> str:
+    import secrets
+
+    from digline.core import project, run_from_json, run_to_json
+
+    rows: dict[tuple[str, str], str] = {}
+    return run_to_json(
+        project(
+            run_from_json(document),
+            lambda kind, text: rows.setdefault((kind, text), secrets.token_urlsafe(16)),
+        )
+    )
+
+
+def _unidentified(document: str) -> str:
+    import json
+
+    raw = json.loads(document)
+    raw["results"][0]["verdicts"][0]["assertion_id"] = ""
+    return json.dumps(raw)
+
+
+@pytest.mark.parametrize(
+    ("edit", "named"),
+    [
+        pytest.param(_projected, "DifferentRegimesError", id="compare-refuses"),
+        pytest.param(_unidentified, "UnidentifiedVerdictError", id="read-refuses"),
+    ],
+)
+def test_a_refusal_from_digline_is_a_usage_error_not_a_crash(
+    pytester: pytest.Pytester,
+    baseline: Baseline,
+    edit: Callable[[str], str],
+    named: str,
+) -> None:
+    """Every refusal in `digline.host.REFUSALS` is the front end declining the
+    request, which is pytest's exit 4, as `UsageError` already was. Was:
+    `INTERNALERROR` and exit 3, which reads as a crash of pytest or of this
+    plugin. (Delta-pass over 0.25.1)"""
+    path = baseline(FINE, FINE)
+    _rewrite_baseline(pytester.path, edit)
+
+    result = pytester.runpytest_subprocess("--digline-suite", str(path))
+
+    assert result.ret == pytest.ExitCode.USAGE_ERROR
+    result.stderr.fnmatch_lines([f"*digline: {named}:*"])
+    assert "INTERNALERROR" not in result.stdout.str() + result.stderr.str()

pytest_digline-0.2.2/tests/test_summary_note.py

@@ -0,0 +1,54 @@
+"""The note `latest` leaves, under the headline it qualifies. (#433)
+
+This plugin compares `latest` against the baseline, and until #433 it took the
+key and dropped the note. The case that matters: the baseline was promoted from
+a run newer than `latest`, so every row holds an older run against a newer
+reference, and a red row there is not a regression.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+from _cycle import cycle
+
+FINE = {"alpha": "Acme, SATISFIED", "beta": "Acme, SATISFIED"}
+
+
+def test_the_note_follows_the_headline_in_the_summary(
+    pytester: pytest.Pytester, repo: Callable[[dict[str, str]], Path]
+) -> None:
+    path = repo(FINE)
+    older = cycle(path, pytester.path, promote=False)
+    newer = cycle(path, pytester.path, promote=True)
+    (gone,) = (pytester.path / ".digline").glob(f"*/runs/**/{newer}.json")
+    gone.unlink()
+
+    # `-W error` too: the note is not a warning, so it cannot fail a session
+    # that turns warnings into errors.
+    result = pytester.runpytest_subprocess("--digline-suite", str(path), "-W", "error")
+
+    expected = (
+        f"note: the baseline was promoted from run {newer}, newer than {older}, "
+        "and that run was not read here"
+    )
+    text = result.stdout.str()
+    assert expected in text
+    assert text.index("= digline =") < text.index(expected)
+    assert result.ret == 0, text
+
+
+def test_no_note_when_latest_steps_over_nothing(
+    pytester: pytest.Pytester, repo: Callable[[dict[str, str]], Path]
+) -> None:
+    """The control: a note on every session would be a line people learn to
+    skip, and would pass the test above."""
+    path = repo(FINE)
+    cycle(path, pytester.path, promote=True)
+    cycle(path, pytester.path, promote=False)
+
+    result = pytester.runpytest_subprocess("--digline-suite", str(path))
+
+    assert "note:" not in result.stdout.str()