feat: upload details model with flags, etc

Author: matt-codecov

migrations/01-init/down.sql

@@ -1,3 +1,4 @@
+DROP TABLE upload_details;
 DROP TABLE context_assoc;
 DROP TABLE branches_data;
 DROP TABLE method_data;

migrations/01-init/up.sql

@@ -58,3 +58,19 @@ CREATE TABLE context_assoc (
     span_id BLOB,
     PRIMARY KEY(context_id, sample_id, branch_id, method_id, span_id)
 );
+
+CREATE TABLE upload_details (
+    context_id INTEGER REFERENCES context(id) NOT NULL,
+    timestamp INTEGER,
+    raw_upload_url VARCHAR,
+    flags VARCHAR, -- JSON
+    provider VARCHAR,
+    build VARCHAR,
+    name VARCHAR,
+    job_name VARCHAR,
+    ci_run_url VARCHAR,
+    state VARCHAR,
+    env VARCHAR,
+    session_type VARCHAR,
+    session_extras VARCHAR -- JSON,
+);

src/report/mod.rs

@@ -22,6 +22,7 @@ pub trait Report {
         &self,
         file: &models::SourceFile,
     ) -> Result<Vec<models::CoverageSample>>;
+    fn get_details_for_upload(&self, upload: &models::Context) -> Result<models::UploadDetails>;
 
     fn merge(&mut self, other: &Self) -> Result<()>;
 }
@@ -85,5 +86,11 @@ pub trait ReportBuilder<R: Report> {
         span_data: Option<&'a models::SpanData>,
     ) -> Result<models::ContextAssoc>;
 
+    fn insert_upload_details(
+        &mut self,
+        context_id: i64,
+        upload_details: models::UploadDetails,
+    ) -> Result<models::UploadDetails>;
+
     fn build(self) -> R;
 }

src/report/models.rs

@@ -56,6 +56,8 @@ use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput,
 use strum_macros::{Display, EnumString};
 use uuid::Uuid;
 
