mirror of
https://github.com/denoland/deno.git
synced 2024-12-13 02:52:54 -05:00
195 lines
5.3 KiB
Rust
195 lines
5.3 KiB
Rust
|
// 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(¤t_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(())
|
||
|
}
|
||
|
}
|