refactor(cli/tools/coverage): strongly type inspector values (#11326)

1 files changed, 106 insertions, 54 deletions

diff --git a/cli/tools/coverage.rs b/cli/tools/coverage.rs
index c7d7a2cb7..3f1257b92 100644
--- a/cli/tools/coverage.rs
+++ b/cli/tools/coverage.rs
@@ -11,7 +11,6 @@ use crate::program_state::ProgramState;
 use crate::source_maps::SourceMapGetter;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
-use deno_core::serde_json::json;
 use deno_core::url::Url;
 use deno_core::LocalInspectorSession;
 use deno_runtime::permissions::Permissions;
@@ -27,6 +26,53 @@ use std::path::PathBuf;
 use swc_common::Span;
 use uuid::Uuid;
 
+// TODO(caspervonb) all of these structs can and should be made private, possibly moved to
+// inspector::protocol.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CoverageRange {
+  pub start_offset: usize,
+  pub end_offset: usize,
+  pub count: usize,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionCoverage {
+  pub function_name: String,
+  pub ranges: Vec<CoverageRange>,
+  pub is_block_coverage: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ScriptCoverage {
+  pub script_id: String,
+  pub url: String,
+  pub functions: Vec<FunctionCoverage>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartPreciseCoverageParameters {
+  pub call_count: bool,
+  pub detailed: bool,
+  pub allow_triggered_updates: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartPreciseCoverageReturnObject {
+  pub timestamp: f64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TakePreciseCoverageReturnObject {
+  pub result: Vec<ScriptCoverage>,
+  pub timestamp: f64,
+}
+
 pub struct CoverageCollector {
   pub dir: PathBuf,
   session: LocalInspectorSession,
@@ -37,31 +83,76 @@ impl CoverageCollector {
     Self { dir, session }
   }
 
-  pub async fn start_collecting(&mut self) -> Result<(), AnyError> {
+  async fn enable_debugger(&mut self) -> Result<(), AnyError> {
     self.session.post_message("Debugger.enable", None).await?;
+
+    Ok(())
+  }
+
+  async fn enable_profiler(&mut self) -> Result<(), AnyError> {
     self.session.post_message("Profiler.enable", None).await?;
-    self
+
+    Ok(())
+  }
+
+  async fn disable_debugger(&mut self) -> Result<(), AnyError> {
+    self.session.post_message("Debugger.disable", None).await?;
+
+    Ok(())
+  }
+
+  async fn disable_profiler(&mut self) -> Result<(), AnyError> {
+    self.session.post_message("Profiler.disable", None).await?;
+
+    Ok(())
+  }
+
+  async fn start_precise_coverage(
+    &mut self,
+    parameters: StartPreciseCoverageParameters,
+  ) -> Result<StartPreciseCoverageReturnObject, AnyError> {
+    let parameters_value = serde_json::to_value(parameters)?;
+    let return_value = self
       .session
-      .post_message(
-        "Profiler.startPreciseCoverage",
-        Some(json!({"callCount": true, "detailed": true})),
-      )
+      .post_message("Profiler.startPreciseCoverage", Some(parameters_value))
       .await?;
-    Ok(())
+
+    let return_object = serde_json::from_value(return_value)?;
+
+    Ok(return_object)
   }
 
-  pub async fn stop_collecting(&mut self) -> Result<(), AnyError> {
-    let result = self
+  async fn take_precise_coverage(
+    &mut self,
+  ) -> Result<TakePreciseCoverageReturnObject, AnyError> {
+    let return_value = self
       .session
       .post_message("Profiler.takePreciseCoverage", None)
       .await?;
 
-    let take_coverage_result: TakePreciseCoverageResult =
-      serde_json::from_value(result)?;
+    let return_object = serde_json::from_value(return_value)?;
+
+    Ok(return_object)
+  }
+
+  pub async fn start_collecting(&mut self) -> Result<(), AnyError> {
+    self.enable_debugger().await?;
+    self.enable_profiler().await?;
+    self
+      .start_precise_coverage(StartPreciseCoverageParameters {
+        call_count: true,
+        detailed: true,
+        allow_triggered_updates: false,
+      })
+      .await?;
+
+    Ok(())
+  }
 
+  pub async fn stop_collecting(&mut self) -> Result<(), AnyError> {
     fs::create_dir_all(&self.dir)?;
 
-    let script_coverages = take_coverage_result.result;
+    let script_coverages = self.take_precise_coverage().await?.result;
     for script_coverage in script_coverages {
       let filename = format!("{}.json", Uuid::new_v4());
       let filepath = self.dir.join(filename);
@@ -72,52 +163,13 @@ impl CoverageCollector {
       out.flush()?;
     }
 
-    self.session.post_message("Profiler.disable", None).await?;
-    self.session.post_message("Debugger.disable", None).await?;
+    self.disable_debugger().await?;
+    self.disable_profiler().await?;
 
     Ok(())
   }
 }
 
-// TODO(caspervonb) all of these structs can and should be made private, possibly moved to
-// inspector::protocol.
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct CoverageRange {
-  pub start_offset: usize,
-  pub end_offset: usize,
-  pub count: usize,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct FunctionCoverage {
-  pub function_name: String,
-  pub ranges: Vec<CoverageRange>,
-  pub is_block_coverage: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct ScriptCoverage {
-  pub script_id: String,
-  pub url: String,
-  pub functions: Vec<FunctionCoverage>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct TakePreciseCoverageResult {
-  result: Vec<ScriptCoverage>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetScriptSourceResult {
-  pub script_source: String,
-  pub bytecode: Option<String>,
-}
-
 pub enum CoverageReporterKind {
   Pretty,
   Lcov,