Queries for partial status page data tested

Author: Jamesbarford

database/src/lib.rs

@@ -1147,6 +1147,10 @@ impl BenchmarkJob {
             | BenchmarkJobStatus::Completed { collector_name, .. } => Some(collector_name),
         }
     }
+
+    pub fn status(&self) -> &BenchmarkJobStatus {
+        &self.status
+    }
 }
 
 /// Describes the final state of a job
@@ -1207,6 +1211,5 @@ impl CollectorConfig {
 #[derive(Debug, PartialEq)]
 pub struct PartialStatusPageData {
     pub completed_requests: Vec<(BenchmarkRequest, String, Vec<String>)>,
-    pub in_progress_jobs: Vec<BenchmarkJob>,
-    pub in_progress_requests: Vec<BenchmarkRequest>,
+    pub in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)>,
 }

database/src/pool.rs

@@ -389,6 +389,7 @@ mod tests {
     use super::*;
     use crate::metric::Metric;
     use crate::tests::run_postgres_test;
+    use crate::BenchmarkJobStatus;
     use crate::{tests::run_db_test, BenchmarkRequestType, Commit, CommitType, Date};
     use chrono::Utc;
     use std::str::FromStr;
@@ -983,6 +984,7 @@ mod tests {
             let benchmark_set = BenchmarkSet(0u32);
             let time = chrono::DateTime::from_str("2021-09-01T00:00:00.000Z").unwrap();
             let tag = "sha-1";
+            let tag_two = "sha-2";
             let collector_name = "collector-1";
             let target = Target::X86_64UnknownLinuxGnu;
 
@@ -995,43 +997,117 @@ mod tests {
                 .await
                 .unwrap();
 
-            /* Create job for the request */
+            complete_request(&*db, tag, collector_name, benchmark_set.0, &target).await;
+            // record a couple of errors against the tag
+            let artifact_id = db.artifact_id(&ArtifactId::Tag(tag.to_string())).await;
+
+            db.record_error(artifact_id, "example-1", "This is an error")
+                .await;
+            db.record_error(artifact_id, "example-2", "This is another error")
+                .await;
+
+            let benchmark_request_two = BenchmarkRequest::create_release(tag_two, time);
+            db.insert_benchmark_request(&benchmark_request_two)
+                .await
+                .unwrap();
+
             db.enqueue_benchmark_job(
-                benchmark_request.tag().unwrap(),
+                benchmark_request_two.tag().unwrap(),
                 &target,
                 &CodegenBackend::Llvm,
                 &Profile::Opt,
                 benchmark_set.0,
             )
             .await
             .unwrap();
+            db.enqueue_benchmark_job(
+                benchmark_request_two.tag().unwrap(),
+                &target,
+                &CodegenBackend::Llvm,
+                &Profile::Debug,
+                benchmark_set.0,
+            )
+            .await
+            .unwrap();
 
-            let job = db
-                .dequeue_benchmark_job(collector_name, &target, &benchmark_set)
-                .await
-                .unwrap()
-                .unwrap();
-
-            assert_eq!(job.request_tag(), benchmark_request.tag().unwrap());
-
-            /* Mark the job as complete */
-            db.mark_benchmark_job_as_completed(job.id(), &BenchmarkJobConclusion::Success)
-                .await
-                .unwrap();
+            db.update_benchmark_request_status(
+                benchmark_request_two.tag().unwrap(),
+                BenchmarkRequestStatus::InProgress,
+            )
+            .await
+            .unwrap();
 
-            // record a couple of errors against the tag
-            let artifact_id = db.artifact_id(&ArtifactId::Tag(tag.to_string())).await;
+            let status_page_data = db.get_status_page_data().await.unwrap();
 
-            db.record_error(artifact_id, "example-1", "This is an error")
-                .await;
-            db.record_error(artifact_id, "example-2", "This is another error")
-                .await;
+            assert!(status_page_data.completed_requests.len() == 1);
+            assert_eq!(status_page_data.completed_requests[0].0.tag().unwrap(), tag);
+            assert!(matches!(
+                status_page_data.completed_requests[0].0.status(),
+                BenchmarkRequestStatus::Completed { .. }
+            ));
+            // can't really test duration
+            // ensure errors are correct
+            assert_eq!(
+                status_page_data.completed_requests[0].2[0],
+                "This is an error".to_string()
+            );
+            assert_eq!(
+                status_page_data.completed_requests[0].2[1],
+                "This is another error".to_string()
+            );
 
-            db.mark_benchmark_request_as_completed(tag).await.unwrap();
+            assert!(status_page_data.in_progress.len() == 1);
+            // we should have 2 jobs
+            assert!(status_page_data.in_progress[0].1.len() == 2);
+            // the request should be in progress
+            assert!(matches!(
+                status_page_data.in_progress[0].0.status(),
+                BenchmarkRequestStatus::InProgress
+            ));
 
-            let status_page_data = db.get_status_page_data().await.unwrap();
+            // Test the first job
+            assert!(matches!(
+                status_page_data.in_progress[0].1[0].target(),
+                Target::X86_64UnknownLinuxGnu
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[0].status(),
+                BenchmarkJobStatus::Queued
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[0].backend(),
+                CodegenBackend::Llvm
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[0].profile(),
+                Profile::Opt
+            ));
+            assert_eq!(
+                status_page_data.in_progress[0].1[0].benchmark_set(),
+                &benchmark_set
+            );
 
-            dbg!("{:?}", status_page_data);
+            // test the second job
+            assert!(matches!(
+                status_page_data.in_progress[0].1[1].target(),
+                Target::X86_64UnknownLinuxGnu
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[1].status(),
+                BenchmarkJobStatus::Queued
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[1].backend(),
+                CodegenBackend::Llvm
+            ));
+            assert!(matches!(
+                status_page_data.in_progress[0].1[1].profile(),
+                Profile::Debug
+            ));
+            assert_eq!(
+                status_page_data.in_progress[0].1[1].benchmark_set(),
+                &benchmark_set
+            );
 
             Ok(ctx)
         })