statisfied that ARRAY_AGG(...) can be used

Author: Jamesbarford

database/src/lib.rs

@@ -1206,7 +1206,7 @@ impl CollectorConfig {
 /// status page
 #[derive(Debug, PartialEq)]
 pub struct PartialStatusPageData {
-    pub completed_requests: Vec<(BenchmarkRequest, u64, Vec<String>)>,
+    pub completed_requests: Vec<(BenchmarkRequest, String, Vec<String>)>,
     pub in_progress_jobs: Vec<BenchmarkJob>,
     pub in_progress_requests: Vec<BenchmarkRequest>,
 }

database/src/pool.rs

@@ -976,13 +976,63 @@ mod tests {
         .await;
     }
 
+    #[tokio::test]
     async fn get_status_page_data() {
         run_postgres_test(|ctx| async {
             let db = ctx.db_client().connection().await;
-            db.add_collector_config("collector-1", &Target::X86_64UnknownLinuxGnu, 1, true)
+            let benchmark_set = BenchmarkSet(0u32);
+            let time = chrono::DateTime::from_str("2021-09-01T00:00:00.000Z").unwrap();
+            let tag = "sha-1";
+            let collector_name = "collector-1";
+            let target = Target::X86_64UnknownLinuxGnu;
+
+            db.add_collector_config(collector_name, &target, benchmark_set.0, true)
+                .await
+                .unwrap();
+
+            let benchmark_request = BenchmarkRequest::create_release(tag, time);
+            db.insert_benchmark_request(&benchmark_request)
+                .await
+                .unwrap();
+
+            /* Create job for the request */
+            db.enqueue_benchmark_job(
+                benchmark_request.tag().unwrap(),
+                &target,
+                &CodegenBackend::Llvm,
+                &Profile::Opt,
+                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();
 
+            // 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;
+
+            db.mark_benchmark_request_as_completed(tag).await.unwrap();
+
+            let status_page_data = db.get_status_page_data().await.unwrap();
+
+            dbg!("{:?}", status_page_data);
+
             Ok(ctx)
         })
         .await;

database/src/pool/postgres.rs

@@ -1918,7 +1918,7 @@ where
         let in_progress_requests_query = format!(
             "
             SELECT {BENCHMARK_REQUEST_COLUMNS}
-            FROM benchmark_requests
+            FROM benchmark_request
             WHERE status = '{BENCHMARK_REQUEST_STATUS_IN_PROGRESS_STR}'
         "
         );
@@ -1972,7 +1972,7 @@ where
             )
             SELECT
                 completed.*,
-                stats.*,
+                stats.duration::TEXT,
                 errors.errors AS errors
             FROM
                 completed
@@ -1989,15 +1989,15 @@ where
             .map(row_to_benchmark_request)
             .collect();
 
-        let completed_requests: Vec<(BenchmarkRequest, u64, Vec<String>)> = self
+        let completed_requests: Vec<(BenchmarkRequest, String, Vec<String>)> = self
             .conn()
             .query(&completed_requests_query, &[])
             .await?
             .iter()
             .map(|it| {
                 (
                     row_to_benchmark_request(it),
-                    it.get::<_, i64>(9) as u64,
+                    it.get::<_, String>(9),
                     it.get::<_, Vec<String>>(10),
                 )
             })
@@ -2008,6 +2008,8 @@ where
             .map(|it| it.tag().unwrap())
             .collect();
 
+        let in_progress_tags: String = in_progress_tags.join(",");
+
         // We don't do a status check on the jobs as we want to return all jobs,
         // irrespective of status, that are attached to an inprogress
         // benchmark_request
@@ -2028,7 +2030,7 @@ where
                     completed_at,
                     retry
                 FROM
-                    job_queue WHERE job_queue.tag IN ($1);",
+                    job_queue WHERE job_queue.request_tag IN ($1);",
                 &[&in_progress_tags],
             )
             .await?;