pytest-digline 0.2.4__tar.gz → 0.3.0__tar.gz

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pytest-digline
-Version: 0.2.4
+Version: 0.3.0
 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/
@@ -9,6 +9,7 @@ Project-URL: Repository, https://github.com/digline/digline
 Project-URL: Issues, https://github.com/digline/digline/issues
 Author-email: Alessandro Prandini <alessandro.prandini@ict-group.it>
 License-Expression: Apache-2.0
+Keywords: baseline,evals,evaluation,llm,pytest,pytest-plugin,regression
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
@@ -17,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: digline>=0.31.0
+Requires-Dist: digline<0.33,>=0.32.0
 Requires-Dist: pytest>=8.0
 Description-Content-Type: text/markdown
 
@@ -44,8 +45,8 @@ digline: alpha · llm_rubric
   reason: signed=True, concise=False
 
 ==================================== digline ===================================
-1 check got worse; every case could be judged; 1 case is suspended; the rules
-are unchanged.
+eval/suite.py: 1 check got worse compared with the reference. Every case could
+be judged. 1 case is suspended. The suite is unchanged from the reference.
 ```
 
 One row per **check** — one assertion on one case — because that is digline's
@@ -77,9 +78,19 @@ The suspension is the one digline state an exit code cannot express: it never
 fails, so it disappears into `0`. pytest has had a state for *a decision rather
 than an outcome* since it was written, and this is it.
 
-**What pytest cannot carry**: the process exit code. `digline compare` exits `1`
-for a regression and `2` for a run it could not judge; a pytest run exits `1`
-for either. The distinction survives in the report — `F` and `E` are counted
+**A session digline did not say green does not end green.** When a suite's
+comparison would make `digline compare` exit `1` or `2` and the session would
+otherwise end `0`, it ends `1`, and the summary says why, one line per suite:
+`eval/suite.py: digline exits 2, so this session does not end green.` That
+covers what fails no row: a pinned file that drifted, and a run that judged
+nothing because every case it measures is suspended. There is no flag. A
+status that is already not `0` is left as it is. pytest's own summary line at
+the bottom can stay green, because it counts the rows' outcomes and not the
+exit status: read the exit code, and the digline line above it says why.
+
+**What a pytest run does not carry**: the difference between digline's `1` and
+`2`. A pytest run exits `1` for either, because pytest's `2` means interrupted.
+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.
 

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/README.md

@@ -21,8 +21,8 @@ digline: alpha · llm_rubric
   reason: signed=True, concise=False
 
 ==================================== digline ===================================
-1 check got worse; every case could be judged; 1 case is suspended; the rules
-are unchanged.
+eval/suite.py: 1 check got worse compared with the reference. Every case could
+be judged. 1 case is suspended. The suite is unchanged from the reference.
 ```
 
 One row per **check** — one assertion on one case — because that is digline's
@@ -54,9 +54,19 @@ The suspension is the one digline state an exit code cannot express: it never
 fails, so it disappears into `0`. pytest has had a state for *a decision rather
 than an outcome* since it was written, and this is it.
 
-**What pytest cannot carry**: the process exit code. `digline compare` exits `1`
-for a regression and `2` for a run it could not judge; a pytest run exits `1`
-for either. The distinction survives in the report — `F` and `E` are counted
+**A session digline did not say green does not end green.** When a suite's
+comparison would make `digline compare` exit `1` or `2` and the session would
+otherwise end `0`, it ends `1`, and the summary says why, one line per suite:
+`eval/suite.py: digline exits 2, so this session does not end green.` That
+covers what fails no row: a pinned file that drifted, and a run that judged
+nothing because every case it measures is suspended. There is no flag. A
+status that is already not `0` is left as it is. pytest's own summary line at
+the bottom can stay green, because it counts the rows' outcomes and not the
+exit status: read the exit code, and the digline line above it says why.
+
+**What a pytest run does not carry**: the difference between digline's `1` and
+`2`. A pytest run exits `1` for either, because pytest's `2` means interrupted.
+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.
 

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-digline"
-version = "0.2.4"
+version = "0.3.0"
 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"
