diff --git a/CLAUDE.md b/CLAUDE.md index 665e260..72fd239 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -92,9 +92,12 @@ case no PR will catch: an advisory against something already merged. **SonarQube Cloud is CI-based since 2026-10-25** — `sonar.yml` and `sonar-project.properties`; automatic analysis is off in the project's settings and must stay off, or the CI analysis is refused. Automatic analysis never analysed a line of Rust and imported no coverage, which is why it -went. The gate's "new code" is *previous version*, and the version comes from `package.json`, so a -release bump starts a new period; new code needs 80 % coverage, so a slice whose new lines no -test reaches turns `main`'s gate red. Dependabot PRs have no `SONAR_TOKEN` and skip the analysis. +went. The gate's "new code" is *previous version*, with the version from `package.json` — but the +first analysis to send one (`1.4.0`) kept the 2026-09-27 baseline, so read `periods` from +`api/qualitygates/project_status` after the next bump instead of assuming it moved. New code needs +80 % coverage and no new issue, so a slice whose new lines no test reaches turns `main`'s gate red, +and so does a `std::fs` call inside an `async fn` (`rust:S7493`) or a tracing field named +`message` (`rust:S6677`). Dependabot PRs have no `SONAR_TOKEN` and skip the analysis. ## Current state diff --git a/crates/pipdock-cli/src/main.rs b/crates/pipdock-cli/src/main.rs index 6658777..4841c05 100644 --- a/crates/pipdock-cli/src/main.rs +++ b/crates/pipdock-cli/src/main.rs @@ -428,7 +428,7 @@ async fn main() -> ExitCode { match result { Ok(exit) => exit.into(), Err(e) => { - tracing::error!(target: "pipdock::cli", code = %e.code, message = %e.message, "failed"); + tracing::error!(target: "pipdock::cli", code = %e.code, error = %e.message, "failed"); let exit = run::exit_for(e.code); // ERROR-CATALOG §3: `error[PD-XXX-NNN]: ` on stderr, or the JSON envelope. if cli.global.json { diff --git a/crates/pipdock-cli/tests/golden.rs b/crates/pipdock-cli/tests/golden.rs index babc841..a9e213a 100644 --- a/crates/pipdock-cli/tests/golden.rs +++ b/crates/pipdock-cli/tests/golden.rs @@ -244,6 +244,35 @@ fn the_human_error_line_carries_its_code() { ); } +#[test] +fn a_logged_failure_names_its_message() { + // `message = %e.message` beside a format string records two fields called `message`, and the + // text formatter prints that field without its name — so the line read `failed + // code=PD-ENV-001 no interpreter at …`, the error's own words indistinguishable from the + // event's (SonarQube rust:S6677). `error=`, as every other failure in the codebase logs it. + let copy = std::env::temp_dir().join(format!("pd-golden-log-{}.log", std::process::id())); + let _ = std::fs::remove_file(©); + let copy_arg = copy.to_string_lossy().into_owned(); + code_of(&[ + "--log-file", + ©_arg, + "list", + "--env", + "C:/definitely/not/here", + ]); + let log = std::fs::read_to_string(©).expect("--log-file wrote its copy"); + let _ = std::fs::remove_file(©); + + let line = log + .lines() + .find(|l| l.contains("PD-ENV-001")) + .unwrap_or_else(|| panic!("the failure was not logged:\n{log}")); + assert!( + line.contains("failed") && line.contains("error=no interpreter at"), + "the error's message must be a field of its own: {line}" + ); +} + #[test] fn an_unknown_schema_type_lists_the_known_ones() { insta::assert_snapshot!("schema-unknown-type", stderr_of(&["schema", "NoSuchType"])); diff --git a/crates/pipdock-core/Cargo.toml b/crates/pipdock-core/Cargo.toml index a246963..2da9851 100644 --- a/crates/pipdock-core/Cargo.toml +++ b/crates/pipdock-core/Cargo.toml @@ -27,7 +27,9 @@ serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.154" sha2 = "0.11.1" thiserror = "2.0.21" -tokio = { version = "1.53.3", features = ["rt-multi-thread", "macros", "process", "io-util", "time", "sync"] } +# `fs`: an async fn that touches a file goes through tokio's pool rather than blocking a runtime +# worker (SonarQube rust:S7493). +tokio = { version = "1.53.3", features = ["rt-multi-thread", "macros", "process", "io-util", "time", "sync", "fs"] } # First-party tokio, for CancellationToken. The alternative was an AtomicBool plus a Notify, # which is what CancellationToken already is, written worse. tokio-util = "0.7.20" diff --git a/crates/pipdock-core/src/engine/mod.rs b/crates/pipdock-core/src/engine/mod.rs index 186c112..0afe35d 100644 --- a/crates/pipdock-core/src/engine/mod.rs +++ b/crates/pipdock-core/src/engine/mod.rs @@ -380,18 +380,6 @@ pub struct InstallSet { pub system: SystemPackages, } -impl InstallSet { - /// Install `specs`, constraining nothing else. - #[must_use] - pub const fn only(specs: Vec) -> Self { - Self { - specs, - constraints: Vec::new(), - system: SystemPackages::Protected, - } - } -} - /// The requirements (and constraints) files one engine invocation reads, deleted when dropped. /// /// **Files, not argv.** Every plan restates the whole installed set (SP-1), one argv entry per diff --git a/crates/pipdock-core/src/exec.rs b/crates/pipdock-core/src/exec.rs index 143fbf1..699ea01 100644 --- a/crates/pipdock-core/src/exec.rs +++ b/crates/pipdock-core/src/exec.rs @@ -1038,6 +1038,35 @@ mod tests { ); } + #[test] + fn a_file_the_user_chose_is_never_blamed_on_the_environment() { + // U25. An export, a saved report or a requirements file is the user's own path, so a + // refusal there is about that folder — not PD-PRM-001's "PipDock may not write to this + // environment", and not PD-SYS-002's full disk. + use std::io::{Error, ErrorKind}; + let p = Path::new(r"C:\Users\me\Desktop\requirements.txt"); + assert_eq!( + user_file_error(p, &Error::from_raw_os_error(32)).code, + Code::PrmFileLocked, + "ERROR_SHARING_VIOLATION: another program has it open" + ); + for kind in [ErrorKind::PermissionDenied, ErrorKind::ReadOnlyFilesystem] { + assert_eq!( + user_file_error(p, &Error::from(kind)).code, + Code::PrmSourceReadOnly, + "{kind:?}" + ); + } + // Everything else is what any file failure is. + assert_eq!( + user_file_error(p, &Error::from_raw_os_error(112)).code, + Code::SysDiskFull + ); + let missing = user_file_error(p, &Error::from(ErrorKind::NotFound)); + assert_eq!(missing.code, Code::IntUnexpected); + assert!(missing.message.contains("requirements.txt"), "{missing}"); + } + #[test] fn interpreter_identity_is_case_folded_on_windows() { // SP-6: the Chocolatey shim and the direct install differ only in casing, and env_hash is diff --git a/crates/pipdock-core/src/flow/mod.rs b/crates/pipdock-core/src/flow/mod.rs index 8ec34a4..969909e 100644 --- a/crates/pipdock-core/src/flow/mod.rs +++ b/crates/pipdock-core/src/flow/mod.rs @@ -741,7 +741,7 @@ fn log_summary(flow: &str, summary: &Result) { "executed" ), Err(e) => { - tracing::warn!(target: "pipdock::flow", flow, code = %e.code, message = %e.message, "refused") + tracing::warn!(target: "pipdock::flow", flow, code = %e.code, error = %e.message, "refused") } } } diff --git a/crates/pipdock-core/src/health/mod.rs b/crates/pipdock-core/src/health/mod.rs index 63b3f8c..bfd973f 100644 --- a/crates/pipdock-core/src/health/mod.rs +++ b/crates/pipdock-core/src/health/mod.rs @@ -488,21 +488,25 @@ pub async fn sync_tools_venv( let requirements = tools_dir.join(REQUIREMENTS_FILE); let manifest_path = tools_dir.join(MANIFEST_FILE); - std::fs::create_dir_all(tools_dir).map_err(|e| fs_failure("create the tools directory", &e))?; + tokio::fs::create_dir_all(tools_dir) + .await + .map_err(|e| fs_failure("create the tools directory", &e))?; // Deleted **before** anything is touched, which inverts `snapshot::create`'s data-then-metadata // ordering — and for the opposite reason. A snapshot writes a sidecar that did not exist; a // re-sync replaces a manifest that already describes the *old* pin set. If the sync then dies // half-way, a surviving manifest would claim tools that have just been part-replaced. With it // gone, a torn sync reads as `NeverSynced` and the next run redoes the whole thing. - let _ = std::fs::remove_file(&manifest_path); + let _ = tokio::fs::remove_file(&manifest_path).await; // A rendering of the ledger, not a copy: this is where the *other* venv's pins, the comments, // and whatever line endings the build machine checked out stop. - std::fs::write(&requirements, requirements_body(&pins)) + tokio::fs::write(&requirements, requirements_body(&pins)) + .await .map_err(|e| fs_failure("write the tools requirements", &e))?; let constraints = tools_dir.join(CONSTRAINTS_FILE); - std::fs::write(&constraints, constraints_body()) + tokio::fs::write(&constraints, constraints_body()) + .await .map_err(|e| fs_failure("write the tools constraints", &e))?; // The venv is rebuilt, not repaired. `pip install -r` over an existing venv is a no-op when @@ -541,8 +545,8 @@ pub async fn sync_tools_venv( ) })?; // Written last: until it exists, the venv is not claimed to be anything. - if let Err(e) = std::fs::write(&manifest_path, json) { - let _ = std::fs::remove_file(&manifest_path); + if let Err(e) = tokio::fs::write(&manifest_path, json).await { + let _ = tokio::fs::remove_file(&manifest_path).await; return Err(fs_failure("write the tools manifest", &e)); } Ok(manifest) diff --git a/crates/pipdock-core/src/health/run.rs b/crates/pipdock-core/src/health/run.rs index 35a56ce..43155bc 100644 --- a/crates/pipdock-core/src/health/run.rs +++ b/crates/pipdock-core/src/health/run.rs @@ -222,7 +222,7 @@ async fn run_one( if tool == "deptry" && let Some(parent) = report_path.parent() { - std::fs::create_dir_all(parent).map_err(|e| { + tokio::fs::create_dir_all(parent).await.map_err(|e| { PdError::new( Code::HltToolFailed, format!("could not make room for deptry's report: {e}"), @@ -241,7 +241,7 @@ async fn run_one( let stdout = match out { Ok(out) if super::is_findings_exit(tool, out.code) => { if tool == "deptry" { - std::fs::read_to_string(&report_path).map_err(|e| { + tokio::fs::read_to_string(&report_path).await.map_err(|e| { PdError::new( Code::HltToolFailed, format!("deptry exited cleanly but wrote no report: {e}"), @@ -261,7 +261,7 @@ async fn run_one( // Cleaned on both paths: `%LOCALAPPDATA%\PipDock\data` is what SECURITY §8 promises a delete // resets, and leaving a report per run turns that into a slow leak. - let _ = std::fs::remove_file(&report_path); + let _ = tokio::fs::remove_file(&report_path).await; stdout } diff --git a/crates/pipdock-core/src/index/mod.rs b/crates/pipdock-core/src/index/mod.rs index ab4c8f6..988651c 100644 --- a/crates/pipdock-core/src/index/mod.rs +++ b/crates/pipdock-core/src/index/mod.rs @@ -301,39 +301,7 @@ pub async fn refresh(app_data: &std::path::Path, now: jiff::Timestamp) -> Result .await .map_err(|e| net_err("could not read the package index", &e))?; let wire_bytes = body.len(); - - // Typed, borrowing the names out of the body: a `serde_json::Value` of 700,000 objects is the - // whole document again in allocations, for a parse that only wants one field of each (M36). - #[derive(serde::Deserialize)] - struct Simple<'a> { - #[serde(borrow)] - projects: Vec>, - } - #[derive(serde::Deserialize)] - struct Project<'a> { - #[serde(borrow)] - name: std::borrow::Cow<'a, str>, - } - let doc: Simple<'_> = serde_json::from_slice(&body).map_err(|e| { - PdError::new( - Code::NetIndexRefreshFailed, - format!("the package index is not the PEP 691 document: {e}"), - ) - })?; - // An empty list is not an index, whatever said it was: a captive portal or a broken mirror. - // Ingesting it replaced every name with none, and search found nothing until the next week's - // refresh (L55). - if doc.projects.is_empty() { - return Err(PdError::new( - Code::NetIndexRefreshFailed, - "the package index listed no projects; the previous index is kept", - )); - } - let rows: Vec<(String, String)> = doc - .projects - .iter() - .map(|p| (crate::model::normalize_name(&p.name), p.name.to_string())) - .collect(); + let rows = parse_simple_index(&body)?; // Opened only now, after the download, and on a blocking thread: hundreds of thousands of // inserts are a second of synchronous work, which on an async worker stalls every other task @@ -356,6 +324,46 @@ pub async fn refresh(app_data: &std::path::Path, now: jiff::Timestamp) -> Result }) } +/// PEP 691's project list as `(normalized, display)` rows — everything `refresh` decides about a +/// body it was given, apart from the download, so it can be held without a network. +/// +/// # Errors +/// `PD-NET-010` for a body that is not the document, or one that lists no projects. +fn parse_simple_index(body: &[u8]) -> Result> { + // Typed, borrowing the names out of the body: a `serde_json::Value` of 700,000 objects is the + // whole document again in allocations, for a parse that only wants one field of each (M36). + #[derive(serde::Deserialize)] + struct Simple<'a> { + #[serde(borrow)] + projects: Vec>, + } + #[derive(serde::Deserialize)] + struct Project<'a> { + #[serde(borrow)] + name: std::borrow::Cow<'a, str>, + } + let doc: Simple<'_> = serde_json::from_slice(body).map_err(|e| { + PdError::new( + Code::NetIndexRefreshFailed, + format!("the package index is not the PEP 691 document: {e}"), + ) + })?; + // An empty list is not an index, whatever said it was: a captive portal or a broken mirror. + // Ingesting it replaced every name with none, and search found nothing until the next week's + // refresh (L55). + if doc.projects.is_empty() { + return Err(PdError::new( + Code::NetIndexRefreshFailed, + "the package index listed no projects; the previous index is kept", + )); + } + Ok(doc + .projects + .iter() + .map(|p| (crate::model::normalize_name(&p.name), p.name.to_string())) + .collect()) +} + /// Replace the `names` table's contents in one transaction. /// /// All-or-nothing on purpose: a refresh interrupted half-way must not leave a partial index that @@ -641,6 +649,43 @@ fn net_code(chain: &str) -> Code { mod tests { use super::*; + #[test] + fn a_pep_691_body_becomes_normalized_rows_with_the_display_name_kept() { + let rows = parse_simple_index( + br#"{"meta": {"api-version": "1.1"}, + "projects": [{"name": "Flask"}, {"name": "zope.interface"}, {"name": "ruamel_yaml"}]}"#, + ) + .expect("a real index"); + assert_eq!( + rows, + [ + ("flask".to_owned(), "Flask".to_owned()), + ("zope-interface".to_owned(), "zope.interface".to_owned()), + ("ruamel-yaml".to_owned(), "ruamel_yaml".to_owned()), + ] + ); + } + + #[test] + fn an_empty_project_list_is_refused_rather_than_wiping_the_index() { + // L55: a captive portal or a broken mirror answering 200 with nothing in it. + let err = parse_simple_index(br#"{"meta": {"api-version": "1.1"}, "projects": []}"#) + .expect_err("an index with no projects"); + assert_eq!(err.code, Code::NetIndexRefreshFailed); + assert!(err.message.contains("previous index is kept"), "{err}"); + } + + #[test] + fn a_body_that_is_not_the_document_is_an_index_error() { + for body in [ + &b"Sign in to the Wi-Fi"[..], + br#"{"projects": "all"}"#, + ] { + let err = parse_simple_index(body).expect_err("not PEP 691"); + assert_eq!(err.code, Code::NetIndexRefreshFailed); + } + } + fn index(names: &[&str]) -> NameIndex { NameIndex { entries: names diff --git a/crates/pipdock-core/src/plan/mod.rs b/crates/pipdock-core/src/plan/mod.rs index 7a69922..aa6b276 100644 --- a/crates/pipdock-core/src/plan/mod.rs +++ b/crates/pipdock-core/src/plan/mod.rs @@ -1239,4 +1239,26 @@ mod tests { "the schema must not promise it either" ); } + + #[test] + fn a_plan_confirmed_for_one_environment_is_refused_in_another() { + // DATA-FLOW §9.3 has two halves the flow tests drive end to end — age and drift. The + // third refusal sits in front of both: a plan accepted for one interpreter, executed + // against another, would install a preview nobody was shown for that environment. + let now = jiff::Timestamp::now(); + let plan = AcceptedPlan::accept( + "plan-1".to_owned(), + ResolutionReport::default(), + "hash-of-a".to_owned(), + &[], + now, + ); + let err = plan + .verify("hash-of-b", &[], now) + .expect_err("another environment"); + assert_eq!(err.code, Code::ResPlanStale); + assert!(err.message.contains("different environment"), "{err}"); + plan.verify("hash-of-a", &[], now) + .expect("the environment it was made for, unchanged, a moment later"); + } } diff --git a/crates/pipdock-core/src/release.rs b/crates/pipdock-core/src/release.rs index 2557c76..3fb62f2 100644 --- a/crates/pipdock-core/src/release.rs +++ b/crates/pipdock-core/src/release.rs @@ -118,14 +118,18 @@ async fn fetch(name: &PkgName, version: &Version) -> Option> { return None; } let doc: serde_json::Value = response.json().await.ok()?; - Some( - doc.get("info") - .and_then(|i| i.get("requires_python")) - .and_then(serde_json::Value::as_str) - .map(str::trim) - .filter(|s| !s.is_empty()) - .map(str::to_owned), - ) + Some(declared_in(&doc)) +} + +/// `info.requires_python` of a release document, `None` when it is absent, null or blank — all +/// three of which PyPI serves for a release that declares nothing. +fn declared_in(doc: &serde_json::Value) -> Option { + doc.get("info") + .and_then(|i| i.get("requires_python")) + .and_then(serde_json::Value::as_str) + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(str::to_owned) } /// Look up many releases at once, at most [`LOOKUP_CONCURRENCY`] in flight. Releases with no @@ -232,4 +236,48 @@ mod tests { assert_eq!(meta.cached(&name, &free), Some(None)); let _ = std::fs::remove_dir_all(&dir); } + + #[tokio::test] + async fn a_remembered_release_is_answered_without_asking_pypi() { + // Both answers come from the store: a constraint, and "declares nothing". Neither + // reaches the network, which this test has no way to offer. + let dir = std::env::temp_dir().join(format!("pd-release-cached-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + let meta = PyPiReleases::new(&dir); + let name = pkg("scipy"); + meta.remember(&name, &Version("1.7.3".into()), Some(">=3.7,<3.10")); + meta.remember(&name, &Version("1.16.0".into()), None); + + let capped = meta.requires_python(&name, &Version("1.7.3".into())).await; + let free = meta.requires_python(&name, &Version("1.16.0".into())).await; + let _ = std::fs::remove_dir_all(&dir); + assert_eq!(capped.as_deref(), Some(">=3.7,<3.10")); + assert_eq!(free, None); + } + + #[tokio::test] + async fn a_version_that_is_not_pep_440_never_reaches_a_url() { + // `fetch` puts the version into a URL path; anything else is unknown, which never blocks, + // and is not remembered as if it were an answer. + let dir = std::env::temp_dir().join(format!("pd-release-url-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + let meta = PyPiReleases::new(&dir); + let (name, odd) = (pkg("scipy"), Version("1.0/../../evil".into())); + assert_eq!(meta.requires_python(&name, &odd).await, None); + assert_eq!(meta.cached(&name, &odd), None, "a failure is not an answer"); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn a_release_document_s_constraint_is_read_trimmed_and_blank_is_none() { + let doc = |v: serde_json::Value| serde_json::json!({ "info": { "requires_python": v } }); + assert_eq!( + declared_in(&doc(" >=3.9 ".into())).as_deref(), + Some(">=3.9") + ); + assert_eq!(declared_in(&doc("".into())), None); + assert_eq!(declared_in(&doc(serde_json::Value::Null)), None); + assert_eq!(declared_in(&serde_json::json!({ "info": {} })), None); + assert_eq!(declared_in(&serde_json::json!({ "urls": [] })), None); + } } diff --git a/crates/pipdock-core/tests/flows.rs b/crates/pipdock-core/tests/flows.rs index 06a427e..675f5a3 100644 --- a/crates/pipdock-core/tests/flows.rs +++ b/crates/pipdock-core/tests/flows.rs @@ -1107,6 +1107,85 @@ async fn a_requires_python_nobody_knows_never_blocks() { assert!(releases.asked.load(std::sync::atomic::Ordering::SeqCst) >= 1); } +#[tokio::test] +async fn forcing_a_latest_this_python_cannot_run_forces_nothing_and_says_why() { + // The SP-1 world, except that httpcore's latest needs a newer Python than the environment's + // 3.12.4. Forcing it would pin a release that cannot install and release httpx from the + // guard set for nothing — so the decision is dropped, httpx is not named as breaking, and the + // preview carries the reason as an incompatible row instead. + let releases = Arc::new(Releases::default().with("httpcore", "1.0.9", ">=3.13")); + let engine = Scripted::default() + .with("httpx", "0.23.0", &["httpcore<0.16.0,>=0.15.0"]) + .with("httpcore", "0.15.0", &["h11<0.13,>=0.11"]) + .with("h11", "0.12.0", &[]) + .offering("httpcore", "1.0.9") + .offering("h11", "0.16.0") + .needing("httpcore", "h11", "0.16"); + let intent = Intent::Update { + all: false, + pkgs: vec!["httpcore".to_owned()], + except: Vec::new(), + force_latest: false, + }; + let (mut flow, step) = UpdateFlow::start( + env(), + Box::new(engine.clone()), + &intent, + &[], + checking(&releases), + ) + .await + .expect("start"); + assert!( + matches!(step, FlowStep::NeedsDecisions { .. }), + "httpx holds httpcore back: {step:?}" + ); + + let step = flow + .decide(&BTreeMap::from([(pkg("httpcore"), Decision::ForceLatest)])) + .await + .expect("decide"); + let report = match step { + FlowStep::NeedsDecisions { report, .. } | FlowStep::NeedsConfirm { report } => report, + other => panic!("a preview, not {other:?}"), + }; + assert!(report.forced.is_empty(), "nothing was forced: {report:?}"); + assert!( + !report + .changes + .iter() + .any(|c| c.name == pkg("httpcore") && c.to.0 == "1.0.9"), + "httpcore did not move to a release this Python cannot run" + ); + let why: Vec<(String, String, String)> = report + .incompatible + .iter() + .map(|m| { + ( + m.pkg.to_string(), + m.version.0.clone(), + m.requires_python.clone(), + ) + }) + .collect(); + assert_eq!( + why, + [( + "httpcore".to_owned(), + "1.0.9".to_owned(), + ">=3.13".to_owned() + )] + ); + + let world = engine.world(); + let last = &world.resolves.last().expect("resolved").adjust; + assert!( + !last.release.contains(&pkg("httpx")), + "httpx stayed in the guard set: forcing was dropped before it reached the engine" + ); + assert!(!last.pins.iter().any(|p| p.name == pkg("httpcore"))); +} + #[tokio::test] async fn a_rollback_across_engines_never_removes_pip() { // C7. uv's freeze has no `--all`, so a uv snapshot never lists pip; compared with pip's @@ -1151,6 +1230,84 @@ async fn a_rollback_across_engines_never_removes_pip() { assert_eq!(restored, ["idna==3.2"]); } +#[tokio::test] +async fn a_rollback_runs_end_to_end_one_package_at_a_time() { + // The restore half of `execute_rollback`, which nothing drove until the analysis measured + // it: each package installs alone, constrained by the rest of the target, so a restore that + // is 90% restorable restores 90% — and what was added since the snapshot goes first. + let engine = Scripted::default() + .with("idna", "3.4", &[]) + .with("urllib3", "2.2.0", &[]) + .with( + "requests", + "2.32.3", + &["idna<4,>=2.5", "urllib3<3,>=1.21.1"], + ); + let dir = app_data("rollback-e2e"); + let hash = pipdock_core::envs::env_hash(std::path::Path::new("python.exe")); + let target = snapshot::create( + &dir, + &hash, + "idna==3.2\nurllib3==1.26.20\n".to_owned(), + Trigger::Manual, + EngineId::Pip, + jiff::Timestamp::now(), + ) + .expect("snapshot"); + let (mut flow, preview) = RollbackFlow::start( + env(), + Box::new(engine.clone()), + &dir, + &target.meta.id, + FlowOptions::default(), + ) + .await + .expect("start"); + assert_eq!(preview.restore.uninstall, [pkg("requests")]); + + let pre = flow + .take_snapshot(&dir) + .await + .expect("the pre-rollback snapshot"); + assert!(matches!(pre.trigger, Trigger::Rollback { .. })); + let (tx, _rx) = tokio::sync::mpsc::unbounded_channel(); + let summary = flow.execute(tx).await.expect("execute"); + let _ = std::fs::remove_dir_all(&dir); + + assert_eq!(summary.counts.ok, 3, "{summary:?}"); + assert_eq!( + summary.plan_id, pre.id, + "the summary is filed under the snapshot it can undo to" + ); + assert_eq!(engine.version_of("requests"), None); + assert_eq!(engine.version_of("idna").as_deref(), Some("3.2")); + assert_eq!(engine.version_of("urllib3").as_deref(), Some("1.26.20")); + + let world = engine.world(); + let alone: Vec<(String, Vec)> = world + .installs + .iter() + .map(|set| { + ( + set.specs + .iter() + .map(|s| s.to_requirement()) + .collect::>() + .join(" "), + set.constraints.iter().map(|c| c.to_requirement()).collect(), + ) + }) + .collect(); + assert_eq!( + alone, + [ + ("idna==3.2".to_owned(), vec!["urllib3==1.26.20".to_owned()]), + ("urllib3==1.26.20".to_owned(), vec!["idna==3.2".to_owned()]), + ], + "one package per step, held to the rest of the target" + ); +} + #[tokio::test] async fn a_held_package_is_restated_in_every_plan() { // H17. `hold_requirements` existed and nothing called it, so a held package was only left diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index ff256a7..d8097cd 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -1439,7 +1439,7 @@ are required, every PR would have been red as well. Dependabot opened a PR for n |---|---| | Analysis | `sonar.yml`: one Windows job — vitest and `cargo llvm-cov` LCOV, clippy's JSON, `sonarqube-scan-action` v8.3.0 pinned by commit, `sonar.qualitygate.wait` so a red gate on `main` reaches Discord | | Scope | `sonar-project.properties`: everything tracked, tests split out, fixtures and binaries excluded, coverage excluded only where no test here can execute the code, with the reason beside each | -| New code | `sonar.projectVersion` from `package.json`, so a release bump starts a period | +| New code | `sonar.projectVersion` from `package.json`, which the previous-version period keys on — though sending the first one did not move it (below) | | The token | In the scanner step's environment alone; a job with no token (Dependabot, forks) is skipped, not failed | | Audits | The four bumps above, and nothing ignored | | Dependabot | A `vitest` group, because `@vitest/coverage-v8` peers vitest exactly; the `rfd` and `typescript` ignores re-checked and both still needed | @@ -1458,6 +1458,24 @@ are required, every PR would have been red as well. Dependabot opened a PR for n once `sonar.sources=.` replaced automatic analysis's own scoping. - **The scanner's signature check works on a Windows runner.** v8 verifies the CLI's OpenPGP signature by default, and Git for Windows' `gpg.exe` does it; no `skipSignatureVerification`. +- **The first analysis of `main` failed its gate**, on the two things automatic analysis could + never have seen. **Sixteen Rust findings**, every one a bug by Sonar's classification: three + `rust:S6677` — `message = %e.message` beside a format string records two fields called + `message`, and the log line read `failed code=PD-ENV-001 no interpreter at …` with the error's + words indistinguishable from the event's (now `error = …`, as every other failure logs it, and + `golden.rs` reads the CLI's log to hold it) — and thirteen `rust:S7493`, `std::fs` inside an + `async fn`: the tools-venv sync, Code Health's deptry report, and the four commands that write or + read a file the user chose, on what may be a network drive. They go through `tokio::fs` now. + And **new-code coverage 78.3 %** against 80 %. +- **Sending a version did not move the baseline.** The analysis that first sent `1.4.0` still + measured new code from 2026-09-27, so "new" was all of 1.4.0's audit — 4 037 lines, 849 of them + uncovered. The answer was tests rather than a setting: the restore half of `execute_rollback`, a + force the environment's Python cannot run, PEP 691 parsing (split out of `index::refresh`, with + L55's empty list finally under test), `user_file_error` (U25), a plan verified against another + environment, the cached half of `release::PyPiReleases`, and the store paths no test had driven + — a resolve that succeeds, a round of decisions, a rollback preview, and late answers on the + error paths. `InstallSet::only` had no caller and went. Estimated against Sonar's own per-line + data before pushing, by a script that reproduced its 78.28 % exactly: 81.2 %. - **Cost:** eight to eleven minutes on a Windows runner beside the required checks, three of them restoring ci-rust.yml's cache read-only. Saving a cache of its own was rejected: the repository is at 8.6 of its 10 GB, and a fourth Windows cargo cache would evict the ones the required checks restore. diff --git a/docs/TESTING.md b/docs/TESTING.md index 5b04c3b..ab8e93c 100644 --- a/docs/TESTING.md +++ b/docs/TESTING.md @@ -72,7 +72,7 @@ The plan was one scripted tauri-driver run on a Windows runner — launch → le ## 3. Coverage & gates -**Coverage is measured since 2026-10-25, and gated only on new code.** `sonar.yml` runs `cargo llvm-cov --workspace` and `npm run test:coverage` (vitest's v8 provider) on Windows and hands both LCOV files to SonarQube Cloud, whose quality gate asks **80 % of new lines** covered — new meaning since the version in `package.json` last changed. The first measurement, of `main` at 1.4.0: **Rust 71.6 %** of 15 364 lines, **TypeScript 68.4 %** of 1 569. The two large holes are honest rather than unmeasured: `pipdock-cli/src/run.rs` (4 %) is the CLI driving a real interpreter, which L2 exercises and L1 cannot, and `src-tauri/src/commands.rs` (0 %) is the IPC surface, reached only by a running app. `sonar-project.properties` excludes from coverage only what no test here can execute (tooling, spikes, `probe.py`, generated bindings, the two entry points) and says why for each. +**Coverage is measured since 2026-10-25, and gated only on new code.** `sonar.yml` runs `cargo llvm-cov --workspace` and `npm run test:coverage` (vitest's v8 provider) on Windows and hands both LCOV files to SonarQube Cloud, whose quality gate asks **80 % of new lines** covered — new meaning since the previous version's period began, which at the switch was still the first analysis (2026-09-27), so all of 1.4.0 counted. The first measurement, of `main` at 1.4.0: **Rust 71.6 %** of 15 364 lines, **TypeScript 68.4 %** of 1 569. The two large holes are honest rather than unmeasured: `pipdock-cli/src/run.rs` (4 %) is the CLI driving a real interpreter, which L2 exercises and L1 cannot, and `src-tauri/src/commands.rs` (0 %) is the IPC surface, reached only by a running app. `sonar-project.properties` excludes from coverage only what no test here can execute (tooling, spikes, `probe.py`, generated bindings, the two entry points) and says why for each. This section once set targets — core ≥ 85 % line coverage, classifiers and plan module ≥ 95 % — that nothing measured until then. They are not the gate; the gate is new code, and §1's rule — a test that failed first — is still the guarantee a percentage cannot give. By file, `errors/catalog.rs` is at 99.5 % and `plan/` at 85–99 %. diff --git a/sonar-project.properties b/sonar-project.properties index ff737a0..10a4d70 100644 --- a/sonar-project.properties +++ b/sonar-project.properties @@ -5,7 +5,8 @@ # could import no coverage at all. It also sent no project version, so the "previous version" # new-code period stayed anchored to the first analysis (2026-09-27) and "new code" only ever grew. # The workflow passes `sonar.projectVersion` from package.json, which is one of the five places the -# version lives (CLAUDE.md), so a release bump is what starts a new period. +# version lives (CLAUDE.md) and what the previous-version period keys on. The first analysis to +# send one kept the old baseline; whether a bump moves it is to be read from the gate, not assumed. sonar.organization=poli0981 sonar.projectKey=poli0981_pipdock diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index b4d1d7f..18fd278 100644 --- a/src-tauri/Cargo.toml +++ b/src-tauri/Cargo.toml @@ -31,7 +31,8 @@ tauri-plugin-clipboard-manager = "2.5.0" serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.154" jiff = "0.2.38" -tokio = { version = "1.53.3", features = ["rt-multi-thread", "sync"] } +# `fs` for the commands that write a file the user chose, which may be on a slow or network drive. +tokio = { version = "1.53.3", features = ["rt-multi-thread", "sync", "fs"] } # `plan_cancel` trips the same `CancellationToken` the core threads through `exec`. tokio-util = "0.7.20" tracing = "0.1.44" diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs index 2ab1ce2..c4fc90d 100644 --- a/src-tauri/src/commands.rs +++ b/src-tauri/src/commands.rs @@ -449,7 +449,8 @@ pub async fn env_export( }; let freeze = engine.freeze(&env).await?; let target = std::path::PathBuf::from(&path); - std::fs::write(&target, freeze) + tokio::fs::write(&target, freeze) + .await .map_err(|e| pipdock_core::exec::user_file_error(&target, &e))?; Ok(target.display().to_string()) } @@ -469,7 +470,8 @@ pub async fn env_export( pub async fn requirements_read( path: String, ) -> Wire { - let text = std::fs::read_to_string(&path) + let text = tokio::fs::read_to_string(&path) + .await .map_err(|e| pipdock_core::exec::user_file_error(std::path::Path::new(&path), &e))?; Ok(pipdock_core::requirements::parse(&text)) } @@ -1239,7 +1241,8 @@ pub async fn audit_save_report( })?; for (target, contents) in [(&md, body), (&json, document)] { - std::fs::write(target, contents) + tokio::fs::write(target, contents) + .await .map_err(|e| pipdock_core::exec::user_file_error(target, &e))?; } Ok(vec![md.display().to_string(), json.display().to_string()]) @@ -1398,7 +1401,8 @@ pub async fn health_save_report( })?; for (target, contents) in [(&md, body), (&json, document)] { - std::fs::write(target, contents) + tokio::fs::write(target, contents) + .await .map_err(|e| pipdock_core::exec::user_file_error(target, &e))?; } Ok(vec![md.display().to_string(), json.display().to_string()]) diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 8a669f4..fa8dc8c 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -92,7 +92,7 @@ pub fn run() { let state = match state::AppState::new() { Ok(state) => state, Err(e) => { - tracing::error!(target: "pipdock::app", code = %e.code, message = %e.message, "could not start"); + tracing::error!(target: "pipdock::app", code = %e.code, error = %e.message, "could not start"); startup_failed(&e, &log); return; } diff --git a/ui/src/components/PdPreviewDiff.test.tsx b/ui/src/components/PdPreviewDiff.test.tsx index caa3fd9..93c1164 100644 --- a/ui/src/components/PdPreviewDiff.test.tsx +++ b/ui/src/components/PdPreviewDiff.test.tsx @@ -176,6 +176,41 @@ describe('what the report says besides the changes', () => { expect(within(section('new-install')).getByText('oldlib')).toBeInTheDocument() }) + it('shows an unattributed blocker as its bare constraint, and a dependent without a version', () => { + // ARCHITECTURE §3: when attribution is ambiguous the constraint is shown without a culprit + // rather than guessed (`Blocker.by` absent), and the probe does not always know a dependent's + // version. Each still counts once toward what forcing breaks. + const numpy = FORCED.forced?.[0] + if (numpy === undefined) throw new Error('the forced fixture forces numpy') + show({ + ...FORCED, + forced: [ + { + ...numpy, + blockers: [{ constraint: 'numpy<2' }, { by: 'pandas', constraint: 'numpy<2,>=1.26.0' }], + }, + ], + yanked: [{ pkg: 'oldlib', version: '2.0.0' }], + }) + const forced = section('forced') + expect(within(forced).getByText('Will break (2)')).toBeInTheDocument() + expect(within(forced).getByText('numpy<2')).toBeInTheDocument() + expect(within(forced).getByText('pandas requires numpy<2,>=1.26.0')).toBeInTheDocument() + // A withdrawal with no reason given is still said, without a dangling colon. + expect( + within(section('yanked')).getByText('oldlib 2.0.0 was withdrawn by its maintainers.'), + ).toBeInTheDocument() + }) + + it('heads a force that breaks nothing by what was forced, not by a count of zero', () => { + const numpy = FORCED.forced?.[0] + if (numpy === undefined) throw new Error('the forced fixture forces numpy') + show({ ...FORCED, forced: [{ pkg: numpy.pkg, latest: numpy.latest, resolved: numpy.resolved }] }) + const forced = section('forced') + expect(within(forced).getByText('Forced (1)')).toBeInTheDocument() + expect(within(forced).queryByText(/Will break/)).toBeNull() + }) + it('does not call a plan whose only content is a left-out package "nothing to change"', () => { // The user asked for numba and is owed the reason it is not happening. show({ changes: [], heldBack: [], incompatible: FORCED.incompatible ?? [] }) diff --git a/ui/src/stores/plan.test.ts b/ui/src/stores/plan.test.ts index 95a4596..924b713 100644 --- a/ui/src/stores/plan.test.ts +++ b/ui/src/stores/plan.test.ts @@ -10,8 +10,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' import * as ipc from '@/ipc' -import type { GuardReport, PyEnv } from '@/ipc' +import type { FlowStep, GuardReport, Intent, PyEnv, RollbackPreview } from '@/ipc' import { PANEL_PHASES, usePlanStore } from '@/stores/plan' +import flowStep from '@/test/fixtures/flow_step.json' +import rollbackPreview from '@/test/fixtures/rollback_preview.json' import { resetStore } from '@/test/stores' // The factory imports lazily because `vi.mock` is hoisted above every import in this file — a @@ -37,6 +39,23 @@ const BREAKING: GuardReport = { } const CLEAR: GuardReport = { removing: ['numpy', 'pandas'], breaks: {}, withDependents: [] } +/** Computed from the real `FlowStep` by `cargo run -p xtask -- ipc-fixtures`. */ +const DECISIONS = flowStep as FlowStep +const SKIPPED: FlowStep = { step: 'nothing', reason: 'everything-skipped' } +const PREVIEW = rollbackPreview as RollbackPreview +const UPDATE_ALL: Intent = { intent: 'update', all: true, pkgs: [], except: [], forceLatest: false } + +/** A promise the test settles by hand, so a second action can overtake the first. */ +function deferred() { + let resolve!: (value: T) => void + let reject!: (reason: unknown) => void + const promise = new Promise((res, rej) => { + resolve = res + reject = rej + }) + return { promise, resolve, reject } +} + describe('usePlanStore', () => { beforeEach(() => { vi.clearAllMocks() @@ -150,4 +169,122 @@ describe('usePlanStore', () => { expect(unlisten).toHaveBeenCalledOnce() expect(usePlanStore.getState().phase).toBe('summary') }) + + it('shows a resolved plan as a preview of the kind that was asked for', async () => { + vi.mocked(ipc.planResolve).mockResolvedValue(DECISIONS) + await usePlanStore.getState().resolve(ENV, { intent: 'install', specs: ['httpx'] }) + + const { phase, step, kind, env } = usePlanStore.getState() + expect(phase).toBe('preview') + expect(step).toEqual(DECISIONS) + expect(kind).toBe('install') + expect(env).toEqual(ENV) + }) + + it('sends the round its answers belong to, and clears them with it', async () => { + vi.mocked(ipc.planResolve).mockResolvedValue(DECISIONS) + vi.mocked(ipc.planDecide).mockResolvedValue(SKIPPED) + await usePlanStore.getState().resolve(ENV, UPDATE_ALL) + usePlanStore.getState().choose('numpy', 'skip') + usePlanStore.getState().choose('scipy', 'force-latest') + + await usePlanStore.getState().submitDecisions() + + expect(ipc.planDecide).toHaveBeenCalledWith({ numpy: 'skip', scipy: 'force-latest' }) + const { phase, step, decisions } = usePlanStore.getState() + expect(phase).toBe('preview') + expect(step).toEqual(SKIPPED) + // The next preview may name other packages; an answer about one no longer in conflict + // would be sent back to a flow that has moved on. + expect(decisions).toEqual({}) + }) + + it('keeps the preview usable when a round of decisions fails', async () => { + // U24: a failed re-resolve leaves the flow as it was, so the screen must too — the same + // preview, with the error beside it, decidable again. + vi.mocked(ipc.planResolve).mockResolvedValue(DECISIONS) + vi.mocked(ipc.planDecide).mockRejectedValue({ code: 'PD-NET-001', message: 'index down' }) + await usePlanStore.getState().resolve(ENV, UPDATE_ALL) + usePlanStore.getState().choose('numpy', 'force-latest') + + await usePlanStore.getState().submitDecisions() + + const { phase, step, error, decisions } = usePlanStore.getState() + expect(phase).toBe('preview') + expect(step).toEqual(DECISIONS) + expect(error?.code).toBe('PD-NET-001') + expect(decisions).toEqual({ numpy: 'force-latest' }) + }) + + it('previews a rollback as a rollback, and confirms it with the rollback command', async () => { + vi.mocked(ipc.snapshotRollbackPreview).mockResolvedValue(PREVIEW) + await usePlanStore.getState().rollback(ENV, PREVIEW.target.id) + + expect(ipc.snapshotRollbackPreview).toHaveBeenCalledWith(ENV, PREVIEW.target.id) + const { phase, preview, kind } = usePlanStore.getState() + expect(phase).toBe('preview') + expect(preview).toEqual(PREVIEW) + expect(kind).toBe('rollback') + + // One Confirm button for both flows: which command it sends is the session's kind. + vi.mocked(ipc.snapshotRollback).mockRejectedValue({ code: 'PD-SNP-001', message: 'no room' }) + await usePlanStore.getState().execute() + expect(ipc.snapshotRollback).toHaveBeenCalledOnce() + expect(ipc.planExecute).not.toHaveBeenCalled() + }) + + it('lands a failed rollback preview where the user can see it', async () => { + vi.mocked(ipc.snapshotRollbackPreview).mockRejectedValue({ + code: 'PD-SNP-002', + message: 'that snapshot is gone', + }) + await usePlanStore.getState().rollback(ENV, 'missing') + + expect(usePlanStore.getState().phase).toBe('failed') + expect(usePlanStore.getState().error?.code).toBe('PD-SNP-002') + }) + + it('drops the answer to a resolve the user has already moved on from', async () => { + // Every action bumps the generation; a reply from the one before it must not overwrite the + // screen the user is now on — here, a preview arriving over an uninstall guard. + const late = deferred() + vi.mocked(ipc.planResolve).mockReturnValue(late.promise) + vi.mocked(ipc.uninstallGuard).mockResolvedValue(BREAKING) + + const resolving = usePlanStore.getState().resolve(ENV, UPDATE_ALL) + await usePlanStore.getState().startUninstall(ENV, ['numpy']) + late.resolve(DECISIONS) + await resolving + + const { phase, step, guard } = usePlanStore.getState() + expect(phase).toBe('guard') + expect(guard).toEqual(BREAKING) + expect(step).toBeNull() + }) + + it('drops a late failure the same way, for every action that waits', async () => { + const lateResolve = deferred() + const lateDecide = deferred() + const latePreview = deferred() + vi.mocked(ipc.planResolve).mockResolvedValueOnce(DECISIONS).mockReturnValueOnce(lateResolve.promise) + vi.mocked(ipc.planDecide).mockReturnValue(lateDecide.promise) + vi.mocked(ipc.snapshotRollbackPreview).mockReturnValue(latePreview.promise) + vi.mocked(ipc.uninstallGuard).mockResolvedValue(CLEAR) + + await usePlanStore.getState().resolve(ENV, UPDATE_ALL) + const deciding = usePlanStore.getState().submitDecisions() + const resolving = usePlanStore.getState().resolve(ENV, UPDATE_ALL) + const previewing = usePlanStore.getState().rollback(ENV, 'id') + await usePlanStore.getState().startUninstall(ENV, ['numpy', 'pandas']) + + lateDecide.reject({ code: 'PD-NET-001', message: 'late' }) + lateResolve.reject({ code: 'PD-NET-001', message: 'late' }) + latePreview.reject({ code: 'PD-NET-001', message: 'late' }) + await Promise.all([deciding, resolving, previewing]) + + const { phase, error, guard } = usePlanStore.getState() + expect(phase).toBe('guard') + expect(guard).toEqual(CLEAR) + expect(error).toBeNull() + }) }) diff --git a/ui/src/stores/races.test.ts b/ui/src/stores/races.test.ts index a2ab8f0..389a536 100644 --- a/ui/src/stores/races.test.ts +++ b/ui/src/stores/races.test.ts @@ -86,6 +86,45 @@ describe('a slow answer for an environment the user has left', () => { expect(useEnvStore.getState().outdated).toEqual([]) expect(useEnvStore.getState().outdatedStatus).toBe('idle') }) + + it('does not put the left environment’s failure on the new one either', async () => { + // The same rule on the error path: an unreachable index for the environment the user left + // must not mark the one they are now looking at as unreadable. + const list = deferredFailure() + const outdated = deferredFailure() + vi.mocked(ipc.pkgList).mockReturnValueOnce(list.promise) + vi.mocked(ipc.pkgOutdated).mockReturnValueOnce(outdated.promise) + const listing = useEnvStore.getState().loadPackages() + const badges = useEnvStore.getState().loadOutdated() + + useEnvStore.getState().select(env('b').interpreter) + list.fail({ code: 'PD-ENV-003', message: 'probe failed' }) + outdated.fail({ code: 'PD-NET-001', message: 'offline' }) + await Promise.all([listing, badges]) + + const { listError, outdatedError, listing: state } = useEnvStore.getState() + expect(listError).toBeNull() + expect(outdatedError).toBeNull() + expect(state).not.toBe('error') + }) +}) + +/** A promise the test rejects when it chooses, with a `PdError`-shaped plain object. */ +function deferredFailure() { + let fail: (error: { code: string; message: string }) => void = () => undefined + const promise = new Promise((_, reject) => { + fail = reject + }) + return { promise, fail } +} + +const meta = (id: string) => ({ + id, + createdAt: '2026-10-25T00:00:00Z', + trigger: 'manual' as const, + engine: 'pip' as const, + packageCount: 3, + appVersion: '1.4.0', }) describe('the timeline', () => { @@ -108,6 +147,54 @@ describe('the timeline', () => { expect(useEnvStore.getState().selectedSnapshot).toBe('two') expect(useEnvStore.getState().diff).toEqual(second) }) + + it('lists the snapshots of the environment that is open, by its hash', async () => { + vi.mocked(ipc.snapshotList).mockResolvedValueOnce([meta('one')]) + await useEnvStore.getState().loadSnapshots() + + // By `envHash`: a snapshot outlives the Python that made it. + expect(ipc.snapshotList).toHaveBeenCalledWith('hash-a') + const { snapshots, snapshotsFor, snapshotsLoading } = useEnvStore.getState() + expect(snapshots).toEqual([meta('one')]) + expect(snapshotsFor).toBe(env('a').interpreter) + expect(snapshotsLoading).toBe('ready') + }) + + it('drops the timeline of an environment closed before it arrived, and its failure', async () => { + useEnvStore.setState({ rows: [row('a'), row('b')] }) + const slow = held[]>() + const failing = deferredFailure() + vi.mocked(ipc.snapshotList).mockReturnValueOnce(slow.promise).mockReturnValueOnce(failing.promise) + + const first = useEnvStore.getState().loadSnapshots() + useEnvStore.getState().openEnv(env('b').interpreter) + slow.release([meta('of-a')]) + await first + expect(useEnvStore.getState().snapshots).not.toEqual([meta('of-a')]) + + const second = useEnvStore.getState().loadSnapshots() + useEnvStore.getState().openEnv(env('a').interpreter) + failing.fail({ code: 'PD-SNP-003', message: 'unreadable' }) + await second + expect(ipc.snapshotList).toHaveBeenCalledTimes(2) + expect(useEnvStore.getState().snapshotsError).toBeNull() + }) + + it('does not show the failure of a diff the user has clicked away from', async () => { + const failing = deferredFailure() + const second = { added: [], removed: [], changed: [] } + vi.mocked(ipc.snapshotDiff).mockReturnValueOnce(failing.promise).mockResolvedValueOnce(second) + + const first = useEnvStore.getState().selectSnapshot('one') + await useEnvStore.getState().selectSnapshot('two') + failing.fail({ code: 'PD-SNP-003', message: 'unreadable' }) + await first + + const { diff, diffLoading, snapshotsError } = useEnvStore.getState() + expect(diff).toEqual(second) + expect(diffLoading).toBe('ready') + expect(snapshotsError).toBeNull() + }) }) describe('leaving a plan the backend is still working on', () => { diff --git a/ui/src/test/ipc.ts b/ui/src/test/ipc.ts index d5688d3..2aa5982 100644 --- a/ui/src/test/ipc.ts +++ b/ui/src/test/ipc.ts @@ -62,7 +62,10 @@ export interface IpcMock { healthDirty: ReturnType reportBugUrl: ReturnType logsTail: ReturnType + snapshotList: ReturnType snapshotDiff: ReturnType + snapshotRollbackPreview: ReturnType + snapshotRollback: ReturnType indexSearch: ReturnType appInfo: ReturnType settingsGet: ReturnType @@ -127,7 +130,13 @@ export function ipcMock(): IpcMock { healthDirty: vi.fn().mockResolvedValue(null), // Settings renders the Logs row, so every Settings test needs this to resolve to a real shape. logsTail: vi.fn().mockResolvedValue({ dir: 'C:/data/logs', lines: [] }), + // An empty timeline. Missing until the timeline's own race tests needed it: every test that + // opened an environment reached `loadSnapshots`, threw on the absent export, and rendered + // the timeline's error without anyone asking for one. + snapshotList: vi.fn().mockResolvedValue([]), snapshotDiff: vi.fn(), + snapshotRollbackPreview: vi.fn(), + snapshotRollback: vi.fn(), // Ready and empty by default: a test about warming says so. indexSearch: vi.fn().mockResolvedValue({ hits: [], ready: true }), // `PdErrorRow` asks for this on mount, so any test that renders a screen containing an error