Pular para o conteúdo
Rust em Português

Lição 17 de 18 · 25 min

Testes

Escreva testes automáticos com #[test], assert! e assert_eq!, rode tudo com cargo test e conheça os testes de integração e de documentação.

Ao terminar, você vai saber:

  • Escrever funções de teste com #[test], assert! e assert_eq!
  • Organizar testes num módulo tests com #[cfg(test)]
  • Rodar e filtrar testes com cargo test
  • Testar que uma função entra em pânico quando deve
  • Saber onde ficam os testes de integração e os de documentação

O compilador do Rust pega muitos erros: tipo errado, referência inválida, caso esquecido no match. Mas ele não sabe se a sua regra de negócio está certa. Se o desconto deveria ser 10% e você escreveu 100%, o código compila feliz.

Para isso existem os testes: pequenas funções que chamam o seu código e conferem o resultado. E o Rust já vem com tudo pronto. Não precisa instalar nada.

Primeiro teste

Crie um projeto de biblioteca (assim fica claro que o foco é a lógica, sem main):

cargo new --lib loja
cd loja

Coloque isto em src/lib.rs:

pub fn aplicar_desconto(valor: f64, percentual: f64) -> f64 {
    valor - valor * percentual / 100.0
}

#[test]
fn desconto_de_dez_por_cento() {
    let resultado = aplicar_desconto(200.0, 10.0);
    assert_eq!(resultado, 180.0);
}

E rode:

cargo test
running 1 test
test desconto_de_dez_por_cento ... ok

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

O #[test] em cima da função avisa o Cargo: “esta função é um teste”. Ela não recebe nada e não devolve nada. Se terminar sem problema, passou. Se entrar em panic!, falhou.

assert! e assert_eq!

São macros que causam panic! quando a condição não é verdadeira:

  • assert!(condicao): falha se a condição for false.
  • assert_eq!(a, b): falha se a for diferente de b.
  • assert_ne!(a, b): falha se a for igual a b.

Veja um teste que falha de propósito:

pub fn aplicar_desconto(valor: f64, percentual: f64) -> f64 {
    valor - valor * percentual // esqueci de dividir por 100
}

#[test]
fn desconto_de_dez_por_cento() {
    assert_eq!(aplicar_desconto(200.0, 10.0), 180.0);
}
---- desconto_de_dez_por_cento stdout ----
thread 'desconto_de_dez_por_cento' panicked at src/lib.rs:7:5:
assertion `left == right` failed
  left: -1800.0
 right: 180.0

O assert_eq! mostra os dois lados: o que a função devolveu (left) e o que você esperava (right). Com isso você acha o bug em segundos.

Dá para acrescentar uma mensagem própria, que aparece quando falha:

fn eh_maior_de_idade(idade: u32) -> bool {
    idade >= 18
}

#[test]
fn dezoito_anos_ja_pode() {
    let idade = 18;
    assert!(eh_maior_de_idade(idade), "com {idade} anos deveria ser maior de idade");
}

O módulo tests

Na prática, os testes ficam num módulo separado, no fim do mesmo arquivo:

pub fn calcular_media(notas: &[f64]) -> Option<f64> {
    if notas.is_empty() {
        return None;
    }
    let soma: f64 = notas.iter().sum();
    Some(soma / notas.len() as f64)
}

pub fn situacao(media: f64) -> &'static str {
    if media >= 7.0 {
        "aprovado"
    } else if media >= 5.0 {
        "recuperação"
    } else {
        "reprovado"
    }
}

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

    #[test]
    fn media_de_tres_notas() {
        assert_eq!(calcular_media(&[6.0, 7.0, 8.0]), Some(7.0));
    }

    #[test]
    fn sem_notas_nao_tem_media() {
        assert_eq!(calcular_media(&[]), None);
    }

    #[test]
    fn sete_e_aprovado() {
        assert_eq!(situacao(7.0), "aprovado");
    }

    #[test]
    fn limites_da_recuperacao() {
        assert_eq!(situacao(5.0), "recuperação");
        assert_eq!(situacao(4.9), "reprovado");
    }
}

Duas linhas novas:

  • #[cfg(test)] diz: “só compile este módulo quando estiver rodando testes”. No cargo build normal, ele some, e o programa final não carrega código de teste.
  • use super::*; traz tudo do módulo de cima (o “pai”) para dentro de tests. Sem isso, você teria que escrever super::situacao em cada chamada. Como tests é um módulo filho, ele enxerga até as funções privadas do pai.

Repare no teste limites_da_recuperacao. Bons testes conferem as bordas: o 5.0 exato, o 4.9 logo abaixo. É nas bordas que os bugs se escondem.

Filtrando testes

cargo test                     # roda todos
cargo test media               # só os que têm "media" no nome
cargo test -- --nocapture      # mostra os println! dos testes

