Extension-gated Python tests never run in CI: no test job builds the Rust extension

[leynos]

Overview

The Python-side tests that exercise the compiled Rust extension are gated on
that extension being importable, and no CI job that runs the test suite builds
it. They therefore skip on every run, in every job, and have done since they
were written.

Evidence

maturin develop appears exactly once in .github/workflows/ci.yml, at
line 293, inside the benchmark-ratchet job — which runs benchmarks, not the
test suite:

$ grep -rn "maturin develop" .github/workflows/*.yml
.github/workflows/ci.yml:293:  UV_CACHE_DIR=.uv-cache UV_TOOL_DIR=.uv-tools uv run maturin develop \

The three jobs that do run tests — lint-test, typecheck-test, and
coverage — reach the suite through make build, which is only a dependency
sync:

build: uv .venv ## Build virtual-env and install deps
	$(UV_RUN_ENV) uv sync --group dev

So the extension is never present when the tests run.

Affected modules

Every module below is gated on the compiled extension and therefore skips:

• cuprum/unittests/test_rust_streams.py
• cuprum/unittests/test_rust_streams_boundary_property.py
• cuprum/unittests/test_rust_extension.py
• cuprum/unittests/test_rust_splice.py
• cuprum/unittests/test_backend.py (the extension-dependent cases)

Why this matters

The skips are silent. A green CI run is indistinguishable from one in which
the entire Python/Rust boundary went unexercised, which is precisely the
boundary most likely to break: FD ownership, the GIL release, error
translation across the PyO3 edge, and the backend-selection fallback.

It also distorts review. PR #241 was asked to "add or unskip the required
Python/Rust boundary integration tests"; the tests already exist and are
already correct — nothing was skipped by omission. The defect is in the CI
wiring, not the test suite, and no amount of test authoring fixes it.

Proposal

Build the extension in the jobs that run the suite, then make the skip loud:

1. Add a maturin develop --manifest-path rust/cuprum-rust/Cargo.toml step to
   lint-test (and coverage, if the coverage numbers should include the
   boundary), mirroring the invocation already proven in benchmark-ratchet.
   Consider a make develop target so local and CI use one definition.
2. Add a CI-only guard that fails when the extension is unimportable — an
   environment variable such as CUPRUM_REQUIRE_RUST_EXTENSION=1 that turns
   the skip into an error. Without this, a future change that breaks the build
   step silently restores the present situation.
3. Consider a job-summary line reporting how many extension-gated tests ran,
   so the count is visible rather than inferred.

Step 2 is the important one: the current failure mode is not "the tests are
missing" but "the tests report success without running".

Cost trade-off

Low to moderate — one build step per job, at the cost of Rust compilation time
on jobs that currently skip it. Worth measuring against the alternative, which
is a boundary that has never been tested in CI.

---

Raised from PR #241.

[coderabbitai]

🔗 Related PRs

#143 - Unify the Rust-availability probes behind one resolver (#128) [merged]
#144 - Fix Command-Query Separation violations (#118) [merged]
#153 - Share one canonical stream-drain loop across consume variants (#115) [merged]
#217 - Skip the maturin wheel build when its script is unreachable (#211) [open]
#224 - Property tests for path/git-ref validators and backend resolver (#70, #72) [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[leynos]

A second blocker, found while trying to satisfy a review comment on #241 that asked for an end-to-end test through the exported rust_consume_stream.

The crate cannot host such a test as configured, independently of the missing CI build step. rust/cuprum-rust/Cargo.toml enables extension-module unconditionally:

pyo3 = { version = "0.29.0", features = ["extension-module"] }

That feature suppresses linking against libpython, because an extension module resolves those symbols from the host interpreter when it is loaded. A Rust test binary has no host interpreter, so a test that starts one fails at link time. Verified with a probe test calling Python::initialize() and cargo test --no-run:

undefined reference to `Py_IsInitialized'
undefined reference to `PyGILState_Ensure'
collect2: error: ld returned 1 exit status
error: could not compile `cuprum-rust` (lib test)

So there is no Rust-side route to the boundary either, and the Python-side tests really are the only ones that can cover it. That strengthens the case for this issue rather than offering an alternative to it.

Implication for the fix. If a future change wants boundary coverage runnable via cargo test as well, it needs the feature made optional:

[features]
default = ["extension-module"]
extension-module = ["pyo3/extension-module"]

with --no-default-features threaded through the Makefile and the test jobs, and maturin left on the default. That is worth weighing against simply building the wheel in CI as proposed above, which is less invasive: it changes no wheel-producing configuration, and getting the feature split wrong breaks wheel builds on every platform.

My recommendation stands as originally written — build the extension in the test jobs and add a CUPRUM_REQUIRE_RUST_EXTENSION guard so the skip becomes a failure. This note is only to record that the seemingly cheaper alternative is not available.

[leynos]

Concrete evidence that this gap hides real defects, not just untested code.

I built the extension locally and ran the gated suite:

1 failed, 65 passed

The failure is test_rust_streams.py::test_rust_pump_stream_propagates_io_errors:

E       assert None in {9, 22}
E        +  where None = OSError('Bad file descriptor (os error 9)').errno

OSErrors crossing the PyO3 boundary carry errno = None. Raised as #265.

Two things this changes about the case for fixing the CI wiring:

1. The gate is not merely untidy. A real, user-visible defect in error conversion has been sitting behind it — a caller cannot branch on errno and must string-match the message instead.
2. The wiring is nearly viable. 65 of 66 pass, so building the extension in the test jobs would not open a floodgate of failures. It needs OSError raised across the PyO3 boundary loses errno (always None) #265 fixed alongside, and then the CUPRUM_REQUIRE_RUST_EXTENSION guard proposed above to keep the gate from silently closing again.

Suggested sequencing: fix #265 first, then land the CI build step plus the guard, so the step arrives green and the guard has something to protect.