Brummel
2532e8fcc3
built_project/project_lock/ScratchPath/ScratchGuard move from their three per-binary copies (cli_run.rs, research_docs.rs, project_load.rs's built_fixture near-copy) into tests/common/mod.rs; project_load's one shared-store-mutating test now takes the lock it previously lacked. The module doc states the boundary plainly: the Mutex serializes threads within one process only — process-parallel runners still race on the shared fixture store (documented, dormant under cargo test's sequential binaries; see the issue thread for the observed process-parallel repro). closes #223
81 lines
3.2 KiB
Rust
81 lines
3.2 KiB
Rust
//! Shared fixture helpers for the `aura-cli` end-to-end test binaries
|
|
//! (`research_docs.rs`, `cli_run.rs`, `project_load.rs`), all of which build
|
|
//! and drive the `tests/fixtures/demo-project` fixture through the real
|
|
//! `aura` binary (#223).
|
|
//!
|
|
//! **Process-local serialization only.** [`project_lock`]'s `Mutex` is a
|
|
//! per-process `static`: it serializes test THREADS within one test-binary
|
|
//! process, but grants no cross-process exclusion. A process-parallel test
|
|
//! runner (e.g. `cargo-nextest`, which forks one process per test binary) —
|
|
//! or simply two concurrent `cargo test` invocations over the same working
|
|
//! tree — still race on the shared `tests/fixtures/demo-project/runs` store.
|
|
//! That boundary is a known, documented limitation (#223), not something
|
|
//! this module claims to close.
|
|
//!
|
|
//! Each of the three test binaries compiles this file as its own `mod
|
|
//! common`, so an item unused by one binary trips that binary's `-D
|
|
//! warnings` `dead_code` lint; see the `#[allow(dead_code)]` markers below
|
|
//! rather than deleting a helper just because one binary doesn't need it.
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::{Mutex, MutexGuard, OnceLock};
|
|
|
|
/// The demo-project fixture (`Aura.toml` present), built once per test-binary
|
|
/// process. Each test binary has its own `OnceLock` (this module is compiled
|
|
/// separately per binary), but `cargo build` is idempotent, so a second
|
|
/// binary building the same fixture is a no-op.
|
|
pub fn built_project() -> &'static PathBuf {
|
|
static BUILT: OnceLock<PathBuf> = OnceLock::new();
|
|
BUILT.get_or_init(|| {
|
|
let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/demo-project");
|
|
let out = std::process::Command::new("cargo")
|
|
.arg("build")
|
|
.current_dir(&dir)
|
|
.output()
|
|
.expect("spawn cargo build for the fixture project");
|
|
assert!(
|
|
out.status.success(),
|
|
"fixture build failed:\n{}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
dir
|
|
})
|
|
}
|
|
|
|
/// Serializes every test that touches the shared demo-project fixture store
|
|
/// (they remove/re-seed `<fixture>/runs`, so parallel test threads would race
|
|
/// on it). A poisoned lock is taken over: one failed test must not cascade
|
|
/// into unrelated lock panics.
|
|
pub fn project_lock() -> MutexGuard<'static, ()> {
|
|
static LOCK: Mutex<()> = Mutex::new(());
|
|
LOCK.lock().unwrap_or_else(|e| e.into_inner())
|
|
}
|
|
|
|
/// A scratch filesystem entry a test writes under the git-tracked
|
|
/// demo-project fixture root (only `runs/` there is fixture-gitignored),
|
|
/// removed on drop — including during a mid-test panic — so a failed
|
|
/// assertion never leaks scratch docs into tracked working-tree state.
|
|
#[allow(dead_code)]
|
|
pub enum ScratchPath {
|
|
File(PathBuf),
|
|
Dir(PathBuf),
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub struct ScratchGuard(pub Vec<ScratchPath>);
|
|
|
|
impl Drop for ScratchGuard {
|
|
fn drop(&mut self) {
|
|
for p in &self.0 {
|
|
match p {
|
|
ScratchPath::File(p) => {
|
|
let _ = std::fs::remove_file(p);
|
|
}
|
|
ScratchPath::Dir(p) => {
|
|
let _ = std::fs::remove_dir_all(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|