Omit checksum verification for local git dependencies

Author: jarhodes314

crates/cargo-test-support/src/registry.rs

@@ -385,6 +385,7 @@ pub struct Package {
     alternative: bool,
     invalid_json: bool,
     proc_macro: bool,
+    generate_checksum: bool,
     links: Option<String>,
     rust_version: Option<String>,
     cargo_features: Vec<String>,
@@ -860,6 +861,7 @@ impl Package {
             alternative: false,
             invalid_json: false,
             proc_macro: false,
+            generate_checksum: true,
             links: None,
             rust_version: None,
             cargo_features: Vec::new(),
@@ -877,6 +879,20 @@ impl Package {
         self
     }
 
+    /// Call with `true` to publish a git dependency in a "local registry".
+    ///
+    /// The difference between this and [Package::local] is that this will
+    /// skip checksum generation as git dependencies do not have checksums.
+    ///
+    /// See `source-replacement.html#local-registry-sources` for more details
+    /// on local registries. See `local_registry.rs` for the tests that use
+    /// this.
+    pub fn local_from_git(&mut self, local: bool) -> &mut Package {
+        self.local = local;
+        self.generate_checksum = !local;
+        self
+    }
+
     /// Call with `true` to publish in an "alternative registry".
     ///
     /// The name of the alternative registry is called "alternative".
@@ -1075,9 +1091,11 @@ impl Package {
                 })
             })
             .collect::<Vec<_>>();
-        let cksum = {
+        let cksum = if self.generate_checksum {
             let c = t!(fs::read(&self.archive_dst()));
             cksum(&c)
+        } else {
+            String::new()
         };
         let name = if self.invalid_json {
             serde_json::json!(1)

src/cargo/core/resolver/mod.rs

@@ -147,7 +147,10 @@ pub fn resolve(
 
     let mut cksums = HashMap::new();
     for (summary, _) in cx.activations.values() {
-        let cksum = summary.checksum().map(|s| s.to_string());
+        let cksum = summary
+            .checksum()
+            .map(|s| s.to_string())
+            .filter(|s| !s.is_empty());
         cksums.insert(summary.package_id(), cksum);
     }
     let graph = cx.graph();

src/cargo/sources/registry/local.rs

@@ -129,7 +129,7 @@ impl<'cfg> RegistryData for LocalRegistry<'cfg> {
         // We don't actually need to download anything per-se, we just need to
         // verify the checksum matches the .crate file itself.
         let actual = Sha256::new().update_file(&crate_file)?.finish_hex();
-        if actual != checksum {
+        if actual != checksum && !checksum.is_empty() {
             anyhow::bail!("failed to verify the checksum of `{}`", pkg)
         }
 

tests/testsuite/local_registry.rs

@@ -2,7 +2,7 @@
 
 use cargo_test_support::paths::{self, CargoPathExt};
 use cargo_test_support::registry::{registry_path, Package};
-use cargo_test_support::{basic_manifest, project, t};
+use cargo_test_support::{basic_manifest, git, path2url, project, t};
 use std::fs;
 
 fn setup() {
@@ -526,3 +526,74 @@ fn crates_io_registry_url_is_optional() {
     p.cargo("build").with_stderr("[FINISHED] [..]").run();
     p.cargo("test").run();
 }
+
+#[cargo_test]
+fn git_dependencies_do_not_require_a_checksum() {
+    let git_project = git::new("dep1", |project| {
+        project
+            .file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
+            .file("src/lib.rs", "pub fn bar() {}")
+    });
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                [package]
+                name = "foo"
+                version = "0.0.1"
+                authors = []
+
+                [dependencies.bar]
+                git = '{}'
+            "#,
+                git_project.url()
+            ),
+        )
+        .file(
+            "src/lib.rs",
+            "extern crate bar; pub fn foo() { bar::bar(); }",
+        )
+        .build();
+
+    p.cargo("generate-lockfile").run();
+
+    let root = paths::root();
+    t!(fs::create_dir(&root.join(".cargo")));
+
+    Package::new("bar", "0.0.1")
+        .local_from_git(true)
+        .file("src/lib.rs", "pub fn bar() {}")
+        .publish();
+
+    t!(fs::write(
+        root.join(".cargo/config"),
+        format!(
+            r#"
+            [source.my-awesome-git-registry]
+            git = '{}'
+            replace-with = 'my-awesome-local-registry'
+
+            [source.my-awesome-local-registry]
+            local-registry = 'registry'
+        "#,
+            git_project.url()
+        )
+    ));
+    p.cargo("clean").run();
+    p.cargo("build")
+        .with_stderr(&format!(
+            "[UNPACKING] bar v0.0.1 ([..])\n\
+             [COMPILING] bar v0.0.1 ({}#[..])\n\
+             [COMPILING] foo v0.0.1 ([CWD])\n\
+             [FINISHED] [..]\n",
+            path2url(&git_project.root())
+        ))
+        .run();
+    p.cargo("build").with_stderr("[FINISHED] [..]").run();
+    p.cargo("test").run();
+    let lockfile = t!(fs::read_to_string(p.root().join("Cargo.lock")));
+    // We only have one dependency, and it should not contain a checksum in the lockfile
+    assert!(!lockfile.contains("checksum"));
+}