1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-22 23:34:47 -05:00
denoland-deno/cli/tools/test/reporters/compound.rs
Matt Mastracci b6e44f91ad
fix(cli): ensure that pre- and post-test output is flushed at the appropriate times (#22611)
Some `deno_std` tests were failing to print output that was resolved
after the last test finished. In addition, output printed before tests
began would sometimes appear above the "running X tests ..." line, and
sometimes below it depending on timing.

We now guarantee that all output is flushed before and after tests run,
making the output consistent.

Pre-test and post-test output are captured in `------ pre-test output
------` and `------ post-test output ------` blocks to differentiate
them from the regular output blocks.

Here's an example of a test (that is much noisier than normal, but an
example of what the output will look like):

```
Check ./load_unload.ts
------- pre-test output -------
load
----- output end -----
running 1 test from ./load_unload.ts
test ...
------- output -------
test
----- output end -----
test ... ok ([WILDCARD])
------- post-test output -------
unload
----- output end -----
```
2024-02-28 22:12:21 +00:00

137 lines
3.4 KiB
Rust

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
use super::*;
pub struct CompoundTestReporter {
test_reporters: Vec<Box<dyn TestReporter>>,
}
impl CompoundTestReporter {
pub fn new(test_reporters: Vec<Box<dyn TestReporter>>) -> Self {
Self { test_reporters }
}
}
impl TestReporter for CompoundTestReporter {
fn report_register(&mut self, description: &TestDescription) {
for reporter in &mut self.test_reporters {
reporter.report_register(description);
}
}
fn report_plan(&mut self, plan: &TestPlan) {
for reporter in &mut self.test_reporters {
reporter.report_plan(plan);
}
}
fn report_wait(&mut self, description: &TestDescription) {
for reporter in &mut self.test_reporters {
reporter.report_wait(description);
}
}
fn report_output(&mut self, output: &[u8]) {
for reporter in &mut self.test_reporters {
reporter.report_output(output);
}
}
fn report_result(
&mut self,
description: &TestDescription,
result: &TestResult,
elapsed: u64,
) {
for reporter in &mut self.test_reporters {
reporter.report_result(description, result, elapsed);
}
}
fn report_uncaught_error(&mut self, origin: &str, error: Box<JsError>) {
for reporter in &mut self.test_reporters {
reporter.report_uncaught_error(origin, error.clone());
}
}
fn report_step_register(&mut self, description: &TestStepDescription) {
for reporter in &mut self.test_reporters {
reporter.report_step_register(description)
}
}
fn report_step_wait(&mut self, description: &TestStepDescription) {
for reporter in &mut self.test_reporters {
reporter.report_step_wait(description)
}
}
fn report_step_result(
&mut self,
desc: &TestStepDescription,
result: &TestStepResult,
elapsed: u64,
tests: &IndexMap<usize, TestDescription>,
test_steps: &IndexMap<usize, TestStepDescription>,
) {
for reporter in &mut self.test_reporters {
reporter.report_step_result(desc, result, elapsed, tests, test_steps);
}
}
fn report_summary(
&mut self,
elapsed: &Duration,
tests: &IndexMap<usize, TestDescription>,
test_steps: &IndexMap<usize, TestStepDescription>,
) {
for reporter in &mut self.test_reporters {
reporter.report_summary(elapsed, tests, test_steps);
}
}
fn report_sigint(
&mut self,
tests_pending: &HashSet<usize>,
tests: &IndexMap<usize, TestDescription>,
test_steps: &IndexMap<usize, TestStepDescription>,
) {
for reporter in &mut self.test_reporters {
reporter.report_sigint(tests_pending, tests, test_steps);
}
}
fn report_completed(&mut self) {
for reporter in &mut self.test_reporters {
reporter.report_completed();
}
}
fn flush_report(
&mut self,
elapsed: &Duration,
tests: &IndexMap<usize, TestDescription>,
test_steps: &IndexMap<usize, TestStepDescription>,
) -> anyhow::Result<()> {
let mut errors = vec![];
for reporter in &mut self.test_reporters {
if let Err(err) = reporter.flush_report(elapsed, tests, test_steps) {
errors.push(err)
}
}
if errors.is_empty() {
Ok(())
} else {
bail!(
"error in one or more wrapped reporters:\n{}",
errors
.iter()
.enumerate()
.fold(String::new(), |acc, (i, err)| {
format!("{}Error #{}: {:?}\n", acc, i + 1, err)
})
)
}
}
}