feat(git): support shallow fetch for Git CLI backend

The newly added tests also ensure the interop between each backend

Author: weihanglo

src/cargo/sources/git/utils.rs

@@ -1032,7 +1032,7 @@ pub fn fetch(
 
     debug!("doing a fetch for {remote_url}");
     let result = if let Some(true) = gctx.net_config()?.git_fetch_with_cli {
-        fetch_with_cli(repo, remote_url, &refspecs, tags, gctx)
+        fetch_with_cli(repo, remote_url, &refspecs, tags, shallow, gctx)
     } else if gctx.cli_unstable().gitoxide.map_or(false, |git| git.fetch) {
         fetch_with_gitoxide(repo, remote_url, refspecs, tags, shallow, gctx)
     } else {
@@ -1076,6 +1076,7 @@ fn fetch_with_cli(
     url: &str,
     refspecs: &[String],
     tags: bool,
+    shallow: gix::remote::fetch::Shallow,
     gctx: &GlobalContext,
 ) -> CargoResult<()> {
     debug!(target: "git-fetch", backend = "git-cli");
@@ -1087,6 +1088,10 @@ fn fetch_with_cli(
     } else {
         cmd.arg("--no-tags");
     }
+    if let gix::remote::fetch::Shallow::DepthAtRemote(depth) = shallow {
+        let depth = 0i32.saturating_add_unsigned(depth.get());
+        cmd.arg(format!("--depth={depth}"));
+    }
     match gctx.shell().verbosity() {
         Verbosity::Normal => {}
         Verbosity::Verbose => {

tests/testsuite/git_shallow.rs

@@ -7,13 +7,15 @@ use crate::git_gc::find_index;
 enum Backend {
     Git2,
     Gitoxide,
+    GitCli,
 }
 
 impl Backend {
     fn to_arg(&self) -> &'static str {
         match self {
             Backend::Git2 => "",
             Backend::Gitoxide => "-Zgitoxide=fetch",
+            Backend::GitCli => "--config=net.git-fetch-with-cli=true",
         }
     }
 
@@ -45,6 +47,11 @@ fn gitoxide_fetch_shallow_dep_two_revs() {
     fetch_dep_two_revs(Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_two_revs() {
+    fetch_dep_two_revs(Backend::GitCli)
+}
+
 fn fetch_dep_two_revs(backend: Backend) {
     let bar = git::new("meta-dep", |project| {
         project
@@ -138,6 +145,11 @@ fn gitoxide_fetch_shallow_dep_branch_and_rev() -> anyhow::Result<()> {
     fetch_shallow_dep_branch_and_rev(Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_branch_and_rev() -> anyhow::Result<()> {
+    fetch_shallow_dep_branch_and_rev(Backend::GitCli)
+}
+
 fn fetch_shallow_dep_branch_and_rev(backend: Backend) -> anyhow::Result<()> {
     let (bar, bar_repo) = git::new_repo("bar", |p| {
         p.file("Cargo.toml", &basic_manifest("bar", "1.0.0"))
@@ -203,6 +215,11 @@ fn gitoxide_fetch_shallow_dep_branch_to_rev() -> anyhow::Result<()> {
     fetch_shallow_dep_branch_to_rev(Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_branch_to_rev() -> anyhow::Result<()> {
+    fetch_shallow_dep_branch_to_rev(Backend::GitCli)
+}
+
 fn fetch_shallow_dep_branch_to_rev(backend: Backend) -> anyhow::Result<()> {
     // db exists from previous build, then dependency changes to refer to revision that isn't
     // available in the shallow fetch.
@@ -292,6 +309,11 @@ fn gitoxide_fetch_shallow_index_then_git2_fetch_complete() -> anyhow::Result<()>
     fetch_shallow_index_then_fetch_complete(Backend::Gitoxide, Backend::Git2)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_index_then_git2_fetch_complete() -> anyhow::Result<()> {
+    fetch_shallow_index_then_fetch_complete(Backend::GitCli, Backend::Git2)
+}
+
 fn fetch_shallow_index_then_fetch_complete(
     backend_1st: Backend,
     backend_2nd: Backend,
@@ -362,11 +384,31 @@ fn gitoxide_fetch_shallow_dep_then_git2_fetch_complete() -> anyhow::Result<()> {
     fetch_shallow_dep_then_fetch_complete(Backend::Gitoxide, Backend::Git2)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_then_git2_fetch_complete() -> anyhow::Result<()> {
+    fetch_shallow_dep_then_fetch_complete(Backend::GitCli, Backend::Git2)
+}
+
 #[cargo_test]
 fn gitoxide_fetch_shallow_dep_then_gitoxide_fetch_complete() -> anyhow::Result<()> {
     fetch_shallow_dep_then_fetch_complete(Backend::Gitoxide, Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_then_gitoxide_fetch_complete() -> anyhow::Result<()> {
+    fetch_shallow_dep_then_fetch_complete(Backend::GitCli, Backend::Gitoxide)
+}
+
+#[cargo_test]
+fn gitoxide_fetch_shallow_dep_then_git_cli_fetch_complete() -> anyhow::Result<()> {
+    fetch_shallow_dep_then_fetch_complete(Backend::Gitoxide, Backend::GitCli)
+}
+
+#[cargo_test]
+fn git_cli_fetch_shallow_dep_then_git_cli_fetch_complete() -> anyhow::Result<()> {
+    fetch_shallow_dep_then_fetch_complete(Backend::GitCli, Backend::GitCli)
+}
+
 fn fetch_shallow_dep_then_fetch_complete(
     backend_1st: Backend,
     backend_2nd: Backend,
@@ -518,6 +560,11 @@ fn gitoxide_fetch_shallow_index_then_preserve_shallow() -> anyhow::Result<()> {
     fetch_shallow_index_then_preserve_shallow(Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_shallow_index_then_preserve_shallow() -> anyhow::Result<()> {
+    fetch_shallow_index_then_preserve_shallow(Backend::GitCli)
+}
+
 fn fetch_shallow_index_then_preserve_shallow(backend: Backend) -> anyhow::Result<()> {
     Package::new("bar", "1.0.0").publish();
     let p = project()
@@ -604,6 +651,11 @@ fn gitoxide_fetch_complete_index_then_shallow() -> anyhow::Result<()> {
     fetch_complete_index_then_shallow(Backend::Gitoxide)
 }
 
+#[cargo_test]
+fn git_cli_fetch_complete_index_then_shallow() -> anyhow::Result<()> {
+    fetch_complete_index_then_shallow(Backend::GitCli)
+}
+
 fn fetch_complete_index_then_shallow(backend: Backend) -> anyhow::Result<()> {
     Package::new("bar", "1.0.0").publish();
     let p = project()
@@ -711,6 +763,25 @@ fn gitoxide_fetch_shallow_index_then_abort_and_update() -> anyhow::Result<()> {
     fetch_shallow_index_then_abort_and_update(Backend::Gitoxide)
 }
 
+// Git CLI cannot recover from stale lock files like Gitoxide can.
+// This test simulates an aborted fetch by creating a stale shallow.lock file.
+// Gitoxide can detect and recover from this, but Git CLI will fail with:
+//
+// ```text
+// fatal: Unable to create \'/path/to/.git/shallow.lock\': File exists.
+//
+// Another git process seems to be running in this repository, e.g.
+// an editor opened by \'git commit\'. Please make sure all processes
+// are terminated then try again. If it still fails, a git process
+// may have crashed in this repository earlier:
+// remove the file manually to continue.
+// ```
+#[cargo_test]
+#[ignore = "Git CLI cannot recover from stale lock files"]
+fn git_cli_fetch_shallow_index_then_abort_and_update() -> anyhow::Result<()> {
+    fetch_shallow_index_then_abort_and_update(Backend::GitCli)
+}
+
 fn fetch_shallow_index_then_abort_and_update(backend: Backend) -> anyhow::Result<()> {
     Package::new("bar", "1.0.0").publish();
     let p = project()