app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 }