@@ -8,6 +8,7 @@ license = "Apache-2.0"
 authors = [
     { name = "Alessandro Prandini", email = "alessandro.prandini@ict-group.it" },
 ]
+keywords = ["pytest", "pytest-plugin", "llm", "evals", "evaluation", "regression", "baseline"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Framework :: Pytest",
@@ -58,7 +59,24 @@ dependencies = [
     # §6.4). Against 0.30.0 the import raises `ImportError`. It was owed at the
     # cut and raised in this package's own release, after the core was on
     # PyPI, because a floor may not name a release that does not exist yet.
-    "digline>=0.31.0",
+    #
+    # 0.32.0, a seventh time, by signature: opening each `--digline-suite`
+    # passes `declared=suite.declared()` to `headline`, and both the argument
+    # and `Suite.declared` first ship in 0.32.0, so the sentence can say that
+    # a run judged nothing (ADR 0049). Against 0.31.0 the call raises
+    # `AttributeError`. The summary also asks `phrase` for
+    # `fact.session_not_green`, a key new in 0.32.0 (ADR 0049 §7); against
+    # 0.31.0 that raises `KeyError`. It was owed at the cut and raised in this
+    # package's own release, after the core was on PyPI, because a floor may
+    # not name a release that does not exist yet.
+    #
+    # And a cap, `<0.33`, the first on the core. 0.32.0 made `declared` a
+    # mandatory argument of `headline`, and 0.2.4, which declared
+    # `digline>=0.31.0` and nothing above it, stopped every session on it with
+    # a `TypeError`. A core minor may change a signature this plugin calls, so
+    # the resolver keeps the core inside the minor this release was run
+    # against, and a user stays on a pair that works.
+    "digline>=0.32.0,<0.33",
     # 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.4 → pytest_digline-0.3.0}/src/pytest_digline/plugin.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 
 import sys
 import traceback
+import warnings
 from collections.abc import Generator, Iterator, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -77,8 +78,10 @@ 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()
+#: Each named suite, by the nodeid of its `DiglineSuite` node, with what was
+#: opened for it: the summary prints its headline and its `latest` note, each
+#: under the path pytest prints for the suite's rows.
+SUITES: pytest.StashKey[list[tuple[str, _Opened]]] = pytest.StashKey()
 
 
 # --------------------------------------------------------------------------- #
@@ -142,7 +145,7 @@ def pytest_configure(config: pytest.Config) -> None:
     and the person who types `--co` after `--digline-run` is always doing it to
     find out what *would* happen.
     """
-    config.stash[HEADLINES] = []
+    config.stash[SUITES] = []
     if config.getoption("digline_run") and config.option.collectonly:
         raise pytest.UsageError(
             "--digline-run calls your provider and --collect-only exists to "
@@ -201,13 +204,155 @@ def pytest_collection_modifyitems(
     **import the user's suite a second time** — a module with an import-time
     side effect would perform it twice.
     """
-    for spec in _specs(config):
+    #: The nodeid a file had before its suites carried their attribute,
+    #: mapped to the nodeids that replaced it: what a stale `--deselect` named.
+    renamed: dict[str, list[str]] = {}
+    specs = _specs(config)
+    _refuse_the_same_suite_twice(specs)
+    for spec in specs:
         opened = _open(spec, config)
-        node = _child(session, DiglineSuite, path=opened.path, opened=opened)
+        node = _suite_node(session, spec, opened, renamed)
         items.extend(node.collect())
-        config.stash[HEADLINES].append(opened.headline)
-        if opened.note:
-            config.stash[HEADLINES].append(f"note: {opened.note}")
+        config.stash[SUITES].append((node.nodeid, opened))
+    _warn_on_stale_deselects(config, renamed)
+
+
+def _refuse_the_same_suite_twice(specs: Sequence[str]) -> None:
+    """Two specs that resolve to one suite are refused, before any suite loads.
+
+    Naming a suite twice asks for nothing: the same rows collected twice, two
+    identical `FAILED` lines, two identical summary lines (#566). Two suites
+    from one file are not one suite, and stay allowed (#571). Refused before
+    the first load, so that `--digline-run` has called no target by the time
+    the session stops. The specs are the user's own text, so the message passes
+    through `visible()`.
+    """
+    if len(specs) < 2:
+        # Inert with no suite named: digline is not imported (ADR 0013 §8).
+        return
+    from digline.report import visible
+
+    seen: dict[tuple[str, str | None], str] = {}
+    for spec in specs:
+        identity = _suite_identity(spec)
+        if identity in seen:
+            raise pytest.UsageError(
+                visible(
+                    f"{seen[identity]!r} and {spec!r} name the same suite. A "
+                    "suite is gated once in a session: name it once."
+                )
+            )
+        seen[identity] = spec
+
+
+def _suite_identity(spec: str) -> tuple[str, str | None]:
+    """The suite a spec resolves to, by the loader's rule and without loading.
+
+    `host.loader.load_suite`: a `.toml` spec is a file and has no attribute. A
+    `file.py[:attribute]` spec, or one with a path separator, is a file
+    resolved from the working directory, with `SUITE_ATTR` when no attribute
+    is given. Anything else is a dotted module name, compared as written: which
+    file it imports is known only by importing it, and this runs before any
+    import, so `pkg.mod:suite` and `pkg/mod.py:suite` are not seen as one.
+
+    **A copy of the loader's rule, declared and pinned.** It mirrors
+    `host.loader.load_suite`, `_split` and the file-or-module test in
+    `_import`. If those change, this follows, and so do `_path_of` and
+    `_attribute_of`. `test_spec_rule_mirrors_the_loader.py` compares all
+    three with what the loader does, so a change there turns red rather than
+    leaving the copies to drift. A public function in `digline.host` would
+    remove the copy and raise this plugin's floor.
+    """
+    from digline.host import SUITE_ATTR, SUITE_SUFFIX
+
+    if spec.endswith(SUITE_SUFFIX):
+        return str(Path(spec).resolve()), None
+    head, sep, tail = spec.rpartition(":")
+    module_part, attribute = (
+        (head, tail) if sep and tail.isidentifier() else (spec, None)
+    )
+    if module_part.endswith(".py") or "/" in module_part or "\\" in module_part:
+        module_part = str(Path(module_part).resolve())
+    return module_part, attribute or SUITE_ATTR
+
+
+def _suite_node(
+    session: pytest.Session, spec: str, opened: _Opened, renamed: dict[str, list[str]]
+) -> DiglineSuite:
+    """The suite's node, named by its attribute when the spec has one.
+
+    Two suites from one file, `both.py:support` and `both.py:billing`, would
+    otherwise be two nodes at one path with identical nodeids, and `-k`,
+    `--deselect` and `--lf` could not tell their rows apart (#566). The node
+    built first is the one pytest names from the path alone: its nodeid is
+    pytest's rendering of that path, which this does not restate, and the
+    attribute is appended to it.
+    """
+    node = _child(session, DiglineSuite, path=opened.path, opened=opened)
+    attribute = _attribute_of(spec)
+    if attribute is None:
+        return node
+    named = _child(
+        session,
+        DiglineSuite,
+        path=opened.path,
+        opened=opened,
+        nodeid=f"{node.nodeid}:{attribute}",
+        name=f"{node.name}:{attribute}",
+    )
+    renamed.setdefault(node.nodeid, []).append(named.nodeid)
+    return named
+
+
+def _warn_on_stale_deselects(
+    config: pytest.Config, renamed: dict[str, list[str]]
+) -> None:
+    """One warning per `--deselect` value written for a nodeid that changed.
+
+    pytest deselects by prefix and says nothing about a prefix that matches
+    nothing, so a value naming a row by its old nodeid would let the row it
+    was meant to exclude run again in silence. The warning names, for that
+    value, the nodeids that replaced it. It does not honour the old form: it
+    says the form changed. A `PytestWarning`, so `-W error` stops the session,
+    which is what whoever passed it asked for, as a usage error. The value is
+    the user's own text, so it passes through `visible()` like every line this
+    plugin prints.
+    """
+    if not renamed:
+        # Inert unless a suite was named with an attribute: nothing to check,
+        # and digline is not imported for nothing (ADR 0013 §8).
+        return
+    from digline.report import visible
+
+    given: list[str] = list(config.getoption("deselect") or [])
+    for value in given:
+        replacements = [
+            new + value[len(old) :]
+            for old, news in renamed.items()
+            if value.startswith(f"{old}::")
+            for new in news
+        ]
+        if not replacements:
+            continue
+        stale = pytest.PytestWarning(
+            visible(
+                f"--deselect {value} names a row by the nodeid it had before a "
+                "suite named as file.py:attribute carried its attribute. It "
+                f"deselects nothing now. Use: {', '.join(replacements)}"
+            )
+        )
+        try:
+            # The warnings summary places this at this line, in the plugin.
+            # That is not a misplaced frame: there is no frame of the user's to
+            # place it in, because the cause is a value on the command line,
+            # not a call. No `stacklevel` reaches the user, so none is tried;
+            # the message carries the value and its replacements instead.
+            warnings.warn(stale, stacklevel=1)
+        except pytest.PytestWarning as exc:
+            # `-W error` turned it into an exception. Refused as a usage error,
+            # as every refusal of the request is here, and not let through as
+            # INTERNALERROR, which reads as a crash of pytest or of this plugin.
+            raise pytest.UsageError(str(exc)) from exc
 
 
 def _child[N: pytest.Item | pytest.File](
@@ -240,6 +385,10 @@ class _Opened:
     #: exactly as `summary_lines` composes it once for a whole listing.
     coincides: str
     headline: str
+    #: What digline exits with for this suite, `exit_code()` of the same
+    #: headline whose sentence is above: 0, 1 or 2, never a refusal, which
+    #: stops the session before an `_Opened` exists. (ADR 0049 §7)
+    exit_code: int
     #: Whether this run carries the judge's own words. False on a redacted run,
     #: where quoting a reason would be quoting something that is not there.
     reasons_available: bool
@@ -318,6 +467,7 @@ def _opened(spec: str, root: Path, *, run_first: bool) -> _Opened:
     from digline.host import load_suite, need_baseline, read_run, resolve_key
     from digline.report import config_changes, headline, scale_lost
     from digline.store import FileResultStore
+    from digline.wire import exit_code
 
     suite, loaded = load_suite(spec, root=root)
     path = _path_of(spec)
@@ -330,13 +480,14 @@ def _opened(spec: str, root: Path, *, run_first: bool) -> _Opened:
     run = read_run(store, suite, resolved.key)
     baseline = need_baseline(store, suite)
     comparison = compare(run, baseline)
-    head = headline(comparison, run, baseline, locale=LOCALE)
+    head = headline(comparison, run, baseline, locale=LOCALE, declared=suite.declared())
     return _Opened(
         path=path,
         suite=suite,
         comparison=comparison,
         coincides=config_changes(comparison.config_changes, LOCALE),
         headline=head.sentence,
+        exit_code=exit_code(head),
         reasons_available=head.reasons_available,
         lost=scale_lost(run),
         note=resolved.note,
@@ -399,16 +550,26 @@ def _measure(
         # while being handed no pin set, so a front end that skipped this would
         # be refused rather than silently recording no control. (ADR 0029 §4)
         pinned=read_pinned(suite, path.parent, root=root, artifacts=artifacts),
+        # A test module importing the application the suite imports is the
+        # normal arrangement here, and the run says so. (ADR 0052, decision 2)
+        modules_unchecked=loaded.modules_unchecked,
     )
     store.write_run(run)
 
 
+def _attribute_of(spec: str) -> str | None:
+    """The `:attribute` a spec ends with, by `_path_of`'s rule, or None."""
+    _head, sep, tail = spec.rpartition(":")
+    return tail if sep and tail.isidentifier() else None
+
+
 def _path_of(spec: str) -> Path:
     """The file a spec names, dropping a trailing `:attribute`.
 
     The loader's own rule (`host.loader._split`): only a trailing `:name`
     counts, and only when `name` is an identifier — so a Windows path like
-    `C:\\suites\\qa.py` keeps its drive letter.
+    `C:\\suites\\qa.py` keeps its drive letter. A copy, pinned with
+    `_suite_identity`'s: see there.
     """
     head, sep, tail = spec.rpartition(":")
     return Path(head if sep and tail.isidentifier() else spec).resolve()
@@ -713,19 +874,79 @@ def pytest_terminal_summary(
     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
+    Each line starts with the path pytest prints for the suite's rows, so with
+    several suites a sentence is joined to its rows by name and not by order.
+
+    Under it, the note `latest` left, as `<path>: 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)
-    if not sentences:
+    none: list[tuple[str, _Opened]] = []
+    suites = config.stash.get(SUITES, none)
+    if not suites:
         return
-    from digline.report import visible
+    from digline.report import phrase, visible
+    from digline.wire import EXIT_OK
 
     terminalreporter.write_sep("=", "digline")
-    for sentence in sentences:
-        # Sanitised at the sink like every other line this plugin writes: the
-        # sentence is built from a stored document — configuration values, an
-        # artifact tally, a canary's case id. (0.10.1)
-        terminalreporter.write_line(visible(sentence))
+    for nodeid, opened in suites:
+        # Named the way pytest names the suite's rows: its path relative to
+        # the directory pytest was started from, which is what
+        # `cwd_relative_nodeid` computes and what the progress lines and the
+        # short test summary print. A path, and not the suite's name: the name
+        # appears nowhere in pytest's report, and the path is the string the
+        # reader already has beside every row. Every line carries it, one
+        # suite or several, so a line is always joined to its rows by name.
+        # Two suites from one file are told apart by the attribute their
+        # nodeid carries, so the prefix carries it too: `both.py:support`.
+        prefix = config.cwd_relative_nodeid(nodeid)
+        lines = [opened.headline]
+        if opened.note:
+            lines.append(f"note: {opened.note}")
+        for line in lines:
+            # Sanitised at the sink like every other line this plugin writes:
+            # the sentence is built from a stored document — configuration
+            # values, an artifact tally, a canary's case id. (0.10.1)
+            terminalreporter.write_line(visible(f"{prefix}: {line}"))
+        if opened.exit_code != EXIT_OK:
+            # Why this session does not end green, for this suite: digline's
+            # code, in digline's words, named by the same prefix as the sentence
+            # that says the cause. (ADR 0049 §7)
+            terminalreporter.write_line(
+                visible(
+                    phrase(
+                        LOCALE,
+                        "fact.session_not_green",
+                        suite=prefix,
+                        code=opened.exit_code,
+                    )
+                )
+            )
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_sessionfinish(session: pytest.Session) -> None:
+    """A session digline did not say green does not end green. (ADR 0049 §7)
+
+    When the session would end `0` and any suite's code is not `0`, it ends
+    `1`, pytest's *tests failed*: pytest's `2` is *interrupted*, which would be
+    false. One rule for every cause, because the code is `exit_code()`'s and
+    not a rule of this plugin's. A status that is already not `0` is left as
+    it is: `1`, `3`, `4`, `5` already say the session is not green.
+
+    `session.exitstatus` is read, not the `exitstatus` the hook is called with:
+    that argument is the same for every implementation, so it cannot show what
+    a plugin before this one set. `trylast` so that this reads after them.
+    pytest returns `session.exitstatus` after this hook (`wrap_session` in
+    `_pytest/main.py`, read at the locked pytest and at the floor this
+    package declares), so what is
+    written here is what the process exits with.
+    """
+    none: list[tuple[str, _Opened]] = []
+    suites = session.config.stash.get(SUITES, none)
+    if not suites or session.exitstatus != pytest.ExitCode.OK:
+        return
+    from digline.wire import EXIT_OK
+
+    if any(opened.exit_code != EXIT_OK for _, opened in suites):
+        session.exitstatus = pytest.ExitCode.TESTS_FAILED

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/tests/_cycle.py

@@ -16,7 +16,13 @@ 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.host import (
+    load_suite,
+    load_target,
+    read_artifacts,
+    read_pinned,
+    utc_now_iso,
+)
 from digline.run import execute
 from digline.store import FileResultStore
 
@@ -27,12 +33,16 @@ def cycle(path: Path, root: Path, *, promote: bool) -> str:
     spec = str(path)
     suite, loaded = load_suite(spec, root=root)
     target = load_target(None, loaded, spec)
+    artifacts = read_artifacts(suite, target, path.parent, root=root)
     run = execute(
         suite,
         target,
         created_at=utc_now_iso(),
         git_commit=None,
-        artifacts=read_artifacts(suite, target, path.parent, root=root),
+        artifacts=artifacts,
+        # As `digline run` and `--digline-run` resolve them: a suite that pins
+        # a file is refused by `execute` without its resolved pin set.
+        pinned=read_pinned(suite, path.parent, root=root, artifacts=artifacts),
     )
     store = FileResultStore(str(root))
     ref = store.write_run(run)
@@ -49,5 +59,6 @@ def cycle(path: Path, root: Path, *, promote: bool) -> str:
                 else key_of(current.created_at, current.config_hash)
             ),
             promoted_at="2026-01-02T09:00:00+00:00",
+            declared=None,
         )
     return ref.key

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/tests/test_contract.py

@@ -1,9 +1,11 @@
 """What survives the translation into pytest, and what does not. (ADR 0013 §7)
 
 The exit codes are digline's contract: `0` proceed, `1` stop and report what got
-worse, `2` stop — the run could not be judged. pytest cannot carry that
-distinction, and this file records the loss as a property rather than leaving it
-to be discovered by somebody building a gate on it.
+worse, `2` stop — the run could not be judged. The plugin does not carry that
+distinction into pytest's exit code. pytest would let it, so the loss is not a
+limit of pytest, and whether the plugin should carry it is open (ADR 0013 §7,
+note of 2026-10-13). This file records the loss as a property rather than
+leaving it to be discovered by somebody building a gate on it.
 """
 
 from __future__ import annotations
@@ -29,7 +31,7 @@ def test_a_clean_comparison_exits_zero(
 def test_a_regression_and_an_unjudged_run_both_exit_one(
     pytester: pytest.Pytester, baseline: Baseline
 ) -> None:
-    """The distinction digline draws and pytest erases.
+    """The distinction digline draws and the plugin does not carry.
 
     `digline compare` exits `1` for a regression and `2` for a run it could not
     judge. Here both are `1`, because pytest's process code says only that

{pytest_digline-0.2.4 → pytest_digline-0.3.0}/tests/test_message.py

@@ -102,7 +102,7 @@ def test_the_headline_is_printed_once_and_is_the_report_s(
     """
     path = baseline(FINE, {**FINE, "alpha": "Acme, unhappy", "beta": "Acme, unhappy"})
     comparison, run, base = _compared(path, pytester.path)
-    sentence = headline(comparison, run, base, locale="en").sentence
+    sentence = headline(comparison, run, base, locale="en", declared=None).sentence
 
     result = pytester.runpytest_subprocess("--digline-suite", str(path))