2021-01-11 12:13:41 -05:00
|
|
|
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
|
2020-02-11 06:01:56 -05:00
|
|
|
|
2021-05-10 19:54:39 -04:00
|
|
|
use crate::ast;
|
2021-07-29 15:03:06 -04:00
|
|
|
use crate::ast::Location;
|
2021-04-28 14:17:04 -04:00
|
|
|
use crate::colors;
|
|
|
|
use crate::create_main_worker;
|
|
|
|
use crate::file_fetcher::File;
|
2021-08-26 15:21:58 -04:00
|
|
|
use crate::file_watcher;
|
|
|
|
use crate::file_watcher::ResolutionResult;
|
|
|
|
use crate::flags::Flags;
|
|
|
|
use crate::fs_util::collect_specifiers;
|
|
|
|
use crate::fs_util::is_supported_test_ext;
|
|
|
|
use crate::fs_util::is_supported_test_path;
|
2021-04-28 14:17:04 -04:00
|
|
|
use crate::media_type::MediaType;
|
|
|
|
use crate::module_graph;
|
2021-08-26 15:21:58 -04:00
|
|
|
use crate::module_graph::GraphBuilder;
|
|
|
|
use crate::module_graph::Module;
|
|
|
|
use crate::module_graph::TypeLib;
|
2021-08-17 06:08:39 -04:00
|
|
|
use crate::ops;
|
2021-04-28 14:17:04 -04:00
|
|
|
use crate::program_state::ProgramState;
|
|
|
|
use crate::tokio_util;
|
|
|
|
use crate::tools::coverage::CoverageCollector;
|
2021-08-26 15:21:58 -04:00
|
|
|
use crate::FetchHandler;
|
2021-07-22 07:34:29 -04:00
|
|
|
use deno_core::error::generic_error;
|
2020-09-14 12:48:57 -04:00
|
|
|
use deno_core::error::AnyError;
|
2021-04-28 14:17:04 -04:00
|
|
|
use deno_core::futures::future;
|
|
|
|
use deno_core::futures::stream;
|
2021-05-26 11:47:33 -04:00
|
|
|
use deno_core::futures::FutureExt;
|
2021-04-28 14:17:04 -04:00
|
|
|
use deno_core::futures::StreamExt;
|
2021-08-26 15:21:58 -04:00
|
|
|
use deno_core::parking_lot::Mutex;
|
2020-09-21 12:36:37 -04:00
|
|
|
use deno_core::serde_json::json;
|
2021-08-17 06:08:39 -04:00
|
|
|
use deno_core::JsRuntime;
|
2021-04-28 14:17:04 -04:00
|
|
|
use deno_core::ModuleSpecifier;
|
|
|
|
use deno_runtime::permissions::Permissions;
|
2021-08-23 10:03:57 -04:00
|
|
|
use log::Level;
|
2021-07-05 21:20:33 -04:00
|
|
|
use rand::rngs::SmallRng;
|
|
|
|
use rand::seq::SliceRandom;
|
|
|
|
use rand::SeedableRng;
|
2021-05-10 19:54:39 -04:00
|
|
|
use regex::Regex;
|
2021-04-28 14:17:04 -04:00
|
|
|
use serde::Deserialize;
|
2021-08-26 15:21:58 -04:00
|
|
|
use std::collections::HashSet;
|
2021-08-23 06:35:38 -04:00
|
|
|
use std::num::NonZeroUsize;
|
2021-04-28 14:17:04 -04:00
|
|
|
use std::path::PathBuf;
|
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::sync::mpsc::Sender;
|
|
|
|
use std::sync::Arc;
|
2021-07-13 18:11:58 -04:00
|
|
|
use std::time::Duration;
|
2021-04-29 07:42:35 -04:00
|
|
|
use std::time::Instant;
|
2021-05-10 19:54:39 -04:00
|
|
|
use swc_common::comments::CommentKind;
|
2021-07-26 08:05:44 -04:00
|
|
|
use uuid::Uuid;
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
/// The test mode is used to determine how a specifier is to be tested.
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
|
|
enum TestMode {
|
|
|
|
/// Test as documentation, type-checking fenced code blocks.
|
|
|
|
Documentation,
|
|
|
|
/// Test as an executable module, loading the module into the isolate and running each test it
|
|
|
|
/// defines.
|
|
|
|
Executable,
|
|
|
|
/// Test as both documentation and an executable module.
|
|
|
|
Both,
|
|
|
|
}
|
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct TestDescription {
|
|
|
|
pub origin: String,
|
|
|
|
pub name: String,
|
|
|
|
}
|
|
|
|
|
2021-04-28 14:17:04 -04:00
|
|
|
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub enum TestResult {
|
|
|
|
Ok,
|
|
|
|
Ignored,
|
|
|
|
Failed(String),
|
|
|
|
}
|
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct TestPlan {
|
|
|
|
pub origin: String,
|
|
|
|
pub total: usize,
|
|
|
|
pub filtered_out: usize,
|
|
|
|
pub used_only: bool,
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
2020-02-11 06:01:56 -05:00
|
|
|
|
2021-04-30 11:56:47 -04:00
|
|
|
#[derive(Debug, Clone, Deserialize)]
|
2021-07-14 15:05:16 -04:00
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub enum TestEvent {
|
|
|
|
Plan(TestPlan),
|
|
|
|
Wait(TestDescription),
|
|
|
|
Result(TestDescription, TestResult, u64),
|
2021-04-30 11:56:47 -04:00
|
|
|
}
|
|
|
|
|
2021-07-13 18:11:58 -04:00
|
|
|
#[derive(Debug, Clone, Deserialize)]
|
|
|
|
pub struct TestSummary {
|
|
|
|
pub total: usize,
|
|
|
|
pub passed: usize,
|
|
|
|
pub failed: usize,
|
|
|
|
pub ignored: usize,
|
|
|
|
pub filtered_out: usize,
|
|
|
|
pub measured: usize,
|
2021-07-14 15:05:16 -04:00
|
|
|
pub failures: Vec<(TestDescription, String)>,
|
2021-07-13 18:11:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TestSummary {
|
|
|
|
fn new() -> TestSummary {
|
|
|
|
TestSummary {
|
|
|
|
total: 0,
|
|
|
|
passed: 0,
|
|
|
|
failed: 0,
|
|
|
|
ignored: 0,
|
|
|
|
filtered_out: 0,
|
|
|
|
measured: 0,
|
|
|
|
failures: Vec::new(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn has_failed(&self) -> bool {
|
|
|
|
self.failed > 0 || !self.failures.is_empty()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn has_pending(&self) -> bool {
|
|
|
|
self.total - self.passed - self.failed - self.ignored > 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-29 07:42:35 -04:00
|
|
|
trait TestReporter {
|
2021-07-14 15:05:16 -04:00
|
|
|
fn report_plan(&mut self, plan: &TestPlan);
|
|
|
|
fn report_wait(&mut self, description: &TestDescription);
|
|
|
|
fn report_result(
|
|
|
|
&mut self,
|
|
|
|
description: &TestDescription,
|
|
|
|
result: &TestResult,
|
|
|
|
elapsed: u64,
|
|
|
|
);
|
|
|
|
fn report_summary(&mut self, summary: &TestSummary, elapsed: &Duration);
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
struct PrettyTestReporter {
|
|
|
|
concurrent: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PrettyTestReporter {
|
|
|
|
fn new(concurrent: bool) -> PrettyTestReporter {
|
2021-07-13 18:11:58 -04:00
|
|
|
PrettyTestReporter { concurrent }
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TestReporter for PrettyTestReporter {
|
2021-07-14 15:05:16 -04:00
|
|
|
fn report_plan(&mut self, plan: &TestPlan) {
|
|
|
|
let inflection = if plan.total == 1 { "test" } else { "tests" };
|
|
|
|
println!("running {} {} from {}", plan.total, inflection, plan.origin);
|
|
|
|
}
|
2021-04-29 07:42:35 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
fn report_wait(&mut self, description: &TestDescription) {
|
|
|
|
if !self.concurrent {
|
|
|
|
print!("test {} ...", description.name);
|
|
|
|
}
|
|
|
|
}
|
2021-04-29 07:42:35 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
fn report_result(
|
|
|
|
&mut self,
|
|
|
|
description: &TestDescription,
|
|
|
|
result: &TestResult,
|
|
|
|
elapsed: u64,
|
|
|
|
) {
|
|
|
|
if self.concurrent {
|
|
|
|
print!("test {} ...", description.name);
|
|
|
|
}
|
2021-07-13 18:11:58 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
let status = match result {
|
|
|
|
TestResult::Ok => colors::green("ok").to_string(),
|
|
|
|
TestResult::Ignored => colors::yellow("ignored").to_string(),
|
|
|
|
TestResult::Failed(_) => colors::red("FAILED").to_string(),
|
|
|
|
};
|
2021-07-13 18:11:58 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
println!(
|
|
|
|
" {} {}",
|
|
|
|
status,
|
|
|
|
colors::gray(format!("({}ms)", elapsed)).to_string()
|
|
|
|
);
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
fn report_summary(&mut self, summary: &TestSummary, elapsed: &Duration) {
|
2021-07-13 18:11:58 -04:00
|
|
|
if !summary.failures.is_empty() {
|
2021-04-29 07:42:35 -04:00
|
|
|
println!("\nfailures:\n");
|
2021-07-14 15:05:16 -04:00
|
|
|
for (description, error) in &summary.failures {
|
|
|
|
println!("{}", description.name);
|
2021-04-29 07:42:35 -04:00
|
|
|
println!("{}", error);
|
|
|
|
println!();
|
|
|
|
}
|
|
|
|
|
|
|
|
println!("failures:\n");
|
2021-07-14 15:05:16 -04:00
|
|
|
for (description, _) in &summary.failures {
|
|
|
|
println!("\t{}", description.name);
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-13 18:11:58 -04:00
|
|
|
let status = if summary.has_failed() || summary.has_pending() {
|
2021-04-29 07:42:35 -04:00
|
|
|
colors::red("FAILED").to_string()
|
|
|
|
} else {
|
|
|
|
colors::green("ok").to_string()
|
|
|
|
};
|
|
|
|
|
|
|
|
println!(
|
2021-07-14 15:05:16 -04:00
|
|
|
"\ntest result: {}. {} passed; {} failed; {} ignored; {} measured; {} filtered out {}\n",
|
|
|
|
status,
|
|
|
|
summary.passed,
|
|
|
|
summary.failed,
|
|
|
|
summary.ignored,
|
|
|
|
summary.measured,
|
|
|
|
summary.filtered_out,
|
|
|
|
colors::gray(format!("({}ms)", elapsed.as_millis())),
|
|
|
|
);
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-10 10:51:30 -04:00
|
|
|
fn create_reporter(concurrent: bool) -> Box<dyn TestReporter + Send> {
|
|
|
|
Box::new(PrettyTestReporter::new(concurrent))
|
2021-04-29 07:42:35 -04:00
|
|
|
}
|
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
/// Test a single specifier as documentation containing test programs, an executable test module or
|
|
|
|
/// both.
|
|
|
|
async fn test_specifier(
|
2021-04-28 14:17:04 -04:00
|
|
|
program_state: Arc<ProgramState>,
|
|
|
|
permissions: Permissions,
|
2021-08-26 15:21:58 -04:00
|
|
|
specifier: ModuleSpecifier,
|
|
|
|
mode: TestMode,
|
2021-07-26 08:05:44 -04:00
|
|
|
filter: Option<String>,
|
|
|
|
shuffle: Option<u64>,
|
2021-04-30 11:56:47 -04:00
|
|
|
channel: Sender<TestEvent>,
|
2021-04-28 14:17:04 -04:00
|
|
|
) -> Result<(), AnyError> {
|
2021-08-26 15:21:58 -04:00
|
|
|
let test_specifier =
|
2021-07-26 08:05:44 -04:00
|
|
|
deno_core::resolve_path(&format!("{}$deno$test.js", Uuid::new_v4()))?;
|
2021-08-12 14:10:14 -04:00
|
|
|
|
|
|
|
let mut test_source = String::new();
|
2021-08-26 15:21:58 -04:00
|
|
|
if mode != TestMode::Documentation {
|
|
|
|
test_source.push_str(&format!("import \"{}\";\n", specifier));
|
2021-08-12 14:10:14 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
test_source
|
|
|
|
.push_str("await new Promise(resolve => setTimeout(resolve, 0));\n");
|
|
|
|
|
2021-08-15 07:54:44 -04:00
|
|
|
test_source.push_str("window.dispatchEvent(new Event('load'));\n");
|
|
|
|
|
2021-08-12 14:10:14 -04:00
|
|
|
test_source.push_str(&format!(
|
|
|
|
"await Deno[Deno.internal].runTests({});\n",
|
2021-07-26 08:05:44 -04:00
|
|
|
json!({
|
2021-08-23 10:03:57 -04:00
|
|
|
"disableLog": program_state.flags.log_level == Some(Level::Error),
|
2021-08-12 14:10:14 -04:00
|
|
|
"filter": filter,
|
|
|
|
"shuffle": shuffle,
|
|
|
|
}),
|
|
|
|
));
|
2021-07-26 08:05:44 -04:00
|
|
|
|
2021-08-15 07:54:44 -04:00
|
|
|
test_source.push_str("window.dispatchEvent(new Event('unload'));\n");
|
|
|
|
|
2021-07-26 08:05:44 -04:00
|
|
|
let test_file = File {
|
2021-08-26 15:21:58 -04:00
|
|
|
local: test_specifier.to_file_path().unwrap(),
|
2021-07-26 08:05:44 -04:00
|
|
|
maybe_types: None,
|
|
|
|
media_type: MediaType::JavaScript,
|
|
|
|
source: test_source.clone(),
|
2021-08-26 15:21:58 -04:00
|
|
|
specifier: test_specifier.clone(),
|
2021-09-02 11:38:19 -04:00
|
|
|
maybe_headers: None,
|
2021-07-26 08:05:44 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
program_state.file_fetcher.insert_cached(test_file);
|
|
|
|
|
2021-08-17 06:08:39 -04:00
|
|
|
let init_ops = |js_runtime: &mut JsRuntime| {
|
|
|
|
ops::testing::init(js_runtime);
|
2021-04-28 14:17:04 -04:00
|
|
|
|
|
|
|
js_runtime
|
|
|
|
.op_state()
|
|
|
|
.borrow_mut()
|
2021-04-30 11:56:47 -04:00
|
|
|
.put::<Sender<TestEvent>>(channel.clone());
|
2021-08-17 06:08:39 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
let mut worker = create_main_worker(
|
|
|
|
&program_state,
|
2021-08-26 15:21:58 -04:00
|
|
|
specifier.clone(),
|
2021-08-17 06:08:39 -04:00
|
|
|
permissions,
|
|
|
|
Some(&init_ops),
|
|
|
|
);
|
2021-04-28 14:17:04 -04:00
|
|
|
|
|
|
|
let mut maybe_coverage_collector = if let Some(ref coverage_dir) =
|
|
|
|
program_state.coverage_dir
|
|
|
|
{
|
2021-05-26 11:47:33 -04:00
|
|
|
let session = worker.create_inspector_session().await;
|
2021-04-28 14:17:04 -04:00
|
|
|
let coverage_dir = PathBuf::from(coverage_dir);
|
|
|
|
let mut coverage_collector = CoverageCollector::new(coverage_dir, session);
|
2021-05-26 11:47:33 -04:00
|
|
|
worker
|
|
|
|
.with_event_loop(coverage_collector.start_collecting().boxed_local())
|
|
|
|
.await?;
|
2021-04-28 14:17:04 -04:00
|
|
|
|
|
|
|
Some(coverage_collector)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
worker.execute_module(&test_specifier).await?;
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-05-26 15:07:12 -04:00
|
|
|
worker
|
|
|
|
.run_event_loop(maybe_coverage_collector.is_none())
|
|
|
|
.await?;
|
2021-04-28 14:17:04 -04:00
|
|
|
|
|
|
|
if let Some(coverage_collector) = maybe_coverage_collector.as_mut() {
|
2021-05-26 11:47:33 -04:00
|
|
|
worker
|
|
|
|
.with_event_loop(coverage_collector.stop_collecting().boxed_local())
|
|
|
|
.await?;
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2021-07-29 15:03:06 -04:00
|
|
|
fn extract_files_from_regex_blocks(
|
|
|
|
location: &Location,
|
|
|
|
source: &str,
|
|
|
|
media_type: &MediaType,
|
|
|
|
blocks_regex: &Regex,
|
|
|
|
lines_regex: &Regex,
|
|
|
|
) -> Result<Vec<File>, AnyError> {
|
|
|
|
let files = blocks_regex
|
2021-07-30 09:03:41 -04:00
|
|
|
.captures_iter(source)
|
2021-07-29 15:03:06 -04:00
|
|
|
.filter_map(|block| {
|
2021-08-14 06:33:58 -04:00
|
|
|
let maybe_attributes: Option<Vec<_>> = block
|
2021-07-29 15:03:06 -04:00
|
|
|
.get(1)
|
2021-08-14 06:33:58 -04:00
|
|
|
.map(|attributes| attributes.as_str().split(' ').collect());
|
|
|
|
|
|
|
|
let file_media_type = if let Some(attributes) = maybe_attributes {
|
|
|
|
if attributes.contains(&"ignore") {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
match attributes.get(0) {
|
|
|
|
Some(&"js") => MediaType::JavaScript,
|
|
|
|
Some(&"jsx") => MediaType::Jsx,
|
|
|
|
Some(&"ts") => MediaType::TypeScript,
|
|
|
|
Some(&"tsx") => MediaType::Tsx,
|
|
|
|
Some(&"") => *media_type,
|
2021-07-29 15:03:06 -04:00
|
|
|
_ => MediaType::Unknown,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*media_type
|
|
|
|
};
|
|
|
|
|
|
|
|
if file_media_type == MediaType::Unknown {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let line_offset = source[0..block.get(0).unwrap().start()]
|
|
|
|
.chars()
|
|
|
|
.filter(|c| *c == '\n')
|
|
|
|
.count();
|
|
|
|
|
|
|
|
let line_count = block.get(0).unwrap().as_str().split('\n').count();
|
|
|
|
|
|
|
|
let body = block.get(2).unwrap();
|
|
|
|
let text = body.as_str();
|
|
|
|
|
|
|
|
// TODO(caspervonb) generate an inline source map
|
|
|
|
let mut file_source = String::new();
|
2021-07-30 09:03:41 -04:00
|
|
|
for line in lines_regex.captures_iter(text) {
|
2021-07-29 15:03:06 -04:00
|
|
|
let text = line.get(1).unwrap();
|
|
|
|
file_source.push_str(&format!("{}\n", text.as_str()));
|
|
|
|
}
|
|
|
|
|
|
|
|
file_source.push_str("export {};");
|
|
|
|
|
|
|
|
let file_specifier = deno_core::resolve_url_or_path(&format!(
|
|
|
|
"{}${}-{}{}",
|
2021-08-06 10:36:16 -04:00
|
|
|
location.specifier,
|
2021-07-29 15:03:06 -04:00
|
|
|
location.line + line_offset,
|
|
|
|
location.line + line_offset + line_count,
|
|
|
|
file_media_type.as_ts_extension(),
|
|
|
|
))
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
Some(File {
|
|
|
|
local: file_specifier.to_file_path().unwrap(),
|
|
|
|
maybe_types: None,
|
|
|
|
media_type: file_media_type,
|
|
|
|
source: file_source,
|
|
|
|
specifier: file_specifier,
|
2021-09-02 11:38:19 -04:00
|
|
|
maybe_headers: None,
|
2021-07-29 15:03:06 -04:00
|
|
|
})
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
Ok(files)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn extract_files_from_source_comments(
|
|
|
|
specifier: &ModuleSpecifier,
|
|
|
|
source: &str,
|
|
|
|
media_type: &MediaType,
|
|
|
|
) -> Result<Vec<File>, AnyError> {
|
2021-07-30 09:03:41 -04:00
|
|
|
let parsed_module = ast::parse(specifier.as_str(), source, media_type)?;
|
2021-08-06 10:36:16 -04:00
|
|
|
let comments = parsed_module.get_comments();
|
2021-07-29 15:03:06 -04:00
|
|
|
let blocks_regex = Regex::new(r"```([^\n]*)\n([\S\s]*?)```")?;
|
|
|
|
let lines_regex = Regex::new(r"(?:\* ?)(?:\# ?)?(.*)")?;
|
|
|
|
|
|
|
|
let files = comments
|
|
|
|
.iter()
|
|
|
|
.filter(|comment| {
|
|
|
|
if comment.kind != CommentKind::Block || !comment.text.starts_with('*') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
true
|
|
|
|
})
|
|
|
|
.flat_map(|comment| {
|
2021-08-06 10:36:16 -04:00
|
|
|
let location = parsed_module.get_location(comment.span.lo);
|
2021-07-29 15:03:06 -04:00
|
|
|
|
|
|
|
extract_files_from_regex_blocks(
|
|
|
|
&location,
|
|
|
|
&comment.text,
|
2021-07-30 09:03:41 -04:00
|
|
|
media_type,
|
2021-07-29 15:03:06 -04:00
|
|
|
&blocks_regex,
|
|
|
|
&lines_regex,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.flatten()
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
Ok(files)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn extract_files_from_fenced_blocks(
|
|
|
|
specifier: &ModuleSpecifier,
|
|
|
|
source: &str,
|
|
|
|
media_type: &MediaType,
|
|
|
|
) -> Result<Vec<File>, AnyError> {
|
|
|
|
let location = Location {
|
2021-08-06 10:36:16 -04:00
|
|
|
specifier: specifier.to_string(),
|
2021-07-29 15:03:06 -04:00
|
|
|
line: 1,
|
|
|
|
col: 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
let blocks_regex = Regex::new(r"```([^\n]*)\n([\S\s]*?)```")?;
|
|
|
|
let lines_regex = Regex::new(r"(?:\# ?)?(.*)")?;
|
|
|
|
|
|
|
|
extract_files_from_regex_blocks(
|
|
|
|
&location,
|
2021-07-30 09:03:41 -04:00
|
|
|
source,
|
|
|
|
media_type,
|
2021-07-29 15:03:06 -04:00
|
|
|
&blocks_regex,
|
|
|
|
&lines_regex,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn fetch_inline_files(
|
|
|
|
program_state: Arc<ProgramState>,
|
|
|
|
specifiers: Vec<ModuleSpecifier>,
|
|
|
|
) -> Result<Vec<File>, AnyError> {
|
|
|
|
let mut files = Vec::new();
|
|
|
|
for specifier in specifiers {
|
|
|
|
let mut fetch_permissions = Permissions::allow_all();
|
|
|
|
let file = program_state
|
|
|
|
.file_fetcher
|
|
|
|
.fetch(&specifier, &mut fetch_permissions)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
let inline_files = if file.media_type == MediaType::Unknown {
|
|
|
|
extract_files_from_fenced_blocks(
|
|
|
|
&file.specifier,
|
|
|
|
&file.source,
|
|
|
|
&file.media_type,
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
extract_files_from_source_comments(
|
|
|
|
&file.specifier,
|
|
|
|
&file.source,
|
|
|
|
&file.media_type,
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
|
|
|
files.extend(inline_files?);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(files)
|
|
|
|
}
|
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
/// Type check a collection of module and document specifiers.
|
|
|
|
async fn check_specifiers(
|
2021-05-10 02:06:13 -04:00
|
|
|
program_state: Arc<ProgramState>,
|
|
|
|
permissions: Permissions,
|
2021-08-26 15:21:58 -04:00
|
|
|
specifiers: Vec<(ModuleSpecifier, TestMode)>,
|
|
|
|
lib: TypeLib,
|
2021-07-22 07:34:29 -04:00
|
|
|
) -> Result<(), AnyError> {
|
2021-08-26 15:21:58 -04:00
|
|
|
let inline_files = fetch_inline_files(
|
|
|
|
program_state.clone(),
|
|
|
|
specifiers
|
|
|
|
.iter()
|
|
|
|
.filter_map(|(specifier, mode)| {
|
|
|
|
if *mode != TestMode::Executable {
|
|
|
|
Some(specifier.clone())
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect(),
|
|
|
|
)
|
|
|
|
.await?;
|
2021-07-05 21:20:33 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
if !inline_files.is_empty() {
|
|
|
|
let specifiers = inline_files
|
|
|
|
.iter()
|
|
|
|
.map(|file| file.specifier.clone())
|
|
|
|
.collect();
|
2021-05-10 19:54:39 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
for file in inline_files {
|
2021-07-29 15:03:06 -04:00
|
|
|
program_state.file_fetcher.insert_cached(file);
|
2021-05-10 19:54:39 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
program_state
|
|
|
|
.prepare_module_graph(
|
2021-07-29 15:03:06 -04:00
|
|
|
specifiers,
|
2021-05-10 19:54:39 -04:00
|
|
|
lib.clone(),
|
2021-05-17 03:44:38 -04:00
|
|
|
Permissions::allow_all(),
|
2021-05-10 19:54:39 -04:00
|
|
|
permissions.clone(),
|
|
|
|
program_state.maybe_import_map.clone(),
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
}
|
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
let module_specifiers = specifiers
|
|
|
|
.iter()
|
|
|
|
.filter_map(|(specifier, mode)| {
|
|
|
|
if *mode != TestMode::Documentation {
|
|
|
|
Some(specifier.clone())
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
2021-08-12 14:10:14 -04:00
|
|
|
|
2021-04-28 14:17:04 -04:00
|
|
|
program_state
|
|
|
|
.prepare_module_graph(
|
2021-08-26 15:21:58 -04:00
|
|
|
module_specifiers,
|
|
|
|
lib,
|
2021-05-17 03:44:38 -04:00
|
|
|
Permissions::allow_all(),
|
2021-08-26 15:21:58 -04:00
|
|
|
permissions,
|
2021-04-28 14:17:04 -04:00
|
|
|
program_state.maybe_import_map.clone(),
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
Ok(())
|
|
|
|
}
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
/// Test a collection of specifiers with test modes concurrently.
|
|
|
|
async fn test_specifiers(
|
|
|
|
program_state: Arc<ProgramState>,
|
|
|
|
permissions: Permissions,
|
|
|
|
specifiers_with_mode: Vec<(ModuleSpecifier, TestMode)>,
|
|
|
|
fail_fast: Option<NonZeroUsize>,
|
|
|
|
filter: Option<String>,
|
|
|
|
shuffle: Option<u64>,
|
|
|
|
concurrent_jobs: NonZeroUsize,
|
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
let specifiers_with_mode = if let Some(seed) = shuffle {
|
|
|
|
let mut rng = SmallRng::seed_from_u64(seed);
|
|
|
|
let mut specifiers_with_mode = specifiers_with_mode.clone();
|
|
|
|
specifiers_with_mode.sort_by_key(|(specifier, _)| specifier.clone());
|
|
|
|
specifiers_with_mode.shuffle(&mut rng);
|
|
|
|
specifiers_with_mode
|
|
|
|
} else {
|
|
|
|
specifiers_with_mode
|
|
|
|
};
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
let (sender, receiver) = channel::<TestEvent>();
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-08-26 15:21:58 -04:00
|
|
|
let join_handles =
|
|
|
|
specifiers_with_mode.iter().map(move |(specifier, mode)| {
|
|
|
|
let program_state = program_state.clone();
|
|
|
|
let permissions = permissions.clone();
|
|
|
|
let specifier = specifier.clone();
|
|
|
|
let mode = mode.clone();
|
|
|
|
let filter = filter.clone();
|
|
|
|
let sender = sender.clone();
|
|
|
|
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
|
|
let join_handle = std::thread::spawn(move || {
|
|
|
|
let future = test_specifier(
|
|
|
|
program_state,
|
|
|
|
permissions,
|
|
|
|
specifier,
|
|
|
|
mode,
|
|
|
|
filter,
|
|
|
|
shuffle,
|
|
|
|
sender,
|
|
|
|
);
|
|
|
|
|
|
|
|
tokio_util::run_basic(future)
|
|
|
|
});
|
|
|
|
|
|
|
|
join_handle.join().unwrap()
|
|
|
|
})
|
|
|
|
});
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-07-22 07:34:29 -04:00
|
|
|
let join_stream = stream::iter(join_handles)
|
2021-08-23 06:35:38 -04:00
|
|
|
.buffer_unordered(concurrent_jobs.get())
|
2021-04-28 14:17:04 -04:00
|
|
|
.collect::<Vec<Result<Result<(), AnyError>, tokio::task::JoinError>>>();
|
|
|
|
|
2021-08-23 06:35:38 -04:00
|
|
|
let mut reporter = create_reporter(concurrent_jobs.get() > 1);
|
2021-04-28 14:17:04 -04:00
|
|
|
let handler = {
|
|
|
|
tokio::task::spawn_blocking(move || {
|
2021-07-13 18:11:58 -04:00
|
|
|
let earlier = Instant::now();
|
|
|
|
let mut summary = TestSummary::new();
|
2021-04-28 14:17:04 -04:00
|
|
|
let mut used_only = false;
|
|
|
|
|
2021-04-30 11:56:47 -04:00
|
|
|
for event in receiver.iter() {
|
2021-07-14 15:05:16 -04:00
|
|
|
match event {
|
|
|
|
TestEvent::Plan(plan) => {
|
|
|
|
summary.total += plan.total;
|
|
|
|
summary.filtered_out += plan.filtered_out;
|
|
|
|
|
|
|
|
if plan.used_only {
|
2021-04-28 14:17:04 -04:00
|
|
|
used_only = true;
|
|
|
|
}
|
2021-07-14 15:05:16 -04:00
|
|
|
|
|
|
|
reporter.report_plan(&plan);
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
2021-07-13 18:11:58 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
TestEvent::Wait(description) => {
|
|
|
|
reporter.report_wait(&description);
|
|
|
|
}
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
TestEvent::Result(description, result, elapsed) => {
|
|
|
|
match &result {
|
|
|
|
TestResult::Ok => {
|
|
|
|
summary.passed += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
TestResult::Ignored => {
|
|
|
|
summary.ignored += 1;
|
|
|
|
}
|
2021-07-13 18:11:58 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
TestResult::Failed(error) => {
|
|
|
|
summary.failed += 1;
|
|
|
|
summary.failures.push((description.clone(), error.clone()));
|
|
|
|
}
|
2021-07-13 18:11:58 -04:00
|
|
|
}
|
2021-04-28 14:17:04 -04:00
|
|
|
|
2021-07-14 15:05:16 -04:00
|
|
|
reporter.report_result(&description, &result, elapsed);
|
|
|
|
}
|
|
|
|
}
|
2021-04-29 07:42:35 -04:00
|
|
|
|
2021-07-12 06:55:42 -04:00
|
|
|
if let Some(x) = fail_fast {
|
2021-08-23 06:37:02 -04:00
|
|
|
if summary.failed >= x.get() {
|
2021-07-12 06:55:42 -04:00
|
|
|
break;
|
|
|
|
}
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-13 18:11:58 -04:00
|
|
|
let elapsed = Instant::now().duration_since(earlier);
|
2021-07-14 15:05:16 -04:00
|
|
|
reporter.report_summary(&summary, &elapsed);
|
2021-04-28 14:17:04 -04:00
|
|
|
|
|
|
|
if used_only {
|
2021-07-22 07:34:29 -04:00
|
|
|
return Err(generic_error(
|
|
|
|
"Test failed because the \"only\" option was used",
|
|
|
|
));
|
|
|
|
}
|
|
|
|
|
|
|
|
if summary.failed > 0 {
|
|
|
|
return Err(generic_error("Test failed"));
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
|
|
|
|
2021-07-22 07:34:29 -04:00
|
|
|
Ok(())
|
2021-04-28 14:17:04 -04:00
|
|
|
})
|
2020-04-02 09:26:40 -04:00
|
|
|
};
|
|
|
|
|
2021-07-22 07:34:29 -04:00
|
|
|
let (join_results, result) = future::join(join_stream, handler).await;
|
2020-10-14 09:19:13 -04:00
|
|
|
|
2021-04-28 14:17:04 -04:00
|
|
|
let mut join_errors = join_results.into_iter().filter_map(|join_result| {
|
|
|
|
join_result
|
|
|
|
.ok()
|
|
|
|
.map(|handle_result| handle_result.err())
|
|
|
|
.flatten()
|
|
|
|
});
|
2020-02-11 06:01:56 -05:00
|
|
|
|
2021-04-28 14:17:04 -04:00
|
|
|
if let Some(e) = join_errors.next() {
|
2021-07-22 07:34:29 -04:00
|
|
|
return Err(e);
|
2021-04-28 14:17:04 -04:00
|
|
|
}
|
2021-07-22 07:34:29 -04:00
|
|
|
|
|
|
|
match result {
|
|
|
|
Ok(result) => {
|
|
|
|
if let Some(err) = result.err() {
|
|
|
|
return Err(err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Err(err) => {
|
|
|
|
return Err(err.into());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
2020-02-11 06:01:56 -05:00
|
|
|
}
|
2021-08-26 15:21:58 -04:00
|
|
|
|
|
|
|
/// Collects specifiers marking them with the appropriate test mode while maintaining the natural
|
|
|
|
/// input order.
|
|
|
|
///
|
|
|
|
/// - Specifiers matching the `is_supported_test_ext` predicate are marked as
|
|
|
|
/// `TestMode::Documentation`.
|
|
|
|
/// - Specifiers matching the `is_supported_test_path` are marked as `TestMode::Executable`.
|
|
|
|
/// - Specifiers matching both predicates are marked as `TestMode::Both`
|
|
|
|
fn collect_specifiers_with_test_mode(
|
|
|
|
include: Vec<String>,
|
|
|
|
ignore: Vec<PathBuf>,
|
|
|
|
include_inline: bool,
|
|
|
|
) -> Result<Vec<(ModuleSpecifier, TestMode)>, AnyError> {
|
|
|
|
let module_specifiers =
|
|
|
|
collect_specifiers(include.clone(), &ignore, is_supported_test_path)?;
|
|
|
|
|
|
|
|
if include_inline {
|
|
|
|
return collect_specifiers(include, &ignore, is_supported_test_ext).map(
|
|
|
|
|specifiers| {
|
|
|
|
specifiers
|
|
|
|
.into_iter()
|
|
|
|
.map(|specifier| {
|
|
|
|
let mode = if module_specifiers.contains(&specifier) {
|
|
|
|
TestMode::Both
|
|
|
|
} else {
|
|
|
|
TestMode::Documentation
|
|
|
|
};
|
|
|
|
|
|
|
|
(specifier, mode)
|
|
|
|
})
|
|
|
|
.collect()
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
let specifiers_with_mode = module_specifiers
|
|
|
|
.into_iter()
|
|
|
|
.map(|specifier| (specifier, TestMode::Executable))
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
Ok(specifiers_with_mode)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Collects module and document specifiers with test modes via `collect_specifiers_with_test_mode`
|
|
|
|
/// which are then pre-fetched and adjusted based on the media type.
|
|
|
|
///
|
|
|
|
/// Specifiers that do not have a known media type that can be executed as a module are marked as
|
|
|
|
/// `TestMode::Documentation`.
|
|
|
|
async fn fetch_specifiers_with_test_mode(
|
|
|
|
program_state: Arc<ProgramState>,
|
|
|
|
include: Vec<String>,
|
|
|
|
ignore: Vec<PathBuf>,
|
|
|
|
include_inline: bool,
|
|
|
|
) -> Result<Vec<(ModuleSpecifier, TestMode)>, AnyError> {
|
|
|
|
let mut specifiers_with_mode =
|
|
|
|
collect_specifiers_with_test_mode(include, ignore, include_inline)?;
|
|
|
|
for (specifier, mode) in &mut specifiers_with_mode {
|
|
|
|
let file = program_state
|
|
|
|
.file_fetcher
|
|
|
|
.fetch(specifier, &mut Permissions::allow_all())
|
|
|
|
.await?;
|
|
|
|
|
2021-09-01 05:31:56 -04:00
|
|
|
if file.media_type == MediaType::Unknown {
|
2021-08-26 15:21:58 -04:00
|
|
|
*mode = TestMode::Documentation
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(specifiers_with_mode)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
|
|
pub async fn run_tests(
|
|
|
|
flags: Flags,
|
|
|
|
include: Option<Vec<String>>,
|
|
|
|
ignore: Vec<PathBuf>,
|
|
|
|
doc: bool,
|
|
|
|
no_run: bool,
|
|
|
|
fail_fast: Option<NonZeroUsize>,
|
|
|
|
allow_none: bool,
|
|
|
|
filter: Option<String>,
|
|
|
|
shuffle: Option<u64>,
|
|
|
|
concurrent_jobs: NonZeroUsize,
|
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
let program_state = ProgramState::build(flags.clone()).await?;
|
|
|
|
let permissions = Permissions::from_options(&flags.clone().into());
|
|
|
|
let specifiers_with_mode = fetch_specifiers_with_test_mode(
|
|
|
|
program_state.clone(),
|
|
|
|
include.unwrap_or_else(|| vec![".".to_string()]),
|
|
|
|
ignore.clone(),
|
|
|
|
doc,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
if !allow_none && specifiers_with_mode.is_empty() {
|
|
|
|
return Err(generic_error("No test modules found"));
|
|
|
|
}
|
|
|
|
|
|
|
|
let lib = if flags.unstable {
|
|
|
|
TypeLib::UnstableDenoWindow
|
|
|
|
} else {
|
|
|
|
TypeLib::DenoWindow
|
|
|
|
};
|
|
|
|
|
|
|
|
check_specifiers(
|
|
|
|
program_state.clone(),
|
|
|
|
permissions.clone(),
|
|
|
|
specifiers_with_mode.clone(),
|
|
|
|
lib,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
if no_run {
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
|
|
|
|
test_specifiers(
|
|
|
|
program_state,
|
|
|
|
permissions,
|
|
|
|
specifiers_with_mode,
|
|
|
|
fail_fast,
|
|
|
|
filter,
|
|
|
|
shuffle,
|
|
|
|
concurrent_jobs,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
|
|
pub async fn run_tests_with_watch(
|
|
|
|
flags: Flags,
|
|
|
|
include: Option<Vec<String>>,
|
|
|
|
ignore: Vec<PathBuf>,
|
|
|
|
doc: bool,
|
|
|
|
no_run: bool,
|
|
|
|
fail_fast: Option<NonZeroUsize>,
|
|
|
|
filter: Option<String>,
|
|
|
|
shuffle: Option<u64>,
|
|
|
|
concurrent_jobs: NonZeroUsize,
|
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
let program_state = ProgramState::build(flags.clone()).await?;
|
|
|
|
let permissions = Permissions::from_options(&flags.clone().into());
|
|
|
|
|
|
|
|
let lib = if flags.unstable {
|
|
|
|
TypeLib::UnstableDenoWindow
|
|
|
|
} else {
|
|
|
|
TypeLib::DenoWindow
|
|
|
|
};
|
|
|
|
|
|
|
|
let handler = Arc::new(Mutex::new(FetchHandler::new(
|
|
|
|
&program_state,
|
|
|
|
Permissions::allow_all(),
|
|
|
|
Permissions::allow_all(),
|
|
|
|
)?));
|
|
|
|
|
|
|
|
let include = include.unwrap_or_else(|| vec![".".to_string()]);
|
|
|
|
let paths_to_watch: Vec<_> = include.iter().map(PathBuf::from).collect();
|
|
|
|
|
|
|
|
let resolver = |changed: Option<Vec<PathBuf>>| {
|
|
|
|
let paths_to_watch = paths_to_watch.clone();
|
|
|
|
let paths_to_watch_clone = paths_to_watch.clone();
|
|
|
|
|
|
|
|
let handler = handler.clone();
|
|
|
|
let program_state = program_state.clone();
|
|
|
|
let files_changed = changed.is_some();
|
|
|
|
let include = include.clone();
|
|
|
|
let ignore = ignore.clone();
|
|
|
|
|
|
|
|
async move {
|
|
|
|
let test_modules = if doc {
|
|
|
|
collect_specifiers(include.clone(), &ignore, is_supported_test_ext)
|
|
|
|
} else {
|
|
|
|
collect_specifiers(include.clone(), &ignore, is_supported_test_path)
|
|
|
|
}?;
|
|
|
|
|
|
|
|
let mut paths_to_watch = paths_to_watch_clone;
|
|
|
|
let mut modules_to_reload = if files_changed {
|
|
|
|
Vec::new()
|
|
|
|
} else {
|
|
|
|
test_modules
|
|
|
|
.iter()
|
|
|
|
.filter_map(|url| deno_core::resolve_url(url.as_str()).ok())
|
|
|
|
.collect()
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut builder = GraphBuilder::new(
|
|
|
|
handler,
|
|
|
|
program_state.maybe_import_map.clone(),
|
|
|
|
program_state.lockfile.clone(),
|
|
|
|
);
|
|
|
|
for specifier in test_modules.iter() {
|
|
|
|
builder.add(specifier, false).await?;
|
|
|
|
}
|
|
|
|
builder
|
|
|
|
.analyze_config_file(&program_state.maybe_config_file)
|
|
|
|
.await?;
|
|
|
|
let graph = builder.get_graph();
|
|
|
|
|
|
|
|
for specifier in test_modules {
|
|
|
|
fn get_dependencies<'a>(
|
|
|
|
graph: &'a module_graph::Graph,
|
|
|
|
module: &'a Module,
|
|
|
|
// This needs to be accessible to skip getting dependencies if they're already there,
|
|
|
|
// otherwise this will cause a stack overflow with circular dependencies
|
|
|
|
output: &mut HashSet<&'a ModuleSpecifier>,
|
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
for dep in module.dependencies.values() {
|
|
|
|
if let Some(specifier) = &dep.maybe_code {
|
|
|
|
if !output.contains(specifier) {
|
|
|
|
output.insert(specifier);
|
|
|
|
|
|
|
|
get_dependencies(
|
|
|
|
graph,
|
|
|
|
graph.get_specifier(specifier)?,
|
|
|
|
output,
|
|
|
|
)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(specifier) = &dep.maybe_type {
|
|
|
|
if !output.contains(specifier) {
|
|
|
|
output.insert(specifier);
|
|
|
|
|
|
|
|
get_dependencies(
|
|
|
|
graph,
|
|
|
|
graph.get_specifier(specifier)?,
|
|
|
|
output,
|
|
|
|
)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
// This test module and all it's dependencies
|
|
|
|
let mut modules = HashSet::new();
|
|
|
|
modules.insert(&specifier);
|
|
|
|
get_dependencies(
|
|
|
|
&graph,
|
|
|
|
graph.get_specifier(&specifier)?,
|
|
|
|
&mut modules,
|
|
|
|
)?;
|
|
|
|
|
|
|
|
paths_to_watch.extend(
|
|
|
|
modules
|
|
|
|
.iter()
|
|
|
|
.filter_map(|specifier| specifier.to_file_path().ok()),
|
|
|
|
);
|
|
|
|
|
|
|
|
if let Some(changed) = &changed {
|
|
|
|
for path in changed.iter().filter_map(|path| {
|
|
|
|
deno_core::resolve_url_or_path(&path.to_string_lossy()).ok()
|
|
|
|
}) {
|
|
|
|
if modules.contains(&&path) {
|
|
|
|
modules_to_reload.push(specifier);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok((paths_to_watch, modules_to_reload))
|
|
|
|
}
|
|
|
|
.map(move |result| {
|
|
|
|
if files_changed
|
|
|
|
&& matches!(result, Ok((_, ref modules)) if modules.is_empty())
|
|
|
|
{
|
|
|
|
ResolutionResult::Ignore
|
|
|
|
} else {
|
|
|
|
match result {
|
|
|
|
Ok((paths_to_watch, modules_to_reload)) => {
|
|
|
|
ResolutionResult::Restart {
|
|
|
|
paths_to_watch,
|
|
|
|
result: Ok(modules_to_reload),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(e) => ResolutionResult::Restart {
|
|
|
|
paths_to_watch,
|
|
|
|
result: Err(e),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
};
|
|
|
|
|
|
|
|
let operation = |modules_to_reload: Vec<ModuleSpecifier>| {
|
|
|
|
let filter = filter.clone();
|
|
|
|
let include = include.clone();
|
|
|
|
let ignore = ignore.clone();
|
|
|
|
let lib = lib.clone();
|
|
|
|
let permissions = permissions.clone();
|
|
|
|
let program_state = program_state.clone();
|
|
|
|
|
|
|
|
async move {
|
|
|
|
let specifiers_with_mode = fetch_specifiers_with_test_mode(
|
|
|
|
program_state.clone(),
|
|
|
|
include.clone(),
|
|
|
|
ignore.clone(),
|
|
|
|
doc,
|
|
|
|
)
|
|
|
|
.await?
|
|
|
|
.iter()
|
|
|
|
.filter(|(specifier, _)| modules_to_reload.contains(specifier))
|
|
|
|
.cloned()
|
|
|
|
.collect::<Vec<(ModuleSpecifier, TestMode)>>();
|
|
|
|
|
|
|
|
check_specifiers(
|
|
|
|
program_state.clone(),
|
|
|
|
permissions.clone(),
|
|
|
|
specifiers_with_mode.clone(),
|
|
|
|
lib,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
if no_run {
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
|
|
|
|
test_specifiers(
|
|
|
|
program_state.clone(),
|
|
|
|
permissions.clone(),
|
|
|
|
specifiers_with_mode,
|
|
|
|
fail_fast,
|
|
|
|
filter.clone(),
|
|
|
|
shuffle,
|
|
|
|
concurrent_jobs,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
file_watcher::watch_func(resolver, operation, "Test").await?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|