102 lines
4.1 KiB
Rust
102 lines
4.1 KiB
Rust
use colored::Colorize;
|
|
use cucumber::{cli, event, parser, Event};
|
|
use std::{
|
|
io::{self, Write},
|
|
time::Instant,
|
|
};
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct DotWriter {
|
|
scenarios_started: usize,
|
|
scenarios_failed: usize,
|
|
scenarios_finished: usize,
|
|
features_started: usize,
|
|
features_finished: usize,
|
|
step_started: usize,
|
|
step_failed: usize,
|
|
step_passed: usize,
|
|
step_skipped: usize,
|
|
start_time: Option<Instant>,
|
|
}
|
|
|
|
impl<W: 'static> cucumber::Writer<W> for DotWriter {
|
|
type Cli = cli::Empty; // we provide no CLI options
|
|
|
|
async fn handle_event(&mut self, ev: parser::Result<Event<event::Cucumber<W>>>, _: &Self::Cli) {
|
|
let green_dot = ".".green();
|
|
let cyan_dash = "-".cyan();
|
|
let red_cross = "X".red();
|
|
match ev {
|
|
Ok(Event { value, .. }) => match value {
|
|
event::Cucumber::Feature(_feature, ev) => match ev {
|
|
event::Feature::Started => {
|
|
self.features_started += 1;
|
|
print!("{green_dot}")
|
|
}
|
|
event::Feature::Scenario(_scenario, ev) => match ev.event {
|
|
event::Scenario::Started => {
|
|
self.scenarios_started += 1;
|
|
print!("{green_dot}")
|
|
}
|
|
event::Scenario::Step(_step, ev) => match ev {
|
|
event::Step::Started => {
|
|
self.step_started += 1;
|
|
print!("{green_dot}")
|
|
}
|
|
event::Step::Passed(..) => {
|
|
self.step_passed += 1;
|
|
print!("{green_dot}")
|
|
}
|
|
event::Step::Skipped => {
|
|
self.step_skipped += 1;
|
|
print!("{cyan_dash}")
|
|
}
|
|
event::Step::Failed(_, _, _, _err) => {
|
|
self.step_failed += 1;
|
|
print!("{red_cross}")
|
|
}
|
|
},
|
|
event::Scenario::Hook(_, _) => {}
|
|
event::Scenario::Background(_, _) => {}
|
|
event::Scenario::Log(_) => {}
|
|
event::Scenario::Finished => {
|
|
self.scenarios_finished += 1;
|
|
}
|
|
},
|
|
event::Feature::Rule(_, _) => {}
|
|
event::Feature::Finished => {
|
|
self.features_finished += 1;
|
|
}
|
|
},
|
|
event::Cucumber::Finished => {
|
|
println!();
|
|
let f = format!("{} failed", self.scenarios_failed).red();
|
|
let p = format!("{} passed", self.scenarios_finished).green();
|
|
println!("{} scenarios ({f}, {p})", self.scenarios_started);
|
|
let f = format!("{} failed", self.step_failed).red();
|
|
let s = format!("{} skipped", self.step_skipped).cyan();
|
|
let p = format!("{} passed", self.step_passed).green();
|
|
println!("{} steps ({f}, {s}, {p})", self.step_started);
|
|
|
|
let elapsed = Instant::now() - self.start_time.unwrap();
|
|
let minutes = elapsed.as_secs() / 60;
|
|
let seconds = (elapsed.as_millis() % 60_000) as f64 / 1000.;
|
|
println!("{}m{}s", minutes, seconds);
|
|
}
|
|
event::Cucumber::ParsingFinished {
|
|
features: _,
|
|
rules: _,
|
|
scenarios: _,
|
|
steps: _,
|
|
parser_errors: _,
|
|
} => {}
|
|
event::Cucumber::Started => {
|
|
self.start_time = Some(Instant::now());
|
|
}
|
|
},
|
|
Err(e) => println!("Error: {e}"),
|
|
}
|
|
let _ = io::stdout().flush();
|
|
}
|
|
}
|