affected_cli.rs (17700B)
1 //! Actual CLI, history and input-mutation regressions in complete standalone copies. 2 use serde_json::Value; 3 use std::fs; 4 use std::path::{Path, PathBuf}; 5 use std::process::{Command, Output}; 6 use std::sync::atomic::{AtomicU64, Ordering}; 7 8 static NEXT: AtomicU64 = AtomicU64::new(0); 9 struct Fixture(PathBuf); 10 impl Fixture { 11 fn new() -> Self { 12 let path = std::env::temp_dir().join(format!( 13 "harvestcircle affected {} {}", 14 std::process::id(), 15 NEXT.fetch_add(1, Ordering::Relaxed) 16 )); 17 fs::create_dir(&path).unwrap(); 18 let source = Path::new(env!("CARGO_MANIFEST_DIR")) 19 .parent() 20 .unwrap() 21 .parent() 22 .unwrap(); 23 copy_archive_source(source, source, &path); 24 Self(path) 25 } 26 fn init(&self) -> String { 27 git(&self.0, &["init", "-b", "master"]); 28 self.commit() 29 } 30 fn commit(&self) -> String { 31 git(&self.0, &["add", "."]); 32 git( 33 &self.0, 34 &[ 35 "-c", 36 "user.name=fixture", 37 "-c", 38 "user.email=fixture@example.invalid", 39 "-c", 40 "commit.gpgsign=false", 41 "commit", 42 "--allow-empty", 43 "-m", 44 "fixture", 45 ], 46 ); 47 String::from_utf8(git(&self.0, &["rev-parse", "HEAD"]).stdout) 48 .unwrap() 49 .trim() 50 .to_owned() 51 } 52 } 53 impl Drop for Fixture { 54 fn drop(&mut self) { 55 fs::remove_dir_all(&self.0).unwrap(); 56 } 57 } 58 fn git(root: &Path, args: &[&str]) -> Output { 59 let output = Command::new("git") 60 .arg("-C") 61 .arg(root) 62 .args(args) 63 .env_remove("GIT_DIR") 64 .env_remove("GIT_WORK_TREE") 65 .env_remove("GIT_INDEX_FILE") 66 .env("GIT_CONFIG_GLOBAL", "/dev/null") 67 .env("GIT_CONFIG_NOSYSTEM", "1") 68 .output() 69 .unwrap(); 70 assert!( 71 output.status.success(), 72 "{}", 73 String::from_utf8_lossy(&output.stderr) 74 ); 75 output 76 } 77 fn report(root: &Path, base: Option<&str>, env: &[(&str, &str)]) -> (Output, Value) { 78 let mut command = Command::new(env!("CARGO_BIN_EXE_harvestcircle_xtask")); 79 command 80 .current_dir(root) 81 .arg("affected-report") 82 .env_remove("HARVESTCIRCLE_AFFECTED_BASE"); 83 if let Some(base) = base { 84 command.args(["--base", base]); 85 } 86 for (name, value) in env { 87 command.env(name, value); 88 } 89 let output = command.output().unwrap(); 90 let value = serde_json::from_slice(&output.stdout) 91 .unwrap_or_else(|e| panic!("{e}: {}", String::from_utf8_lossy(&output.stderr))); 92 (output, value) 93 } 94 fn assert_all(value: &Value) { 95 for lane in ["native", "web", "interop"] { 96 assert_eq!(value["selection"][lane], true, "{}", value["selection"]); 97 } 98 } 99 fn append(root: &Path, path: &str) { 100 let p = root.join(path); 101 let mut text = fs::read_to_string(&p).unwrap(); 102 text.push('\n'); 103 fs::write(p, text).unwrap(); 104 } 105 106 #[test] 107 fn web_only_changes_keep_native_source_identity_but_not_head_provenance() { 108 let fixture = Fixture::new(); 109 let base = fixture.init(); 110 let (first, before) = report(&fixture.0, Some(&base), &[]); 111 assert!(first.status.success()); 112 append(&fixture.0, "web/src/app.html"); 113 fixture.commit(); 114 let (second, after) = report(&fixture.0.join("web/src"), Some(&base), &[]); 115 assert!(second.status.success()); 116 assert_eq!(after["selection"]["web"], true); 117 if after["native"]["input_identity"].is_null() || after["web"]["input_identity"].is_null() { 118 assert_all(&after); 119 } else { 120 assert_eq!(after["selection"]["native"], false); 121 } 122 assert_eq!( 123 before["native"]["source_identity"], 124 after["native"]["source_identity"] 125 ); 126 assert_ne!( 127 before["web"]["source_identity"], 128 after["web"]["source_identity"] 129 ); 130 assert_ne!( 131 before["source_provenance"]["head"], 132 after["source_provenance"]["head"] 133 ); 134 assert_eq!(after["native"]["execution"], "NOT_EXECUTED"); 135 assert_eq!(after["native"]["reuse"], "NOT_ACCEPTED_BY_THIS_REPORT"); 136 } 137 #[test] 138 fn old_and_new_rename_paths_deletion_unknown_and_missing_base_widen() { 139 let fixture = Fixture::new(); 140 fixture.init(); 141 fs::write( 142 fixture.0.join("web/old name.ts"), 143 "export const fixture = 1;\n", 144 ) 145 .unwrap(); 146 fixture.commit(); 147 fs::rename( 148 fixture.0.join("web/old name.ts"), 149 fixture.0.join("web/new name.ts"), 150 ) 151 .unwrap(); 152 fixture.commit(); 153 // Rename detection requires an actual old-path base, not a pre-add base. 154 let previous = String::from_utf8(git(&fixture.0, &["rev-parse", "HEAD^"]).stdout).unwrap(); 155 let (_, renamed) = report(&fixture.0, Some(previous.trim()), &[]); 156 assert_all(&renamed); 157 let paths = renamed["selection"]["changed_paths"].as_array().unwrap(); 158 assert!(paths.contains(&Value::from("web/old name.ts"))); 159 assert!(paths.contains(&Value::from("web/new name.ts"))); 160 let deletion_base = fixture.commit(); 161 fs::remove_file(fixture.0.join("web/new name.ts")).unwrap(); 162 let (deleted, value) = report(&fixture.0, Some(&deletion_base), &[]); 163 assert!(!deleted.status.success()); 164 assert_all(&value); 165 assert_eq!(value["repository_safety"]["status"], "FAIL"); 166 fixture.commit(); 167 fs::write( 168 fixture.0.join("unknown input.txt"), 169 "ordinary unknown input\n", 170 ) 171 .unwrap(); 172 let (_, unknown) = report(&fixture.0, Some(&deletion_base), &[]); 173 assert_all(&unknown); 174 for base in [None, Some("missing-revision"), Some("bad\nrevision")] { 175 let (_, v) = report(&fixture.0, base, &[]); 176 assert_all(&v); 177 assert!(!v["selection"]["reasons"].as_array().unwrap().is_empty()); 178 } 179 } 180 #[test] 181 fn native_lock_shared_fixture_make_and_environment_invalidate_inputs() { 182 let fixture = Fixture::new(); 183 let base = fixture.init(); 184 let (_, before) = report(&fixture.0, Some(&base), &[]); 185 append(&fixture.0, "core/Cargo.lock"); 186 let (_, native) = report(&fixture.0, Some(&base), &[]); 187 assert_eq!(native["selection"]["native"], true); 188 assert_ne!( 189 before["native"]["source_identity"], 190 native["native"]["source_identity"] 191 ); 192 append(&fixture.0, "Makefile"); 193 let (_, both) = report(&fixture.0, Some(&base), &[]); 194 assert_all(&both); 195 let (_, environment) = report( 196 &fixture.0, 197 Some(&base), 198 &[("RUSTFLAGS", "--cfg harvestcircle_input_probe")], 199 ); 200 assert_ne!( 201 both["native"]["inputs"]["environment_sha256"], 202 environment["native"]["inputs"]["environment_sha256"] 203 ); 204 assert_eq!( 205 both["native"]["source_identity"], 206 environment["native"]["source_identity"] 207 ); 208 let shared = fixture.0.join("contracts/interop/affected fixture.json"); 209 fs::write(shared, "{}\n").unwrap(); 210 let (_, shared) = report(&fixture.0, Some(&base), &[]); 211 assert_all(&shared); 212 assert_ne!( 213 both["web"]["source_identity"], 214 shared["web"]["source_identity"] 215 ); 216 } 217 #[test] 218 fn archive_nested_parent_and_shallow_history_are_explicit_conservative_fallbacks() { 219 let fixture = Fixture::new(); 220 let (archive, v) = report(&fixture.0, None, &[]); 221 assert!(archive.status.success()); 222 assert_all(&v); 223 let parent = fixture.0.parent().unwrap().join(format!( 224 "harvestcircle parent {}", 225 NEXT.fetch_add(1, Ordering::Relaxed) 226 )); 227 fs::create_dir(&parent).unwrap(); 228 let capsule = parent.join("capsule"); 229 fs::rename(&fixture.0, &capsule).unwrap(); 230 git(&parent, &["init", "-b", "master"]); 231 let (_, v) = report(&capsule, None, &[]); 232 assert_all(&v); 233 assert!(v["source_provenance"]["head"].is_null()); 234 assert!( 235 v["selection"]["reasons"] 236 .as_array() 237 .unwrap() 238 .iter() 239 .any(|v| v.as_str().unwrap().contains("enclosing history")) 240 ); 241 fs::rename(&capsule, &fixture.0).unwrap(); 242 fs::remove_dir_all(parent).unwrap(); 243 let base = fixture.init(); 244 fs::write(fixture.0.join(".git/shallow"), format!("{base}\n")).unwrap(); 245 let (_, v) = report(&fixture.0, Some(&base), &[]); 246 assert_all(&v); 247 assert!( 248 v["selection"]["reasons"] 249 .as_array() 250 .unwrap() 251 .iter() 252 .any(|v| v.as_str().unwrap().contains("shallow")) 253 ); 254 } 255 #[test] 256 fn forced_generated_input_never_escapes_fresh_policy_and_missing_tools_never_claim_reuse() { 257 let fixture = Fixture::new(); 258 let base = fixture.init(); 259 let tools = Fixture(std::env::temp_dir().join(format!( 260 "harvestcircle tool absence {} {}", 261 std::process::id(), 262 NEXT.fetch_add(1, Ordering::Relaxed) 263 ))); 264 fs::create_dir(&tools.0).unwrap(); 265 let git_executable = std::env::split_paths(&std::env::var_os("PATH").unwrap()) 266 .map(|path| path.join("git")) 267 .find(|path| path.is_file()) 268 .unwrap(); 269 #[cfg(unix)] 270 std::os::unix::fs::symlink(git_executable, tools.0.join("git")).unwrap(); 271 #[cfg(not(unix))] 272 fs::copy(git_executable, tools.0.join("git.exe")).unwrap(); 273 let (_, v) = report( 274 &fixture.0, 275 Some(&base), 276 &[("PATH", tools.0.to_str().unwrap())], 277 ); 278 assert_all(&v); 279 assert_eq!(v["native"]["availability"], "TOOL_UNAVAILABLE"); 280 assert_eq!(v["web"]["availability"], "TOOL_UNAVAILABLE"); 281 assert!(v["native"]["input_identity"].is_null()); 282 fs::create_dir_all(fixture.0.join("web/build")).unwrap(); 283 fs::write( 284 fixture.0.join("web/build/forced.js"), 285 "ordinary generated output\n", 286 ) 287 .unwrap(); 288 git(&fixture.0, &["add", "-f", "web/build/forced.js"]); 289 let (output, v) = report(&fixture.0, Some(&base), &[]); 290 assert!(!output.status.success()); 291 assert_eq!(v["repository_safety"]["status"], "FAIL"); 292 } 293 294 #[test] 295 fn linked_worktree_has_own_history_and_malformed_paths_fail_fresh_policy() { 296 let fixture = Fixture::new(); 297 let base = fixture.init(); 298 let linked = Fixture(std::env::temp_dir().join(format!( 299 "harvestcircle affected worktree {} {}", 300 std::process::id(), 301 NEXT.fetch_add(1, Ordering::Relaxed) 302 ))); 303 git( 304 &fixture.0, 305 &[ 306 "worktree", 307 "add", 308 "--detach", 309 linked.0.to_str().unwrap(), 310 "HEAD", 311 ], 312 ); 313 append(&linked.0, "web/src/app.html"); 314 let (output, v) = report(&linked.0.join("web"), Some(&base), &[]); 315 assert!(output.status.success()); 316 assert_eq!(v["selection"]["merge_base"], base); 317 assert_eq!(v["source_provenance"]["head"], base); 318 assert_eq!(v["source_provenance"]["dirty"], true); 319 fs::write( 320 linked.0.join("web/literal%2fescape.ts"), 321 "export const fixture = true;\n", 322 ) 323 .unwrap(); 324 let (output, v) = report(&linked.0, Some(&base), &[]); 325 assert!(!output.status.success()); 326 assert_all(&v); 327 assert_eq!(v["repository_safety"]["status"], "FAIL"); 328 } 329 #[cfg(unix)] 330 #[test] 331 fn executable_mode_and_profile_feature_inputs_change_identity() { 332 use std::os::unix::fs::PermissionsExt; 333 let fixture = Fixture::new(); 334 let base = fixture.init(); 335 let (_, before) = report(&fixture.0, Some(&base), &[]); 336 fs::set_permissions( 337 fixture.0.join("Makefile"), 338 fs::Permissions::from_mode(0o755), 339 ) 340 .unwrap(); 341 let (_, after) = report(&fixture.0, Some(&base), &[]); 342 assert_all(&after); 343 assert_ne!( 344 before["native"]["source_identity"], 345 after["native"]["source_identity"] 346 ); 347 assert_ne!( 348 before["web"]["source_identity"], 349 after["web"]["source_identity"] 350 ); 351 let (_, configured) = report( 352 &fixture.0, 353 Some(&base), 354 &[ 355 ("HARVESTCIRCLE_NATIVE_FEATURES", "feature_probe"), 356 ("HARVESTCIRCLE_NATIVE_PROFILE", "release"), 357 ("HARVESTCIRCLE_BUILD_MODE", "governed"), 358 ], 359 ); 360 assert_eq!( 361 after["native"]["source_identity"], 362 configured["native"]["source_identity"] 363 ); 364 assert_ne!( 365 after["native"]["inputs"]["environment_sha256"], 366 configured["native"]["inputs"]["environment_sha256"] 367 ); 368 } 369 370 #[test] 371 fn every_consumed_non_head_native_build_input_invalidates_the_fingerprint() { 372 let fixture = Fixture::new(); 373 let base = fixture.init(); 374 let (_, before) = report(&fixture.0, Some(&base), &[]); 375 for name in [ 376 "SOURCE_DATE_EPOCH", 377 "HARVESTCIRCLE_BUILD_RADROOTS_REVISION", 378 "HARVESTCIRCLE_BUILD_RUST_TOOLCHAIN", 379 "HARVESTCIRCLE_BUILD_JAVA_TOOLCHAIN", 380 "HARVESTCIRCLE_BUILD_KOTLIN_TOOLCHAIN", 381 ] { 382 let (_, after) = report(&fixture.0, Some(&base), &[(name, "input_probe")]); 383 assert_eq!( 384 before["native"]["source_identity"], 385 after["native"]["source_identity"] 386 ); 387 assert_ne!( 388 before["native"]["inputs"]["environment_sha256"], 389 after["native"]["inputs"]["environment_sha256"], 390 "{name}" 391 ); 392 if !before["native"]["input_identity"].is_null() { 393 assert_ne!( 394 before["native"]["input_identity"], after["native"]["input_identity"], 395 "{name}" 396 ); 397 } 398 } 399 let (_, provenance) = report( 400 &fixture.0, 401 Some(&base), 402 &[ 403 ("HARVESTCIRCLE_BUILD_SOURCE_COMMIT", "source_probe"), 404 ("HARVESTCIRCLE_BUILD_SOURCE_DIRTY", "source_probe"), 405 ], 406 ); 407 assert_eq!( 408 before["native"]["source_identity"], 409 provenance["native"]["source_identity"] 410 ); 411 assert_ne!( 412 before["source_provenance"]["producer_environment_sha256"], 413 provenance["source_provenance"]["producer_environment_sha256"] 414 ); 415 } 416 417 #[test] 418 fn compiler_cargo_and_jvm_families_are_bounded_hashed_and_never_qualify_custom_artifacts() { 419 let fixture = Fixture::new(); 420 let base = fixture.init(); 421 let (_, before) = report(&fixture.0, Some(&base), &[]); 422 for name in [ 423 "RUSTC_WRAPPER", 424 "CARGO_BUILD_TARGET", 425 "CARGO_PROFILE_RELEASE_OPT_LEVEL", 426 "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS", 427 "CFLAGS_x86_64_unknown_linux_gnu", 428 "HOST_CXXFLAGS", 429 "TARGET_CC", 430 "CARGO_ENCODED_RUSTDOCFLAGS", 431 "JAVA_OPTS", 432 "_JAVA_OPTIONS", 433 "ORG_GRADLE_PROJECT_nativeOs", 434 ] { 435 let (_, after) = report(&fixture.0, Some(&base), &[(name, "controlled_input_probe")]); 436 assert_eq!( 437 before["native"]["source_identity"], 438 after["native"]["source_identity"] 439 ); 440 assert_ne!( 441 before["native"]["inputs"]["environment_sha256"], 442 after["native"]["inputs"]["environment_sha256"], 443 "{name}" 444 ); 445 assert!( 446 !serde_json::to_string(&after) 447 .unwrap() 448 .contains("controlled_input_probe") 449 ); 450 assert_eq!(after["native"]["reuse"], "NOT_ACCEPTED_BY_THIS_REPORT"); 451 if !before["native"]["input_identity"].is_null() { 452 assert_ne!( 453 before["native"]["input_identity"], after["native"]["input_identity"], 454 "{name}" 455 ); 456 } 457 } 458 let oversized = "x".repeat(65537); 459 let (_, after) = report(&fixture.0, Some(&base), &[("RUSTFLAGS", &oversized)]); 460 assert_all(&after); 461 assert_eq!(after["native"]["availability"], "INPUT_UNAVAILABLE"); 462 assert!(after["native"]["input_identity"].is_null()); 463 assert_eq!( 464 after["native"]["source_identity"], 465 before["native"]["source_identity"] 466 ); 467 } 468 469 fn copy_archive_source(source: &Path, directory: &Path, destination: &Path) { 470 for entry in fs::read_dir(directory).unwrap() { 471 let entry = entry.unwrap(); 472 let path = entry.path(); 473 let relative = path.strip_prefix(source).unwrap(); 474 let parts = relative 475 .components() 476 .map(|part| part.as_os_str().to_str().unwrap()) 477 .collect::<Vec<_>>(); 478 if matches!( 479 parts[0], 480 ".git" | ".gradle" | ".kotlin" | ".idea" | "build" | "target" | "out" 481 ) || parts 482 .iter() 483 .any(|part| matches!(*part, "build" | "target" | "out")) 484 || (matches!(parts[0], "build-logic" | "buildSrc") 485 && parts 486 .get(1) 487 .is_some_and(|part| matches!(*part, ".gradle" | ".kotlin"))) 488 || (parts[0] == "web" 489 && (parts.contains(&"node_modules") 490 || parts.get(1).is_some_and(|part| { 491 matches!( 492 *part, 493 ".svelte-kit" | "coverage" | "test-results" | "playwright-report" 494 ) 495 }))) 496 { 497 continue; 498 } 499 let file_type = entry.file_type().unwrap(); 500 assert!( 501 !file_type.is_symlink(), 502 "fixture source symlink: {relative:?}" 503 ); 504 if file_type.is_dir() { 505 fs::create_dir_all(destination.join(relative)).unwrap(); 506 copy_archive_source(source, &path, destination); 507 } else { 508 assert!( 509 file_type.is_file(), 510 "fixture source is not regular: {relative:?}" 511 ); 512 fs::create_dir_all(destination.join(relative).parent().unwrap()).unwrap(); 513 fs::copy(&path, destination.join(relative)).unwrap(); 514 } 515 } 516 }