fix some edge cases & add some more tests for incomplete builds in db

migrations/20240313103708_make_release_fields_optional.down.sql

@@ -1,3 +1,18 @@
+DELETE FROM builds WHERE rid in (
+    SELECT id FROM releases WHERE (
+        release_time IS NULL OR
+        target_name IS NULL OR
+        yanked IS NULL OR
+        is_library IS NULL OR
+        rustdoc_status IS NULL OR
+        have_examples IS NULL OR
+        downloads IS NULL OR
+        doc_targets IS NULL OR
+        default_target IS NULL OR
+        archive_storage IS NULL
+    )
+);
+
 DELETE FROM releases WHERE (
     release_time IS NULL OR
     target_name IS NULL OR

src/db/add_package.rs

@@ -608,6 +608,118 @@ mod test {
     use crate::utils::CargoMetadata;
     use test_case::test_case;
 
+    #[test]
+    fn test_set_build_to_error() {
+        async_wrapper(|env| async move {
+            let mut conn = env.async_db().await.async_conn().await;
+            let crate_id = initialize_crate(&mut conn, "krate").await?;
+            let release_id = initialize_release(&mut conn, crate_id, "0.1.0").await?;
+            let build_id = initialize_build(&mut conn, release_id).await?;
+
+            update_build_with_error(&mut conn, build_id, Some("error message")).await?;
+
+            let row = sqlx::query!(
+                r#"SELECT
+                rustc_version,
+                docsrs_version,
+                build_status as "build_status: BuildStatus",
+                errors
+                FROM builds
+                WHERE id = $1"#,
+                build_id
+            )
+            .fetch_one(&mut *conn)
+            .await?;
+
+            assert!(row.rustc_version.is_none());
+            assert!(row.docsrs_version.is_none());
+            assert_eq!(row.build_status, BuildStatus::Failure);
+            assert_eq!(row.errors, Some("error message".into()));
+
+            Ok(())
+        })
+    }
+
+    #[test]
+    fn test_finish_build_success() {
+        async_wrapper(|env| async move {
+            let mut conn = env.async_db().await.async_conn().await;
+            let crate_id = initialize_crate(&mut conn, "krate").await?;
+            let release_id = initialize_release(&mut conn, crate_id, "0.1.0").await?;
+            let build_id = initialize_build(&mut conn, release_id).await?;
+
+            finish_build(
+                &mut conn,
+                build_id,
+                "rustc_version",
+                "docsrs_version",
+                BuildStatus::Success,
+                None,
+            )
+            .await?;
+
+            let row = sqlx::query!(
+                r#"SELECT
+                rustc_version,
+                docsrs_version,
+                build_status as "build_status: BuildStatus",
+                errors
+                FROM builds
+                WHERE id = $1"#,
+                build_id
+            )
+            .fetch_one(&mut *conn)
+            .await?;
+
+            assert_eq!(row.rustc_version, Some("rustc_version".into()));
+            assert_eq!(row.docsrs_version, Some("docsrs_version".into()));
+            assert_eq!(row.build_status, BuildStatus::Success);
+            assert!(row.errors.is_none());
+
+            Ok(())
+        })
+    }
+
+    #[test]
+    fn test_finish_build_error() {
+        async_wrapper(|env| async move {
+            let mut conn = env.async_db().await.async_conn().await;
+            let crate_id = initialize_crate(&mut conn, "krate").await?;
+            let release_id = initialize_release(&mut conn, crate_id, "0.1.0").await?;
+            let build_id = initialize_build(&mut conn, release_id).await?;
+
+            finish_build(
+                &mut conn,
+                build_id,
+                "rustc_version",
+                "docsrs_version",
+                BuildStatus::Failure,
+                Some("error message"),
+            )
+            .await?;
+
+            let row = sqlx::query!(
+                r#"SELECT
+                rustc_version,
+                docsrs_version,
+                build_status as "build_status: BuildStatus",
+                errors
+                FROM builds
+                WHERE id = $1"#,
+                build_id
+            )
+            .fetch_one(&mut *conn)
+            .await?;
+
+            assert_eq!(row.rustc_version, Some("rustc_version".into()));
+            assert_eq!(row.docsrs_version, Some("docsrs_version".into()));
+            assert_eq!(row.build_status, BuildStatus::Failure);
+            assert_eq!(row.errors, Some("error message".into()));
+
+            Ok(())
+        })
+    }
+
     #[test]
     fn new_keywords() {
         wrapper(|env| {

src/docbuilder/rustwide_builder.rs

@@ -1062,21 +1062,24 @@ mod tests {
             let mut conn = env.db().conn();
             let row = conn
                 .query_one(
-                    "SELECT
+                    r#"SELECT
                         r.rustdoc_status,
                         r.default_target,
                         r.doc_targets,
                         r.archive_storage,
                         cov.total_items,
-                        b.id as build_id
+                        b.id as build_id,
+                        b.build_status::TEXT as build_status,
+                        b.docsrs_version,
+                        b.rustc_version
                     FROM
                         crates as c
                         INNER JOIN releases AS r ON c.id = r.crate_id
                         INNER JOIN builds as b ON r.id = b.rid
                         LEFT OUTER JOIN doc_coverage AS cov ON r.id = cov.release_id
                     WHERE
                         c.name = $1 AND
-                        r.version = $2",
+                        r.version = $2"#,
                     &[&crate_, &version],
                 )
                 .unwrap();
@@ -1085,6 +1088,9 @@ mod tests {
             assert_eq!(row.get::<_, String>("default_target"), default_target);
             assert!(row.get::<_, Option<i32>>("total_items").is_some());
             assert!(row.get::<_, bool>("archive_storage"));
+            assert!(!row.get::<_, String>("docsrs_version").is_empty());
+            assert!(!row.get::<_, String>("rustc_version").is_empty());
+            assert_eq!(row.get::<_, String>("build_status"), "success");
 
             let mut targets: Vec<String> = row
                 .get::<_, Value>("doc_targets")
@@ -1363,6 +1369,49 @@ mod tests {
         });
     }
 
+    #[test]
+    #[ignore]
+    fn test_build_failures_before_build() {
+        wrapper(|env| {
+            // https://github.com/rust-lang/docs.rs/issues/2491
+            // package without Cargo.toml, so fails directly in the fetch stage.
+            let crate_ = "emheap";
+            let version = "0.1.0";
+            let mut builder = RustwideBuilder::init(env).unwrap();
+            builder.update_toolchain()?;
+
+            // `Result` is `Ok`, but the build-result is `false`
+            assert!(!builder.build_package(crate_, version, PackageKind::CratesIo)?);
+
+            let row = env.runtime().block_on(async {
+                let mut conn = env.async_db().await.async_conn().await;
+                sqlx::query!(
+                    r#"SELECT
+                       rustc_version,
+                       docsrs_version,
+                       build_status as "build_status: BuildStatus",
+                       errors
+                       FROM
+                       crates as c
+                       INNER JOIN releases as r on c.id = r.crate_id
+                       INNER JOIN builds as b on b.rid = r.id
+                       WHERE c.name = $1 and r.version = $2"#,
+                    crate_,
+                    version,
+                )
+                .fetch_one(&mut *conn)
+                .await
+            })?;
+
+            assert!(row.rustc_version.is_none());
+            assert!(row.docsrs_version.is_none());
+            assert_eq!(row.build_status, BuildStatus::Failure);
+            assert!(row.errors.unwrap().contains("missing Cargo.toml"));
+
+            Ok(())
+        });
+    }
+
     #[test]
     #[ignore]
     fn test_implicit_features_for_optional_dependencies() {