From c76c09e3354bc3aedc6de94f177f92c2c96593d6 Mon Sep 17 00:00:00 2001 From: Casper Beyer Date: Thu, 8 Jul 2021 23:53:56 +0800 Subject: refactor(cli/tools/coverage): strongly type inspector values (#11326) --- cli/tools/coverage.rs | 160 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 106 insertions(+), 54 deletions(-) (limited to 'cli/tools/coverage.rs') 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, + 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, +} + +#[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, + 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 { + 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 { + 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, - 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, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -struct TakePreciseCoverageResult { - result: Vec, -} - -#[derive(Debug, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GetScriptSourceResult { - pub script_source: String, - pub bytecode: Option, -} - pub enum CoverageReporterKind { Pretty, Lcov, -- cgit v1.2.3