Enum ExecutionError 

#[non_exhaustive]
pub enum ExecutionError {
    Skip {
        message: Option<String>,
    },
    StepNotFound {
        index: usize,
        keyword: StepKeyword,
        text: String,
        feature_path: String,
        scenario_name: String,
    },
    MissingFixtures(Arc<MissingFixturesDetails>),
    HandlerFailed {
        index: usize,
        keyword: StepKeyword,
        text: String,
        error: Arc<StepError>,
        feature_path: String,
        scenario_name: String,
    },
}

Error type for step execution failures.

This enum captures all failure modes during step execution, distinguishing between control flow signals (skip requests) and actual errors (missing steps, fixture validation failures, handler errors).

Variants

• Skip: Control flow signal indicating the step requested skipping. This is not an error condition but a deliberate execution path.
• StepNotFound: The step pattern was not found in the registry.
• MissingFixtures: Required fixtures were not available in the context.
• HandlerFailed: The step handler returned an error.

Examples

use rstest_bdd::execution::ExecutionError;

let error = ExecutionError::Skip { message: Some("not implemented yet".into()) };
assert!(error.is_skip());
assert_eq!(error.skip_message(), Some("not implemented yet"));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Skip

Step requested to skip execution.

Fields

message: Option<String>

Optional message explaining why the step was skipped.

StepNotFound

Step pattern not found in the registry.

Fields

index: usize

Zero-based step index.

keyword: StepKeyword

The step keyword (Given, When, Then, etc.).

text: String

The step text that was not found.

feature_path: String

Path to the feature file.

scenario_name: String

Name of the scenario.

MissingFixtures(Arc<MissingFixturesDetails>)

Required fixtures missing from context.

The details are wrapped in Arc to reduce the size of Result<T, ExecutionError>.

HandlerFailed

Step handler returned an error.

Fields

index: usize

Zero-based step index.

keyword: StepKeyword

The step keyword (Given, When, Then, etc.).

text: String

The step text.

error: Arc<StepError>

The error returned by the handler, wrapped in Arc for Clone.

feature_path: String

Path to the feature file.

scenario_name: String

Name of the scenario.

Implementations

impl ExecutionError

pub fn is_skip(&self) -> bool

Returns true if this error represents a skip request.

Skip requests are control flow signals, not actual errors. Use this method to distinguish between errors that should fail a test and skip signals that should mark the test as skipped.

Examples

use rstest_bdd::execution::ExecutionError;

let skip = ExecutionError::Skip { message: None };
assert!(skip.is_skip());

let not_found = ExecutionError::StepNotFound {
    index: 0,
    keyword: rstest_bdd::StepKeyword::Given,
    text: "missing".into(),
    feature_path: "test.feature".into(),
    scenario_name: "test".into(),
};
assert!(!not_found.is_skip());

pub fn skip_message(&self) -> Option<&str>

Returns the skip message if this is a skip error.

Returns None if this is not a skip error, or if the skip has no message.

Examples

use rstest_bdd::execution::ExecutionError;

let skip_with_msg = ExecutionError::Skip { message: Some("reason".into()) };
assert_eq!(skip_with_msg.skip_message(), Some("reason"));

let skip_no_msg = ExecutionError::Skip { message: None };
assert_eq!(skip_no_msg.skip_message(), None);

let not_skip = ExecutionError::StepNotFound {
    index: 0,
    keyword: rstest_bdd::StepKeyword::Given,
    text: "missing".into(),
    feature_path: "test.feature".into(),
    scenario_name: "test".into(),
};
assert_eq!(not_skip.skip_message(), None);

impl ExecutionError

pub fn format_with_loader(&self, loader: &FluentLanguageLoader) -> String

Render the error message using the provided Fluent loader.

This allows formatting the error using a specific locale loader rather than the global default. This is useful when you need consistent locale handling across nested error types.

Examples

use i18n_embed::fluent::fluent_language_loader;
use unic_langid::langid;
use rstest_bdd::execution::ExecutionError;

let loader = {
    use i18n_embed::LanguageLoader;
    use rstest_bdd::Localizations;
    let loader = fluent_language_loader!();
    i18n_embed::select(&loader, &Localizations, &[langid!("en-US")])
        .expect("en-US locale should always be available");
    loader
};
let error = ExecutionError::Skip { message: Some("not implemented".into()) };
let message = error.format_with_loader(&loader);
assert!(message.contains("skipped"));
assert!(message.contains("not implemented"));

Trait Implementations

impl Clone for ExecutionError

fn clone(&self) -> ExecutionError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionError

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

Formats the value using the given formatter.

impl Display for ExecutionError

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

Formats the value using the given formatter.

impl Error for ExecutionError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.