feat: use `GIX_TEST_FIXTURE_HASH` environment variable.

For now, there is no direct way to set it, but that may change once we have tests that need it.

Christoph Rüßler committed 9 months ago

Commit 7f50c301 parent 28fbeb84 files · +64 −20Browse files

Unified · Split

4 files

Cargo.lock +1 −0
tests/tools/Cargo.toml +1 −0
tests/tools/src/lib.rs +56 −19
tests/tools/src/tests.rs +6 −1

@@ -2418,6 +2418,7 @@ dependencies = [ · 2417 unmodified lines
2418	"fs_extra",	2418	"fs_extra",
2419	"gix-discover",	2419	"gix-discover",
2420	"gix-fs",	2420	"gix-fs",
		2421	"gix-hash",
2421	"gix-lock",	2422	"gix-lock",
2422	"gix-tempfile",	2423	"gix-tempfile",
2423	"gix-worktree",	2424	"gix-worktree",

tests/tools/Cargo.toml+1−0

@@ -25,6 +25,7 @@ default = [] · 24 unmodified lines
25	xz = ["dep:xz2"]	25	xz = ["dep:xz2"]
26		26
27	[dependencies]	27	[dependencies]
		28	gix-hash = { version = "^0.22.0", path = "../../gix-hash" }
28	gix-lock = { version = "^21.0.0", path = "../../gix-lock" }	29	gix-lock = { version = "^21.0.0", path = "../../gix-lock" }
29	gix-discover = { version = "^0.46.0", path = "../../gix-discover" }	30	gix-discover = { version = "^0.46.0", path = "../../gix-discover" }
30	gix-worktree = { version = "^0.47.0", path = "../../gix-worktree" }	31	gix-worktree = { version = "^0.47.0", path = "../../gix-worktree" }

tests/tools/src/lib.rs+56−19

     StandaloneTest,
 }
-/// Don't add a suffix to the archive name as `args` are platform dependent, none-deterministic,
+/// Don't add a suffix to the archive name as `args` are platform dependent, non-deterministic,
 /// or otherwise don't influence the content of the archive.
 /// Note that this also means that `args` won't be used to control the hash of the archive itself.
 #[derive(Copy, Clone)]
     Ok(())
 }
