feat(unstable): record raw coverage into a directory (#8642)

1 files changed, 98 insertions, 34 deletions

diff --git a/cli/tools/coverage.rs b/cli/tools/coverage.rs
index 229cb8020..53385b482 100644
--- a/cli/tools/coverage.rs
+++ b/cli/tools/coverage.rs
@@ -7,14 +7,19 @@ use deno_core::serde_json::json;
 use deno_core::url::Url;
 use deno_runtime::inspector::InspectorSession;
 use serde::Deserialize;
+use serde::Serialize;
+use std::fs;
+use std::path::PathBuf;
+use uuid::Uuid;
 
 pub struct CoverageCollector {
+  pub dir: PathBuf,
   session: Box<InspectorSession>,
 }
 
 impl CoverageCollector {
-  pub fn new(session: Box<InspectorSession>) -> Self {
-    Self { session }
+  pub fn new(dir: PathBuf, session: Box<InspectorSession>) -> Self {
+    Self { dir, session }
   }
 
   pub async fn start_collecting(&mut self) -> Result<(), AnyError> {
@@ -33,7 +38,7 @@ impl CoverageCollector {
     Ok(())
   }
 
-  pub async fn collect(&mut self) -> Result<Vec<Coverage>, AnyError> {
+  pub async fn stop_collecting(&mut self) -> Result<(), AnyError> {
     let result = self
       .session
       .post_message("Profiler.takePreciseCoverage", None)
@@ -42,9 +47,11 @@ impl CoverageCollector {
     let take_coverage_result: TakePreciseCoverageResult =
       serde_json::from_value(result)?;
 
-    let mut coverages: Vec<Coverage> = Vec::new();
-    for script_coverage in take_coverage_result.result {
-      let result = self
+    fs::create_dir_all(&self.dir)?;
+
+    let script_coverages = take_coverage_result.result;
+    for script_coverage in script_coverages {
+      let get_script_source_value = self
         .session
         .post_message(
           "Debugger.getScriptSource",
@@ -55,22 +62,28 @@ impl CoverageCollector {
         .await?;
 
       let get_script_source_result: GetScriptSourceResult =
-        serde_json::from_value(result)?;
+        serde_json::from_value(get_script_source_value)?;
 
-      coverages.push(Coverage {
+      let script_source = get_script_source_result.script_source.clone();
+
+      let coverage = Coverage {
         script_coverage,
-        script_source: get_script_source_result.script_source,
-      })
+        script_source,
+      };
+
+      // TODO(caspervonb) Would be much better to look up the source during the reporting stage
+      // instead of storing it here.
+      // Long term, that's what we should be doing.
+      let filename = format!("{}.json", Uuid::new_v4());
+      let json = serde_json::to_string(&coverage)?;
+      fs::write(self.dir.join(filename), &json)?;
     }
 
-    Ok(coverages)
-  }
-
-  pub async fn stop_collecting(&mut self) -> Result<(), AnyError> {
     self
       .session
       .post_message("Profiler.stopPreciseCoverage", None)
       .await?;
+
     self.session.post_message("Profiler.disable", None).await?;
     self.session.post_message("Debugger.disable", None).await?;
 
@@ -78,7 +91,9 @@ impl CoverageCollector {
   }
 }
 
-#[derive(Debug, Deserialize)]
+// TODO(caspervonb) all of these structs can and should be made private, possibly moved to
+// inspector::protocol.
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CoverageRange {
   pub start_offset: usize,
@@ -86,7 +101,7 @@ pub struct CoverageRange {
   pub count: usize,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FunctionCoverage {
   pub function_name: String,
@@ -94,7 +109,7 @@ pub struct FunctionCoverage {
   pub is_block_coverage: bool,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ScriptCoverage {
   pub script_id: String,
@@ -102,7 +117,7 @@ pub struct ScriptCoverage {
   pub functions: Vec<FunctionCoverage>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Coverage {
   pub script_coverage: ScriptCoverage,
@@ -132,8 +147,12 @@ impl PrettyCoverageReporter {
     PrettyCoverageReporter { quiet }
   }
 
-  pub fn visit_coverage(&mut self, coverage: &Coverage) {
-    let lines = coverage.script_source.lines().collect::<Vec<_>>();
+  pub fn visit_coverage(
+    &mut self,
+    script_coverage: &ScriptCoverage,
+    script_source: &str,
+  ) {
+    let lines = script_source.lines().collect::<Vec<_>>();
 
     let mut covered_lines: Vec<usize> = Vec::new();
     let mut uncovered_lines: Vec<usize> = Vec::new();
@@ -143,7 +162,7 @@ impl PrettyCoverageReporter {
       let line_end_offset = line_start_offset + line.len();
 
       let mut count = 0;
-      for function in &coverage.script_coverage.functions {
+      for function in &script_coverage.functions {
         for range in &function.ranges {
           if range.start_offset <= line_start_offset
             && range.end_offset >= line_end_offset
@@ -167,7 +186,7 @@ impl PrettyCoverageReporter {
     }
 
     if !self.quiet {
-      print!("cover {} ... ", coverage.script_coverage.url);
+      print!("cover {} ... ", script_coverage.url);
 
       let line_coverage_ratio = covered_lines.len() as f32 / lines.len() as f32;
       let line_coverage = format!(
@@ -212,10 +231,41 @@ impl PrettyCoverageReporter {
   }
 }
 
-pub fn filter_script_coverages(
+fn collect_coverages(dir: &PathBuf) -> Result<Vec<Coverage>, AnyError> {
+  let mut coverages: Vec<Coverage> = Vec::new();
+
+  let entries = fs::read_dir(dir)?;
+  for entry in entries {
+    let json = fs::read_to_string(entry.unwrap().path())?;
+    let coverage: Coverage = serde_json::from_str(&json)?;
+
+    coverages.push(coverage);
+  }
+
+  // TODO(caspervonb) drain_filter would make this cleaner, its nightly at the moment.
+  if coverages.len() > 1 {
+    coverages.sort_by_key(|k| k.script_coverage.url.clone());
+
+    for i in (1..coverages.len() - 1).rev() {
+      if coverages[i].script_coverage.url
+        == coverages[i - 1].script_coverage.url
+      {
+        let current = coverages.remove(i);
+        let previous = &mut coverages[i - 1];
+
+        for function in current.script_coverage.functions {
+          previous.script_coverage.functions.push(function);
+        }
+      }
+    }
+  }
+
+  Ok(coverages)
+}
+
+fn filter_coverages(
   coverages: Vec<Coverage>,
-  test_file_url: Url,
-  test_modules: Vec<Url>,
+  exclude: Vec<Url>,
 ) -> Vec<Coverage> {
   coverages
     .into_iter()
@@ -225,20 +275,16 @@ pub fn filter_script_coverages(
           return false;
         }
 
-        if url == test_file_url {
-          return false;
-        }
-
-        for test_module_url in &test_modules {
-          if &url == test_module_url {
+        for module_url in &exclude {
+          if &url == module_url {
             return false;
           }
         }
 
         if let Ok(path) = url.to_file_path() {
-          for test_module_url in &test_modules {
-            if let Ok(test_module_path) = test_module_url.to_file_path() {
-              if path.starts_with(test_module_path.parent().unwrap()) {
+          for module_url in &exclude {
+            if let Ok(module_path) = module_url.to_file_path() {
+              if path.starts_with(module_path.parent().unwrap()) {
                 return true;
               }
             }
@@ -250,3 +296,21 @@ pub fn filter_script_coverages(
     })
     .collect::<Vec<Coverage>>()
 }
+
+pub fn report_coverages(
+  dir: &PathBuf,
+  quiet: bool,
+  exclude: Vec<Url>,
+) -> Result<(), AnyError> {
+  let coverages = collect_coverages(dir)?;
+  let coverages = filter_coverages(coverages, exclude);
+
+  let mut coverage_reporter = PrettyCoverageReporter::new(quiet);
+  for coverage in coverages {
+    let script_coverage = coverage.script_coverage;
+    let script_source = coverage.script_source;
+    coverage_reporter.visit_coverage(&script_coverage, &script_source);
+  }
+
+  Ok(())
+}