Struct cucumber::writer::Libtest

pub struct Libtest<W, Out: Write = Stdout> { /* private fields */ }

Available on crate feature libtest only.

libtest compatible Writer.

Currently used only to support --format=json option.

Ordering

This Writer isn’t Normalized by itself, so should be wrapped into a writer::Normalize, otherwise will produce output Events in a broken order.

Ideally, we shouldn’t wrap this into a writer::Normalize and leave this to tools, parsing JSON output. Unfortunately, not all tools can do that (ex. IntelliJ Rust), so it’s still recommended to wrap this into writer::Normalize even if it can mess up timing reports.

Implementations

impl<W: Debug + World> Libtest<W, Stdout>

pub fn stdout() -> Normalize<W, Self>

Creates a new Normalized Libtest Writer outputting into the io::Stdout.

pub fn or<AnotherWriter: Writer<W>>(
    writer: AnotherWriter
) -> Or<W, AnotherWriter>

Creates a new Writer which uses a Normalized Libtest in case Cli::format is set to Json, or provided the writer otherwise.

pub fn or_basic() -> OrBasic<W>

Creates a new Writer which uses a Normalized Libtest in case Cli::format is set to Json, or a Normalized writer::Basic otherwise.

impl<W: Debug + World, Out: Write> Libtest<W, Out>

pub fn new(output: Out) -> Normalize<W, Self>

Creates a new Normalized Libtest Writer outputting into the provided output.

Theoretically, normalization should be done by the tool that’s consuming the output og this Writer. But lack of clear specification of the libtest’s JSON output leads to some tools struggling to interpret it. So, we recommend using a Normalized Libtest::new() rather than a non-Normalized Libtest::raw().

pub const fn raw(output: Out) -> Self

Creates a new non-Normalized Libtest Writer outputting into the provided output.

Theoretically, normalization should be done by the tool that’s consuming the output og this Writer. But lack of clear specification of the libtest’s JSON output leads to some tools struggling to interpret it. So, we recommend using a Normalized Libtest::new() rather than a non-Normalized Libtest::raw().

Trait Implementations

impl<'val, W, Val, Out> Arbitrary<'val, W, Val> for Libtest<W, Out>where
    W: World + Debug,
    Val: AsRef<str> + 'val,
    Out: Write,

fn write<'life0, 'async_trait>(
    &'life0 mut self,
    val: Val
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>where
    'val: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Writes val to the Writer’s output.

impl<W: Clone, Out: Clone + Write> Clone for Libtest<W, Out>

fn clone(&self) -> Libtest<W, Out>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<W: Debug, Out: Debug + Write> Debug for Libtest<W, Out>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W, O> Stats<W> for Libtest<W, O>where
    O: Write,
    Self: Writer<W>,

fn passed_steps(&self) -> usize

Returns number of Passed Steps.

fn skipped_steps(&self) -> usize

Returns number of Skipped Steps.

fn failed_steps(&self) -> usize

Returns number of Failed Steps.

fn retried_steps(&self) -> usize

Returns number of retried Steps.

fn parsing_errors(&self) -> usize

Returns number of parsing errors.

fn hook_errors(&self) -> usize

Returns number of failed Scenario hooks.

fn execution_has_failed(&self) -> bool

Indicates whether there were failures/errors during execution.

impl<W: World + Debug, Out: Write> Writer<W> for Libtest<W, Out>

type Cli = Cli

CLI options of this Writer. In case no options should be introduced, just use cli::Empty.

fn handle_event<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    event: Result<Event<Cucumber<W>>>,
    cli: &'life1 Self::Cli
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Handles the given Cucumber event.

impl<W, O: Write> NonTransforming for Libtest<W, O>