-/// Like `scripted_fixture_read_only()`], but passes `args` to `script_name`.
+/// Like [`scripted_fixture_read_only()`], but passes `args` to `script_name`.
 pub fn scripted_fixture_read_only_with_args(
     script_name: impl AsRef<Path>,
     args: impl IntoIterator<Item = impl Into<String>>,
 where
     F: FnOnce(FixtureState<'_>) -> PostResult<T>,
 {
-    rust_fixture_read_only_inner(name, version, make_fixture, None, DirectoryRoot::IntegrationTest)
+    rust_fixture_read_only_inner(name, version, None, make_fixture, None, DirectoryRoot::IntegrationTest)
 }
 /// Like [`rust_fixture_read_only()`], but does not prefix the fixture directory with `tests`.
 where
     F: FnOnce(FixtureState<'_>) -> PostResult<T>,
 {
-    rust_fixture_read_only_inner(name, version, make_fixture, None, DirectoryRoot::StandaloneTest)
+    rust_fixture_read_only_inner(name, version, None, make_fixture, None, DirectoryRoot::StandaloneTest)
 }
 /// Execute a Rust closure in a directory, returning a writable temporary directory.
 where
     F: FnMut(FixtureState<'_>) -> PostResult<T>,
 {
-    rust_fixture_writable_inner(name, version, make_fixture, mode, DirectoryRoot::IntegrationTest)
+    rust_fixture_writable_inner(name, version, None, make_fixture, mode, DirectoryRoot::IntegrationTest)
 }
 /// Like [`rust_fixture_writable()`], but does not prefix the fixture directory with `tests`.
 where
     F: FnMut(FixtureState<'_>) -> PostResult<T>,
 {
-    rust_fixture_writable_inner(name, version, make_fixture, mode, DirectoryRoot::StandaloneTest)
+    rust_fixture_writable_inner(name, version, None, make_fixture, mode, DirectoryRoot::StandaloneTest)
 }
 fn rust_fixture_writable_inner<T, F>(
     name: &str,
     version: u32,
+    object_hash: Option<gix_hash::Kind>,
     mut make_fixture: F,
     mode: Creation,
     root: DirectoryRoot,
     let dst = tempfile::TempDir::new()?;
     let res = match mode {
         Creation::CopyFromReadOnly => {
-            let (ro_dir, _res_ignored) = rust_fixture_read_only_inner(name, version, &mut make_fixture, None, root)?;
+            let (ro_dir, _res_ignored) =
+                rust_fixture_read_only_inner(name, version, object_hash, &mut make_fixture, None, root)?;
             copy_recursively_into_existing_dir(ro_dir, dst.path())?;
             let res = make_fixture(FixtureState::Fresh(dst.path()))?;
             res
         }
         Creation::Execute => {
-            let (_, res) = rust_fixture_read_only_inner(name, version, make_fixture, Some(dst.path()), root)?;
+            let (_, res) =
+                rust_fixture_read_only_inner(name, version, object_hash, make_fixture, Some(dst.path()), root)?;
             res
         }
     };
 fn rust_fixture_read_only_inner<T, F>(
     name: &str,
     version: u32,
+    object_hash: Option<gix_hash::Kind>,
     make_fixture: F,
     destination_dir: Option<&Path>,
     root: DirectoryRoot,
         Path::new(ARCHIVE_DIR_NAME).join(format!("{archive_name}.{}", tar_extension())),
         root,
     );
-    let (force_run, script_result_directory) = force_and_dir(destination_dir, root, &archive_name, &script_identity);
+    let (force_run, script_result_directory) =
+        force_and_dir(destination_dir, root, &archive_name, object_hash, &script_identity);
     let _marker = marker_if_needed(destination_dir, archive_name)?;
     run_fixture_generator_with_marker_handling(
     destination_dir: Option<&Path>,
     root: DirectoryRoot,
     archive_name: impl AsRef<Path>,
+    hash_kind: Option<gix_hash::Kind>,
     script_identity: &dyn std::fmt::Display,
 ) -> (bool, PathBuf) {
     destination_dir.map_or_else(
         || {
             let dir = fixture_path_inner(
-                Path::new("generated-do-not-edit").join(archive_name).join(format!(
+                Path::new("generated-do-not-edit")
-                    "{}-{}",
+                    .join(archive_name)
-                    script_identity,
+                    .join(hash_kind.unwrap_or_else(hash_kind_from_env).to_string())
-                    family_name()
+                    .join(format!("{}-{}", script_identity, family_name())),
-                )),
                 root,
             );
             (false, dir)
         gix_tempfile::signal::handler::Mode::DeleteTempfilesOnTerminationAndRestoreDefaultBehaviour,
     );
+    let hash_kind = hash_kind_from_env();
+    eprintln!("Using hash '{hash_kind}' when determining which fixture to use or recreate");
     let script_location = script_name.as_ref();
     let script_path = fixture_path_inner(script_location, root);
     let post_version = post_process.as_ref().map(|(v, _)| *v);
     let script_identity = {
         let mut map = SCRIPT_IDENTITY.lock();
-        let key = args.iter().fold(script_path.clone(), |p, a| p.join(a));
+        let init = if hash_kind == gix_hash::Kind::Sha1 {
+            script_path.clone()
+        } else {
+            script_path.clone().join(hash_kind.to_string())
+        };
+        let key = args.iter().fold(init, |p, a| p.join(a));
         // Include post_version in the key if present
         let key = if let Some(v) = post_version {
             key.join(format!("post-v{v}"))
                 }
                 ArgsInHash::No => "".into(),
             };
+            let potential_hash_suffix = if hash_kind == gix_hash::Kind::Sha1 {
+                "".into()
+            } else {
+                format!("_{hash_kind}")
+            };
             Path::new(ARCHIVE_DIR_NAME).join(format!(
-                "{}{suffix}.{}",
+                "{}{suffix}{potential_hash_suffix}.{}",
                 script_basename.to_str().expect("valid UTF-8"),
                 tar_extension()
             ))
         },
         root,
     );
-    let (force_run, script_result_directory) = force_and_dir(destination_dir, root, script_basename, &script_identity);
+    let (force_run, script_result_directory) = force_and_dir(
+        destination_dir,
+        root,
+        script_basename,
+        Some(hash_kind),
+        &script_identity,
+    );
     let _marker = marker_if_needed(destination_dir, script_basename)?;
     let script_identity_for_archive = match args_in_hash {
         |fixture_state| {
             if let FixtureState::Uninitialized(dir) = fixture_state {
                 let mut cmd = std::process::Command::new(&script_absolute_path);
-                let output = match configure_command(&mut cmd, &args, dir).output() {
+                let output = match configure_command(&mut cmd, hash_kind, &args, dir).output() {
                     Ok(out) => out,
                     Err(err)
                         if err.kind() == std::io::ErrorKind::PermissionDenied
                             || err.raw_os_error() == Some(193) /* windows */ =>
                     {
                         cmd = std::process::Command::new(bash_program());
-                        configure_command(cmd.arg(&script_absolute_path), &args, dir).output()?
+                        configure_command(cmd.arg(&script_absolute_path), hash_kind, &args, dir).output()?
                     }
                     Err(err) => return Err(err.into()),
                 };
     Ok((script_result_directory, res))
 }
+fn hash_kind_from_env() -> gix_hash::Kind {
+    env::var_os("GIX_TEST_FIXTURE_HASH").and_then(|value| value.into_string().ok()).map(|object_kind| {
+        gix_hash::Kind::from_str(&object_kind).unwrap_or_else(|_| {
+                    panic!(
+                        "GIX_TEST_FIXTURE_HASH was set to {object_kind} which is an invalid value. Valid values are {}. Exiting.",
+                        gix_hash::Kind::all().iter().map(std::string::ToString::to_string).collect::<Vec<_>>().join(", ")
+                    )
+                })
+    }).unwrap_or_default()
+}
 #[cfg(windows)]
 const NULL_DEVICE: &str = "nul"; // See `gix_path::env::git::NULL_DEVICE` on why this form is used.
 #[cfg(not(windows))]
 fn configure_command<'a, I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
     cmd: &'a mut std::process::Command,
+    hash_kind: gix_hash::Kind,
     args: I,
     script_result_directory: &Path,
 ) -> &'a mut std::process::Command {
         .env("GIT_CONFIG_VALUE_2", "main")
         .env("GIT_CONFIG_KEY_3", "protocol.file.allow")
         .env("GIT_CONFIG_VALUE_3", "always")
+        .env("GIT_DEFAULT_HASH", hash_kind.to_string())
 }
 /// Get the path attempted as a `bash` interpreter, for fixture scripts having no `#!` we can use.

tests/tools/src/tests.rs+6−1

     let mut cmd = std::process::Command::new(GIT_PROGRAM);
     cmd.env("GIT_CONFIG_SYSTEM", SCOPE_ENV_VALUE);
     cmd.env("GIT_CONFIG_GLOBAL", SCOPE_ENV_VALUE);
-    configure_command(&mut cmd, ["config", "-l", "--show-origin"], temp.path());
+    configure_command(
+        &mut cmd,
+        gix_hash::Kind::default(),
+        ["config", "-l", "--show-origin"],
+        temp.path(),
+    );
     let output = cmd.output().expect("can run git");
     let lines: Vec<_> = output