Auto merge of #11360 - arlosi:beta-sparse-wait, r=epage

[BETA-1.66] Fix wait-for-publish with sparse registry

Beta backport of #11356

r? `@epage`

Author: bors

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

@@ -469,6 +469,7 @@ impl Drop for HttpServerHandle {
 }
 
 /// Request to the test http server
+#[derive(Clone)]
 pub struct Request {
     pub url: Url,
     pub method: String,

src/cargo/sources/registry/http_remote.rs

@@ -549,6 +549,7 @@ impl<'cfg> RegistryData for HttpRegistry<'cfg> {
         // All it does is ensure that a subsequent load will double-check files with the
         // server rather than rely on a locally cached copy of the index files.
         debug!("invalidated index cache");
+        self.fresh.clear();
         self.requested_update = true;
     }
 

tests/testsuite/publish.rs

@@ -2547,6 +2547,97 @@ See [..]
         .run();
 }
 
+#[cargo_test]
+fn wait_for_subsequent_publish() {
+    // Counter for number of tries before the package is "published"
+    let arc: Arc<Mutex<u32>> = Arc::new(Mutex::new(0));
+    let arc2 = arc.clone();
+    let publish_req = Arc::new(Mutex::new(None));
+    let publish_req2 = publish_req.clone();
+
+    let registry = registry::RegistryBuilder::new()
+        .http_index()
+        .http_api()
+        .add_responder("/api/v1/crates/new", move |req, server| {
+            // Capture the publish request, but defer publishing
+            *publish_req.lock().unwrap() = Some(req.clone());
+            server.ok(req)
+        })
+        .add_responder("/index/de/la/delay", move |req, server| {
+            let mut lock = arc.lock().unwrap();
+            *lock += 1;
+            if *lock == 3 {
+                // Run the publish on the 3rd attempt
+                server.publish(&publish_req2.lock().unwrap().as_ref().unwrap());
+            }
+            server.index(req)
+        })
+        .build();
+
+    // Publish an earlier version
+    Package::new("delay", "0.0.1")
+        .file("src/lib.rs", "")
+        .publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "delay"
+                version = "0.0.2"
+                authors = []
+                license = "MIT"
+                description = "foo"
+
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("publish --no-verify -Z sparse-registry")
+        .masquerade_as_nightly_cargo(&["sparse-registry"])
+        .replace_crates_io(registry.index_url())
+        .with_status(0)
+        .with_stderr(
+            "\
+[UPDATING] crates.io index
+[WARNING] manifest has no documentation, [..]
+See [..]
+[PACKAGING] delay v0.0.2 ([CWD])
+[UPLOADING] delay v0.0.2 ([CWD])
+[UPDATING] crates.io index
+[WAITING] on `delay` to propagate to crates.io index (ctrl-c to wait asynchronously)
+",
+        )
+        .run();
+
+    // Verify the responder has been pinged
+    let lock = arc2.lock().unwrap();
+    assert_eq!(*lock, 3);
+    drop(lock);
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.0.1"
+                authors = []
+                [dependencies]
+                delay = "0.0.2"
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build -Z sparse-registry")
+        .masquerade_as_nightly_cargo(&["sparse-registry"])
+        .with_status(0)
+        .run();
+}
+
 #[cargo_test]
 fn skip_wait_for_publish() {
     // Intentionally using local registry so the crate never makes it to the index