adjust to changes in git-testtools

Author: Byron

git-attributes/tests/match_group/mod.rs

@@ -32,7 +32,7 @@ mod ignore {
 
     #[test]
     fn from_git_dir() -> crate::Result {
-        let dir = git_testtools::scripted_fixture_repo_read_only("make_global_and_external_and_dir_ignores.sh")?;
+        let dir = git_testtools::scripted_fixture_read_only("make_global_and_external_and_dir_ignores.sh")?;
         let repo_dir = dir.join("repo");
         let git_dir = repo_dir.join(".git");
         let baseline = std::fs::read(git_dir.parent().unwrap().join("git-check-ignore.baseline"))?;

git-commitgraph/tests/commitgraph.rs

@@ -60,9 +60,9 @@ pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHa
     );
 }
 
-use git_testtools::scripted_fixture_repo_read_only;
+use git_testtools::scripted_fixture_read_only;
 pub fn make_readonly_repo(script_path: &str) -> std::path::PathBuf {
-    scripted_fixture_repo_read_only(script_path).expect("script succeeds all the time")
+    scripted_fixture_read_only(script_path).expect("script succeeds all the time")
 }
 
 pub fn hex_to_id(hex: &[u8]) -> git_hash::ObjectId {

git-config/tests/file/init/comfort.rs

@@ -21,7 +21,7 @@ fn from_environment_overrides() {
 #[test]
 #[serial]
 fn from_git_dir() -> crate::Result {
-    let worktree_dir = git_testtools::scripted_fixture_repo_read_only("make_config_repo.sh")?;
+    let worktree_dir = git_testtools::scripted_fixture_read_only("make_config_repo.sh")?;
     let git_dir = worktree_dir.join(".git");
     let worktree_dir = worktree_dir.canonicalize()?;
     let _env = Env::new()
@@ -84,7 +84,7 @@ fn from_git_dir() -> crate::Result {
 #[test]
 #[serial]
 fn from_git_dir_with_worktree_extension() -> crate::Result {
-    let git_dir = git_testtools::scripted_fixture_repo_read_only("config_with_worktree_extension.sh")?
+    let git_dir = git_testtools::scripted_fixture_read_only("config_with_worktree_extension.sh")?
         .join("main-worktree")
         .join(".git");
     let config = git_config::File::from_git_dir(git_dir)?;

git-date/tests/time/baseline.rs

@@ -13,7 +13,7 @@ struct Sample {
 
 static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
     (|| -> Result<_> {
-        let base = git_testtools::scripted_fixture_repo_read_only("generate_git_date_baseline.sh")?;
+        let base = git_testtools::scripted_fixture_read_only("generate_git_date_baseline.sh")?;
         let mut map = HashMap::new();
         let file = std::fs::read(base.join("baseline.git"))?;
         let baseline = std::str::from_utf8(&file).expect("valid utf");

git-diff/tests/tree/mod.rs

@@ -11,7 +11,7 @@ mod changes {
 
         fn db(args: impl IntoIterator<Item = &'static str>) -> crate::Result<git_odb::Handle> {
             git_odb::at(
-                git_testtools::scripted_fixture_repo_read_only_with_args("make_diff_repo.sh", args)?
+                git_testtools::scripted_fixture_read_only_with_args("make_diff_repo.sh", args)?
                     .join(".git")
                     .join("objects"),
             )

git-discover/tests/is_git/mod.rs

@@ -7,7 +7,7 @@ fn verify_on_exfat() -> crate::Result<()> {
 
     use git_discover::repository::Kind;
 
-    let fixtures = git_testtools::scripted_fixture_repo_read_only("make_exfat_repo_darwin.sh")?;
+    let fixtures = git_testtools::scripted_fixture_read_only("make_exfat_repo_darwin.sh")?;
     let mount_point = tempfile::tempdir()?;
 
     let _cleanup = {

git-discover/tests/isolated.rs

@@ -6,7 +6,7 @@ use serial_test::serial;
 #[test]
 #[serial]
 fn upwards_with_relative_directories_and_optional_ceiling() -> git_testtools::Result {
-    let repo = git_testtools::scripted_fixture_repo_read_only("make_basic_repo.sh")?;
+    let repo = git_testtools::scripted_fixture_read_only("make_basic_repo.sh")?;
 
     std::env::set_current_dir(repo.join("subdir"))?;
     let cwd = std::env::current_dir()?;

git-discover/tests/upwards/mod.rs

@@ -226,7 +226,7 @@ fn cross_fs() -> crate::Result {
         return Ok(());
     }
 
-    let top_level_repo = git_testtools::scripted_fixture_repo_writable("make_basic_repo.sh")?;
+    let top_level_repo = git_testtools::scripted_fixture_writable("make_basic_repo.sh")?;
 
     let _cleanup = {
         // Create an empty dmg file
@@ -307,7 +307,7 @@ fn do_not_shorten_absolute_paths() -> crate::Result {
 mod submodules {
     #[test]
     fn by_their_worktree_checkout() -> crate::Result {
-        let dir = git_testtools::scripted_fixture_repo_read_only("make_submodules.sh")?;
+        let dir = git_testtools::scripted_fixture_read_only("make_submodules.sh")?;
         let parent = dir.join("with-submodules");
         let modules = parent.join(".git").join("modules");
         for module in ["m1", "dir/m1"] {
@@ -336,7 +336,7 @@ mod submodules {
 
     #[test]
     fn by_their_module_git_dir() -> crate::Result {
-        let dir = git_testtools::scripted_fixture_repo_read_only("make_submodules.sh")?;
+        let dir = git_testtools::scripted_fixture_read_only("make_submodules.sh")?;
         let modules = dir.join("with-submodules").join(".git").join("modules");
         for module in ["m1", "dir/m1"] {
             let submodule_m1_gitdir = modules.join(module);
@@ -353,5 +353,5 @@ mod submodules {
 }
 
 pub(crate) fn repo_path() -> crate::Result<PathBuf> {
-    git_testtools::scripted_fixture_repo_read_only("make_basic_repo.sh")
+    git_testtools::scripted_fixture_read_only("make_basic_repo.sh")
 }

git-glob/tests/pattern/matching.rs

@@ -43,7 +43,7 @@ impl<'a> Baseline<'a> {
 
 #[test]
 fn compare_baseline_with_ours() {
-    let dir = git_testtools::scripted_fixture_repo_read_only("make_baseline.sh").unwrap();
+    let dir = git_testtools::scripted_fixture_read_only("make_baseline.sh").unwrap();
     let (mut total_matches, mut total_correct, mut panics) = (0, 0, 0);
     let mut mismatches = Vec::new();
     for (input_file, expected_matches, case) in &[

git-index/tests/index/init.rs

@@ -1,7 +1,7 @@
 use git_index::{verify::extensions::no_find, State};
 use git_repository as git;
 use git_repository::prelude::FindExt;
-use git_testtools::scripted_fixture_repo_read_only;
+use git_testtools::scripted_fixture_read_only;
 
 #[test]
 fn from_tree() -> crate::Result {
@@ -13,7 +13,7 @@ fn from_tree() -> crate::Result {
     ];
 
     for fixture in fixtures {
-        let repo_dir = scripted_fixture_repo_read_only(fixture)?;
+        let repo_dir = scripted_fixture_read_only(fixture)?;
         let repo = git::open(&repo_dir)?;
 
         let tree_id = repo.head_commit()?.tree_id()?;

git-index/tests/index/mod.rs

@@ -4,7 +4,7 @@ mod file;
 mod init;
 
 pub fn fixture_index_path(name: &str) -> PathBuf {
-    let dir = git_testtools::scripted_fixture_repo_read_only(Path::new("make_index").join(name).with_extension("sh"))
+    let dir = git_testtools::scripted_fixture_read_only(Path::new("make_index").join(name).with_extension("sh"))
         .expect("script works");
     dir.join(".git").join("index")
 }

git-odb/tests/odb/mod.rs

@@ -1,4 +1,4 @@
-pub use git_testtools::{fixture_path, hex_to_id, scripted_fixture_repo_read_only};
+pub use git_testtools::{fixture_path, hex_to_id, scripted_fixture_read_only};
 
 pub type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 

git-odb/tests/odb/regression/mod.rs

@@ -20,7 +20,7 @@ mod repo_with_small_packs {
     #[cfg(feature = "internal-testing-git-features-parallel")]
     fn multi_threaded_access_will_not_panic() {
         for arg in ["no", "without-multi-index"] {
-            let base = git_testtools::scripted_fixture_repo_read_only_with_args("make_repo_multi_index.sh", Some(arg))
+            let base = git_testtools::scripted_fixture_read_only_with_args("make_repo_multi_index.sh", Some(arg))
                 .unwrap()
                 .join(".git")
                 .join("objects");

git-odb/tests/odb/store/dynamic.rs

@@ -34,7 +34,7 @@ fn db_with_all_object_sources() -> crate::Result<(git_odb::Handle, tempfile::Tem
 
 #[test]
 fn multi_index_access() -> crate::Result {
-    let dir = git_testtools::scripted_fixture_repo_writable("make_repo_multi_index.sh")?;
+    let dir = git_testtools::scripted_fixture_writable("make_repo_multi_index.sh")?;
     let handle = git_odb::at(dir.path().join(".git/objects"))?;
 
     assert_eq!(
@@ -130,7 +130,7 @@ fn multi_index_access() -> crate::Result {
 
 #[test]
 fn multi_index_keep_open() -> crate::Result {
-    let dir = git_testtools::scripted_fixture_repo_writable("make_repo_multi_index.sh")?;
+    let dir = git_testtools::scripted_fixture_writable("make_repo_multi_index.sh")?;
     let (stable_handle, handle) = {
         let mut stable_handle = git_odb::at(dir.path().join(".git/objects"))?;
         let handle = stable_handle.clone();
@@ -207,7 +207,7 @@ fn write() -> crate::Result {
 
 #[test]
 fn object_replacement() {
-    let dir = git_testtools::scripted_fixture_repo_read_only("make_replaced_history.sh").unwrap();
+    let dir = git_testtools::scripted_fixture_read_only("make_replaced_history.sh").unwrap();
     let handle = git_odb::at(dir.join(".git/objects")).unwrap();
     let mut buf = Vec::new();
     let short_history_link = hex_to_id("434e5a872d6738d1fffd1e11e52a1840b73668c6");

git-pack/tests/pack/data/output/mod.rs

@@ -31,7 +31,7 @@ fn db(kind: DbKind) -> crate::Result<git_odb::HandleArc> {
         DeterministicGeneratedContent => "make_pack_gen_repo.sh",
         DeterministicGeneratedContentMultiIndex => "make_pack_gen_repo_multi_index.sh",
     };
-    let path: PathBuf = git_testtools::scripted_fixture_repo_read_only(name)?
+    let path: PathBuf = git_testtools::scripted_fixture_read_only(name)?
         .join(".git")
         .join("objects");
     git_odb::Store::at_opts(path, Vec::new(), git_odb::store::init::Options::default())

git-pack/tests/pack/mod.rs

@@ -13,7 +13,7 @@ const PACKS_AND_INDICES: &[(&'static str, &'static str)] =
 const V2_PACKS_AND_INDICES: &[(&'static str, &'static str)] =
     &[(SMALL_PACK_INDEX, SMALL_PACK), (INDEX_V2, PACK_FOR_INDEX_V2)];
 
-pub use git_testtools::{fixture_path, hex_to_id, scripted_fixture_repo_read_only};
+pub use git_testtools::{fixture_path, hex_to_id, scripted_fixture_read_only};
 
 pub type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 

git-pack/tests/pack/multi_index/mod.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use git_pack::multi_index::File;
 
 fn multi_index() -> (File, PathBuf) {
-    let path = git_testtools::scripted_fixture_repo_read_only("make_pack_gen_repo_multi_index.sh")
+    let path = git_testtools::scripted_fixture_read_only("make_pack_gen_repo_multi_index.sh")
         .expect("test fixture exists")
         .join(".git/objects/pack/multi-pack-index");
     let file = git_pack::multi_index::File::at(&path).unwrap();

git-pathspec/tests/pathspec.rs

@@ -32,7 +32,7 @@ mod parse {
     }
 
     static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
-        let base = git_testtools::scripted_fixture_repo_read_only("generate_pathspec_baseline.sh").unwrap();
+        let base = git_testtools::scripted_fixture_read_only("generate_pathspec_baseline.sh").unwrap();
 
         (|| -> crate::Result<_> {
             let mut map = HashMap::new();

git-ref/tests/file/log.rs

@@ -35,11 +35,9 @@ mod iter {
     use std::path::PathBuf;
 
     fn reflog_dir() -> crate::Result<PathBuf> {
-        Ok(
-            git_testtools::scripted_fixture_repo_read_only("make_repo_for_reflog.sh")?
-                .join(".git")
-                .join("logs"),
-        )
+        Ok(git_testtools::scripted_fixture_read_only("make_repo_for_reflog.sh")?
+            .join(".git")
+            .join("logs"))
     }
     fn reflog(name: &str) -> crate::Result<Vec<u8>> {
         Ok(std::fs::read(reflog_dir()?.join(name))?)

git-ref/tests/file/mod.rs

@@ -14,7 +14,7 @@ pub fn store_with_packed_refs() -> crate::Result<Store> {
 }
 
 pub fn store_at(name: &str) -> crate::Result<Store> {
-    let path = git_testtools::scripted_fixture_repo_read_only(name)?;
+    let path = git_testtools::scripted_fixture_read_only(name)?;
     Ok(Store::at(
         path.join(".git"),
         git_ref::store::WriteReflog::Normal,
@@ -23,7 +23,7 @@ pub fn store_at(name: &str) -> crate::Result<Store> {
 }
 
 fn store_writable(name: &str) -> crate::Result<(git_testtools::tempfile::TempDir, Store)> {
-    let dir = git_testtools::scripted_fixture_repo_writable(name)?;
+    let dir = git_testtools::scripted_fixture_writable(name)?;
     let git_dir = dir.path().join(".git");
     Ok((
         dir,

git-ref/tests/file/store/reflog.rs

@@ -1,6 +1,6 @@
 fn store() -> crate::Result<crate::file::Store> {
     Ok(crate::file::Store::at(
-        git_testtools::scripted_fixture_repo_read_only("make_repo_for_reflog.sh")?.join(".git"),
+        git_testtools::scripted_fixture_read_only("make_repo_for_reflog.sh")?.join(".git"),
         git_ref::store::WriteReflog::Disable,
         git_hash::Kind::Sha1,
     ))

git-ref/tests/file/worktree.rs

@@ -11,10 +11,10 @@ fn dir(packed: bool, writable: bool) -> crate::Result<(PathBuf, Option<tempfile:
         args.push("packed");
     }
     if writable {
-        git_testtools::scripted_fixture_repo_writable_with_args(name, args, Creation::ExecuteScript)
+        git_testtools::scripted_fixture_writable_with_args(name, args, Creation::ExecuteScript)
             .map(|tmp| (tmp.path().to_owned(), tmp.into()))
     } else {
-        git_testtools::scripted_fixture_repo_read_only_with_args(name, args).map(|p| (p, None))
+        git_testtools::scripted_fixture_read_only_with_args(name, args).map(|p| (p, None))
     }
 }
 

git-ref/tests/packed/iter.rs

@@ -17,7 +17,7 @@ fn empty() -> crate::Result {
 
 #[test]
 fn packed_refs_with_header() -> crate::Result {
-    let dir = git_testtools::scripted_fixture_repo_read_only("make_packed_ref_repository.sh")?;
+    let dir = git_testtools::scripted_fixture_read_only("make_packed_ref_repository.sh")?;
     let buf = std::fs::read(dir.join(".git").join("packed-refs"))?;
     let iter = packed::Iter::new(&buf)?;
     assert_eq!(iter.count(), 8, "it finds the right amount of items");

git-ref/tests/store/mod.rs

@@ -2,7 +2,7 @@
 #[cfg(feature = "internal-testing-git-features-parallel")]
 fn is_send_and_sync() {
     pub fn store_at(name: &str) -> crate::Result<git_ref::file::Store> {
-        let path = git_testtools::scripted_fixture_repo_read_only(name)?;
+        let path = git_testtools::scripted_fixture_read_only(name)?;
         Ok(git_ref::file::Store::at(
             path.join(".git"),
             git_ref::store::WriteReflog::Normal,

git-refspec/tests/matching/mod.rs

@@ -204,7 +204,7 @@ pub mod baseline {
     }
 
     fn parse_input() -> crate::Result<Vec<Ref>> {
-        let dir = git_testtools::scripted_fixture_repo_read_only("match_baseline.sh")?;
+        let dir = git_testtools::scripted_fixture_read_only("match_baseline.sh")?;
         let refs_buf = std::fs::read(dir.join("clone").join("remote-refs.list"))?;
         let mut out = Vec::new();
         for line in refs_buf.lines() {
@@ -228,7 +228,7 @@ pub mod baseline {
     }
 
     pub(crate) fn parse() -> crate::Result<Baseline> {
-        let dir = git_testtools::scripted_fixture_repo_read_only("match_baseline.sh")?;
+        let dir = git_testtools::scripted_fixture_read_only("match_baseline.sh")?;
         let buf = std::fs::read(dir.join("clone").join("baseline.git"))?;
 
         let mut map = HashMap::new();

git-refspec/tests/parse/mod.rs

@@ -2,11 +2,11 @@ use std::panic::catch_unwind;
 
 use bstr::ByteSlice;
 use git_refspec::parse::Operation;
-use git_testtools::scripted_fixture_repo_read_only;
+use git_testtools::scripted_fixture_read_only;
 
 #[test]
 fn baseline() {
-    let dir = scripted_fixture_repo_read_only("parse_baseline.sh").unwrap();
+    let dir = scripted_fixture_read_only("parse_baseline.sh").unwrap();
     let baseline = std::fs::read(dir.join("baseline.git")).unwrap();
     let mut lines = baseline.lines();
     let mut panics = 0;

git-repository/src/remote/connection/fetch/update_refs/tests.rs

@@ -7,7 +7,7 @@ mod update {
 
     fn base_repo_path() -> String {
         git::path::realpath(
-            git_testtools::scripted_fixture_repo_read_only("make_remote_repos.sh")
+            git_testtools::scripted_fixture_read_only("make_remote_repos.sh")
                 .unwrap()
                 .join("base"),
         )
@@ -17,12 +17,12 @@ mod update {
     }
 
     fn repo(name: &str) -> git::Repository {
-        let dir = git_testtools::scripted_fixture_repo_read_only_with_args("make_fetch_repos.sh", [base_repo_path()])
-            .unwrap();
+        let dir =
+            git_testtools::scripted_fixture_read_only_with_args("make_fetch_repos.sh", [base_repo_path()]).unwrap();
         git::open_opts(dir.join(name), git::open::Options::isolated()).unwrap()
     }
     fn repo_rw(name: &str) -> (git::Repository, git_testtools::tempfile::TempDir) {
-        let dir = git_testtools::scripted_fixture_repo_writable_with_args(
+        let dir = git_testtools::scripted_fixture_writable_with_args(
             "make_fetch_repos.sh",
             [base_repo_path()],
             git_testtools::Creation::ExecuteScript,
@@ -169,7 +169,7 @@ mod update {
 
     #[test]
     fn checked_out_branches_in_worktrees_are_rejected_with_additional_information() -> Result {
-        let root = git_path::realpath(git_testtools::scripted_fixture_repo_read_only_with_args(
+        let root = git_path::realpath(git_testtools::scripted_fixture_read_only_with_args(
             "make_fetch_repos.sh",
             [base_repo_path()],
         )?)?;

git-repository/tests/clone/mod.rs

@@ -199,7 +199,7 @@ mod blocking_io {
     fn fetch_and_checkout_empty_remote_repo() -> crate::Result {
         let tmp = git_testtools::tempfile::TempDir::new()?;
         let mut prepare = git::prepare_clone(
-            git_testtools::scripted_fixture_repo_read_only("make_empty_repo.sh")?,
+            git_testtools::scripted_fixture_read_only("make_empty_repo.sh")?,
             tmp.path(),
         )?;
         let (mut checkout, out) = prepare

git-repository/tests/remote/fetch.rs

@@ -12,7 +12,7 @@ mod blocking_and_async_io {
 
     pub(crate) fn base_repo_path() -> String {
         git::path::realpath(
-            git_testtools::scripted_fixture_repo_read_only("make_remote_repos.sh")
+            git_testtools::scripted_fixture_read_only("make_remote_repos.sh")
                 .unwrap()
                 .join("base"),
         )
@@ -22,13 +22,13 @@ mod blocking_and_async_io {
     }
 
     pub(crate) fn repo_path(name: &str) -> std::path::PathBuf {
-        let dir = git_testtools::scripted_fixture_repo_read_only_with_args("make_fetch_repos.sh", [base_repo_path()])
-            .unwrap();
+        let dir =
+            git_testtools::scripted_fixture_read_only_with_args("make_fetch_repos.sh", [base_repo_path()]).unwrap();
         dir.join(name)
     }
 
     pub(crate) fn repo_rw(name: &str) -> (git::Repository, git_testtools::tempfile::TempDir) {
-        let dir = git_testtools::scripted_fixture_repo_writable_with_args(
+        let dir = git_testtools::scripted_fixture_writable_with_args(
             "make_fetch_repos.sh",
             [base_repo_path()],
             git_testtools::Creation::ExecuteScript,