Execução de testes com GitHub Actions
Integre testes automatizados de unidade e de integração ao seu fluxo de integração contínua para garantir a qualidade do código e evitar regressões.
Execução de testes com GitHub Actions é uma aula grátis de CI/CD with GitHub Actions & DevOps Pipelines 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 CI/CD with GitHub Actions & DevOps Pipelines, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
Por que automatizar testes na integração contínua?
Imagine fazer uma alteração no seu código e saber imediatamente se isso quebrou outra coisa. Esse é o poder dos testes automatizados no seu fluxo de integração contínua!
Integração Contínua (CI) consiste em mesclar frequentemente as alterações de código em um repositório central. Os testes automatizados são os guardiões desse processo.
Eles detectam problemas antecipadamente, fornecem retorno rápido e aumentam a confiança em cada alteração de código.
Tipos de testes no seu fluxo
Quando falamos sobre testes automatizados, dois tipos principais costumam surgir: testes unitários e testes de integração.
- Testes unitários: concentram-se em partes pequenas e isoladas do seu código, como uma única função ou método. Eles são rápidos e identificam exatamente os problemas.
- Testes de integração: verificam se diferentes partes do seu sistema funcionam corretamente em conjunto, por exemplo, quando seu código interage com um banco de dados ou uma API.
Ambos são essenciais para garantir que seu software seja robusto e confiável.
Automatizando testes com as ações do GitHub
As ações do GitHub podem funcionar como seu executor pessoal de testes, executando automaticamente seus testes sempre que você envia um novo código.
Você define um fluxo de trabalho que especifica quando executar, qual ambiente usar e quais comandos executar.
Isso garante que cada alteração seja validada de maneira consistente, sem esforço manual.
Preparando um projeto Java para testes
Para demonstrar, usaremos um projeto Java simples gerenciado com Maven, uma ferramenta popular de automação de compilação.
O Maven ajuda a gerenciar as dependências do projeto e fornece comandos para compilar o código e executar testes.
Nosso projeto terá uma classe Java simples e um teste correspondente do JUnit (conceitualmente).
Nosso primeiro exemplo de teste executável
Aqui está uma classe Java simples e um teste básico para verificar sua funcionalidade. Para simplificar, estamos simulando um teste unitário sem uma configuração completa do JUnit.
O método main atua como nosso executor de testes, verificando se o método add funciona conforme o esperado.
Experimente executá-lo para ver a saída!
public class Calculator {
// Method to be tested
public int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
// Simulate a test case
int expected = 5;
int actual = calc.add(2, 3);
if (actual == expected) {
System.out.println("Test Passed: 2 + 3 = " + actual);
} else {
System.out.println("Test Failed: Expected " + expected + ", Got " + actual);
}
}
}Criando seu fluxo de trabalho de testes
Agora, vejamos como seria um arquivo de fluxo de trabalho das ações do GitHub (.github/workflows/test.yml) para executar nossos testes.
Este arquivo YAML define as etapas que as ações do GitHub seguirão para configurar o ambiente e executar nossos comandos de teste.
Usaremos o comando test do Maven para executar testes reais do JUnit em um projeto real.
name: Java CI with Maven
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up JDK 17
uses: actions/setup-java@v4
with:
java-version: '17'
distribution: 'temurin'
cache: maven
- name: Run Maven Tests
run: mvn test
Entendendo cada etapa do fluxo de trabalho
Vamos detalhar as principais etapas do nosso fluxo de trabalho de testes:
on: push / pull_request: aciona o fluxo de trabalho quando há envios de código ou solicitações de pull para a ramificaçãomain.runs-on: ubuntu-latest: especifica o sistema operacional da máquina virtual (executor) onde o fluxo de trabalho será executado.actions/checkout@v4: uma ação pré-criada que extrai o código do seu repositório para o executor.actions/setup-java@v4: outra ação para configurar o Kit de Desenvolvimento do Java (JDK) no executor.run: mvn test: esta é a etapa crucial! Ela executa o comando do Maven para compilar seu código e executar todos os testes definidos.
Lidando com falhas de testes na integração contínua
Um dos principais benefícios dos testes na integração contínua é o retorno imediato. Se algum teste falhar, a tarefa do fluxo de trabalho das ações do GitHub falhará.
Isso indica claramente que a alteração recente no código introduziu um problema ou uma regressão.
Você pode então revisar os registros do fluxo de trabalho para identificar exatamente qual teste falhou e por quê, ajudando a corrigir os problemas rapidamente.
O impacto: qualidade e confiança
Integrar testes automatizados ao seu fluxo de integração contínua é um pilar do desenvolvimento moderno de software.
Isso evita ativamente regressões, garante uma qualidade consistente do código e reduz significativamente o risco de implantar recursos com falhas.
Esse processo aumenta a confiança na sua base de código, permitindo que sua equipe inove com mais rapidez e confiabilidade.
Verificação de testes do fluxo de trabalho
Considere um fluxo de trabalho das ações do GitHub criado para executar testes. Qual é a finalidade principal da etapa run: mvn test em um projeto Java?
Recapitulação: testes no seu fluxo de integração contínua
Nesta lição, exploramos como integrar testes automatizados ao seu fluxo de integração contínua das ações do GitHub.
Abordamos:
- A importância dos testes automatizados para a qualidade do código.
- A diferença entre testes unitários e testes de integração.
- Como estruturar um fluxo de trabalho das ações do GitHub para executar testes Java usando Maven.
- Como entender etapas do fluxo de trabalho, como
checkoutesetup-java. - O papel fundamental de
mvn testna execução dos seus testes. - Como as ações do GitHub relatam falhas nos testes.
Os testes automatizados são essenciais para detectar problemas antecipadamente e manter uma base de código robusta!
Perguntas Frequentes
A aula “Execução de testes com GitHub Actions” é grátis?
Sim — o texto completo de “Execução de testes com GitHub Actions” é 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 CI/CD with GitHub Actions & DevOps Pipelines, atualize para CoddyKit PRO. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
O que vou aprender em “Execução de testes com GitHub Actions”?
Integre testes automatizados de unidade e de integração ao seu fluxo de integração contínua para garantir a qualidade do código e evitar regressões. Você pratica CI/CD with GitHub Actions & DevOps Pipelines 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 CI/CD with GitHub Actions & DevOps Pipelines?
Nenhuma experiência prévia é necessária. CI/CD with GitHub Actions & DevOps Pipelines 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 “Execução de testes com GitHub Actions”?
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 CI/CD with GitHub Actions & DevOps Pipelines?
Sim. Cada aula de CI/CD with GitHub Actions & DevOps Pipelines 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
- Acionadores e eventos de fluxos de trabalho
- Execução de testes com GitHub Actions
- Análise estática e verificações de qualidade do código
- Armazenando dependências em cache para compilações mais rápidas