+use crate::parsers::json::JsonVal;
+
 #[derive(PartialEq, Debug, Clone, Copy, Default)]
 pub enum CoverageType {
     #[default]
@@ -320,17 +322,17 @@ pub struct Context {
 #[derive(PartialEq, Debug, Default)]
 pub struct UploadDetails {
     pub context_id: i64,
-
-    pub timestamp: i64,
-    pub raw_upload_url: String,
-    pub flags: Vec<String>,
-    pub provider: String,
-    pub build: String,
-    pub name: String,
-    pub job_name: String,
-    pub ci_run_url: String,
-    pub state: String,
-    pub env: String,
-    pub session_type: String,
-    pub session_extras: String,
+    pub timestamp: Option<i64>,
+    pub raw_upload_url: Option<String>,
+    /// JSON array
+    pub flags: Option<JsonVal>,
+    pub provider: Option<String>,
+    pub build: Option<String>,
+    pub name: Option<String>,
+    pub job_name: Option<String>,
+    pub ci_run_url: Option<String>,
+    pub state: Option<String>,
+    pub env: Option<String>,
+    pub session_type: Option<String>,
+    pub session_extras: Option<JsonVal>,
 }

src/report/sqlite_report.rs

@@ -8,6 +8,7 @@ use uuid::Uuid;
 
 use crate::{
     error::Result,
+    parsers::json::JsonVal,
     report::{models, Report, ReportBuilder},
 };
 
@@ -30,6 +31,14 @@ fn open_database(filename: &PathBuf) -> Result<Connection> {
     Ok(conn)
 }
 
+/// Can't implement foreign traits (`ToSql`/`FromSql`) on foreign types
+/// (`serde_json::Value`) so this helper function fills in.
+fn json_value_from_sql(s: String, col: usize) -> rusqlite::Result<Option<JsonVal>> {
+    serde_json::from_str(s.as_str()).map_err(|e| {
+        rusqlite::Error::FromSqlConversionFailure(col, rusqlite::types::Type::Text, Box::new(e))
+    })
+}
+
 impl SqliteReport {
     pub fn new(filename: PathBuf) -> Result<SqliteReport> {
         let conn = open_database(&filename)?;
@@ -156,6 +165,32 @@ impl Report for SqliteReport {
         Ok(result)
     }
 
+    fn get_details_for_upload(&self, upload: &models::Context) -> Result<models::UploadDetails> {
+        assert_eq!(upload.context_type, models::ContextType::Upload);
+        let mut stmt = self.conn.prepare("SELECT context_id, timestamp, raw_upload_url, flags, provider, build, name, job_name, ci_run_url, state, env, session_type, session_extras FROM upload_details WHERE context_id = ?1")?;
+        Ok(stmt.query_row([upload.id], |row| {
+            Ok(models::UploadDetails {
+                context_id: row.get(0)?,
+                timestamp: row.get(1)?,
+                raw_upload_url: row.get(2)?,
+                flags: row
+                    .get::<usize, String>(3)
+                    .and_then(|s| json_value_from_sql(s, 3))?,
+                provider: row.get(4)?,
+                build: row.get(5)?,
+                name: row.get(6)?,
+                job_name: row.get(7)?,
+                ci_run_url: row.get(8)?,
+                state: row.get(9)?,
+                env: row.get(10)?,
+                session_type: row.get(11)?,
+                session_extras: row
+                    .get::<usize, String>(12)
+                    .and_then(|s| json_value_from_sql(s, 12))?,
+            })
+        })?)
+    }
+
     /// Merge `other` into `self` without modifying `other`.
     ///
     /// TODO: Probably put this in a commit
@@ -413,6 +448,35 @@ impl ReportBuilder<SqliteReport> for SqliteReportBuilder {
         )?)
     }
 
+    fn insert_upload_details(
+        &mut self,
+        context_id: i64,
+        mut upload_details: models::UploadDetails,
+    ) -> Result<models::UploadDetails> {
+        upload_details.context_id = context_id;
+        let mut stmt = self.conn.prepare("INSERT INTO upload_details (context_id, timestamp, raw_upload_url, flags, provider, build, name, job_name, ci_run_url, state, env, session_type, session_extras) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)")?;
+        let _ = stmt.execute((
+            &upload_details.context_id,
+            &upload_details.timestamp,
+            &upload_details.raw_upload_url,
+            &upload_details.flags.as_ref().map(|v| v.to_string()),
+            &upload_details.provider,
+            &upload_details.build,
+            &upload_details.name,
+            &upload_details.job_name,
+            &upload_details.ci_run_url,
+            &upload_details.state,
+            &upload_details.env,
+            &upload_details.session_type,
+            &upload_details
+                .session_extras
+                .as_ref()
+                .map(|v| v.to_string()),
+        ))?;
+
+        Ok(upload_details)
+    }
+
     fn build(self) -> SqliteReport {
         SqliteReport {
             filename: self.filename,
@@ -652,6 +716,8 @@ mod tests {
     }
 
     mod sqlite_report_builder {
+        use serde_json::{json, json_internal};
+
         use super::*;
 
         fn hash_id(key: &str) -> i64 {
@@ -949,5 +1015,51 @@ mod tests {
                 .unwrap();
             assert_eq!(actual_assoc, expected_assoc);
         }
+
+        #[test]
+        fn test_insert_upload_details() {
+            let ctx = setup();
+            let db_file = ctx.temp_dir.path().join("db.sqlite");
+            let mut report_builder = SqliteReportBuilder::new(db_file).unwrap();
+
+            let upload = report_builder
+                .insert_context(models::ContextType::Upload, "codecov-rs CI")
+                .unwrap();
+            let inserted_details = models::UploadDetails {
+                context_id: upload.id,
+                timestamp: Some(123),
+                raw_upload_url: Some("https://example.com".to_string()),
+                flags: Some(json!(["abc".to_string(), "def".to_string()])),
+                provider: Some("provider".to_string()),
+                build: Some("build".to_string()),
+                name: Some("name".to_string()),
+                job_name: Some("job name".to_string()),
+                ci_run_url: Some("https://example.com".to_string()),
+                state: Some("state".to_string()),
+                env: Some("env".to_string()),
+                session_type: Some("uploaded".to_string()),
+                session_extras: Some(json!({})),
+            };
+            let inserted_details = report_builder
+                .insert_upload_details(upload.id, inserted_details)
+                .unwrap();
+
+            let other_upload = report_builder
+                .insert_context(models::ContextType::Upload, "codecov-rs CI 2")
+                .unwrap();
+
+            let report = report_builder.build();
+            let fetched_details = report.get_details_for_upload(&upload).unwrap();
+            assert_eq!(fetched_details, inserted_details);
+
+            let other_details_result = report.get_details_for_upload(&other_upload);
+            assert!(other_details_result.is_err());
+            match other_details_result {
+                Err(crate::error::CodecovError::SqliteError(
+                    rusqlite::Error::QueryReturnedNoRows,
+                )) => {}
+                _ => assert!(false),
+            }
+        }
     }
 }