Rust Unit Testing

What is Unit Testing in Rust?

Unit testing is the process of testing individual functions or methods in isolation to verify their correctness. In Rust:

1. Unit tests are written inside the same file as the code being tested.
2. These tests are kept in a separate module, annotated with #[cfg(test)].
3. Rust provides built-in macros like assert!, assert_eq! and assert_ne! to make testing straightforward.

Why Use Unit Testing?

1. Catch Bugs Early: Detect issues in specific functions before they affect the entire program.
2. Ensure Code Reliability: Verify that your code behaves as expected in different scenarios.
3. Improve Maintainability: Changes in the codebase are easier to manage with reliable tests.

How to Write Unit Tests in Rust

Unit tests are written in a dedicated module within the same file as the code being tested. Here’s the basic structure:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_name() {
        // Test logic here
    }
}

Example: Writing a Basic Unit Test

Function to Test

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Unit Test

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5); // Passes if add(2, 3) equals 5
    }
}

Explanation:

• #[cfg(test)]: Indicates that this module is only compiled during testing.
• #[test]: Marks the function as a test case.
• assert_eq!: Checks if two values are equal. If they’re not, the test fails.

Testing Error Scenarios

You can write tests to verify that functions handle errors correctly using Rust’s Result type.

Example: Function Returning a Result

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_divide_success() {
        assert_eq!(divide(10, 2), Ok(5)); // Passes
    }

    #[test]
    fn test_divide_error() {
        assert_eq!(divide(10, 0), Err(String::from("Cannot divide by zero"))); // Passes
    }
}

Testing Panics

To test code that should panic, use the #[should_panic] attribute.

Example: Testing a Panic

fn will_panic() {
    panic!("This function always panics");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[should_panic]
    fn test_panic() {
        will_panic(); // Passes because it panics
    }
}

Explanation:

• #[should_panic]: Passes the test if the function panics.

Running Unit Tests

You can run unit tests using the cargo test command:

cargo test

Output Example

running 2 tests
test tests::test_add ... ok
test tests::test_not_equal ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Ignoring Tests

Sometimes, you may want to skip running certain tests temporarily. Use the #[ignore] attribute for this purpose.

Example: Ignored Test

#[test]
#[ignore]
fn test_ignored() {
    assert_eq!(1 + 1, 2);
}

Run ignored tests explicitly using:

cargo test -- --ignored

Advantages of Unit Testing

1. Early Bug Detection: Identifies errors in isolated components before integration.
2. Improved Refactoring: Makes it easier to modify code without breaking functionality.
3. Better Code Documentation: Tests act as a form of documentation for expected behavior.

When to Use Unit Testing?

• Testing simple, reusable functions like add, divide, etc.
• Verifying algorithms or logic in isolation.
• Ensuring that edge cases are handled correctly.