Learn Rust Coding · Aula

Testes unitários

Atributo test

Testes unitários é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Testes em Rust

Rust tem testes integrados à linguagem — não é necessário nenhum framework externo. Os testes são funções comuns anotadas com #[test] e executadas por cargo test.

Seu primeiro teste

Uma função de teste não recebe argumentos e usa asserções. Se retornar normalmente, ela será aprovada; se entrar em pânico, falhará.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

fn main() {
    println!("{}", add(2, 3));
}

Macros de asserção

As asserções padrão são:

assert!(cond) — falha se a condição for falsa
assert_eq!(a, b) — falha se os valores não forem iguais
assert_ne!(a, b) — falha se os valores forem iguais

fn main() {
    let x = 4;
    assert!(x > 0);
    assert_eq!(x, 4);
    assert_ne!(x, 5);
    println!("All assertions passed");
}

O módulo tests

Por convenção, os testes unitários ficam em um módulo anotado com #[cfg(test)], para serem compilados somente durante os testes.

fn square(n: i32) -> i32 {
    n * n
}

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

    #[test]
    fn squares_correctly() {
        assert_eq!(square(5), 25);
    }
}

fn main() {
    println!("{}", square(5));
}

use super::*

Como o módulo de teste está aninhado, use super::* traz para o escopo os itens do módulo pai, ou seja, as funções que você quer testar.

Executando testes

cargo test compila e executa todos os testes. O comando informa quantos foram aprovados, falharam ou foram ignorados.

cargo test

Testando pânicos

Use #[should_panic] para verificar se uma função entra em pânico sob determinadas condições.

fn checked_div(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("division by zero");
    }
    a / b
}

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

    #[test]
    #[should_panic(expected = "division by zero")]
    fn panics_on_zero() {
        checked_div(10, 0);
    }
}

fn main() {}

Testes que retornam Result

Um teste pode retornar Result, permitindo usar o operador ?. Retornar Err faz o teste falhar.

fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

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

    #[test]
    fn parses_number() -> Result<(), std::num::ParseIntError> {
        let n = parse("42")?;
        assert_eq!(n, 42);
        Ok(())
    }
}

fn main() {}

Ignorando testes

Marque com #[ignore] os testes lentos ou específicos de determinado ambiente. Execute-os explicitamente com cargo test -- --ignored.

#[test]
#[ignore]
fn expensive_test() {
    // long-running work
}

fn main() {}

Opções úteis para testes

Opções úteis ao executar testes:

cargo test name — executa testes cujo nome corresponde ao texto informado
cargo test -- --nocapture — exibe a saída de println
cargo test -- --test-threads=1 — executa em série

Testando funções privadas

Como o módulo de teste está aninhado no mesmo arquivo, ele pode acessar funções privadas — algo que os testes de integração não podem fazer. Essa é uma vantagem importante dos testes unitários.

fn internal(n: i32) -> i32 {
    n + 1
}

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

    #[test]
    fn tests_private() {
        assert_eq!(internal(4), 5);
    }
}

fn main() {
    println!("{}", internal(4));
}

Verificação rápida

Qual atributo marca uma função como um teste que o Cargo deve executar?

Recapitulação

Você aprendeu sobre os testes integrados do Rust:

#[test] marca funções de teste
Asserções: assert!, assert_eq!, assert_ne!
Os testes ficam em um módulo #[cfg(test)] com use super::*
#[should_panic] e testes que retornam Result lidam com erros
cargo test executa tudo

Perguntas Frequentes

A aula “Testes unitários” é grátis?

Sim — o texto completo de “Testes unitários” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Testes unitários”?

Atributo test Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Testes unitários”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding