Tests d'intégration transparents pour votre application Go sur les actions GitHub avec PostgreSQL

Introduction

Les tests d'intégration sont cruciaux pour garantir que votre application Go fonctionne parfaitement avec des dépendances externes telles que des bases de données. Dans ce blog, nous explorerons comment configurer et exécuter des tests d'intégration pour une application Go à l'aide de GitHub Actions. Nous configurerons une base de données PostgreSQL dans le pipeline CI, rationaliserons le processus de test et garantirons que votre base de code est fiable et prête pour la production à chaque poussée. Allons-y !.

Nous avons créé des tests unitaires et des intégrations dans un article précédent c'est par ici !. Dans cet article, nous souhaitons exécuter ces tests sur tous les commits dans notre référentiel github.

Actions GitHub

Il s'agit d'une plateforme d'intégration continue et de livraison continue (CI/CD) qui vous permet d'automatiser votre pipeline de build, de test et de déploiement.
Github Actions vous permet d'exécuter des workflows lorsque d'autres événements se produisent dans votre référentiel

Flux de travail Github

Un workflow est un processus automatisé configurable qui exécutera une ou plusieurs tâches. Les workflows sont définis par un fichier YAML archivé dans votre référentiel et s'exécuteront lorsqu'ils seront déclenchés par un événement dans votre référentiel. Les workflows sont définis dans le .github/workfows.

• Un Événement est une activité spécifique dans un référentiel qui déclenche l'exécution d'un workflow. Dans notre cas, ce sera un coup de pouce vers notre succursale.
• Jobs est un ensemble d'étapes dans un flux de travail exécuté sur le même coureur.
• Runners est un serveur qui exécute vos workflows lorsqu'ils sont déclenchés. Chaque exécuteur peut exécuter une seule tâche à la fois.

Flux de travail Yaml

• La première étape serait de créer le dossier .github/workflows où se trouvera notre fichier yaml.
• Ensuite, créez le fichier yaml. Dans ce cas, nous le nommerons ci-test.yml.

name: ci-test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  POSTGRES_USER: postgres
  POSTGRES_PASSWORD: Password123
  POSTGRES_DB: crud_db

jobs:
  build:
    name: tests
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres
        env:
          POSTGRES_USER: ${{ env.POSTGRES_USER }}
          POSTGRES_PASSWORD: ${{ env.POSTGRES_PASSWORD }}
          POSTGRES_DB: ${{ env.POSTGRES_DB }}
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: "1.22"

      - name: Install dbmate for golang migrations
        run: |
          sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
          sudo chmod +x /usr/local/bin/dbmate
          which dbmate

      - name: Construct DB URL
        id: construct_url
        run: echo "DB_URL=postgres://${{ env.POSTGRES_USER }}:${{ env.POSTGRES_PASSWORD }}@localhost:5432/${{ env.POSTGRES_DB }}?sslmode=disable" >> $GITHUB_ENV

      - run: env

      - name: Make Migrations
        run: make migrations URL=${{ env.DB_URL }}

      - name: Seed test DB
        run: go run db/seed.go

      - name: Test
        run: make test

Yaml descriptif

• La première partie est de nommer l'action dans ce cas c'est ci-test.

Déclencheurs de flux de travail

• La deuxième section décrit les déclencheurs. Événements qui déclenchent l'action. Dans ce fichier nous avons deux événements qui vont déclencher l'exécution de ces jobs, des pushes et des pull request ciblant les branches principales. Cela garantit que chaque modification de code destinée à la production est testée avant d'être fusionnée, préservant ainsi l'intégrité du projet.

Variables d'environnement

Les workflows Github prennent en charge les variables d'environnement globales et spécifiques à la tâche. Ces variables décrivent les informations d'identification postgres que nous utiliserons plus tard dans notre fichier yaml.

Emploi

name: ci-test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  POSTGRES_USER: postgres
  POSTGRES_PASSWORD: Password123
  POSTGRES_DB: crud_db

