Struct Bindings 

pub struct Bindings<W> {
    pub world: W,
    /* private fields */
}

Fields

world: W

Implementations

impl<W> Bindings<W>

pub fn new(world: W) -> Self

pub fn fresh(self, services: &[&str]) -> Self

The services to start afresh before each test (a subset of those it needs).

pub fn needs(self, services: &[&str]) -> Self

The external services these bindings need (see crate::service).

pub fn observe<V: Into<Value>>( self, subject: &str, f: impl FnMut(&W) -> V + 'static, ) -> Self

How to read a state. Subjects match the vocabulary ignoring case and a leading “the”.

pub fn set(self, subject: &str, f: impl FnMut(&mut W, &Value) + 'static) -> Self

How to change a state, as an action and (unless Bindings::arrange says otherwise) when arranging the start.

pub fn arrange( self, subject: &str, f: impl FnMut(&mut W, &Value) + 'static, ) -> Self

How to put a state in place before the first step, when that differs from Bindings::set.

pub fn on(self, event: &str, f: impl FnMut(&mut W) + 'static) -> Self

pub fn on_reset(self, f: impl FnMut(&mut W) + 'static) -> Self

pub fn on_settle(self, f: impl FnMut(&mut W) + 'static) -> Self

pub fn on_advance(self, f: impl FnMut(&mut W) -> Progress + 'static) -> Self

pub fn on_screenshot(self, f: impl FnMut(&W) -> Screenshot + 'static) -> Self

Trait Implementations

impl<W> Driver for Bindings<W>

fn needs(&self) -> Vec<String>

The external services this driver needs for its tests (see crate::service): a controller, a database. The runner starts them before a plan, and when one cannot be had here the plans are “not supported yet”, with what to do about it.

fn fresh(&self) -> Vec<String>

The services that must be started afresh before each test (a database the last test wrote to): a subset of Driver::needs.

fn reset(&mut self) -> Result<(), String>

Put the system in its starting state (what the Background describes), before each test.

fn arrange(&mut self, var: &Variable, value: &Value) -> Result<(), String>

Make var hold value before the first step (“Given …”).

fn set(&mut self, var: &Variable, value: &Value) -> Result<(), String>

Make var hold value as an action (“When the dial is 80 %”).

fn perform(&mut self, event: &Event) -> Result<(), String>

Make event happen (“When the user presses reset”).

fn observe(&mut self, var: &Variable) -> Result<Value, String>

What var is now. Enumerated values are matched to the vocabulary ignoring case.

fn settle(&mut self)

Let the system settle after an action, before anything is observed: long enough for what should happen to happen, and for what shouldn’t to show. Without it, “Then the kettle is off” could pass in the instant before it switches on.

fn advance(&mut self) -> Progress

Let a little time pass before the runner observes again.

fn screenshot(&mut self) -> Result<Option<Screenshot>, String>

fn supports(&self, need: Need<'_>) -> bool

Can it do need? The runner checks every plan up front, so a missing binding fails the test before it starts instead of halfway through.

fn can_arrange(&self, var: &Variable, value: &Value) -> bool

Can it put var in value to start a test? Driver::supports only knows the state; a driver that can arrange some of its values and not others (a test account that can’t be emptied can’t start with no messages) says so here, and the tests that need the rest are “not supported yet” instead of failing.