Crate test_env_helpers

Some setup and teardown macro helpers to mimic Jest’s setup and teardown functionality. Also includes a skip macro that mimics the skip functionality in Jest.

There are currently five macros provided: after_all, after_each, before_all, before_each, and skip. I would like to implement only to match Jest’s only functionality. I’m unsure of a great way to do that currently, however.

Getting Started

Using these macros is fairly simple. The four after/before functions all require a function with the same name as the attribute and are only valid when applied to a mod. They are all used like in the below example. Replace before_each with whichever method you want to use. The code in the matching function will be inserted into every fn in the containing mod that has an attribute with the word “test” in it. This is to allow for use with not just normal #[test] attributes, but also other flavors like #[tokio::test] and #[test_case(0)].

#[cfg(test)]
use test_env_helpers::*;

#[before_each]
#[cfg(test)]
mod my_tests{
    fn before_each(){println!("I'm in every test!")}
    #[test]
    fn test_1(){}
    #[test]
    fn test_2(){}
    #[test]
    fn test_3(){}
}

The skip macro is valid on either a mod or an individual test and will remove the mod or test it is applied to. You can use it to skip tests that aren’t working correctly or that you don’t want to run for some reason.

#[cfg(test)]
use test_env_helpers::*;

#[cfg(test)]
mod my_tests{
    #[skip]
    #[test]
    fn broken_test(){panic!("I'm hella broke")}
    #[skip]
    mod broken_mod{
        #[test]
        fn i_will_not_be_run(){panic!("I get skipped too")}
    }
    #[test]
    fn test_2(){}
    #[test]
    fn test_3(){}
}

Attribute Macros

after_all

Will run the code in the matching after_all function exactly once when all of the tests have run. This works by counting the number of #[test] attributes and decrementing a counter at the beginning of every test. Once the counter reaches 0, it will run the code in after_all. It uses std::sync::Once internally to ensure that the code is run at maximum one time.

after_each

Will run the code in the matching after_each function at the end of every #[test] function. Useful if you want to cleanup after a test or reset some external state. If the test panics, this code will not be run. If you need something that is infallible, you should use before_each instead.

before_all

Will run the code in the matching before_all function exactly once at the very beginning of a test run. It uses std::sync::Once internally to ensure that the code is run at maximum one time. Useful for setting up some external state that will be reused in multiple tests.

before_each

Will run the code in the matching before_each function at the beginning of every test. Useful to reset state to ensure that a test has a clean slate.

skip

Will skip running the code it is applied on. You can use it to skip tests that aren’t working correctly or that you don’t want to run for some reason. There are no checks to make sure it’s applied to a #[test] or mod. It will remove whatever it is applied to from the final AST.