Struct RuleTester 

pub struct RuleTester { /* private fields */ }

A rule under test, with a throwaway project to run it in.

The project is removed when the tester is dropped.

Implementations

impl RuleTester

pub fn new(name: &str, rule_source: &str) -> Result<Self, TestError>

Build a tester for a rule’s source.

name labels the temporary directory and need not be unique — every tester gets its own directory regardless, so a test file with a fn tester() helper shared across cases works. It has to: two testers sharing a directory would delete each other’s project mid-run, and the resulting error would point at the config rather than at the collision.

Errors

Returns TestError::Setup if the temporary project cannot be written.

pub fn with_extension( name: &str, rule_source: &str, extension: &str, ) -> Result<Self, TestError>

Build a tester whose subject files use a given extension.

Needed for a rule targeting tsx, since which grammar parses a file is decided by its extension — a TSX rule tested against a .ts file would never match.

Errors

As RuleTester::new.

pub fn configured( name: &str, rule_source: &str, options: &str, ) -> Result<Self, TestError>

Build a tester for a factory rule — one whose default export returns a rule when called with options — using the given options expression.

options is JavaScript, spliced into the generated config as rule(<options>). Passing the options as source rather than as a serialized value is deliberate: a factory takes whatever its author designed, and a harness that only accepted JSON could not test one taking a function or a regular expression.

let tester = RuleTester::configured(
    "restricted",
    RULE_SOURCE,
    "{ restrictions: [{ module: 'lodash' }] }",
)
.expect("builds");

Errors

As RuleTester::new.

pub fn run(&self, source: &str) -> Result<Vec<Violation>, TestError>

Run the rule over a single source file and return what it reported.

Errors

Returns TestError::Load if the rule does not load, or TestError::Run if it throws or breaches a budget.

pub fn accepts(&self, source: &str) -> Result<(), TestError>

Assert the rule reports nothing for this source.

Errors

Returns TestError::Mismatch listing what was reported, since “expected none, got some” is only actionable if you can see which.

pub fn reports_at( &self, source: &str, expected: &[(u32, u32)], ) -> Result<(), TestError>

Assert the rule reports at exactly these one-based positions, in order.

Positions rather than a count, because a rule reporting the right number of violations in the wrong places is a rule that is wrong — and a count-only assertion is exactly what lets that through.

Errors

Returns TestError::Mismatch showing expected and actual side by side.

pub fn reports_messages( &self, source: &str, expected: &[&str], ) -> Result<(), TestError>

Assert the rule reports exactly these messages, in order.

For a rule that substitutes its own message per match — the position alone would not show whether the right one was chosen.

Errors

Returns TestError::Mismatch showing both lists.

Trait Implementations

impl Debug for RuleTester

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

Formats the value using the given formatter.

impl Drop for RuleTester

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.