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 forfalse.assert_eq!(a, b): falha seafor diferente deb.assert_ne!(a, b): falha seafor igual ab.
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”. Nocargo buildnormal, 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 detests. Sem isso, você teria que escreversuper::situacaoem cada chamada. Comotestsé 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 empanic!.assert!,assert_eq!eassert_ne!conferem resultados e mostram os valores quando falham.- Testes de unidade ficam em
#[cfg(test)] mod testscomuse super::*;. cargo testroda tudo;cargo test nomefiltra.#[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");
}
}