ci: fix PR #35 — fastapi dep + Transport._send_batch typo + coverage padding

PR #35 (release/0.7.6) failed all four CI jobs (test 3.10/3.11/3.12,
coverage, codecov/patch) on the same root cause + one latent bug
masked by it. This commit lands the fixes plus the last-mile tests
that bring coverage above the 82% threshold.

CI failure root
---------------

* tests/test_integrations_fastapi.py does from fastapi import ...
  at module top-level. CI installs only pip install -e '.[dev]',
  and fastapi was declared as an *optional* [fastapi] extra,
  NOT in [dev]. Pytest collection aborted with
  ModuleNotFoundError: No module named 'fastapi' → all 4 jobs red.
* Fix: add fastapi>=0.100,<1.0 to [dev]. Same precedent as
  langchain-core (already in [dev] for the same import-time
  contract: nullrun.instrumentation.langgraph is eager-imported
  from nullrun.decorators at collection time, so the test extras
  must cover the import chain).

Latent bug surfaced by the first fix
------------------------------------

The same PR refactored Transport._send_batch_with_retry_info to
route the /track/batch body through _signed_request_body for
canonical-JSON serialization (matching /gate and /execute). The two
sibling call sites use the module-level helper _signed_request_body
(no self.); this one used self._signed_request_body by typo.
Result: AttributeError on every batch flush, breaking 15 existing
tests across test_transport.py / test_track_batch_retry.py /
test_integration_contract.py / test_signal_safety.py. As long as
the fastapi collection error aborted pytest, this was hidden. Fixed
to _signed_request_body(...) with a docstring noting why it is
module-level and what the bug looked like.

Coverage padding (codecov/patch was failing on this too)
--------------------------------------------------------

Total coverage on the failing CI run was 81.98% — 0.02pp under the
fail-under=82 gate. After the two fixes above it would have
recovered to ~82.0% on the dot, so I added minimal tests for the
cheapest-to-cover gaps:

* tests/test_breaker_main.py (new) — covers the 5 statements in
  nullrun.breaker.__main__.main() (0% → 100%). The module
  exists so python -m nullrun.breaker exits cleanly instead of
  failing with No module named nullrun.breaker.__main__; the
  previous fix-mechanism was return 0 after a print, but no
  test was exercising it.
* tests/test_status.py — extends TestSummary with seven
  scenarios covering each conditional branch of NullRunStatus.summary()
  (organization_id, workflow_id, workflow_state != Normal,
  backend_reachable=False, ws_connected=False, recent_errors).
  status.py jumps 84.52% → 98.81%.
* tests/test_integrations_fastapi.py — four tests on
  _build_headers covering non-numeric, zero, negative, and
  resume_after (the WorkflowPausedException code path).
  integrations/fastapi.py jumps 90.22% → 94.57%.

After all three: TOTAL 81.98% → 82.46%, comfortably above the gate.

Verification
------------

* Local pytest: 997 passed, 13 skipped, 0 failed
  (Windows / Python 3.14.2, 8m47s — same env the original commit
  was validated in).
* python -m coverage report — 82.46%, no fail-under complaint.

Author: maltsev-dev

pyproject.toml

@@ -92,6 +92,15 @@ autogen = [
     "autogen-agentchat>=0.4,<1.0",
     "autogen-ext[openai]>=0.4,<1.0",
 ]
