WIP

Author: syphar

src/test/fakes.rs

@@ -46,9 +46,10 @@ pub(crate) struct FakeBuild {
     s3_build_log: Option<String>,
     other_build_logs: HashMap<String, String>,
     db_build_log: Option<String>,
-    rustc_version: String,
-    docsrs_version: String,
+    rustc_version: Option<String>,
+    docsrs_version: Option<String>,
     build_status: BuildStatus,
+    errors: Option<String>,
 }
 
 const DEFAULT_CONTENT: &[u8] =
@@ -547,14 +548,21 @@ impl FakeGithubStats {
 impl FakeBuild {
     pub(crate) fn rustc_version(self, rustc_version: impl Into<String>) -> Self {
         Self {
-            rustc_version: rustc_version.into(),
+            rustc_version: Some(rustc_version.into()),
             ..self
         }
     }
 
     pub(crate) fn docsrs_version(self, docsrs_version: impl Into<String>) -> Self {
         Self {
-            docsrs_version: docsrs_version.into(),
+            docsrs_version: Some(docsrs_version.into()),
+            ..self
+        }
+    }
+
+    pub(crate) fn errors(self, errors: impl Into<String>) -> Self {
+        Self {
+            errors: Some(errors.into()),
             ..self
         }
     }
@@ -605,6 +613,18 @@ impl FakeBuild {
         }
     }
 
+    pub(crate) fn empty_failed() -> Self {
+        Self {
+            s3_build_log: None,
+            db_build_log: None,
+            other_build_logs: HashMap::new(),
+            rustc_version: None,
+            docsrs_version: None,
+            build_status: BuildStatus::Failure,
+            errors: None,
+        }
+    }
+
     async fn create(
         &self,
         conn: &mut sqlx::PgConnection,
@@ -613,15 +633,26 @@ impl FakeBuild {
         default_target: &str,
     ) -> Result<()> {
         let build_id = crate::db::initialize_build(&mut *conn, release_id).await?;
-        crate::db::finish_build(
-            &mut *conn,
-            build_id,
-            &self.rustc_version,
-            &self.docsrs_version,
-            self.build_status,
-            None,
-        )
-        .await?;
+
+        if let (Some(rustc_version), Some(docsrs_version)) =
+            (&self.rustc_version, &self.docsrs_version)
+        {
+            crate::db::finish_build(
+                &mut *conn,
+                build_id,
+                rustc_version,
+                docsrs_version,
+                self.build_status,
+                self.errors.as_deref(),
+            )
+            .await?;
+        } else {
+            assert_eq!(self.build_status, BuildStatus::Failure);
+            assert!(self.rustc_version.is_none());
+            assert!(self.docsrs_version.is_none());
+            crate::db::update_build_with_error(&mut *conn, build_id, self.errors.as_deref())
+                .await?;
+        }
 
         if let Some(db_build_log) = self.db_build_log.as_deref() {
             sqlx::query!(
@@ -653,14 +684,16 @@ impl FakeBuild {
 }
 
 impl Default for FakeBuild {
+    /// create a default fake _finished_ build
     fn default() -> Self {
         Self {
             s3_build_log: Some("It works!".into()),
             db_build_log: None,
             other_build_logs: HashMap::new(),
-            rustc_version: "rustc 2.0.0-nightly (000000000 1970-01-01)".into(),
-            docsrs_version: "docs.rs 1.0.0 (000000000 1970-01-01)".into(),
+            rustc_version: Some("rustc 2.0.0-nightly (000000000 1970-01-01)".into()),
+            docsrs_version: Some("docs.rs 1.0.0 (000000000 1970-01-01)".into()),
             build_status: BuildStatus::Success,
+            errors: None,
         }
     }
 }

src/web/build_details.rs

@@ -149,6 +149,42 @@ mod tests {
             .collect()
     }
 
+    #[test]
+    fn test_partial_build_result() {
+        wrapper(|env| {
+            let release_id = env
+                .fake_release()
+                .name("foo")
+                .version("0.1.0")
+                .builds(vec![FakeBuild::empty_failed().errors("some random error")])
+                .create()?;
+
+            let build_id = env.runtime().block_on(async {
+                let mut conn = env.async_db().await.async_conn().await;
+
+                sqlx::query_scalar!("SELECT id FROM builds WHERE rid = $1", release_id)
+                    .fetch_one(&mut *conn)
+                    .await
+            })?;
+
+            let page = kuchikiki::parse_html().one(
+                env.frontend()
+                    .get(&format!("/crate/foo/0.1.0/builds/{build_id}"))
+                    .send()?
+                    .error_for_status()?
+                    .text()?,
+            );
+
+            let info_text = dbg!(page.select("pre").unwrap().next())
+                .unwrap()
+                .text_contents();
+
+            assert!(info_text.contains("some random error"));
+
+            Ok(())
+        });
+    }
+
     #[test]
     fn db_build_logs() {
         wrapper(|env| {