Struct cucumber::runner::Basic

pub struct Basic<World, F = WhichScenarioFn, Before = BeforeHookFn<World>, After = AfterHookFn<World>> { /* private fields */ }

Default Runner implementation which follows order guarantees from the Runner trait docs.

Executes Scenarios concurrently based on the custom function, which returns ScenarioType. Also, can limit maximum number of concurrent Scenarios.

Implementations

impl<World, Which, Before, After> Basic<World, Which, Before, After>

pub fn max_concurrent_scenarios(self, max: impl Into<Option<usize>>) -> Self

If max is Some, then number of concurrently executed Scenarios will be limited.

pub fn retries(self, retries: impl Into<Option<usize>>) -> Self

If retries is Some, then failed Scenarios will be retried specified number of times.

pub fn retry_after(self, after: impl Into<Option<Duration>>) -> Self

If after is Some, then failed Scenarios will be retried after the specified Duration.

pub fn retry_filter(
    self,
    tag_expression: impl Into<Option<TagOperation>>
) -> Self

If filter is Some, then failed Scenarios will be retried only if they’re matching the specified tag_expression.

pub const fn fail_fast(self) -> Self

Makes stop running tests on the first failure.

NOTE: All the already started Scenarios at the moment of failure will be finished.

NOTE: Retried Scenarios are considered as failed, only in case they exhaust all retry attempts and still fail.

pub fn which_scenario<F>(self, func: F) -> Basic<World, F, Before, After>where
    F: Fn(&Feature, Option<&Rule>, &Scenario) -> ScenarioType + 'static,

Function determining whether a Scenario is Concurrent or a Serial one.

pub fn retry_options<R>(self, func: R) -> Selfwhere
    R: Fn(&Feature, Option<&Rule>, &Scenario, &Cli) -> Option<RetryOptions> + 'static,

Function determining Scenario’s RetryOptions.

pub fn before<Func>(self, func: Func) -> Basic<World, Which, Func, After>where
    Func: for<'a> Fn(&'a Feature, Option<&'a Rule>, &'a Scenario, &'a mut World) -> LocalBoxFuture<'a, ()>,

Sets a hook, executed on each Scenario before running all its Steps, including Background ones.

pub fn after<Func>(self, func: Func) -> Basic<World, Which, Before, Func>where
    Func: for<'a> Fn(&'a Feature, Option<&'a Rule>, &'a Scenario, &'a ScenarioFinished, Option<&'a mut World>) -> LocalBoxFuture<'a, ()>,

Sets hook, executed on each Scenario after running all its Steps, even after Skipped of Failed ones.

Last World argument is supplied to the function, in case it was initialized before by running before hook or any Step.

pub fn steps(self, steps: Collection<World>) -> Self

Sets the given Collection of Steps to this Runner.

pub fn given(self, regex: Regex, step: Step<World>) -> Self

Adds a Given Step matching the given regex.

pub fn when(self, regex: Regex, step: Step<World>) -> Self

Adds a When Step matching the given regex.

pub fn then(self, regex: Regex, step: Step<World>) -> Self

Adds a Then Step matching the given regex.

Trait Implementations

impl<World, F: Clone, B: Clone, A: Clone> Clone for Basic<World, F, B, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<World, F, B, A> Debug for Basic<World, F, B, A>

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

Formats the value using the given formatter.

impl<World> Default for Basic<World>

fn default() -> Self

Returns the “default value” for a type.

impl<W, Which, Before, After> Runner<W> for Basic<W, Which, Before, After>where
    W: World,
    Which: Fn(&Feature, Option<&Rule>, &Scenario) -> ScenarioType + 'static,
    Before: for<'a> Fn(&'a Feature, Option<&'a Rule>, &'a Scenario, &'a mut W) -> LocalBoxFuture<'a, ()> + 'static,
    After: for<'a> Fn(&'a Feature, Option<&'a Rule>, &'a Scenario, &'a ScenarioFinished, Option<&'a mut W>) -> LocalBoxFuture<'a, ()> + 'static,

type Cli = Cli

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

type EventStream = Pin<Box<dyn Stream<Item = Result<Event<Cucumber<W>>, Error>> + 'static, Global>>

Output events [Stream].

fn run<S>(self, features: S, cli: Cli) -> Self::EventStreamwhere
    S: Stream<Item = Result<Feature>> + 'static,

Executes the given [Stream] of Features transforming it into a [Stream] of executed Cucumber events.