Terraform Infrastructure as Code · Aula

Testes unitários com Terratest

Aprenda a escrever testes unitários para seus módulos do Terraform usando o Terratest, uma biblioteca Go para testar código de infraestrutura.

Testes unitários com Terratest é uma aula grátis de Terraform Infrastructure as Code no CoddyKit. Esta é a aula 2 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 Terraform Infrastructure as Code, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Terraform Infrastructure as Code inclui 4 aulas no total.

Por que testar sua IaC?

A Infraestrutura como Código (IaC) permite gerenciar a infraestrutura como se fosse software. Assim como o software, as configurações de IaC podem conter erros!

Confiabilidade: Identifique erros antes da implantação.
Consistência: Garanta que os recursos sejam provisionados conforme o esperado.
Confiança: Faça alterações com menos receio de danificar a infraestrutura existente.

Testar seu código do Terraform é essencial para criar ambientes de nuvem robustos e fáceis de manter.

Testes unitários e de integração

Ao testar IaC, geralmente falamos sobre dois tipos principais:

Testes unitários: Concentram-se em partes pequenas e isoladas do código, como um único módulo do Terraform. Eles garantem que os componentes individuais funcionem corretamente de forma isolada.
Testes de integração: Verificam se vários componentes ou módulos funcionam juntos como um sistema, geralmente implantando recursos reais em um ambiente de nuvem.

Nesta lição, vamos nos concentrar nos testes unitários dos seus módulos do Terraform.

Apresentando o Terratest

Terratest é uma biblioteca Go desenvolvida pela HashiCorp (os criadores do Terraform), projetada especificamente para testar código de infraestrutura.

Ela ajuda você a escrever testes automatizados para seu código do Terraform, Packer, Kubernetes e outros códigos de IaC.
O Terratest pode implantar infraestrutura real no seu provedor de nuvem, executar asserções sobre ela e depois limpá-la.
É uma ferramenta poderosa tanto para testes unitários quanto para testes de integração.

Pré-requisitos do Terratest

Para começar a usar o Terratest, precisará de alguns recursos:

Go: O Terratest é uma biblioteca de Go, portanto, precisa ter o Go instalado (recomenda-se a versão 1.13 ou superior).
Terraform CLI: A interface de linha de comandos do Terraform deve estar instalada e acessível.
Credenciais do provedor de nuvem: Se estiver implementando recursos reais (mesmo em testes unitários que acedem a uma API de nuvem), precisará de acesso autenticado ao provedor de nuvem (por exemplo, a AWS CLI configurada).

Também precisará de conhecimentos básicos dos conceitos de programação em Go.

Estrutura de um arquivo de teste em Go

Os testes do Terratest são escritos em Go e seguem as convenções padrão de testes da linguagem:

Os arquivos de teste terminam com _test.go (por exemplo, main_test.go).
As funções de teste começam com Test (por exemplo, TestMyModule(t *testing.T)).
Utilizam o pacote integrado testing do Go.

Normalmente, esses arquivos ficam junto do seu módulo do Terraform ou em um diretório test dedicado.

Explicação de `terraform.Options`

O elemento central de um teste do Terraform com Terratest é a estrutura terraform.Options. Esse objeto informa ao Terratest como executar o Terraform.

Entre os campos principais estão:

TerraformDir: caminho para o módulo do Terraform.
Vars: variáveis de entrada do módulo do Terraform.
EnvVars: variáveis de ambiente a serem definidas para o processo do Terraform.
BackendConfig: configuração do backend do Terraform.

Essa estrutura funciona como o plano para executar comandos do Terraform durante o teste.

Fluxo básico de um teste

Um teste unitário típico do Terraform com Terratest segue estas etapas:

Definir as opções: crie uma estrutura terraform.Options que aponte para o seu módulo e defina as variáveis.
Implementar: use terraform.InitAndApply(t, options) para inicializar e aplicar a sua configuração.
Adiar a destruição: adicione imediatamente defer terraform.Destroy(t, options) para garantir a limpeza depois da execução do teste.
Verificar: use testify/assert do Go ou terraform.Output do Terratest para verificar propriedades ou saídas dos recursos.

Isso garante um ambiente de teste limpo e isolado.

Codificando `terraform.Options`

A seguir, apresentamos um programa simples em Go que demonstra como configurar terraform.Options. Esta é uma etapa fundamental para qualquer interação com o Terratest.

package main

import (
	"fmt"
	"path/filepath"
	"github.com/gruntwork-io/terratest/modules/terraform"
)

func main() {
	// Define the path to your Terraform configuration directory.
	// In a real test, this would point to your module under test.
	terraformConfigDir := filepath.Join(".", "my-example-module")

	// Create a terraform.Options object.
	// This struct holds all the configuration for running Terraform via Terratest.
	options := &terraform.Options{
		TerraformDir: terraformConfigDir,
		// You would add input variables here, e.g.:
		// Vars: map[string]interface{}{"instance_type": "t2.micro"},
		// And environment variables, e.g.:
		// EnvVars: map[string]string{"AWS_REGION": "us-east-1"},
	}

	fmt.Println("--- Terratest Options Configuration Demo ---")
	fmt.Printf("Configured Terraform Directory: %s\n", options.TerraformDir)
	fmt.Println("This shows how to initialize Terratest options.")
	fmt.Println("Actual Terratest unit tests are run using 'go test' command.")
}

Verificando as saídas

Depois de aplicar a configuração do Terraform, deverá verificar as suas saídas. O Terratest fornece funções para recuperar esses valores facilmente.

terraform.Output(t, options, "output_name"): recupera uma saída de texto única.
terraform.OutputMap(t, options, "output_name"): recupera uma saída em formato de mapa.
terraform.OutputList(t, options, "output_name"): recupera uma saída em formato de lista.

Em seguida, use as verificações do pacote de testes do Go (por exemplo, de github.com/stretchr/testify/assert) para confirmar se as saídas correspondem ao que espera.

Verifique a sua compreensão

O Terratest ajuda a testar o seu código do Terraform interagindo com recursos de nuvem reais. Qual das opções a seguir não é uma etapa típica do fluxo de trabalho de um teste unitário com Terratest?

Recapitulação e próximos passos

Aprendeu os fundamentos dos testes unitários do Terraform com o Terratest!

O Terratest é uma biblioteca de Go para testar IaC.
Permite implementar, verificar e limpar uma infraestrutura de nuvem real.
Entre os componentes principais estão os arquivos _test.go, func TestXxx(t *testing.T) e a estrutura terraform.Options.
O fluxo de trabalho envolve definir opções, aplicar o Terraform, fazer verificações e garantir a limpeza com defer.

Em seguida, explore como escrever verificações mais complexas e integrar o Terratest aos seus pipelines de CI/CD para realizar testes automatizados.

Perguntas Frequentes

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

Sim — o texto completo de “Testes unitários com Terratest” é 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 Terraform Infrastructure as Code, atualize para CoddyKit PRO. O curso de Terraform Infrastructure as Code inclui 4 aulas no total.

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

Aprenda a escrever testes unitários para seus módulos do Terraform usando o Terratest, uma biblioteca Go para testar código de infraestrutura. Você pratica Terraform Infrastructure as Code 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 Terraform Infrastructure as Code?

Nenhuma experiência prévia é necessária. Terraform Infrastructure as Code 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 2 de 4.

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

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 Terraform Infrastructure as Code?

Sim. Cada aula de Terraform Infrastructure as Code 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

`validate` e `fmt` do Terraform
Testes unitários com Terratest
Testes de integração de recursos de nuvem
Política como código e verificações de conformidade

← Voltar para Terraform Infrastructure as Code