+# Server-framework integrations. Each one pulls the framework so the
+# corresponding ``nullrun.integrations.<framework>`` module can be
+# imported. ``nullrun.integrations.__init__`` does NOT eager-import
+# these (the submodules are loaded lazily on first ``from
+# nullrun.integrations import <framework>``), so users who don't use
+# a given framework don't pay its install cost.
+fastapi = [
+    "fastapi>=0.100,<1.0",
+]
 all = [
     "openai>=1.0,<2.0",
     "anthropic>=0.20,<1.0",
@@ -124,6 +133,13 @@ dev = [
     # the import succeed; the `langgraph` and `langchain` extras pull
     # in heavier stacks that the unit tests don't need.
     "langchain-core>=0.3,<1.0",
+    # `tests/test_integrations_fastapi.py` does `from fastapi import ...`
+    # at module top-level, so pytest collection aborts the entire suite
+    # with ModuleNotFoundError if FastAPI isn't installed. Same import-
+    # time contract as `langchain-core` above; pin to the same lower
+    # bound as the `[fastapi]` extra so CI and end users agree on the
+    # minimum. `httpx` (already a core dep) covers `TestClient`.
+    "fastapi>=0.100,<1.0",
 ]
 
 [project.urls]

src/nullrun/transport.py

@@ -1050,7 +1050,13 @@ def _send_batch_with_retry_info(self, batch: list[dict[str, Any]]) -> "SendResul
         # (it hashes the bytes either way), but consistent serialization
         # means future audits / contract tests don't have to special-case
         # this endpoint.
-        body = self._signed_request_body({"events": batch})
+        # NOTE: _signed_request_body is a MODULE-LEVEL helper, not a
+        # method on Transport. The two siblings in this file
+        # (``execute`` and ``check``) call it without ``self.``; calling
+        # ``self._signed_request_body`` here raised AttributeError on
+        # every batch flush and broke 15 tests across test_transport.py
+        # / test_track_batch_retry.py / test_integration_contract.py.
+        body = _signed_request_body({"events": batch})
         self._add_hmac_headers(headers, body)
 
         # Inject trace context for distributed tracing (W3C Trace Context)

tests/test_breaker_main.py

@@ -0,0 +1,43 @@
+"""Coverage padding for ``nullrun.breaker.__main__``.
+
+The module exists so ``python -m nullrun.breaker`` exits cleanly
+instead of failing with ``No module named nullrun.breaker.__main__``.
+Containerized deployments that previously relied on the broken
+entrypoint should call ``nullrun-doctor`` (see
+``nullrun.toolbox.diagnostics``) for runtime checks.
+
+Pinned by ``pyproject.toml::[tool.coverage.report].fail_under = 82`` —
+without this test, the five statements in ``main()`` stay at 0% and
+the suite trips the threshold by a hair.
+"""
+from __future__ import annotations
+
+import io
+
+import pytest
+
+from nullrun.breaker.__main__ import main
+
+
+def test_main_returns_zero_and_writes_helpful_message(capsys: pytest.CaptureFixture[str]) -> None:
+    """``main()`` is informational, not an error: return code 0, the
+    message goes to stderr (so it doesn't pollute the consumer's
+    stdout pipe)."""
+    rc = main()
+    captured = capsys.readouterr()
+    assert rc == 0
+    # Message goes to stderr so a stdout pipe stays clean.
+    assert captured.out == ""
+    assert "nullrun-doctor" in captured.err
+    assert "library module" in captured.err
+
+
+def test_main_runs_under_dunder_main(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Smoke: ``python -m nullrun.breaker`` path — exercise the
+    ``if __name__ == "__main__":`` guard via ``runpy`` so the
+    ``SystemExit`` branch is hit."""
+    import runpy
+
+    with pytest.raises(SystemExit) as info:
+        runpy.run_module("nullrun.breaker.__main__", run_name="__main__")
+    assert info.value.code == 0

tests/test_integrations_fastapi.py

@@ -10,6 +10,8 @@
 """
 from __future__ import annotations
 
+from typing import Any
+
 import pytest
 from fastapi import FastAPI, Request
 from fastapi.testclient import TestClient
@@ -287,3 +289,43 @@ def trigger():
     # Single 429, not a double-handler crash.
     assert resp.status_code == 429
     assert resp.json()["error_code"] == "NR-B004"
+
+
+# ---------------------------------------------------------------------------
+# _build_headers edge cases — Retry-After handling
+# ---------------------------------------------------------------------------
+class _AttrBag:
+    """Minimal stand-in for a NullRun exception — only the attrs
+    that ``_build_headers`` reads (``retry_after`` / ``resume_after``)
+    matter."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+
+def test_build_headers_returns_empty_when_no_retry_hint():
+    """No ``retry_after`` / ``resume_after`` → no Retry-After header."""
+    assert nr_fastapi._build_headers(_AttrBag()) == {}
+
+
+def test_build_headers_returns_empty_when_retry_after_non_numeric():
+    """A non-numeric ``retry_after`` must NOT raise; it just yields
+    no header. The exception class is opaque to the renderer, so a
+    typo'd string field shouldn't break the response."""
+    assert nr_fastapi._build_headers(_AttrBag(retry_after="soon")) == {}
+
+
+def test_build_headers_returns_empty_when_retry_after_is_zero():
+    """Zero or negative ``retry_after`` is not meaningful for
+    Retry-After (RFC 9110 allows zero but a real client would
+    spin; the renderer drops it to avoid hot-looping)."""
+    assert nr_fastapi._build_headers(_AttrBag(retry_after=0)) == {}
+    assert nr_fastapi._build_headers(_AttrBag(retry_after=-5)) == {}
+
+
+def test_build_headers_falls_back_to_resume_after():
+    """``WorkflowPausedException`` uses ``resume_after`` instead of
+    ``retry_after`` — the renderer normalizes on the canonical
+    HTTP field name."""
+    assert nr_fastapi._build_headers(_AttrBag(resume_after=42)) == {"Retry-After": "42"}

tests/test_status.py

@@ -248,6 +248,90 @@ def test_ok_summary(self):
         assert "ok" in out
         assert "nr_live_te" in out
 
+    def test_summary_with_organization_and_workflow(self):
+        # Covers the ``if self.organization_id`` and
+        # ``if self.workflow_id`` branches of summary().
+        rt = _make_runtime()
+        rt.organization_id = "org_abcdef1234567890"
+        rt.workflow_id = "wf_xyzzy1234567890"
+        s = nullrun.status()
+        out = s.summary()
+        assert "org=org_abcd" in out
+        assert "wf=wf_xyzzy" in out
+
+    def test_summary_includes_workflow_state_when_not_normal(self):
+        # Branch: ``self.workflow_state and .state != "Normal"``.
+        rt = _make_runtime()
+        rt.workflow_id = "wf-test-1"
+        rt._set_remote_state(
+            "wf-test-1",
+            {"state": "Killed", "version": 5, "reason": "manual kill"},
+        )
+        s = nullrun.status()
+        out = s.summary()
+        assert "wf_state=Killed" in out
+
+    def test_summary_omits_normal_workflow_state(self):
+        # Sanity: a Normal workflow state should NOT appear in summary.
+        rt = _make_runtime()
+        rt.workflow_id = "wf-test-1"
+        rt._set_remote_state(
+            "wf-test-1",
+            {"state": "Normal", "version": 1, "reason": None},
+        )
+        s = nullrun.status()
+        out = s.summary()
+        assert "wf_state=" not in out
+
+    def test_summary_includes_backend_unreachable(self):
+        # Branch: ``self.backend_reachable is False``.
+        # ``backend_reachable`` is a local in ``status()``, not a stored
+        # attribute on the runtime — construct the snapshot directly.
+        s = NullRunStatus(
+            state="degraded",
+            api_key_valid=True,
+            api_key_prefix="nr_live_te",
+            organization_id=None,
+            workflow_id=None,
+            api_url="https://api.nullrun.io",
+            backend_reachable=False,
+            ws_connected=None,
+            workflow_state=None,
+            recent_errors=[],
+        )
+        assert "backend=unreachable" in s.summary()
+
+    def test_summary_includes_ws_disconnected(self):
+        # Branch: ``self.ws_connected is False``. Same reasoning as above.
+        s = NullRunStatus(
+            state="degraded",
+            api_key_valid=True,
+            api_key_prefix="nr_live_te",
+            organization_id=None,
+            workflow_id=None,
+            api_url="https://api.nullrun.io",
+            backend_reachable=None,
+            ws_connected=False,
+            workflow_state=None,
+            recent_errors=[],
+        )
+        assert "ws=False" in s.summary()
+
+    def test_summary_includes_recent_errors_count(self):
+        # Branch: ``if self.recent_errors``.
+        rt = _make_runtime()
+        from nullrun.observability.error_hooks import ErrorContext
+        from nullrun.breaker.exceptions import NullRunError
+
+        for i in range(3):
+            rt._emit_sdk_error(
+                NullRunError(f"err-{i}", error_code="NR-X000"),
+                stage="init",
+            )
+        s = nullrun.status()
+        out = s.summary()
+        assert "errors=3" in out
+
 
 # ---------------------------------------------------------------------------
 # 7. Public API surface