From 98542e2b675fd5a70f392546ed2919cae707f35d Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Thu, 19 Nov 2026 21:35:42 +0100 Subject: [PATCH] Run Jenkins without Xvfb and temporarily lower headless coverage floor --- Cargo.lock | 2 +- Cargo.toml | 2 +- Jenkinsfile | 17 ++++++++++------- coverage.toml | 2 ++ docs/changelog.md | 9 +++++++++ docs/development/ci.md | 31 ++++++++++++++++--------------- scripts/ci.py | 9 +++++++-- tests/test_ci_badges.py | 13 +++++++++++++ 8 files changed, 59 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5d0c895..7e83579 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2212,7 +2212,7 @@ dependencies = [ [[package]] name = "pdf-presenter" -version = "0.1.26" +version = "0.1.27" dependencies = [ "bytemuck", "chrono", diff --git a/Cargo.toml b/Cargo.toml index c8aa457..1f7ada7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ default-members = ["crates/pdf-presenter"] resolver = "3" [workspace.package] -version = "0.1.26" +version = "0.1.27" edition = "2024" license = "MIT" repository = "https://proxy.dandaedre.com/gitea/idle-org/pdf-presenter" diff --git a/Jenkinsfile b/Jenkinsfile index 2224587..1b353f3 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -12,6 +12,7 @@ pipeline { PYTHONUNBUFFERED = '1' PYTHONDONTWRITEBYTECODE = '1' NO_COLOR = '1' + PDF_PRESENTER_HEADLESS_CI = '1' CARGO_TERM_COLOR = 'never' BADGE_ROOT = '/mnt/assets/coverage' } @@ -31,11 +32,6 @@ pipeline { set -eu uv run --no-project --python ">=3.11" python -c 'import sys; assert sys.version_info >= (3, 11), "Python 3.11+ required for CI"' test -n "${BRANCH_NAME:?Configure this job as a Multibranch Pipeline}" - if ! command -v Xvfb >/dev/null 2>&1; then - echo 'Xvfb is missing from the Jenkins worker PATH. uv manages Python, not the X server.' >&2 - echo 'Provision the worker with xvfb (Debian/Ubuntu) or xorg-vfbserver (FreeBSD), then rerun.' >&2 - exit 1 - fi uname -sr rustc --version if ! cargo llvm-cov --version | grep -Fx 'cargo-llvm-cov 0.9.1'; then @@ -64,7 +60,8 @@ pipeline { sh ''' set -eu uv run --no-project --python ">=3.11" python -m unittest discover -s tests -v - uv run --no-project --python ">=3.11" python scripts/gui_ci.py cargo test --locked --workspace --all-features + unset PDF_PRESENTER_GUI_TESTS + cargo test --locked --workspace --all-features cargo build --locked --workspace --all-features uv run --no-project --python ">=3.11" python scripts/ci.py tests-passed ''' @@ -72,7 +69,13 @@ pipeline { } } stage('Coverage') { - steps { sh 'uv run --no-project --python ">=3.11" python scripts/gui_ci.py python scripts/ci.py coverage' } + steps { + sh ''' + set -eu + unset PDF_PRESENTER_GUI_TESTS + uv run --no-project --python ">=3.11" python scripts/ci.py coverage + ''' + } } } diff --git a/coverage.toml b/coverage.toml index 77351fb..fe84aa4 100644 --- a/coverage.toml +++ b/coverage.toml @@ -1,4 +1,6 @@ # Whole application; never exclude future GUI or renderer code to meet this floor. line-floor = 75.0 +# Temporary Jenkins floor while its worker cannot run native-window tests. +headless-line-floor = 60.0 tool = "cargo-llvm-cov" tool-version = "0.9.1" diff --git a/docs/changelog.md b/docs/changelog.md index b1e8e25..74d33f2 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -2,6 +2,15 @@ ## Unreleased +### 0.1.27 + +- Remove Jenkins's Xvfb prerequisite and native-window test wrapper. Keep native + smoke available locally and all production code in coverage. Temporarily use a + 60% headless Jenkins floor; local full-GUI runs retain the 75% floor. Coverage + badges still show the actual measurement and tool/test failures remain failures. + Headless coverage passes at 65.21%; all 13 Python helper tests pass. Jenkins + shell blocks pass syntax checks; the remote job has not been rerun. + ### 0.1.26 - Display transparent slide areas on white by default. Appearance now offers diff --git a/docs/development/ci.md b/docs/development/ci.md index 9c655e9..128cf26 100644 --- a/docs/development/ci.md +++ b/docs/development/ci.md @@ -13,17 +13,18 @@ no system `python3` alias or project virtual environment is required. On workers without a supported uv-managed Python build (including FreeBSD), provision Python 3.11+ for uv to discover. -Native GUI CI additionally requires Xvfb and ordinary X11 -client libraries (on FreeBSD install `xorg-vfbserver` and the required X11 packages). The pipeline installs cargo-llvm-cov 0.9.1 and the rustfmt, -Clippy and llvm-tools-preview components. It builds and tests without a sibling -checkout or PDF renderer. `scripts/gui_ci.py` starts an isolated Xvfb server for -tests/coverage, waits at most 10 seconds for readiness and always cleans it up. -It enables the native smoke integration test. `uv` does not supply Xvfb: an -administrator must provision the Jenkins worker (`apt-get install xvfb` on -Debian/Ubuntu, or `pkg install xorg-vfbserver` on FreeBSD) and expose it on PATH. -A failure at `command -v Xvfb` means that prerequisite is missing, not a Python -version error. Missing Xvfb fails with provisioning guidance; GUI -production code is never excluded from coverage. +Jenkins runs headless tests and coverage without Xvfb. Native-window smoke tests +remain available locally but are not enabled in Jenkins; egui rendering, document, +worker and other headless tests still run. The pipeline installs cargo-llvm-cov 0.9.1 +and the rustfmt, Clippy and llvm-tools-preview components. + +The temporary Jenkins coverage floor is **60%**, selected explicitly by +`PDF_PRESENTER_HEADLESS_CI=1` and `headless-line-floor` in `coverage.toml`. The normal +local full-GUI floor remains **75%**. Both measure all production code, including +GUI code; tool/test failures still fail the build and badges report the actual +measurement. Restore full native testing and the 75% Jenkins floor when a display +server becomes available. Headless coverage measured 65.21% for 0.1.26; this is a +snapshot, not physical-display acceptance. ```sh uv run --no-project --python ">=3.11" python -m unittest discover -s tests -v @@ -35,7 +36,7 @@ RUSTDOCFLAGS="-D warnings" cargo doc --locked --workspace --all-features --no-de PDF_PRESENTER_GUI_TESTS=1 uv run --no-project --python ">=3.11" python scripts/ci.py coverage ``` -Coverage measures the entire Rust workspace with a 75% floor. Add all future +Coverage measures the entire Rust workspace with the selected floor. Add all future production GUI and renderer code to this same gate. Badge helpers are derived from Canvas Pilot and have tests for invalid/stale reports and isolated publication. @@ -49,10 +50,10 @@ The Jenkinsfile still requires a real Jenkins run; local tests cannot validate worker configuration or prove the remote pipeline has run. -The coverage command above needs a usable desktop session. On a headless POSIX host, +The coverage command above needs a usable desktop session. On a headless POSIX host with Xvfb installed, run `uv run --no-project --python ">=3.11" python scripts/gui_ci.py python scripts/ci.py coverage` instead. To include native smoke in local workspace tests, set `PDF_PRESENTER_GUI_TESTS=1`. Without it, -the ordinary tests remain headless and explicitly skip native-window smoke. CI sets -it through the virtual-display wrapper for both tests and coverage. Xvfb tests cannot +the ordinary tests remain headless and explicitly skip native-window smoke. CI uses +neither the flag nor the virtual-display wrapper. Xvfb tests cannot validate actual monitor routing, compositor policy, macOS Spaces or Windows desktop behavior. The wrapper starts no network listener and alters no physical display. diff --git a/scripts/ci.py b/scripts/ci.py index 63b4693..2f92fca 100644 --- a/scripts/ci.py +++ b/scripts/ci.py @@ -27,6 +27,11 @@ def config(): return tomllib.loads((ROOT / "coverage.toml").read_text()) +def coverage_floor(): + key = "headless-line-floor" if os.environ.get("PDF_PRESENTER_HEADLESS_CI") == "1" else "line-floor" + return config()[key] + + def measure(report, floor, tool_status): """Process an independently generated summary before deciding pass/fail.""" marker = Path(f"coverage/.coverage-ready-{build_number()}") @@ -80,7 +85,7 @@ def finalize(): if lines and lines[0] == build: print("\n".join(lines[1:])) else: - print(f"Line coverage: unavailable; required minimum: {config()['line-floor']:.2f}%; reason: coverage stage did not complete") + print(f"Line coverage: unavailable; required minimum: {coverage_floor():.2f}%; reason: coverage stage did not complete") for path in (passed, ready, Path("coverage/summary.json"), summary): path.unlink(missing_ok=True) for name in ("version", "test", "coverage"): @@ -116,7 +121,7 @@ def main(): print(f"Coverage tool could not start: {error}", flush=True) print(f"Coverage tool exit status: {status}", flush=True) try: - return measure(summary, config()["line-floor"], status) + return measure(summary, coverage_floor(), status) finally: summary.unlink(missing_ok=True) elif action == "finalize": diff --git a/tests/test_ci_badges.py b/tests/test_ci_badges.py index 8652f8b..c5cc9a0 100644 --- a/tests/test_ci_badges.py +++ b/tests/test_ci_badges.py @@ -93,6 +93,19 @@ class BadgeTests(unittest.TestCase): self.assertFalse(Path("coverage/.coverage-ready-42").exists()) self.assertIn("failing", Path("coverage/test.svg").read_text()) + def test_headless_floor_is_explicit_and_still_enforces_threshold_and_tool_errors(self): + for enabled, floor in [("", 75), ("0", 75), ("1", 60)]: + with patch.dict(os.environ, {"PDF_PRESENTER_HEADLESS_CI": enabled}): + self.assertEqual(ci.coverage_floor(), floor) + with patch.dict(os.environ, {"PDF_PRESENTER_HEADLESS_CI": "1"}): + for covered, status, expected in [(6521, 0, 0), (6000, 0, 0), (5999, 0, 1), (6521, 7, 7)]: + with self.subTest(covered=covered, status=status), contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(ci.measure(self.report(covered), ci.coverage_floor(), status), expected) + output = io.StringIO() + with contextlib.redirect_stdout(output): + ci.finalize() + self.assertIn("60.00%", output.getvalue()) + def test_coverage_from_fresh_checkout_reports_tool_failure_without_traceback(self): Path("coverage").rmdir()