Por padrão, o Cargo esconde o que os testes imprimem quando eles passam, para a saída ficar limpa.

Testando que deu panic

Às vezes o comportamento certo é parar. Por exemplo, uma função que divide a conta entre amigos não deve aceitar zero pessoas. O atributo #[should_panic] inverte o teste: ele passa se a função entrar em pânico.

pub fn dividir_conta(total: f64, pessoas: u32) -> f64 {
    if pessoas == 0 {
        panic!("a conta precisa de pelo menos uma pessoa");
    }
    total / pessoas as f64
}

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

    #[test]
    fn divide_entre_quatro() {
        assert_eq!(dividir_conta(120.0, 4), 30.0);
    }

    #[test]
    #[should_panic(expected = "pelo menos uma pessoa")]
    fn zero_pessoas_da_panic() {
        dividir_conta(120.0, 0);
    }
}

O expected confere se a mensagem do pânico contém aquele trecho. Assim o teste não passa por engano com um pânico de outro motivo.

Em código real, muitas vezes é melhor devolver um Result em vez de entrar em pânico, como você viu em Option e Result. Aí o teste é um assert! comum: assert!(dividir_conta(120.0, 0).is_err()).

Testes de integração na pasta tests/

Os testes do módulo tests são testes de unidade: ficam junto do código e podem mexer nas partes privadas. Há também os testes de integração, que usam o seu crate de fora, como qualquer outro programa usaria.

Eles moram numa pasta tests/, ao lado de src/:

loja/
├── Cargo.toml
├── src/
│   └── lib.rs
└── tests/
    └── notas.rs

O conteúdo de tests/notas.rs chama a biblioteca pelo nome do crate (aqui, loja):

use loja::{calcular_media, situacao};

#[test]
fn aluno_aprovado_de_ponta_a_ponta() {
    let media = calcular_media(&[8.0, 7.5, 9.0]).unwrap();
    assert_eq!(situacao(media), "aprovado");
}

Não precisa de #[cfg(test)]: a pasta tests/ só é compilada no cargo test. Como estão do lado de fora, esses testes só enxergam o que é pub. Se uma função privada mudar, eles não quebram, desde que a parte pública continue igual.

Testes de integração funcionam com crates biblioteca. Por isso é comum deixar a lógica em src/lib.rs e uma main.rs bem curta.

Testes na documentação

Existe ainda um terceiro tipo, bem característico do Rust. Comentários com três barras (///) viram a documentação da função, e os blocos de código dentro deles também são testados pelo cargo test:

/// Soma o frete ao valor da compra.
///
/// ```
/// let total = loja::com_frete(100.0, 15.0);
/// assert_eq!(total, 115.0);
/// ```
pub fn com_frete(valor: f64, frete: f64) -> f64 {
    valor + frete
}

Assim o exemplo da documentação nunca fica desatualizado: se a função mudar e o exemplo parar de funcionar, o teste falha. É assim que os crates do docs.rs mantêm seus exemplos corretos.

Resumo

  • #[test] marca uma função de teste; ela falha se entrar em panic!.
  • assert!, assert_eq! e assert_ne! conferem resultados e mostram os valores quando falham.
  • Testes de unidade ficam em #[cfg(test)] mod tests com use super::*;.
  • cargo test roda tudo; cargo test nome filtra.
  • #[should_panic(expected = "...")] testa que a função para quando deve.
  • A pasta tests/ guarda testes de integração; blocos de código em comentários /// também são testados.

Desafio

Escreva a função pub fn classificar_imc(peso: f64, altura: f64) -> &'static str que calcula o IMC (peso dividido pela altura ao quadrado) e devolve "abaixo do peso" (menor que 18,5), "normal" (de 18,5 até menos de 25) ou "acima do peso" (25 ou mais). Escreva testes para os três casos e para a borda de 25 exatos.

Ver uma resposta
pub fn classificar_imc(peso: f64, altura: f64) -> &'static str {
    let imc = peso / (altura * altura);
    if imc < 18.5 {
        "abaixo do peso"
    } else if imc < 25.0 {
        "normal"
    } else {
        "acima do peso"
    }
}

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

    #[test]
    fn abaixo_do_peso() {
        assert_eq!(classificar_imc(50.0, 1.80), "abaixo do peso");
    }

    #[test]
    fn peso_normal() {
        assert_eq!(classificar_imc(70.0, 1.75), "normal");
    }

    #[test]
    fn acima_do_peso() {
        assert_eq!(classificar_imc(95.0, 1.70), "acima do peso");
    }

    #[test]
    fn vinte_e_cinco_exatos_ja_e_acima() {
        // 100 / (2 x 2) = 25
        assert_eq!(classificar_imc(100.0, 2.0), "acima do peso");
    }
}
Salvo só neste navegador.