spectacular 0.1.0

Spectacular gives your Rust tests three layers of hooks that stack in a predictable order:

Installation

[dev-dependencies]
spectacular = "0.1"

Quick Start

RSpec-style DSL

use spectacular::spec;

spec! {
    mod arithmetic {
        it "adds two numbers" {
            assert_eq!(2 + 2, 4);
        }

        it "multiplies two numbers" {
            assert_eq!(3 * 7, 21);
        }
    }
}

Attribute style

use spectacular::{test_suite, test_case};

#[test_suite]
mod arithmetic {
    #[test_case]
    fn adds_two_numbers() {
        assert_eq!(2 + 2, 4);
    }

    #[test_case]
    fn multiplies_two_numbers() {
        assert_eq!(3 * 7, 21);
    }
}

Hooks

Group hooks

Group hooks run within a single test module. before runs once before the first test; after runs once after the last test. before_each and after_each run around every test.

use spectacular::spec;
use std::sync::atomic::{AtomicBool, Ordering};

static READY: AtomicBool = AtomicBool::new(false);

spec! {
    mod with_hooks {
        use super::*;

        before { READY.store(true, Ordering::SeqCst); }
        after  { /* cleanup */ }
        before_each { /* per-test setup */ }
        after_each  { /* per-test teardown */ }

        it "runs after setup" {
            assert!(READY.load(Ordering::SeqCst));
        }
    }
}

Suite hooks (3-layer)

Suite hooks run across all opted-in groups. Place suite! as a sibling of your test groups, then opt in with suite; (DSL) or #[test_suite(suite)] (attribute style):

use spectacular::{suite, spec};
use std::sync::atomic::{AtomicBool, Ordering};

static DB_READY: AtomicBool = AtomicBool::new(false);

suite! {
    before      { DB_READY.store(true, Ordering::SeqCst); }
    before_each { /* per-test transaction */ }
    after_each  { /* rollback */ }
}

spec! {
    mod database_tests {
        use super::*;
        suite;

        it "has database access" {
            assert!(DB_READY.load(Ordering::SeqCst));
        }
    }
}

Groups without suite; skip the suite layer entirely -- no runtime cost, no coupling.

Hook Execution Order

For each test in a group that opts into suite hooks:

suite::before            (Once -- first test in binary triggers it)
  group::before          (Once -- first test in group triggers it)
    suite::before_each
      group::before_each
        TEST
      group::after_each
    suite::after_each
  group::after           (countdown -- last test in group triggers it)

After-hooks are protected by catch_unwind, so cleanup runs even if a test panics.

Attribute Style Reference

License

MIT -- see LICENSE for details.