Add missing hash_kind

Author: cruessler

tests/tools/src/tests.rs

@@ -44,7 +44,12 @@ fn configure_command_clears_external_config() {
     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

tests/tools/tests/tools/rust_fixture.rs

@@ -3,18 +3,23 @@ use gix_testtools::{Creation, FixtureState, Result};
 #[test]
 fn rust_fixture_read_only_creates_and_caches_fixture() -> Result {
     // First call should create the fixture
-    let (dir, (a, b, c)) = gix_testtools::rust_fixture_read_only("test_fixture_read_only", 1, |fixture| {
-        let dir = fixture.path();
-        let a = dir.join("test_file.txt");
-        let b = dir.join("subdir");
-        let c = dir.join("subdir/nested.txt");
-        if fixture.is_uninitialized() {
-            std::fs::write(&a, "test content")?;
-            std::fs::create_dir(&b)?;
-            std::fs::write(&c, "nested content")?;
-        }
-        Ok((a, b, c))
-    })?;
+    let (dir, (a, b, c)) = gix_testtools::rust_fixture_read_only(
+        "test_fixture_read_only",
+        1,
+        |fixture| {
+            let dir = fixture.path();
+            let a = dir.join("test_file.txt");
+            let b = dir.join("subdir");
+            let c = dir.join("subdir/nested.txt");
+            if fixture.is_uninitialized() {
+                std::fs::write(&a, "test content")?;
+                std::fs::create_dir(&b)?;
+                std::fs::write(&c, "nested content")?;
+            }
+            Ok((a, b, c))
+        },
+        gix_hash::Kind::default(),
+    )?;
 
     // Verify the fixture was created correctly
     assert!(dir.is_dir());
@@ -26,13 +31,18 @@ fn rust_fixture_read_only_creates_and_caches_fixture() -> Result {
 
     // Second call with same version should return cached result
     // The closure is still called but knows that it's fresh.
-    let (dir2, _) = gix_testtools::rust_fixture_read_only("test_fixture_read_only", 1, |fixture| {
-        assert!(
-            matches!(fixture, gix_testtools::FixtureState::Fresh(_)),
-            "Expected cached fixture on second call"
-        );
-        Ok(())
-    })?;
+    let (dir2, _) = gix_testtools::rust_fixture_read_only(
+        "test_fixture_read_only",
+        1,
+        |fixture| {
+            assert!(
+                matches!(fixture, gix_testtools::FixtureState::Fresh(_)),
+                "Expected cached fixture on second call"
+            );
+            Ok(())
+        },
+        gix_hash::Kind::default(),
+    )?;
 
     // Both should point to the same directory
     assert_eq!(dir, dir2);
@@ -43,20 +53,30 @@ fn rust_fixture_read_only_creates_and_caches_fixture() -> Result {
 #[test]
 fn rust_fixture_read_only_version_change_invalidates_cache() -> Result {
     // Create fixture with version 1
-    let (dir1, _) = gix_testtools::rust_fixture_read_only("test_fixture_version", 1, |fixture| {
-        if let FixtureState::Uninitialized(dir) = fixture {
-            std::fs::write(dir.join("version.txt"), "v1")?;
-        }
-        Ok(())
-    })?;
+    let (dir1, _) = gix_testtools::rust_fixture_read_only(
+        "test_fixture_version",
+        1,
+        |fixture| {
+            if let FixtureState::Uninitialized(dir) = fixture {
+                std::fs::write(dir.join("version.txt"), "v1")?;
+            }
+            Ok(())
+        },
+        gix_hash::Kind::default(),
+    )?;
 
     // Version 2 should create a new fixture in a different directory
-    let (dir2, _) = gix_testtools::rust_fixture_read_only("test_fixture_version", 2, |fixture| {
-        if let FixtureState::Uninitialized(dir) = fixture {
-            std::fs::write(dir.join("version.txt"), "v2")?;
-        }
-        Ok(())
-    })?;
+    let (dir2, _) = gix_testtools::rust_fixture_read_only(
+        "test_fixture_version",
+        2,
+        |fixture| {
+            if let FixtureState::Uninitialized(dir) = fixture {
+                std::fs::write(dir.join("version.txt"), "v2")?;
+            }
+            Ok(())
+        },
+        gix_hash::Kind::default(),
+    )?;
 
     assert_ne!(
         dir1, dir2,
@@ -73,12 +93,18 @@ fn rust_fixture_read_only_version_change_invalidates_cache() -> Result {
 #[test]
 fn rust_fixture_writable() -> Result {
     for creation in [Creation::CopyFromReadOnly, Creation::Execute] {
-        let (tmp, _) = gix_testtools::rust_fixture_writable("test_fixture_writable_copy", 1, creation, |fixture| {
-            if let FixtureState::Uninitialized(dir) = fixture {
-                std::fs::write(dir.join("original.txt"), "original content")?;
-            }
-            Ok(())
-        })?;
+        let (tmp, _) = gix_testtools::rust_fixture_writable(
+            "test_fixture_writable_copy",
+            1,
+            creation,
+            |fixture| {
+                if let FixtureState::Uninitialized(dir) = fixture {
+                    std::fs::write(dir.join("original.txt"), "original content")?;
+                }
+                Ok(())
+            },
+            gix_hash::Kind::default(),
+        )?;
 
         // Verify the fixture was created
         let original_path = tmp.path().join("original.txt");
@@ -97,9 +123,12 @@ fn rust_fixture_writable() -> Result {
 #[test]
 fn rust_fixture_closure_error_propagates() {
     // Test that errors from the closure are properly propagated
-    let res = gix_testtools::rust_fixture_read_only("test_fixture_error", 1, |_fixture| {
-        Err::<(), _>("intentional error".into())
-    });
+    let res = gix_testtools::rust_fixture_read_only(
+        "test_fixture_error",
+        1,
+        |_fixture| Err::<(), _>("intentional error".into()),
+        gix_hash::Kind::default(),
+    );
 
     let err_msg = res.unwrap_err().to_string();
     assert!(
@@ -110,12 +139,17 @@ fn rust_fixture_closure_error_propagates() {
 
 #[test]
 fn rust_fixture_standalone_uses_fixtures_directory() -> Result {
-    let (dir, _) = gix_testtools::rust_fixture_read_only_standalone("test_fixture_standalone", 1, |fixture| {
-        if let FixtureState::Uninitialized(dir) = fixture {
-            std::fs::write(dir.join("standalone.txt"), "standalone")?;
-        }
-        Ok(())
-    })?;
+    let (dir, _) = gix_testtools::rust_fixture_read_only_standalone(
+        "test_fixture_standalone",
+        1,
+        |fixture| {
+            if let FixtureState::Uninitialized(dir) = fixture {
+                std::fs::write(dir.join("standalone.txt"), "standalone")?;
+            }
+            Ok(())
+        },
+        gix_hash::Kind::default(),
+    )?;
 
     // Standalone fixtures are stored in fixtures/generated-do-not-edit, not tests/fixtures/...
     let dir_str = dir.to_string_lossy();