jobs:
  build:
    name: tests
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres
        env:
          POSTGRES_USER: ${{ env.POSTGRES_USER }}
          POSTGRES_PASSWORD: ${{ env.POSTGRES_PASSWORD }}
          POSTGRES_DB: ${{ env.POSTGRES_DB }}
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: "1.22"

      - name: Install dbmate for golang migrations
        run: |
          sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
          sudo chmod +x /usr/local/bin/dbmate
          which dbmate

      - name: Construct DB URL
        id: construct_url
        run: echo "DB_URL=postgres://${{ env.POSTGRES_USER }}:${{ env.POSTGRES_PASSWORD }}@localhost:5432/${{ env.POSTGRES_DB }}?sslmode=disable" >> $GITHUB_ENV

      - run: env

      - name: Make Migrations
        run: make migrations URL=${{ env.DB_URL }}

      - name: Seed test DB
        run: go run db/seed.go

      - name: Test
        run: make test

Ici, nous avons attribué un nom au travail qui effectuera les tâches principales, à savoir la construction et le test de notre code.
Runner - décrit l'endroit où le flux de travail s'exécutera, qui sera une machine virtuelle Ubuntu.

Services

Les workflows Github Actions vous permettent de définir des services. Dans ce cas, nous avons besoin d'une base de données Postgres sur laquelle exécuter nos tests.

• Un conteneur PostgreSQL est créé à l'aide de l'image Docker officielle de PostgreSQL.
• Le conteneur est configuré avec les variables d'environnement que nous avons déclarées précédemment

Étapes du flux de travail

• La première étape consiste à extraire le code du référentiel

jobs:
  build:
    name: tests
    runs-on: ubuntu-latest

Cette ligne récupère la dernière version du référentiel, donnant accès à tous les fichiers sources.

• La deuxième étape consiste à configurer le golang dans le coureur.

- uses: actions/checkout@v4

• La troisième étape consiste à installer dbmate sur notre coureur. Dbmate est un outil de migration qui gérera les migrations d'applications.

- name: Set up Go
  uses: actions/setup-go@v4
  with:
    go-version: "1.22"

• Quatrièmement, construire l'URL de la base de données

- name: Install dbmate for golang migrations
  run: |
    sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
    sudo chmod +x /usr/local/bin/dbmate
    which dbmate

• Cinquièmement, nous exécutons des migrations de base de données pour configurer nos relations qui seront amorcées avec la date.

- name: Construct DB URL
  id: construct_url
  run: echo "DB_URL=postgres://${{ env.POSTGRES_USER }}:${{ env.POSTGRES_PASSWORD }}@localhost:5432/${{ env.POSTGRES_DB }}?sslmode=disable" >> $GITHUB_ENV

• L'avant-dernière action consiste à ensemencer la base de données avec des données de test.

- name: Make Migrations
  run: make migrations URL=${{ env.DB_URL }}

Le fichier seed.go amorce la base de données avec les données de test. Mise en place d'un environnement de test réaliste. Pour inspecter ce fichier plus en détail, visitez ici

La dernière étape consiste à exécuter notre test go à l'aide du fichier make

- name: Seed test DB
  run: go run db/seed.go

Ce workflow s'exécutera désormais chaque fois que nous ferons une pull request ou pousserons du code vers notre branche principale

Quelques avantages de l'adoption de l'action Github.

Comme nous l'avons vu, l'action github vous permet de le faire

1. Tests automatisés : exécutez des tests de manière cohérente à chaque modification de code.
2. Avoir des intégrations de bases de données - fournir un véritable environnement Postgres pour les tests, simulant les conditions de production
3. Environnement reproductible - L'action Github utilise des services conteneurisés et des étapes prédéfinies pour garantir des résultats cohérents dans toutes les exécutions.
4. Boucle de commentaires rapides : ils permettent aux développeurs de recevoir des commentaires rapides en cas de problème, ce qui permet une résolution plus rapide des problèmes.
5. Collaboration simplifiée – Ils garantissent que les modifications de tous les contributeurs sont vérifiées avant leur apparition, maintenant ainsi la qualité du code et la stabilité du projet

Conclusions

En tirant parti des actions GitHub, ce flux de travail rationalise les tests et la configuration de la base de données, garantissant ainsi un développement logiciel robuste et fiable.
Visitez le référentiel github pour afficher le code en cours de test avec l'action décrite ci-dessus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!