How to run setup code before any tests run in Rust?

In Rust, if you want to run some setup code before executing any tests, you can use several different approaches. Rust does not provide a built-in testing framework feature like some other languages do to support before-all test setup. However, we can leverage some strategies to achieve this. Here are some ways to implement this functionality:

1. Using the lazy_static Macro for Initialization

lazy_static is a crate that allows you to define static variables initialized the first time they are accessed during program runtime. This can be used to execute setup code before the first test runs.

First, add the lazy_static dependency to your Cargo.toml:

toml
[dependencies]
lazy_static = "1.4"

Then, in your test module, use it as follows:

rust
#[cfg(test)]
mod tests {
    use lazy_static::lazy_static;

    lazy_static! {
        static ref SETUP: () = {
            println!("Performing global initialization...");
            // Execute your setup code here
        };
    }

    #[test]
    fn test1() {
        println!("Executing test1");
        // Trigger SETUP before use
        let _ = &*SETUP;
    }

    #[test]
    fn test2() {
        println!("Executing test2");
        // Trigger SETUP before use
        let _ = &*SETUP;
    }
}

In the above example, the SETUP static variable is defined by the lazy_static macro and accessed in each test to ensure the setup code executes. The drawback is that you must explicitly trigger initialization in each test.

2. Using a Test Configuration Function

Although Rust does not directly support executing code before all tests run, you can simulate this behavior by writing a configuration function and calling it before each test. This is less automatic than lazy_static but provides more explicit control:

rust
#[cfg(test)]
mod tests {
    fn setup() {
        println!("Performing global initialization...");
        // Execute your setup code here
    }

    #[test]
    fn test1() {
        setup();
        println!("Executing test1");
        // Test code
    }

    #[test]
    fn test2() {
        setup();
        println!("Executing test2");
        // Test code
    }
}

Summary

Both methods have pros and cons. The lazy_static approach ensures global initialization code runs only once, while manually calling the configuration function provides better visibility and direct control. Choose the appropriate method based on your test requirements and personal preference. If the global state does not need resetting between tests, lazy_static may be preferable. If you prefer each test to start from a clean state, manually calling the initialization function is more suitable.