First round of experimental multi-repo testing

Author: mkeeler

Cargo.toml

@@ -31,6 +31,7 @@ structopt = "0.3"
 time = "0.1.39"
 tempfile = "3.1.0"
 thread-id = "3.3.0" # remove when we work with minimal-versions without it
+paste = "0.1.12"
 
 [features]
 unstable = []

src/blame.rs

@@ -290,9 +290,7 @@ mod tests {
     use std::fs::{self, File};
     use std::path::Path;
 
-    #[test]
-    fn smoke() {
-        let (_td, repo) = crate::test::repo_init();
+    repo_test!(smoke, Typical, TypicalWorktree, BareWorktree {
         let mut index = repo.index().unwrap();
 
         let root = repo.path().parent().unwrap();
@@ -322,5 +320,5 @@ mod tests {
         assert_eq!(hunk.path(), Some(Path::new("foo/bar")));
         assert_eq!(hunk.lines_in_hunk(), 0);
         assert!(!hunk.is_boundary())
-    }
+    });
 }

src/branch.rs

@@ -153,8 +153,7 @@ impl<'repo> Drop for Branches<'repo> {
 mod tests {
     use crate::BranchType;
 
-    #[test]
-    fn smoke() {
+    repo_test!(smoke, Typical, TypicalWorktree, BareWorktree {
         let (_td, repo) = crate::test::repo_init();
         let head = repo.head().unwrap();
         let target = head.target().unwrap();
@@ -174,5 +173,5 @@ mod tests {
         b1.set_upstream(None).unwrap();
 
         b1.delete().unwrap();
-    }
+    });
 }

src/test.rs

@@ -17,7 +17,21 @@ macro_rules! t {
     };
 }
 
-pub fn repo_init() -> (TempDir, Repository) {
+// `repo_test! will
+macro_rules! repo_test {
+    ($test_name:ident, $($repo_type:ident),+ $test_body:block) => {
+        paste::item! {
+            $(#[test]
+            fn [<$test_name _ $repo_type:snake>]() {
+                #[allow(unused_variables)]
+                let (td, repo) = $crate::test::repo_init2($crate::test::RepoType::$repo_type);
+                $test_body
+            })+
+        }
+    }
+}
+
+pub fn repo_init_typical() -> (TempDir, Repository) {
     let td = TempDir::new().unwrap();
     let repo = Repository::init(td.path()).unwrap();
     {
@@ -35,6 +49,31 @@ pub fn repo_init() -> (TempDir, Repository) {
     (td, repo)
 }
 
+pub fn repo_init_bare() -> (TempDir, Repository) {
+    panic!("unimplemented")
+}
+
+pub fn repo_init_bare_worktree() -> (TempDir, Repository) {
+    panic!("unimplemented")
+}
+
+pub fn repo_init_typical_worktree() -> (TempDir, Repository) {
+    panic!("unimplemented")
+}
+
+pub fn repo_init() -> (TempDir, Repository) {
+    repo_init_typical()
+}
+
+pub fn repo_init2(repo_type: RepoType) -> (TempDir, Repository) {
+    match repo_type {
+        RepoType::Typical => repo_init_typical(),
+        RepoType::Bare => repo_init_bare(),
+        RepoType::BareWorktree => repo_init_bare_worktree(),
+        RepoType::TypicalWorktree => repo_init_typical_worktree(),
+    }
+}
+
 pub fn commit(repo: &Repository) -> (Oid, Oid) {
     let mut index = t!(repo.index());
     let root = repo.path().parent().unwrap();
@@ -62,6 +101,14 @@ pub fn worktrees_env_init(repo: &Repository) -> (TempDir, Branch<'_>) {
     (wtdir, branch)
 }
 
+#[derive(Debug,Clone,Copy)]
+pub enum RepoType {
+    Typical,
+    TypicalWorktree,
+    Bare,
+    BareWorktree,
+}
+
 #[cfg(windows)]
 pub fn realpath(original: &Path) -> io::Result<PathBuf> {
     Ok(original.to_path_buf())

src/worktree.rs

@@ -264,9 +264,7 @@ mod tests {
     use crate::WorktreeLockStatus;
     use tempfile::TempDir;
 
-    #[test]
-    fn smoke_add_no_ref() {
-        let (_td, repo) = crate::test::repo_init();
+    repo_test!(smoke_add_no_ref, Typical, Bare {
         let wtdir = TempDir::new().unwrap();
         let wt_path = wtdir.path().join("tree-no-ref-dir");
         let opts = WorktreeAddOptions::new(None);
@@ -279,11 +277,9 @@ mod tests {
         );
         let status = wt.is_locked().unwrap();
         assert_eq!(status, WorktreeLockStatus::Unlocked);
-    }
+    });
 
-    #[test]
-    fn smoke_add_locked() {
-        let (_td, repo) = crate::test::repo_init();
+    repo_test!(smoke_add_locked, Typical, Bare {
         let wtdir = TempDir::new().unwrap();
         let wt_path = wtdir.path().join("locked-tree");
         let mut opts = WorktreeAddOptions::new(None);
@@ -304,11 +300,9 @@ mod tests {
             wt.is_locked().unwrap(),
             WorktreeLockStatus::Locked(Some("my reason".to_string()))
         );
-    }
+    });
 
-    #[test]
-    fn smoke_add_from_branch() {
-        let (_td, repo) = crate::test::repo_init();
+    repo_test!(smoke_add_from_branch, Typical, Bare {
         let (wt_top, branch) = crate::test::worktrees_env_init(&repo);
         let wt_path = wt_top.path().join("test");
         let opts = WorktreeAddOptions::new(Some(branch.into_reference()));
@@ -321,5 +315,5 @@ mod tests {
         );
         let status = wt.is_locked().unwrap();
         assert_eq!(status, WorktreeLockStatus::Unlocked);
-    }
+    });
 }