1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-13 02:52:54 -05:00
denoland-deno/cli/tools/test/reporters/junit.rs

195 lines
5.3 KiB
Rust
Raw Normal View History

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use super::*;
pub struct JunitTestReporter {
path: String,
// Stores TestCases (i.e. Tests) by the Test ID
cases: IndexMap<usize, quick_junit::TestCase>,
}
impl JunitTestReporter {
pub fn new(path: String) -> Self {
Self {
path,
cases: IndexMap::new(),
}
}
fn convert_status(status: &TestResult) -> quick_junit::TestCaseStatus {
match status {
TestResult::Ok => quick_junit::TestCaseStatus::success(),
TestResult::Ignored => quick_junit::TestCaseStatus::skipped(),
TestResult::Failed(failure) => quick_junit::TestCaseStatus::NonSuccess {
kind: quick_junit::NonSuccessKind::Failure,
message: Some(failure.to_string()),
ty: None,
description: None,
reruns: vec![],
},
TestResult::Cancelled => quick_junit::TestCaseStatus::NonSuccess {
kind: quick_junit::NonSuccessKind::Error,
message: Some("Cancelled".to_string()),
ty: None,
description: None,
reruns: vec![],
},
}
}
}
impl TestReporter for JunitTestReporter {
fn report_register(&mut self, description: &TestDescription) {
self.cases.insert(
description.id,
quick_junit::TestCase::new(
description.name.clone(),
quick_junit::TestCaseStatus::skipped(),
),
);
}
fn report_plan(&mut self, _plan: &TestPlan) {}
fn report_wait(&mut self, _description: &TestDescription) {}
fn report_output(&mut self, _output: &[u8]) {
/*
TODO(skycoop): Right now I can't include stdout/stderr in the report because
we have a global pair of output streams that don't differentiate between the
output of different tests. This is a nice to have feature, so we can come
back to it later
*/
}
fn report_result(
&mut self,
description: &TestDescription,
result: &TestResult,
elapsed: u64,
) {
if let Some(case) = self.cases.get_mut(&description.id) {
case.status = Self::convert_status(result);
case.set_time(Duration::from_millis(elapsed));
}
}
fn report_uncaught_error(&mut self, _origin: &str, _error: Box<JsError>) {}
fn report_step_register(&mut self, _description: &TestStepDescription) {}
fn report_step_wait(&mut self, _description: &TestStepDescription) {}
fn report_step_result(
&mut self,
description: &TestStepDescription,
result: &TestStepResult,
_elapsed: u64,
_tests: &IndexMap<usize, TestDescription>,
test_steps: &IndexMap<usize, TestStepDescription>,
) {
let status = match result {
TestStepResult::Ok => "passed",
TestStepResult::Ignored => "skipped",
TestStepResult::Failed(_) => "failure",
};
let root_id: usize;
let mut name = String::new();
{
let mut ancestors = vec![];
let mut current_desc = description;
loop {
if let Some(d) = test_steps.get(&current_desc.parent_id) {
ancestors.push(&d.name);
current_desc = d;
} else {
root_id = current_desc.parent_id;
break;
}
}
ancestors.reverse();
for n in ancestors {
name.push_str(n);
name.push_str(" ... ");
}
name.push_str(&description.name);
}
if let Some(case) = self.cases.get_mut(&root_id) {
case.add_property(quick_junit::Property::new(
format!("step[{}]", status),
name,
));
}
}
fn report_summary(
&mut self,
_elapsed: &Duration,
_tests: &IndexMap<usize, TestDescription>,
_test_steps: &IndexMap<usize, TestStepDescription>,
) {
}
fn report_sigint(
&mut self,
tests_pending: &HashSet<usize>,
tests: &IndexMap<usize, TestDescription>,
_test_steps: &IndexMap<usize, TestStepDescription>,
) {
for id in tests_pending {
if let Some(description) = tests.get(id) {
self.report_result(description, &TestResult::Cancelled, 0)
}
}
}
fn flush_report(
&mut self,
elapsed: &Duration,
tests: &IndexMap<usize, TestDescription>,
_test_steps: &IndexMap<usize, TestStepDescription>,
) -> anyhow::Result<()> {
let mut suites: IndexMap<String, quick_junit::TestSuite> = IndexMap::new();
for (id, case) in &self.cases {
if let Some(test) = tests.get(id) {
suites
.entry(test.location.file_name.clone())
.and_modify(|s| {
s.add_test_case(case.clone());
})
.or_insert_with(|| {
quick_junit::TestSuite::new(test.location.file_name.clone())
.add_test_case(case.clone())
.to_owned()
});
}
}
let mut report = quick_junit::Report::new("deno test");
report.set_time(*elapsed).add_test_suites(
suites
.values()
.cloned()
.collect::<Vec<quick_junit::TestSuite>>(),
);
if self.path == "-" {
report
.serialize(std::io::stdout())
.with_context(|| "Failed to write JUnit report to stdout")?;
} else {
let file =
std::fs::File::create(self.path.clone()).with_context(|| {
format!("Failed to open JUnit report file {}", self.path)
})?;
report.serialize(file).with_context(|| {
format!("Failed to write JUnit report to {}", self.path)
})?;
}
Ok(())
}
}