Como criar e testar projetos com o Go

Introdução

Este guia mostra como criar, testar e publicar um pacote Go.

Os executores hospedados no GitHub têm um cache de ferramentas com programas de software pré-instalados, incluindo as dependências do Go. Para ver a lista completa de programas de software atualizados e as versões pré-instaladas do Go, confira "Sobre executores hospedados no GitHub".

Pré-requisitos

Você já deve estar familiarizado com a sintaxe YAML e como é usado com GitHub Actions. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Recomendamos que você tenha um entendimento básico da linguagem Go. Para obter mais informações, confira Introdução ao Go.

Como usar o fluxo de trabalho inicial do Go

O GitHub oferece um fluxo de trabalho inicial do Go que deve funcionar na maioria dos projetos Go. Este guia inclui exemplos que você pode usar para personalizar o fluxo de trabalho inicial. Para obter mais informações, confira o fluxo de trabalho inicial do Go.

Para experimentar uma introdução rápida, adicione o fluxo de trabalho inicial ao diretório .github/workflows do repositório.

name: Go package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.15'

      - name: Build
        run: go build -v ./...

      - name: Test
        run: go test -v ./...

Como especificar uma versão do Go

A maneira mais fácil de especificar uma versão do Go é usando a ação setup-go fornecida pelo GitHub. Para obter mais informações, confira a ação setup-go.

Para usar uma versão pré-instalada do Go em um executor hospedado no GitHub, passe a versão relevante para a propriedade go-version da ação setup-go. Essa ação localiza uma versão específica do Go no cache de ferramentas em cada executor e adiciona os binários necessários a PATH. Estas alterações persistirão para o resto do trabalho.

A ação setup-go é a maneira recomendada de usar o Go com o GitHub Actions, pois garante um comportamento consistente entre diferentes executores e diferentes versões do Go. Se você estiver usando um executor auto-hospedado, precisará instalar o Go e adicioná-lo a PATH.

Como usar várias versões do Go

name: Go

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.14', '1.15', '1.16.x' ]

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go ${{ matrix.go-version }}
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      # You can test your matrix by printing the current Go version
      - name: Display Go version
        run: go version

Como usar uma versão específica do Go

Você pode configurar o trabalho para usar uma versão específica do Go, como 1.16.2. Como alternativa, você pode usar a sintaxe da versão semântica para obter a última versão secundária. Este exemplo usa a última versão de patch do Go 1.16.

      - name: Setup Go 1.16.x
        uses: actions/setup-go@v3
        with:
          # Semantic version range syntax or exact version of Go
          go-version: '1.16.x'

Instalar dependências

Você pode usar go get para instalar dependências:

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
      - name: Install dependencies
        run: |
          go get .
          go get example.com/octo-examplemodule
          go get example.com/octo-examplemodule@v1.3.4

Memorizar dependências

Você pode armazenar em cache e restaurar as dependências usando a ação setup-go. Por padrão, o cache é desabilitado, mas você pode definir o parâmetro cache como true para habilitá-lo.

Quando o cache está habilitado, a ação setup-go procura o arquivo de dependência, go.sum, na raiz do repositório e usa o hash do arquivo de dependência como parte da chave de cache.

      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
          cache: true

Como alternativa, você pode usar o parâmetro cache-dependency-path para casos em que vários arquivos de dependência são usados ou quando eles estão localizados em diferentes subdiretórios.

      - uses: actions/setup-go@v3
        with:
          go-version: '1.17'
          cache: true
          cache-dependency-path: subdir/go.sum

Se você tiver um requisito personalizado ou precisar ter controles mais refinados para o cache, use a ação cache. Para obter mais informações, confira "Caching dependencies to speed up workflows".

Criar e testar seu código

Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Este fluxo de trabalho de exemplo demonstra como usar go build e go test em um trabalho:

name: Go
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.16.x'
      - name: Install dependencies
        run: go get .
      - name: Build
        run: go build -v ./...
      - name: Test with the Go CLI
        run: go test

Empacotar dados do fluxo de trabalho como artefatos

Após a conclusão de um fluxo de trabalho, você poderá fazer o upload dos artefatos resultantes para análise. Por exemplo, é possível que você precise salvar os arquivos de registro, os despejos de núcleo, os resultados de teste ou capturas de tela. O exemplo a seguir demonstra como você pode usar a ação upload-artifact para carregar os resultados do teste.

Para obter mais informações, confira "Armazenar dados do fluxo de trabalho como artefatos".

name: Upload Go test results

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.14', '1.15', '1.16.x' ]

    steps:
      - uses: actions/checkout@v3
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      - name: Install dependencies
        run: go get .
      - name: Test with Go
        run: go test -json > TestResults-${{ matrix.go-version }}.json
      - name: Upload Go test results
        uses: actions/upload-artifact@v3
        with:
          name: Go-results-${{ matrix.go-version }}
          path: TestResults-${{ matrix.go-version }}.json