Тестирование в Rust: #[test] и интеграционные тесты

1// src/lib.rs
2pub fn add(a: i32, b: i32) -> i32 {
3    a + b
4}
5
6#[cfg(test)]
7mod tests {
8    use super::*;
9
10    #[test]
11    fn test_add() {
12        assert_eq!(add(2, 3), 5);
13    }
14
15    #[test]
16    fn test_add_negative() {
17        assert_eq!(add(-1, -1), -2);
18    }
19}

1# Все тесты
2cargo test
3
4# Конкретный тест
5cargo test test_add
6
7# С verbose выводом
8cargo test -- --nocapture
9
10# Тесты с паниками
11cargo test -- --ignored

1#[test]
2fn test_assertions() {
3    assert!(true);                    // Проверка истинности
4    assert_eq!(2 + 2, 4);           // Равенство
5    assert_ne!(2 + 2, 5);           // Неравенство
6    assert!(add(2, 3) > 4);         // Условие
7}

1#[test]
2fn test_with_message() {
3    let result = add(2, 3);
4    assert_eq!(
5        result, 5,
6        "add(2, 3) should be 5, got {}", result
7    );
8}

1#[derive(Debug, PartialEq)]
2enum AppError {
3    NotFound,
4    InvalidInput(String),
5}
6
7fn process(input: &str) -> Result<i32, AppError> {
8    if input.is_empty() {
9        return Err(AppError::InvalidInput("empty input".to_string()));
10    }
11    input.parse().map_err(|_| AppError::InvalidInput("not a number".to_string()))
12}
13
14#[cfg(test)]
15mod tests {
16    use super::*;
17
18    #[test]
19    fn test_process_valid() {
20        assert_eq!(process("42").unwrap(), 42);
21    }
22
23    #[test]
24    fn test_process_empty() {
25        assert_eq!(
26            process(""),
27            Err(AppError::InvalidInput("empty input".to_string()))
28        );
29    }
30
31    #[test]
32    fn test_process_invalid() {
33        match process("abc") {
34            Err(AppError::InvalidInput(msg)) => {
35                assert!(msg.contains("not a number"));
36            }
37            _ => panic!("Expected InvalidInput error"),
38        }
39    }
40}

1mylib/
2├── src/
3│   └── lib.rs
4├── tests/
5│   ├── integration_test.rs
6│   └── common/
7│       └── mod.rs

1// tests/integration_test.rs
2use mylib;
3
4#[test]
5fn test_integration() {
6    let result = mylib::add(2, 3);
7    assert_eq!(result, 5);
8}
9
10// tests/common/mod.rs — общие утилиты
11pub fn setup() {
12    // Настройка тестового окружения
13}

1#[test]
2fn test_add_various() {
3    let test_cases = vec![
4        (2, 3, 5),
5        (-1, -1, -2),
6        (0, 0, 0),
7        (100, 200, 300),
8    ];
9
10    for (a, b, expected) in test_cases {
11        assert_eq!(add(a, b), expected, "Failed for {} + {}", a, b);
12    }
13}

1use tokio;
2
3#[tokio::test]
4async fn test_async_function() {
5    let result = async_function().await;
6    assert_eq!(result, 42);
7}
8
9async fn async_function() -> i32 {
10    tokio::time::sleep(Duration::from_millis(10)).await;
11    42
12}

1#![feature(test)]
2extern crate test;
3
4use test::Bencher;
5
6#[bench]
7fn bench_add(b: &mut Bencher) {
8    b.iter(|| {
9        add(2, 3)
10    });
11}

1// Определение трейта
2trait Database {
3    fn get_user(&self, id: u32) -> Option<User>;
4}
5
6// Мок
7struct MockDatabase {
8    users: Vec<User>,
9}
10
11impl Database for MockDatabase {
12    fn get_user(&self, id: u32) -> Option<User> {
13        self.users.iter().find(|u| u.id == id).cloned()
14    }
15}
16
17#[cfg(test)]
18mod tests {
19    use super::*;
20
21    #[test]
22    fn test_with_mock() {
23        let mock = MockDatabase {
24            users: vec![User { id: 1, name: "Alice".to_string() }],
25        };
26
27        let result = mock.get_user(1);
28        assert!(result.is_some());
29        assert_eq!(result.unwrap().name, "Alice");
30    }
31}

1// tests/data/
2// test_users.json
3// test_orders.json
4
5use std::fs;
6
7#[test]
8fn test_with_fixture() {
9    let data = fs::read_to_string("tests/data/test_users.json")
10        .expect("Failed to read test data");
11
12    let users: Vec<User> = serde_json::from_str(&data)
13        .expect("Failed to parse test data");
14
15    assert!(!users.is_empty());
16}

1#[test]
2fn test_add_returns_sum_of_two_numbers() {
3    assert_eq!(add(2, 3), 5);
4}
5
6#[test]
7fn test_add_handles_negative_numbers() {
8    assert_eq!(add(-1, -1), -2);
9}

1#[test]
2fn test_add_edge_cases() {
3    assert_eq!(add(i32::MAX, 1), i32::MIN + 1); // Overflow
4    assert_eq!(add(i32::MIN, -1), i32::MAX);    // Underflow
5}