Testes em Rust: frameworks e ferramentas

Rust é uma linguagem de programação de sistemas que dá enorme ênfase à confiabilidade e segurança. O sistema de testes embutido é uma das principais características, permitindo escrever código de qualidade sem a necessidade de instalar frameworks de terceiros. Neste artigo, veremos em detalhes as principais ferramentas para testes em Rust: desde testes unitários simples até testes baseados em propriedades complexos e benchmarks.

Framework de testes embutido

Em Rust, os testes são executados com o comando cargo test. Testes são funções comuns marcadas com o atributo #[test]. O framework coleta automaticamente todas essas funções no seu projeto e as executa.

Testes unitários

Testes unitários geralmente ficam no mesmo arquivo que o código testado, em um módulo separado tests. Isso permite testar funções privadas.

// src/lib.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

fn private_helper(x: i32) -> i32 {    x * 2}

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

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

    #[test]    fn test_private_helper() {        assert_eq!(private_helper(5), 10);    }}

Execução: cargo test

Testes de integração

Testes de integração ficam no diretório tests/ na raiz do projeto. Cada arquivo nesta pasta é um crate separado que testa sua API pública.

// tests/integration_test.rsuse my_crate::add;

#[test]fn test_add_integration() {    assert_eq!(add(10, 20), 30);}

Macros para verificações

Rust fornece várias macros embutidas para escrever verificações:

assert!(expression) — entra em pânico se a expressão for falsa.
assert_eq!(left, right) — verifica igualdade usando PartialEq.
assert_ne!(left, right) — verifica desigualdade.
debug_assert!() — funciona apenas em compilações debug.

#[test]fn test_with_assert() {    let result = some_function();    assert!(result.is_ok(), "Esperava Ok, obtido: {:?}", result);    assert_eq!(result.unwrap(), 42);}

Doctests

Um dos recursos mais poderosos do Rust é a capacidade de escrever testes diretamente na documentação. O código dentro dos blocos /// ou //! é automaticamente compilado e executado como um teste.

/// Soma dois números.////// # Exemplos////// ```/// use my_crate::add;/// assert_eq!(add(1, 2), 3);/// ```pub fn add(a: i32, b: i32) -> i32 {    a + b}

Execução: cargo test — os doctests são executados junto com os testes comuns.

Testes baseados em propriedades com proptest

A biblioteca proptest (análoga ao Hypothesis em Python ou QuickCheck em Haskell) permite gerar dados de entrada aleatórios e verificar invariantes.

use proptest::prelude::*;

fn reverse_string(s: &str) -> String {    s.chars().rev().collect()}

proptest! {    #[test]    fn test_reverse_twice(s in ".*") {        let reversed = reverse_string(&s);        let double_reversed = reverse_string(&reversed);        assert_eq!(s, double_reversed);    }}

Instalação: cargo add proptest

Benchmarks

Para medir desempenho em Rust, existem benchmarks estáveis (a partir do Rust 1.78) via cargo bench e o crate criterion para cenários mais complexos.

Benchmarks embutidos (nightly)

#![feature(test)]extern crate test;

#[bench]fn bench_add(b: &mut test::Bencher) {    b.iter(|| add(1, 2));}

Benchmarks com criterion

Também na biblioteca

Integração de Métricas Prometheus em PHP: Bibliotecas e Exemplos

Swagger-PHP para PHP: guia completo com exemplos

Testcontainers para Java: guia completo com exemplos práticos

Planejador de Tarefas em C++: criando um Task Scheduler do zero

Chalk para JavaScript (Node.js): guia completo com exemplos

Testes em Rust: frameworks e ferramentas