GitHub Actions: Build e Teste Básico

Introdução

No desenvolvimento de software moderno, Integração Contínua (CI) é uma prática crucial onde os desenvolvedores frequentemente mesclam suas alterações de código em um repositório central. Builds e testes automatizados são executados para verificar essas alterações.

GitHub Actions é uma plataforma CI/CD popular que permite automatizar seu pipeline de build, teste e deploy diretamente no GitHub.

Neste laboratório, você aprenderá a criar um fluxo de trabalho (workflow) básico do GitHub Actions para um projeto Node.js. Você definirá etapas para configurar o ambiente Node.js, instalar dependências e executar testes. Finalmente, você fará commit e push dessas alterações para o seu repositório GitHub.

Este laboratório baseia-se no repositório que você criou nos laboratórios anteriores. Você clonará o repositório github-actions-demo e criará um fluxo de trabalho de CI para um projeto Node.js.

Ao final deste laboratório, você entenderá a estrutura de um arquivo de fluxo de trabalho .yml e como configurar etapas essenciais de CI.

Adicionar configuração do Node.js com uses actions/setup-node@v4

Nesta etapa, você clonará o repositório e criará um arquivo de fluxo de trabalho (workflow) com a configuração do ambiente Node.js. Os fluxos de trabalho do GitHub Actions são definidos em arquivos YAML localizados no diretório .github/workflows do seu repositório.

1. Na página do seu repositório GitHub para github-actions-demo, clique no botão verde Code.
2. Certifique-se de que a aba HTTPS esteja selecionada e copie o URL. Ele deve ser algo como https://github.com/your-username/github-actions-demo.git.
3. Abra o terminal no ambiente LabEx. O caminho padrão é ~/project.
4. Use o comando git clone para baixar o repositório. Substitua your-username pelo seu nome de usuário real do GitHub.

cd ~/project
git clone https://github.com/your-username/github-actions-demo.git

5. Navegue até o repositório clonado:

cd ~/project/github-actions-demo

6. Crie um novo arquivo chamado node-ci.yml dentro do diretório .github/workflows:

touch .github/workflows/node-ci.yml

7. Abra .github/workflows/node-ci.yml no WebIDE e comece adicionando o nome do fluxo de trabalho e o gatilho (trigger):

name: Node.js CI

on: [push]

8. Adicione a seção jobs e defina o job de build com seu executor (runner):

jobs:
  build:
    runs-on: ubuntu-latest

9. Adicione a seção steps. Primeiro, adicione a etapa de checkout para obter o código do repositório:

steps:
  - uses: actions/checkout@v4

10. Adicione a etapa de configuração do Node.js:

- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: "20"

Seu arquivo completo deve agora se parecer com isto:

name: Node.js CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"

Explicação

• name: O nome do seu fluxo de trabalho.
• on: [push]: Aciona o fluxo de trabalho sempre que o código é enviado (pushed) para o repositório.
• jobs: Agrupa todas as tarefas que são executadas no fluxo de trabalho.
• runs-on: ubuntu-latest: Configura o job para ser executado em uma máquina virtual hospedada pelo GitHub rodando a versão mais recente do Ubuntu.
• steps: Uma sequência de tarefas.
• uses: actions/checkout@v4: Faz o checkout do seu repositório para que o fluxo de trabalho possa acessá-lo.
• uses: actions/setup-node@v4: Esta é a action oficial para instalar o Node.js no executor (runner). Especificamos a versão '20'.

Adicionar etapa para instalar dependências com run npm install

Agora que o ambiente está configurado com Node.js, o próximo passo lógico em um pipeline de CI (Integração Contínua) é instalar as dependências do projeto. Isso garante que todas as bibliotecas externas necessárias para sua aplicação estejam disponíveis antes da compilação ou dos testes.

Abra novamente o arquivo .github/workflows/node-ci.yml e adicione a etapa para instalar as dependências.

Adicione as seguintes linhas ao final da seção steps (certifique-se de manter a indentação correta):

- name: Install dependencies
  run: npm install

Seu .github/workflows/node-ci.yml completo deve agora se parecer com isto:

name: Node.js CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
      - name: Install dependencies
        run: npm install

Explicação

• run: npm install: Isso executa o comando npm install no shell do runner. Ele lê o arquivo package.json (que criaremos mais tarde) e instala as dependências listadas.

Adicionar etapa para executar testes com run npm test

Após a instalação das dependências, a parte mais crítica da Integração Contínua (Continuous Integration - CI) é a execução de testes automatizados. Isso garante que as novas alterações não quebrem a funcionalidade existente.

Abra o arquivo .github/workflows/node-ci.yml e adicione a etapa para executar os testes.

Adicione as seguintes linhas ao final da seção steps:

- name: Run tests
  run: npm test

Seu arquivo .github/workflows/node-ci.yml final deve se parecer com isto:

