Crate serial_test 

serial_test

serial_test allows for the creation of serialised Rust tests using the serial attribute e.g.

#[test]
#[serial]
fn test_serial_one() {
  // Do things
}

#[test]
#[serial(some_key)]
fn test_serial_another() {
  // Do things
}

#[test]
#[parallel]
fn test_parallel_another() {
  // Do parallel things
}

Multiple tests with the serial attribute are guaranteed to be executed in serial. Ordering of the tests is not guaranteed however. Other tests with the parallel attribute may run at the same time as each other, but not at the same time as a test with serial. Tests with neither attribute may run at any time and no guarantees are made about their timing!

For cases like doctests and integration tests where the tests are run as separate processes, we also support file_serial/file_parallel, with similar properties but based off file locking. Note that there are no guarantees about one test with serial/parallel and another with file_serial/file_parallel as they lock using different methods.

#[test]
#[file_serial]
fn test_serial_three() {
  // Do things
}

All of the attributes can also be applied at a mod level and will be automagically applied to all test functions in that block

#[cfg(test)]
#[serial]
mod serial_attr_tests {
    fn foo() {
        // Won't have `serial` applied, because not a test function
        println!("Nothing");
    }

    #[test]
    fn test_bar() {
       // Will be run serially
    }
}

All of the attributes support an optional crate argument for other macros generating the attributes, which lets them re-export the serial_test crate and supply an import path. This defaults to assuming it can just import serial_test for the use of internal functions. Note this is crate = <import-path> not crate => <import-path> unlike the path in file_serial for historical reasons

// Assuming wrapper::refs:serial is a re-export of serial_test
#[test]
#[serial(crate = wrapper::refs:serial)]
fn test_generated() {
  // Do things
}

Feature flags

• logging (enabled by default) — Switches on debug logging
• async (enabled by default) — Enables async features using futures
• file_locks — The file_locks feature unlocks the file_serial/file_parallel macros

Internal-only features

• test_logging — Switches on debug with env_logger. Generally only needed by internal serial_test work.

Functions

is_locked_file_seriallyfile_locks

Check if the current thread is holding a file_serial lock

is_locked_serially

Check if the current thread is holding a serial lock

Attribute Macros

file_parallelfile_locks

Allows for the creation of file-serialised parallel Rust tests that won’t clash with file-serialised serial tests

file_serialfile_locks

Allows for the creation of file-serialised Rust tests

parallel

Allows for the creation of parallel Rust tests that won’t clash with serial tests

serial

Allows for the creation of serialised Rust tests