🥮 mooncakes.io
    Sign in

    moonrockz/moonspec/runner does not have a README file

    FeatureCache

    source
    pub struct FeatureCache {
      // private fields
    }

    In-memory cache of parsed Gherkin features, keyed by path. Mutation is controlled — only load_* methods can add entries.

    FeatureCache::contains

    source
    fn FeatureCache::contains(self : FeatureCache, path : String) -> Bool

    Check if a path is cached.

    FeatureCache::features

    source

    Return all cached features as (path, feature) pairs.

    FeatureCache::get

    source

    Look up a cached feature by path.

    FeatureCache::length

    source
    fn FeatureCache::length(self : FeatureCache) -> Int

    Number of cached features.

    FeatureCache::load_file

    source
    fn FeatureCache::load_file(self : FeatureCache, path : String) -> Unit raise

    Load a feature from a file path. Idempotent — skips if already cached.

    FeatureCache::load_from_source

    source
    fn FeatureCache::load_from_source(self : FeatureCache, source : FeatureSource) -> Unit raise

    Load a feature from any FeatureSource variant.

    FeatureCache::load_parsed

    source
    fn FeatureCache::load_parsed(self : FeatureCache, path : String, feature : 
    Feature    ) -> Unit

    Store a pre-parsed feature directly.

    FeatureCache::load_text

    source
    fn FeatureCache::load_text(self : FeatureCache, path : String, content : String) -> Unit raise

    Load a feature from inline text. Always overwrites existing entry.

    FeatureCache::new

    source

    Create an empty feature cache.

    FeatureResult

    source
    pub(all) struct FeatureResult {
      name : String
      scenarios : Array[ScenarioResult]
      duration_ms : Int64
    }

    Result of executing a feature.

    FeatureSource

    source
    pub(all) enum FeatureSource {
      Text(String, String)
      File(String)
      Parsed(String, 
    Feature    )
    }

    Input source for a feature to be loaded into the cache.
    impl Eq for FeatureSource

    PickleFilter

    source
    pub struct PickleFilter {
      tag_expression : TagExpression
      scenario_names : Array[String]
    }

    Filter compiled pickles by tags, names, or URI+line.

    PickleFilter::apply

    source

    Apply all active filters. Filters are AND'd.

    PickleFilter::new

    source

    PickleFilter::with_names

    source
    fn PickleFilter::with_names(self : PickleFilter, names : Array[String]) -> PickleFilter

    PickleFilter::with_tags

    source
    fn PickleFilter::with_tags(self : PickleFilter, expr : String) -> PickleFilter raise

    RunResult

    source
    pub(all) struct RunResult {
      features : Array[FeatureResult]
      summary : RunSummary
    }

    Complete result of a test run.
    impl Show for RunResult

    RunSummary

    source
    pub(all) struct RunSummary {
      total_scenarios : Int
      passed : Int
      failed : Int
      undefined : Int
      pending : Int
      skipped : Int
      duration_ms : Int64
    }

    Summary of an entire run.
    impl Eq for RunSummary
    impl Show for RunSummary

    ScenarioResult

    source
    pub(all) struct ScenarioResult {
      feature_name : String
      scenario_name : String
      pickle_id : String
      tags : Array[String]
      steps : Array[StepResult]
      status : ScenarioStatus
      duration_ms : Int64
    }

    Result of executing a scenario.

    ScenarioStatus

    source
    pub(all) enum ScenarioStatus {
      Passed
      Failed
      Skipped
      Undefined
      Pending
    }

    Aggregate status of a scenario.

    ScenarioStatus::from_steps

    source
    fn ScenarioStatus::from_steps(steps : Array[StepStatus]) -> ScenarioStatus

    Derive scenario status from step statuses.

    StepResult

    source
    pub(all) struct StepResult {
      text : String
      keyword : String
      status : StepStatus
      duration_ms : Int64
      diagnostic : Error?
    }

    Result of executing a single step.
    impl Show for StepResult

    StepStatus

    source
    pub(all) enum StepStatus {
      Passed
      Failed(String)
      Skipped
      Undefined
      Pending
    }

    Status of a single step execution.
    impl Eq for StepStatus
    impl Show for StepStatus

    StepStatus::is_passed

    source
    fn StepStatus::is_passed(self : StepStatus) -> Bool

    Check if a step passed.

    TagExpression

    source
    pub(all) enum TagExpression {
      TagLiteral(String)
      Not(TagExpression)
      And(TagExpression, TagExpression)
      Or(TagExpression, TagExpression)
      Always
    }

    A boolean expression over tags, supporting and, or, not, parentheses, and bare @tag literals.
    impl Eq for TagExpression

    TagExpression::matches

    source
    fn TagExpression::matches(self : TagExpression, tags : Array[String]) -> Bool

    Evaluate whether this expression matches a given set of tags.

    TagExpression::parse

    source
    fn TagExpression::parse(input : String) -> TagExpression raise

    Parse a tag expression string into a TagExpression AST. An empty string yields Always which matches any set of tags.

    compile_pickles

    source

    Compile all cached features into Pickle instances. This is the main entry point for the pickle compiler.

    execute_scenario

    source
    fn execute_scenario(registry : 
    StepRegistry    , feature_name~ : String, scenario_name~ : String, pickle_id~ : String, tags~ : Array[String], steps~ : Array[
    PickleStep    ]) -> ScenarioResult

    Execute a single scenario from a compiled Pickle.

    execute_scenario_with_hooks

    source
    fn[W : 
    Hooks    ] execute_scenario_with_hooks(world : W, registry : 
    StepRegistry    , feature_name~ : String, scenario_name~ : String, pickle_id~ : String, tags~ : Array[String], steps~ : Array[
    PickleStep    ]) -> ScenarioResult

    Execute a single scenario with lifecycle hooks. Calls before/after_scenario and before/after_step on the world.

    run

    source
    async fn[W : 
    World    ] run(factory : () -> W, features : Array[FeatureSource], tag_expr? : String, scenario_name? : String, parallel? : Int) -> RunResult

    Run all features and collect results.

    A fresh world is created per scenario via factory() for isolation. When parallel is greater than 0, pickles are executed concurrently using @async.all() with bounded concurrency. Otherwise, pickles run sequentially.

    run_or_fail

    source
    async fn[W : 
    World    ] run_or_fail(factory : () -> W, features : Array[FeatureSource], tag_expr? : String, scenario_name? : String, parallel? : Int) -> RunResult

    Run all features, raising MoonspecError on any failure.

    This is the ergonomic test API. Use in generated tests and manual tests where you want structured error output instead of manual result inspection.

    run_with_hooks

    source
    async fn[W : 
    World     + 
    Hooks    ] run_with_hooks(factory : () -> W, features : Array[FeatureSource], tag_expr? : String, scenario_name? : String, parallel? : Int) -> RunResult

    Run all features with lifecycle hooks and collect results.

    Like run, but calls before/after_scenario and before/after_step hooks on the world. The world must implement both World and Hooks traits.

    runner_version

    source
    fn runner_version() -> String

    moonspec runner — Scenario execution and lifecycle.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io