name: Node.js CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test

Explicação

• run: npm test: Isso executa o script de teste definido no seu package.json. Se os testes falharem (retornarem um código diferente de zero), o fluxo do GitHub Action será marcado como falho.

Criar um package.json e um arquivo de teste simples

Para que o fluxo de trabalho que acabamos de criar funcione de fato, precisamos de uma estrutura de projeto Node.js. Especificamente, o comando npm install necessita de um arquivo package.json, e o npm test precisa de um script de teste definido.

1. Certifique-se de estar no diretório do repositório:

cd ~/project/github-actions-demo

2. Crie um arquivo package.json na raiz do repositório:

touch package.json

3. Abra o package.json e adicione o seguinte conteúdo. Isso define um projeto básico e um script de teste simples que sempre passa (sai com código 0).

{
  "name": "github-actions-demo",
  "version": "1.0.0",
  "description": "Demo project",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Running tests...\" && exit 0"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

4. Em seguida, vamos atualizar o index.js para representar o código da nossa aplicação.

echo "console.log('Hello, GitHub Actions!');" > index.js

Agora você tem um projeto Node.js mínimo que satisfaz os requisitos do fluxo de trabalho que definimos:

1. O npm install será executado (mesmo que não haja dependências, ele verificará o package.json).
2. O npm test executará o comando echo "Running tests..." && exit 0.

Fazer commit, push e verificar build/teste na execução do fluxo de trabalho

Agora que criamos a definição do workflow e os arquivos do projeto, precisamos fazer o commit e o push deles para o GitHub. O envio desses commits acionará o runner do Action para executar as etapas que definimos.

1. Certifique-se de estar no diretório do repositório:

cd ~/project/github-actions-demo

2. Verifique o status do seu repositório:

git status

3. Adicione todos os arquivos à área de staging:

git add .

4. Faça o commit das alterações com uma mensagem descritiva:

git commit -m "Add Node.js CI workflow and project files"

5. Faça o push das alterações para o repositório remoto no GitHub:

git push

Nota sobre Autenticação:
Quando você executa git push, o WebIDE solicitará automaticamente a autenticação. Siga estas etapas detalhadas:

1. Um popup aparecerá com a mensagem: "The extension 'GitHub' wants to sign in using GitHub." Clique em Allow.
2. Uma nova notificação aparecerá. Clique em "Copy&Continue to GitHub", e depois clique em "Open" no próximo prompt.
3. Faça login na sua conta do GitHub na janela do navegador que abrir e insira o código de autorização que foi copiado. Após confirmar a autorização, a página fechará automaticamente.
4. Aguarde alguns segundos e você verá o terminal concluir a operação de push com sucesso.

Nota de Privacidade: O WebIDE solicitará acesso total à sua conta do GitHub para fins de autenticação. Você não precisa se preocupar com questões de privacidade - a VM LabEx será destruída imediatamente após você concluir o laboratório atual, e suas credenciais e informações de autorização não serão retidas.

Verifique a Execução do Workflow

1. Visite seu repositório no GitHub em um navegador da web: https://github.com/your-username/github-actions-demo
2. Clique na aba Actions no topo da página do repositório.
3. Você deverá ver uma execução de workflow listada, provavelmente nomeada "Add Node.js CI workflow and project files" ou "Node.js CI".

Nota: Ao enviar código, múltiplas Ações podem ser acionadas se você tiver vários arquivos de workflow no seu repositório. Por favor, identifique a execução de workflow correta verificando o nome do workflow na barra lateral esquerda ou usando a lista de execuções de workflow no lado direito.

4. Clique no título da execução do workflow e, em seguida, clique no job build para ver os logs detalhados.

Você pode expandir cada etapa para ver o que aconteceu:

• Checkout code: Mostra que o repositório foi clonado (checked out)
• Use Node.js: Mostra que o Node.js v20 foi instalado
• Install dependencies: Mostra que npm install foi executado
• Run tests: Mostra que npm test foi executado e você deverá ver a saída Running tests...

Se todas as etapas foram concluídas com sucesso, seu workflow de CI está funcionando corretamente.

Resumo

Neste laboratório, você criou com sucesso um fluxo de trabalho básico de Integração Contínua (CI) usando o GitHub Actions. Você aprendeu a:

1. Criar um arquivo de fluxo de trabalho .yml no diretório .github/workflows.
2. Configurar o fluxo de trabalho para ser acionado em eventos de push.
3. Usar a action actions/setup-node para configurar o ambiente Node.js.
4. Adicionar etapas para instalar dependências (npm install) e executar testes (npm test).
5. Configurar uma estrutura de projeto Node.js básica para suportar o fluxo de trabalho.

Essas habilidades formam a base das práticas modernas de DevOps, permitindo automatizar a verificação do seu código toda vez que você faz uma alteração.