Write feature files

Feature: Lantern delivery
  Scenario: Deliver a lantern
    Given a lantern on the trolley
    When the departure bell rings
    Then the lantern arrives upright

Feature: Packing the hamper
  Background:
    Given an empty hamper

  Scenario: Pack the picnic
    When the following items are packed:
      | item       | quantity | fragile |
      | shortbread | 12       | no      |
      | teapot     | 1        | yes     |
      | lantern    | 2        | yes     |
    Then the hamper holds 15 items
    And 2 kinds of item need careful handling

  Scenario: Leave a note on top
    When a note is tucked under the lid:
      """
      Back by dusk.
      Save Marrow a biscuit.
      """
    Then the note mentions "biscuit"

//! A `DataTableRow` struct binding a Gherkin data table, and a step that
//! captures a doc string as a plain `String` argument.

use rstest::fixture;
use rstest_bdd::datatable::Rows;
use rstest_bdd_macros::{DataTableRow, given, scenario, then, when};

#[derive(Debug, DataTableRow)]
struct Item {
    item: String,
    quantity: u32,
    #[datatable(truthy)]
    fragile: bool,
}

#[derive(Default)]
struct Hamper {
    items: Vec<Item>,
    note: String,
}

#[fixture]
fn hamper() -> Hamper {
    Hamper::default()
}

#[given("an empty hamper")]
fn empty(hamper: &mut Hamper) {
    hamper.items.clear();
}

#[when("the following items are packed:")]
fn pack(hamper: &mut Hamper, #[datatable] rows: Rows<Item>) {
    hamper.items.extend(rows);
}

#[then("the hamper holds {total:u32} items")]
fn holds(hamper: &Hamper, total: u32) {
    let packed: u32 = hamper.items.iter().map(|row| row.quantity).sum();
    assert_eq!(packed, total);
}

#[then("{kinds:usize} kinds of item need careful handling")]
fn fragile(hamper: &Hamper, kinds: usize) {
    let careful: Vec<&str> = hamper
        .items
        .iter()
        .filter(|row| row.fragile)
        .map(|row| row.item.as_str())
        .collect();
    assert_eq!(careful.len(), kinds, "fragile: {careful:?}");
}

#[when("a note is tucked under the lid:")]
fn tuck(hamper: &mut Hamper, docstring: String) {
    hamper.note = docstring;
}

#[then("the note mentions \"{word}\"")]
fn mentions(hamper: &Hamper, word: String) {
    assert!(hamper.note.contains(&word), "note: {:?}", hamper.note);
}

#[scenario(path = "tests/features/hamper.feature", name = "Pack the picnic")]
fn pack_the_picnic(hamper: Hamper) {
    let _ = hamper;
}

#[scenario(path = "tests/features/hamper.feature", name = "Leave a note on top")]
fn leave_a_note(hamper: Hamper) {
    let _ = hamper;
}

Feature: Counting lanterns
  Scenario Outline: Deliver <count> lanterns
    Given a trolley carrying <count> lanterns
    When the departure bell rings
    Then <count> lanterns arrive at the picnic

    Examples:
      | count |
      | 1     |
      | 2     |
      | 0     |

Feature: Picnic weather
  @smoke
  Scenario: A dry evening
    Given the forecast is "dry"
    Then the blanket goes on the grass

  @wip
  Scenario: Fog over the loch
    Given the forecast is "fog"
    Then the lanterns are lit early

  @smoke @allow_skipped
  Scenario: Thunder in the hills
    Given the forecast is "thunder"
    Then the blanket goes on the grass

# language: fr
Fonctionnalité: Le pique-nique aux lanternes
  Scénario: Livrer une lanterne
    Soit une lanterne sur le chariot
    Quand la cloche du départ sonne
    Alors la lanterne arrive debout

//! A scenario written in French, exercising the `# language: fr` Gherkin
//! header and its Soit/Quand/Alors keywords.

use rstest::fixture;
use rstest_bdd_macros::{given, scenario, then, when};

#[derive(Default)]
struct Chariot {
    debout: bool,
    arrive: bool,
}

#[fixture]
fn chariot() -> Chariot {
    Chariot::default()
}

#[given("une lanterne sur le chariot")]
fn charger(chariot: &mut Chariot) {
    chariot.debout = true;
}

#[when("la cloche du départ sonne")]
fn partir(chariot: &mut Chariot) {
    chariot.arrive = true;
}

#[then("la lanterne arrive debout")]
fn verifier(chariot: &Chariot) {
    assert!(chariot.arrive && chariot.debout);
}

#[scenario(path = "tests/features/pique_nique.feature")]
fn livrer_une_lanterne(chariot: Chariot) {
    let _ = chariot;
}