Padrões de Teste em Rust

Padrões abrangentes de teste em Rust para escrever testes confiáveis e de fácil manutenção, seguindo a metodologia TDD.

Quando Usar

• Escrevendo novas funções, métodos ou traits em Rust
• Adicionando cobertura de testes a código existente
• Criando benchmarks para código crítico de performance
• Implementando testes baseados em propriedades para validação de entrada
• Seguindo o fluxo de trabalho TDD em projetos Rust

Como Funciona

1. Identifique o código alvo — Encontre a função, trait ou módulo a ser testado
2. Escreva um teste — Use #[test] em um módulo #[cfg(test)], rstest para testes parametrizados, ou proptest para testes baseados em propriedades
3. Mock de dependências — Use mockall para isolar a unidade sob teste
4. Execute os testes (VERMELHO) — Verifique se o teste falha com o erro esperado
5. Implemente (VERDE) — Escreva o código mínimo para passar
6. Refatore — Melhore mantendo os testes verdes
7. Verifique a cobertura — Use cargo-llvm-cov, mire em 80%+

Fluxo de Trabalho TDD para Rust

O Ciclo VERMELHO-VERDE-REFACTOR

RED     → Write a failing test first
GREEN   → Write minimal code to pass the test
REFACTOR → Improve code while keeping tests green
REPEAT  → Continue with next requirement

TDD Passo a Passo em Rust

// RED: Write test first, use todo!() as placeholder
pub fn add(a: i32, b: i32) -> i32 { todo!() }

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_add() { assert_eq!(add(2, 3), 5); }
}
// cargo test → panics at 'not yet implemented'

// GREEN: Replace todo!() with minimal implementation
pub fn add(a: i32, b: i32) -> i32 { a + b }
// cargo test → PASS, then REFACTOR while keeping tests green

Testes de Unidade

Organização de Testes em Nível de Módulo

// src/user.rs
pub struct User {
    pub name: String,
    pub email: String,
}

impl User {
    pub fn new(name: impl Into<String>, email: impl Into<String>) -> Result<Self, String> {
        let email = email.into();
        if !email.contains('@') {
            return Err(format!("invalid email: {email}"));
        }
        Ok(Self { name: name.into(), email })
    }

    pub fn display_name(&self) -> &str {
        &self.name
    }
}

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

    #[test]
    fn creates_user_with_valid_email() {
        let user = User::new("Alice", "alice@example.com").unwrap();
        assert_eq!(user.display_name(), "Alice");
        assert_eq!(user.email, "alice@example.com");
    }

    #[test]
    fn rejects_invalid_email() {
        let result = User::new("Bob", "not-an-email");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("invalid email"));
    }
}

Macros de Assertiva

assert_eq!(2 + 2, 4);                                    // Equality
assert_ne!(2 + 2, 5);                                    // Inequality
assert!(vec![1, 2, 3].contains(&2));                     // Boolean
assert_eq!(value, 42, "expected 42 but got {value}");    // Custom message
assert!((0.1_f64 + 0.2 - 0.3).abs() < f64::EPSILON);   // Float comparison

Testes de Erro e Pânico

Testando Retornos de Result

#[test]
fn parse_returns_error_for_invalid_input() {
    let result = parse_config("}{invalid");
    assert!(result.is_err());

    // Assert specific error variant
    let err = result.unwrap_err();
    assert!(matches!(err, ConfigError::ParseError(_)));
}

#[test]
fn parse_succeeds_for_valid_input() -> Result<(), Box<dyn std::error::Error>> {
    let config = parse_config(r#"{"port": 8080}"#)?;
    assert_eq!(config.port, 8080);
    Ok(()) // Test fails if any ? returns Err
}

Testando Pânicos

#[test]
#[should_panic]
fn panics_on_empty_input() {
    process(&[]);
}

#[test]
#[should_panic(expected = "index out of bounds")]
fn panics_with_specific_message() {
    let v: Vec<i32> = vec![];
    let _ = v[0];
}

Testes de Integração

Estrutura de Arquivos

my_crate/
├── src/
│   └── lib.rs
├── tests/              # Integration tests
│   ├── api_test.rs     # Each file is a separate test binary
│   ├── db_test.rs
│   └── common/         # Shared test utilities
│       └── mod.rs

Escrevendo Testes de Integração

// tests/api_test.rs
use my_crate::{App, Config};

#[test]
fn full_request_lifecycle() {
    let config = Config::test_default();
    let app = App::new(config);

    let response = app.handle_request("/health");
    assert_eq!(response.status, 200);
    assert_eq!(response.body, "OK");
}

Testes Assíncronos

Com Tokio

#[tokio::test]

…