Go Academy · Aula

Escrevendo testes unitários com testing

Funções TestXxx, t.Error, t.Fatal e t.Helper

Escrevendo testes unitários com testing é uma aula grátis de Go Academy 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 Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Pacote de testes

O pacote integrado testing de Go fornece tudo o que é necessário para testes unitários: funções de teste, relatório de falhas e binários de teste. Nenhuma estrutura externa é necessária.

Assinatura da função de teste

As funções de teste devem começar com Test, receber *testing.T e estar em arquivos que terminem com _test.go.

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2,3) = %d; want 5", got)
    }
}

t.Error versus t.Fatal

t.Error marca uma falha e continua; t.Fatal marca uma falha e interrompe imediatamente o teste atual. Use Fatal quando as asserções seguintes dependerem daquela que falhou.

Execução de testes

Execute todos os testes: go test ./.... Execute um teste específico: go test -run TestAdd. Adicione -v para obter uma saída detalhada.

go test -v -run TestAdd ./...

t.Helper

Marque os auxiliares de asserção com t.Helper() para que as mensagens de erro indiquem a linha do chamador, não a linha do auxiliar.

func assertEqual(t *testing.T, got, want int) {
    t.Helper()
    if got != want {
        t.Errorf("got %d; want %d", got, want)
    }
}

TestMain

TestMain(m *testing.M) é um ponto de entrada opcional para configuração e limpeza antes e depois da execução de todo o conjunto de testes (por exemplo, iniciar um banco de dados de teste).

func TestMain(m *testing.M) {
    setup()
    code := m.Run()
    teardown()
    os.Exit(code)
}

Subtestes com t.Run

Agrupe casos relacionados com t.Run. Cada subteste é executado de forma independente e pode ser selecionado com -run TestFoo/SubcaseName.

func TestMath(t *testing.T) {
    t.Run("addition", func(t *testing.T) { /* ... */ })
    t.Run("subtraction", func(t *testing.T) { /* ... */ })
}

Estrutura dos arquivos de teste

Os testes no mesmo pacote podem acessar identificadores não exportados. Os testes em um pacote _test (testes de caixa-preta) só podem acessar identificadores exportados.

// white-box: package mylib
// black-box: package mylib_test

go test -cover

Meça a cobertura de código com go test -cover. Para obter um relatório HTML detalhado: go test -coverprofile=c.out ./... && go tool cover -html=c.out.

Testes com interfaces

Projete o código com base em interfaces para que os testes possam fornecer implementações falsas sem iniciar serviços reais.

t.Parallel

Chame t.Parallel() no início de um teste para marcá-lo como seguro para execução simultânea com outros testes paralelos, acelerando o conjunto de testes.

func TestRead(t *testing.T) {
    t.Parallel()
    // ...
}

Verificação rápida

Qual é a diferença entre t.Error e t.Fatal?

Recapitulação: testes unitários com testing

Pontos principais:

Funções de teste: TestXxx(t *testing.T) em arquivos _test.go
t.Error continua; t.Fatal interrompe o teste
t.Helper() para obter números de linha de erro limpos nos auxiliares
t.Run para subtestes; t.Parallel para testes simultâneos

Perguntas Frequentes

A aula “Escrevendo testes unitários com testing” é grátis?

Sim — o texto completo de “Escrevendo testes unitários com testing” é 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 Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Escrevendo testes unitários com testing”?

Funções TestXxx, t.Error, t.Fatal e t.Helper Você pratica Go Academy 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 Go Academy?

Nenhuma experiência prévia é necessária. Go Academy 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 “Escrevendo testes unitários com testing”?

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 Go Academy?

Sim. Cada aula de Go Academy 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 Go Academy