add rustdoc json to test fakes, update delete_version to also delete json

Author: syphar

src/db/delete.rs

@@ -11,7 +11,7 @@ use super::{CrateId, update_latest_version_id};
 
 /// List of directories in docs.rs's underlying storage (either the database or S3) containing a
 /// subdirectory named after the crate. Those subdirectories will be deleted.
-static LIBRARY_STORAGE_PATHS_TO_DELETE: &[&str] = &["rustdoc", "sources"];
+static LIBRARY_STORAGE_PATHS_TO_DELETE: &[&str] = &["rustdoc", "rustdoc-json", "sources"];
 static OTHER_STORAGE_PATHS_TO_DELETE: &[&str] = &["sources"];
 
 #[derive(Debug, thiserror::Error)]
@@ -222,6 +222,7 @@ mod tests {
     use super::*;
     use crate::db::ReleaseId;
     use crate::registry_api::{CrateOwner, OwnerKind};
+    use crate::storage::rustdoc_json_path;
     use crate::test::{async_wrapper, fake_release_that_failed_before_build};
     use test_case::test_case;
 
@@ -426,6 +427,17 @@ mod tests {
                     .rustdoc_file_exists("a", "1.0.0", None, "a/index.html", archive_storage)
                     .await?
             );
+            assert!(
+                env.async_storage()
+                    .await
+                    .exists(&rustdoc_json_path(
+                        "a",
+                        "1.0.0",
+                        "x86_64-unknown-linux-gnu",
+                        crate::storage::RustdocJsonFormatVersion::Latest
+                    ))
+                    .await?
+            );
             let crate_id = sqlx::query_scalar!(
                 r#"SELECT crate_id as "crate_id: CrateId" FROM releases WHERE id = $1"#,
                 v1.0
@@ -457,6 +469,17 @@ mod tests {
                     .rustdoc_file_exists("a", "2.0.0", None, "a/index.html", archive_storage)
                     .await?
             );
+            assert!(
+                env.async_storage()
+                    .await
+                    .exists(&rustdoc_json_path(
+                        "a",
+                        "2.0.0",
+                        "x86_64-unknown-linux-gnu",
+                        crate::storage::RustdocJsonFormatVersion::Latest
+                    ))
+                    .await?
+            );
             assert_eq!(
                 owners(&mut conn, crate_id).await?,
                 vec!["Peter Rabbit".to_string()]
@@ -494,13 +517,36 @@ mod tests {
                         .await?
                 );
             }
+            assert!(
+                !env.async_storage()
+                    .await
+                    .exists(&rustdoc_json_path(
+                        "a",
+                        "1.0.0",
+                        "x86_64-unknown-linux-gnu",
+                        crate::storage::RustdocJsonFormatVersion::Latest
+                    ))
+                    .await?
+            );
+
             assert!(release_exists(&mut conn, v2).await?);
             assert!(
                 env.async_storage()
                     .await
                     .rustdoc_file_exists("a", "2.0.0", None, "a/index.html", archive_storage)
                     .await?
             );
+            assert!(
+                env.async_storage()
+                    .await
+                    .exists(&rustdoc_json_path(
+                        "a",
+                        "2.0.0",
+                        "x86_64-unknown-linux-gnu",
+                        crate::storage::RustdocJsonFormatVersion::Latest
+                    ))
+                    .await?
+            );
             assert_eq!(
                 owners(&mut conn, crate_id).await?,
                 vec!["Peter Rabbit".to_string()]

src/storage/mod.rs

@@ -831,7 +831,7 @@ pub(crate) fn rustdoc_json_path(
     format_version: RustdocJsonFormatVersion,
 ) -> String {
     format!(
-        "/rustdoc-json/{name}/{version}/{target}/{name}_{version}_{target}_{format_version}.json.zst"
+        "rustdoc-json/{name}/{version}/{target}/{name}_{version}_{target}_{format_version}.json.zst"
     )
 }
 

src/test/fakes.rs

@@ -9,7 +9,8 @@ use crate::docbuilder::DocCoverage;
 use crate::error::Result;
 use crate::registry_api::{CrateData, CrateOwner, ReleaseData};
 use crate::storage::{
-    AsyncStorage, CompressionAlgorithm, rustdoc_archive_path, source_archive_path,
+    AsyncStorage, CompressionAlgorithm, RustdocJsonFormatVersion, rustdoc_archive_path,
+    rustdoc_json_path, source_archive_path,
 };
 use crate::utils::{Dependency, MetadataPackage, Target};
 use anyhow::{Context, bail};
@@ -512,10 +513,38 @@ impl<'a> FakeRelease<'a> {
         }
         store_files_into(&self.source_files, crate_dir)?;
 
+        let default_target = self.default_target.unwrap_or("x86_64-unknown-linux-gnu");
+
+        {
+            let mut targets = self.doc_targets.clone();
+            if !targets.contains(&default_target.to_owned()) {
+                targets.push(default_target.to_owned());
+            }
+            for target in &targets {
+                for format_version in [
+                    RustdocJsonFormatVersion::Version(42),
+                    RustdocJsonFormatVersion::Latest,
+                ] {
+                    storage
+                        .store_one(
+                            &rustdoc_json_path(
+                                &package.name,
+                                &package.version,
+                                &target,
+                                format_version,
+                            ),
+                            serde_json::to_vec(&serde_json::json!({
+                                "format_version": 42
+                            }))?,
+                        )
+                        .await?;
+                }
+            }
+        }
+
         // Many tests rely on the default-target being linux, so it should not
         // be set to docsrs_metadata::HOST_TARGET, because then tests fail on all
         // non-linux platforms.
-        let default_target = self.default_target.unwrap_or("x86_64-unknown-linux-gnu");
         let mut async_conn = db.async_conn().await;
         let crate_id = initialize_crate(&mut async_conn, &package.name).await?;
         let release_id = initialize_release(&mut async_conn, crate_id, &package.version).await?;