From 8771eda021478323bd1bb28a8240af668a754aba Mon Sep 17 00:00:00 2001 From: Matt Hammerly Date: Mon, 9 Sep 2024 15:25:47 -0700 Subject: [PATCH] stop taking an RNG as an argument for parse_pyreport and SqliteReportBuilder --- Cargo.lock | 1 + core/Cargo.toml | 2 +- core/src/parsers/pyreport/mod.rs | 27 +----- core/src/report/pyreport/chunks.rs | 50 ++++++---- core/src/report/pyreport/report_json.rs | 112 +++++++++++++---------- core/src/report/sqlite/models.rs | 72 +++++++++++++++ core/src/report/sqlite/report.rs | 5 +- core/src/report/sqlite/report_builder.rs | 38 +------- core/tests/test_pyreport_shim.rs | 90 +++++++++--------- 9 files changed, 215 insertions(+), 182 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8972bd6..54fff2b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -439,6 +439,7 @@ dependencies = [ "fallible-streaming-iterator", "hashlink", "libsqlite3-sys", + "serde_json", "smallvec", ] diff --git a/core/Cargo.toml b/core/Cargo.toml index 1174700..4d0155f 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -12,7 +12,7 @@ testing = [] include_dir = "0.7.3" memmap2 = "0.9.4" rand = "0.8.5" -rusqlite = { version = "0.31.0", features = ["bundled", "limits"] } +rusqlite = { version = "0.31.0", features = ["bundled", "limits", "serde_json"] } rusqlite_migration = { version = "1.2.0", features = ["from-directory"] } seahash = "4.1.0" serde = { version = "1.0.204", features = ["derive"] } diff --git a/core/src/parsers/pyreport/mod.rs b/core/src/parsers/pyreport/mod.rs index fb3a9a0..ec03538 100644 --- a/core/src/parsers/pyreport/mod.rs +++ b/core/src/parsers/pyreport/mod.rs @@ -40,32 +40,7 @@ pub fn parse_pyreport( chunks_file: &File, out_path: PathBuf, ) -> Result { - parse_pyreport_with_builder( - report_json_file, - chunks_file, - SqliteReportBuilder::new(out_path)?, - ) -} - -/// See [`parse_pyreport`] -pub fn parse_pyreport_with_seed( - report_json_file: &File, - chunks_file: &File, - out_path: PathBuf, - seed: u64, -) -> Result { - parse_pyreport_with_builder( - report_json_file, - chunks_file, - SqliteReportBuilder::new_with_seed(out_path, seed)?, - ) -} - -fn parse_pyreport_with_builder( - report_json_file: &File, - chunks_file: &File, - mut report_builder: SqliteReportBuilder, -) -> Result { + let mut report_builder = SqliteReportBuilder::new(out_path)?; // Encapsulate all of this in a block so that `report_builder_tx` gets torn down // at the end. Otherwise, it'll hold onto a reference to `report_builder` // and prevent us from consuming `report_builder` to actually build a diff --git a/core/src/report/pyreport/chunks.rs b/core/src/report/pyreport/chunks.rs index 5a3a841..ecfd3ce 100644 --- a/core/src/report/pyreport/chunks.rs +++ b/core/src/report/pyreport/chunks.rs @@ -319,7 +319,10 @@ mod tests { use tempfile::TempDir; use super::*; - use crate::report::{sqlite::SqliteReportBuilder, ReportBuilder}; + use crate::report::{ + sqlite::{Insertable, SqliteReportBuilder}, + ReportBuilder, + }; struct Ctx { temp_dir: TempDir, @@ -332,11 +335,12 @@ mod tests { } fn build_sample_report(path: PathBuf) -> Result { - let mut builder = SqliteReportBuilder::new_with_seed(path, 5)?; + let mut builder = SqliteReportBuilder::new(path)?; let file_1 = builder.insert_file("src/report/report.rs")?; let file_2 = builder.insert_file("src/report/models.rs")?; - let upload_1 = builder.insert_raw_upload(models::RawUpload { + let upload_1 = models::RawUpload { + id: 5, timestamp: Some(123), raw_upload_url: Some("upload 1 url".to_string()), flags: Some(json!(["flag on upload 1"])), @@ -350,8 +354,13 @@ mod tests { session_type: Some("type upload 1".to_string()), session_extras: Some(json!({"k1": "v1"})), ..Default::default() - })?; - let upload_2 = builder.insert_raw_upload(models::RawUpload { + }; + // Insert directly, not through report builder, because we don't want a random + // ID + upload_1.insert(&builder.conn)?; + + let upload_2 = models::RawUpload { + id: 10, timestamp: Some(456), raw_upload_url: Some("upload 2 url".to_string()), flags: Some(json!(["flag on upload 2"])), @@ -365,7 +374,10 @@ mod tests { session_type: Some("type upload 2".to_string()), session_extras: Some(json!({"k2": "v2"})), ..Default::default() - })?; + }; + // Insert directly, not through report builder, because we don't want a random + // ID + upload_2.insert(&builder.conn)?; let line_1 = builder.insert_coverage_sample(models::CoverageSample { raw_upload_id: upload_1.id, @@ -911,47 +923,47 @@ mod tests { let chunks_header = json!({"labels_index": {"1": "test-case", "2": "test-case 2"}}); // line_1 variable in build_sample_report() - let file_1_header = json!({"present_sessions": [1]}); + let file_1_header = json!({"present_sessions": [0]}); let file_1_line_1 = json!([ 3, null, - [[1, 3]], + [[0, 3]], null, null, - [[1, 3, null, ["test-case", "test-case 2"]]] + [[0, 3, null, ["test-case", "test-case 2"]]] ]); // method_sample_1 variable in build_sample_report() let file_1_line_2 = json!([ 2, "m", - [[1, 2, null, null, [2, 4]]], + [[0, 2, null, null, [2, 4]]], null, [2, 4], - [[1, 2, "m", ["test-case 2"]]] + [[0, 2, "m", ["test-case 2"]]] ]); // branch_sample_1 variable in build_sample_report() - let file_1_line_3 = json!(["2/2", "b", [[1, "2/2"]]]); + let file_1_line_3 = json!(["2/2", "b", [[0, "2/2"]]]); // line_with_partial_1 variable in build_sample_report() - let file_1_line_8 = json!([3, null, [[1, 3, null, [[3, null, 3]]]]]); + let file_1_line_8 = json!([3, null, [[0, 3, null, [[3, null, 3]]]]]); let file_2_header = json!({"present_sessions": [0, 1]}); // line_2 variable in build_sample_report() let file_2_line_1 = json!([ 4, null, - [[1, 4]], + [[0, 4]], null, null, - [[1, 4, null, ["test-case", "test-case 2"]]] + [[0, 4, null, ["test-case", "test-case 2"]]] ]); // method_sample_2 variable in build_sample_report() - let file_2_line_2 = json!([5, "m", [[1, 5]]]); + let file_2_line_2 = json!([5, "m", [[0, 5]]]); // line_3 variable in build_sample_report() - let file_2_line_3 = json!([0, null, [[0, 0]],]); + let file_2_line_3 = json!([0, null, [[1, 0]],]); // method_sample_3 variable in build_sample_report() - let file_2_line_5 = json!([0, "m", [[0, 0, null, null, [2, 4]]], null, [2, 4]]); + let file_2_line_5 = json!([0, "m", [[1, 0, null, null, [2, 4]]], null, [2, 4]]); // branch_sample_2 variable in build_sample_report() - let file_2_line_6 = json!(["2/4", "b", [[1, "2/4", ["2", "3"]]],]); + let file_2_line_6 = json!(["2/4", "b", [[0, "2/4", ["2", "3"]]],]); let expected = format!( "{chunks_header} diff --git a/core/src/report/pyreport/report_json.rs b/core/src/report/pyreport/report_json.rs index de47548..3185795 100644 --- a/core/src/report/pyreport/report_json.rs +++ b/core/src/report/pyreport/report_json.rs @@ -243,7 +243,10 @@ mod tests { use tempfile::TempDir; use super::*; - use crate::report::{sqlite::SqliteReportBuilder, ReportBuilder}; + use crate::report::{ + sqlite::{Insertable, SqliteReportBuilder}, + ReportBuilder, + }; struct Ctx { temp_dir: TempDir, @@ -256,11 +259,12 @@ mod tests { } fn build_sample_report(path: PathBuf) -> Result { - let mut builder = SqliteReportBuilder::new_with_seed(path, 5)?; + let mut builder = SqliteReportBuilder::new(path)?; let file_1 = builder.insert_file("src/report/report.rs")?; let file_2 = builder.insert_file("src/report/models.rs")?; - let upload_1 = builder.insert_raw_upload(models::RawUpload { + let upload_1 = models::RawUpload { + id: 5, timestamp: Some(123), raw_upload_url: Some("upload 1 url".to_string()), flags: Some(json!(["flag on upload 1"])), @@ -274,8 +278,13 @@ mod tests { session_type: Some("type upload 1".to_string()), session_extras: Some(json!({"k1": "v1"})), ..Default::default() - })?; - let upload_2 = builder.insert_raw_upload(models::RawUpload { + }; + // Insert directly, not through report builder, because we don't want a random + // ID + upload_1.insert(&builder.conn)?; + + let upload_2 = models::RawUpload { + id: 10, timestamp: Some(456), raw_upload_url: Some("upload 2 url".to_string()), flags: Some(json!(["flag on upload 2"])), @@ -289,7 +298,10 @@ mod tests { session_type: Some("type upload 2".to_string()), session_extras: Some(json!({"k2": "v2"})), ..Default::default() - })?; + }; + // Insert directly, not through report builder, because we don't want a random + // ID + upload_2.insert(&builder.conn)?; let line_1 = builder.insert_coverage_sample(models::CoverageSample { raw_upload_id: upload_1.id, @@ -572,35 +584,6 @@ mod tests { let expected = json!({ "sessions": { "0": { - "t": [ - 1, // file count - 2, // line count - 0, // hits - 2, // misses - 0, // partials - "0", // coverage % - 0, // branch count - 1, // method count - 0, // messages - 0, // sessions - 2, // hit_complexity_paths - 4, // total_complexity - 0 // diff - ], - "d": 456, - "a": "upload 2 url", - "f": ["flag on upload 2"], - "c": "provider upload 2", - "n": "build upload 2", - "N": "name upload 2", - "j": "job name upload 2", - "u": "ci run url upload 2", - "p": "state upload 2", - "e": "env upload 2", - "st": "type upload 2", - "se": {"k2": "v2"}, - }, - "1": { "t": [ 2, // file count 7, // line count @@ -628,6 +611,35 @@ mod tests { "e": "env upload 1", "st": "type upload 1", "se": {"k1": "v1"}, + }, + "1": { + "t": [ + 1, // file count + 2, // line count + 0, // hits + 2, // misses + 0, // partials + "0", // coverage % + 0, // branch count + 1, // method count + 0, // messages + 0, // sessions + 2, // hit_complexity_paths + 4, // total_complexity + 0 // diff + ], + "d": 456, + "a": "upload 2 url", + "f": ["flag on upload 2"], + "c": "provider upload 2", + "n": "build upload 2", + "N": "name upload 2", + "j": "job name upload 2", + "u": "ci run url upload 2", + "p": "state upload 2", + "e": "env upload 2", + "st": "type upload 2", + "se": {"k2": "v2"}, } } }); @@ -663,21 +675,6 @@ mod tests { }, "sessions": { "0": { - "t": [1, 2, 0, 2, 0, "0", 0, 1, 0, 0, 2, 4, 0], - "d": 456, - "a": "upload 2 url", - "f": ["flag on upload 2"], - "c": "provider upload 2", - "n": "build upload 2", - "N": "name upload 2", - "j": "job name upload 2", - "u": "ci run url upload 2", - "p": "state upload 2", - "e": "env upload 2", - "st": "type upload 2", - "se": {"k2": "v2"}, - }, - "1": { "t": [2, 7, 6, 0, 1, "85.71429", 2, 2, 0, 0, 2, 4, 0], "d": 123, "a": "upload 1 url", @@ -691,6 +688,21 @@ mod tests { "e": "env upload 1", "st": "type upload 1", "se": {"k1": "v1"}, + }, + "1": { + "t": [1, 2, 0, 2, 0, "0", 0, 1, 0, 0, 2, 4, 0], + "d": 456, + "a": "upload 2 url", + "f": ["flag on upload 2"], + "c": "provider upload 2", + "n": "build upload 2", + "N": "name upload 2", + "j": "job name upload 2", + "u": "ci run url upload 2", + "p": "state upload 2", + "e": "env upload 2", + "st": "type upload 2", + "se": {"k2": "v2"}, } } }); diff --git a/core/src/report/sqlite/models.rs b/core/src/report/sqlite/models.rs index a609917..c2e4492 100644 --- a/core/src/report/sqlite/models.rs +++ b/core/src/report/sqlite/models.rs @@ -449,6 +449,43 @@ impl Insertable for Context { } } +impl Insertable for RawUpload { + const TABLE_NAME: &'static str = "raw_upload"; + const FIELDS: &'static [&'static str] = &[ + "id", + "timestamp", + "raw_upload_url", + "flags", + "provider", + "build", + "name", + "job_name", + "ci_run_url", + "state", + "env", + "session_type", + "session_extras", + ]; + + fn extend_params<'a>(&'a self, params: &mut Vec<&'a dyn rusqlite::ToSql>) { + params.extend(&[ + &self.id as &dyn rusqlite::ToSql, + &self.timestamp as &dyn rusqlite::ToSql, + &self.raw_upload_url as &dyn rusqlite::ToSql, + &self.flags as &dyn rusqlite::ToSql, + &self.provider as &dyn rusqlite::ToSql, + &self.build as &dyn rusqlite::ToSql, + &self.name as &dyn rusqlite::ToSql, + &self.job_name as &dyn rusqlite::ToSql, + &self.ci_run_url as &dyn rusqlite::ToSql, + &self.state as &dyn rusqlite::ToSql, + &self.env as &dyn rusqlite::ToSql, + &self.session_type as &dyn rusqlite::ToSql, + &self.session_extras as &dyn rusqlite::ToSql, + ]) + } +} + impl<'a> std::convert::TryFrom<&'a rusqlite::Row<'a>> for RawUpload { type Error = rusqlite::Error; @@ -516,6 +553,7 @@ impl<'a> std::convert::TryFrom<&'a rusqlite::Row<'a>> for ReportTotals { #[cfg(test)] mod tests { + use serde_json::json; use tempfile::TempDir; use super::{ @@ -897,4 +935,38 @@ mod tests { "sqlite failure: 'UNIQUE constraint failed: span_data.raw_upload_id, span_data.local_span_id'" ); } + + #[test] + fn test_raw_upload_single_insert() { + let ctx = setup(); + + let model = RawUpload { + id: 5, + 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!({})), + ..Default::default() + }; + + model.insert(&ctx.report.conn).unwrap(); + let duplicate_result = model.insert(&ctx.report.conn); + + let uploads = ctx.report.list_raw_uploads().unwrap(); + assert_eq!(uploads, vec![model]); + + let error = duplicate_result.unwrap_err(); + assert_eq!( + error.to_string(), + "sqlite failure: 'UNIQUE constraint failed: raw_upload.id'" + ); + } } diff --git a/core/src/report/sqlite/report.rs b/core/src/report/sqlite/report.rs index baac2c0..84e8f93 100644 --- a/core/src/report/sqlite/report.rs +++ b/core/src/report/sqlite/report.rs @@ -214,7 +214,7 @@ mod tests { let db_file_left = ctx.temp_dir.path().join("left.sqlite"); let db_file_right = ctx.temp_dir.path().join("right.sqlite"); - let mut left_report_builder = SqliteReportBuilder::new_with_seed(db_file_left, 5).unwrap(); + let mut left_report_builder = SqliteReportBuilder::new(db_file_left).unwrap(); let file_1 = left_report_builder.insert_file("src/report.rs").unwrap(); let file_2 = left_report_builder .insert_file("src/report/models.rs") @@ -262,8 +262,7 @@ mod tests { }); } - let mut right_report_builder = - SqliteReportBuilder::new_with_seed(db_file_right, 10).unwrap(); + let mut right_report_builder = SqliteReportBuilder::new(db_file_right).unwrap(); let file_2 = right_report_builder .insert_file("src/report/models.rs") .unwrap(); diff --git a/core/src/report/sqlite/report_builder.rs b/core/src/report/sqlite/report_builder.rs index a961c1a..29728b7 100644 --- a/core/src/report/sqlite/report_builder.rs +++ b/core/src/report/sqlite/report_builder.rs @@ -3,7 +3,7 @@ use std::{ path::{Path, PathBuf}, }; -use rand::{rngs::StdRng, Rng, SeedableRng}; +use rand::Rng; use rusqlite::{Connection, Transaction}; use super::{models::Insertable, open_database, SqliteReport}; @@ -21,7 +21,6 @@ use crate::{ /// `build()` from moving it into a `SqliteReport`. pub struct SqliteReportBuilderTx<'a> { id_sequence: &'a mut RangeFrom, - rng: &'a mut StdRng, pub filename: &'a Path, pub conn: Transaction<'a>, @@ -48,29 +47,18 @@ pub struct SqliteReportBuilder { /// A single sequence is shared for [`CoverageSample`], [`BranchesData`], /// [`MethodData`], and [`SpanData`]. id_sequence: RangeFrom, - - rng: StdRng, } impl SqliteReportBuilder { - fn new_with_rng(filename: PathBuf, rng: StdRng) -> Result { + pub fn new(filename: PathBuf) -> Result { let conn = open_database(&filename)?; Ok(SqliteReportBuilder { filename, conn, id_sequence: 0.., - rng, }) } - pub fn new_with_seed(filename: PathBuf, seed: u64) -> Result { - Self::new_with_rng(filename, StdRng::seed_from_u64(seed)) - } - - pub fn new(filename: PathBuf) -> Result { - Self::new_with_rng(filename, StdRng::from_entropy()) - } - /// Create a [`SqliteReportBuilderTx`] with a [`rusqlite::Transaction`] that /// will automatically commit itself when it goes out of scope. /// @@ -81,7 +69,6 @@ impl SqliteReportBuilder { filename: &self.filename, conn: self.conn.transaction()?, id_sequence: &mut self.id_sequence, - rng: &mut self.rng, }; builder_tx .conn @@ -327,25 +314,8 @@ impl<'a> ReportBuilder for SqliteReportBuilderTx<'a> { &mut self, mut raw_upload: models::RawUpload, ) -> Result { - let mut stmt = self.conn.prepare_cached("INSERT INTO raw_upload (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)")?; - - raw_upload.id = self.rng.gen(); - let _ = stmt.execute(( - &raw_upload.id, - &raw_upload.timestamp, - &raw_upload.raw_upload_url, - &raw_upload.flags.as_ref().map(|v| v.to_string()), - &raw_upload.provider, - &raw_upload.build, - &raw_upload.name, - &raw_upload.job_name, - &raw_upload.ci_run_url, - &raw_upload.state, - &raw_upload.env, - &raw_upload.session_type, - &raw_upload.session_extras.as_ref().map(|v| v.to_string()), - ))?; - + raw_upload.id = rand::thread_rng().gen(); + raw_upload.insert(&self.conn)?; Ok(raw_upload) } diff --git a/core/tests/test_pyreport_shim.rs b/core/tests/test_pyreport_shim.rs index 4c3a4a4..364d690 100644 --- a/core/tests/test_pyreport_shim.rs +++ b/core/tests/test_pyreport_shim.rs @@ -9,7 +9,6 @@ use codecov_rs::{ models, pyreport::ToPyreport, Report, ReportBuilder, SqliteReport, SqliteReportBuilder, }, }; -use rand::{rngs::StdRng, Rng, SeedableRng}; use serde_json::json; use tempfile::TempDir; use test_utils::fixtures::{ @@ -35,17 +34,34 @@ fn setup() -> Ctx { fn test_parse_report_json() { let input = read_fixture(Pyreport, Small, "codecov-rs-reports-json-d2a9ba1.txt").unwrap(); - let rng_seed = 5; - let mut rng = StdRng::seed_from_u64(rng_seed); + let test_ctx = setup(); + let mut report_builder = SqliteReportBuilder::new(test_ctx.db_file).unwrap(); + let ParsedReportJson { + files: file_id_map, + sessions: session_id_map, + } = report_json::parse_report_json(&input, &mut report_builder).expect("Failed to parse"); + let report = report_builder.build().unwrap(); + + // Test database inserts let expected_files = vec![ models::SourceFile::new("src/report.rs"), models::SourceFile::new("src/report/models.rs"), models::SourceFile::new("src/report/schema.rs"), ]; + let files = report.list_files().unwrap(); + assert_eq!(files, expected_files); + + let contexts = report.list_contexts().unwrap(); + assert!(contexts.is_empty()); + + // The inserted RawUpload has a random ID that we need to work around for our + // asserts + let uploads = report.list_raw_uploads().unwrap(); + assert_eq!(uploads.len(), 1); let expected_session = models::RawUpload { - id: rng.gen(), + id: uploads[0].id, timestamp: Some(1704827412), raw_upload_url: Some("v4/raw/2024-01-09/BD18D96000B80FA280C411B0081460E1/d2a9ba133c9b30468d97e7fad1462728571ad699/065067fe-7677-4bd8-93b2-0a8d0b879f78/340c0c0b-a955-46a0-9de9-3a9b5f2e81e2.txt".to_string()), flags: Some(json!([])), @@ -59,36 +75,18 @@ fn test_parse_report_json() { session_type: Some("uploaded".to_string()), session_extras: Some(json!({})), }; + assert_eq!(uploads[0], expected_session); - let expected_json_files = HashMap::from([ + // Test return of `parse_report_json()` + let expected_file_id_map = HashMap::from([ (0, expected_files[0].id), (1, expected_files[1].id), (2, expected_files[2].id), ]); + assert_eq!(file_id_map, expected_file_id_map); - let expected_json_sessions = HashMap::from([(0, expected_session.id)]); - - let test_ctx = setup(); - let mut report_builder = - SqliteReportBuilder::new_with_seed(test_ctx.db_file, rng_seed).unwrap(); - - let ParsedReportJson { - files: actual_files, - sessions: actual_sessions, - } = report_json::parse_report_json(&input, &mut report_builder).expect("Failed to parse"); - assert_eq!(actual_files, expected_json_files); - assert_eq!(actual_sessions, expected_json_sessions); - - let report = report_builder.build().unwrap(); - - let files = report.list_files().unwrap(); - assert_eq!(files, expected_files); - - let contexts = report.list_contexts().unwrap(); - assert!(contexts.is_empty()); - - let uploads = report.list_raw_uploads().unwrap(); - assert_eq!(uploads, vec![expected_session]); + let expected_session_id_map = HashMap::from([(0, expected_session.id)]); + assert_eq!(session_id_map, expected_session_id_map); } #[test] @@ -210,19 +208,21 @@ fn test_parse_pyreport() { let chunks_file = open_fixture(Pyreport, Small, "codecov-rs-chunks-d2a9ba1.txt").unwrap(); let test_ctx = setup(); - let rng_seed = 5; - let mut rng = StdRng::seed_from_u64(rng_seed); + let report = pyreport::parse_pyreport(&report_json_file, &chunks_file, test_ctx.db_file) + .expect("Failed to parse pyreport"); - let report = pyreport::parse_pyreport_with_seed( - &report_json_file, - &chunks_file, - test_ctx.db_file, - rng_seed, - ) - .expect("Failed to parse pyreport"); + let expected_files = [ + models::SourceFile::new("src/report.rs"), + models::SourceFile::new("src/report/models.rs"), + models::SourceFile::new("src/report/schema.rs"), + ]; + let files = report.list_files().unwrap(); + assert_eq!(files, expected_files); + let uploads = report.list_raw_uploads().unwrap(); + assert_eq!(uploads.len(), 1); let expected_session = models::RawUpload { - id: rng.gen(), + id: uploads[0].id, timestamp: Some(1704827412), raw_upload_url: Some("v4/raw/2024-01-09/BD18D96000B80FA280C411B0081460E1/d2a9ba133c9b30468d97e7fad1462728571ad699/065067fe-7677-4bd8-93b2-0a8d0b879f78/340c0c0b-a955-46a0-9de9-3a9b5f2e81e2.txt".to_string()), flags: Some(json!([])), @@ -236,12 +236,10 @@ fn test_parse_pyreport() { session_type: Some("uploaded".to_string()), session_extras: Some(json!({})), }; + assert_eq!(uploads[0], expected_session); - let expected_files = [ - models::SourceFile::new("src/report.rs"), - models::SourceFile::new("src/report/models.rs"), - models::SourceFile::new("src/report/schema.rs"), - ]; + let contexts = report.list_contexts().unwrap(); + assert!(contexts.is_empty()); // Helper function for creating our expected values let mut coverage_sample_id_iterator = 0..; @@ -301,12 +299,6 @@ fn test_parse_pyreport() { .list_coverage_samples() .expect("Failed to list coverage samples"); assert_eq!(actual_coverage_samples, expected_coverage_samples); - - let contexts = report.list_contexts().unwrap(); - assert!(contexts.is_empty()); - - let uploads = report.list_raw_uploads().unwrap(); - assert_eq!(uploads, vec![expected_session]); } #[test]