Declarative Testing Framework

Demonstrate allows tests to be written without as a much repetitive code within the demonstrate! macro, which will generate the corresponding full tests.

This testing library is highly influenced by speculate.rs and ruspec which both take inspiration from RSpec.

The following new block definitions are utilized by Demonstrate:

• before/after — A block of source code that will be included at the start or end of each test respectively in the current and nested describe/context blocks.

• describe/context/given/when — describe, context, given, when are aliases for eachother. Specifies a new scope of tests which can contain a before and/or after block, nested describe/context blocks, and it/test blocks. These translate to Rust mod blocks, but also allow for shared test properties to be defined such as tests having outer attributes, being async, and having Return<()> types.

• it/test/then — it, test and then are aliases for eachother. Represents one test that translate to a Rust unit test.

Example

use demonstrate::demonstrate;

fn is_4() -> u8 {
    4
}

demonstrate! {
    describe "module" {
        use super::*;

        before {
            let four = 4;
        }

        #[should_panic]
        it "can fail" {
            assert!(four != 4)
        }

        test "is returnable" -> Result<(), &'static str> {
            if is_4() == four {
                Ok(())
            } else {
                Err("It isn't 4! :o")
            }
        }

        #[async_attributes::test]
        async context "asynchronous" {
            before {
                let is_4_task = async_std::task::spawn(async {
                    is_4()
                });
            }

            it "awaits" {
                assert_eq!(four, is_4_task.await)
            }
        }
    }
}

License

^{Licensed under MIT license.}