Nahtlose Integrationstests für Ihre Go-Anwendung auf GitHub-Aktionen mit PostgreSQL

Einführung

Integrationstests sind entscheidend, um sicherzustellen, dass Ihre Go-Anwendung einwandfrei mit externen Abhängigkeiten wie Datenbanken funktioniert. In diesem Blog erfahren Sie, wie Sie mithilfe von GitHub Actions Integrationstests für eine Go-Anwendung einrichten und ausführen. Wir konfigurieren eine PostgreSQL-Datenbank innerhalb der CI-Pipeline, optimieren den Testprozess und stellen sicher, dass Ihre Codebasis bei jedem Push zuverlässig und produktionsbereit ist. Lass uns eintauchen!.

In einem früheren Artikel haben wir hier Unit-Tests und Integrationen erstellt!. In diesem Artikel möchten wir diese Tests für alle Commits in unserem Github-Repository ausführen.

Github-Aktionen

Es handelt sich um eine Plattform für kontinuierliche Integration und kontinuierliche Bereitstellung (CI/CD), mit der Sie Ihre Build-, Test- und Bereitstellungspipeline automatisieren können.
Mit Github Actions können Sie Workflows ausführen, wenn andere Ereignisse in Ihrem Repository passieren

Github-Workflows

Ein Workflow ist ein konfigurierbarer automatisierter Prozess, der einen oder mehrere Jobs ausführt. Workflows werden durch eine in Ihr Repository eingecheckte YAML-Datei definiert und werden ausgeführt, wenn sie durch ein Ereignis in Ihrem Repository ausgelöst wird. Workflows werden in .github/workfows.

definiert

• Ereignis ist eine bestimmte Aktivität in einem Repository, die eine Workflow-Ausführung auslöst. In unserem Fall wird dies ein Push für unsere Filiale sein.
• Jobs ist eine Reihe von Schritten in einem Workflow, die auf demselben Läufer ausgeführt werden.
• Runners ist ein Server, der Ihre Workflows ausführt, wenn sie ausgelöst werden. Jeder Läufer kann jeweils einen einzelnen Job ausführen.

Workflow Yaml

• Der erste Schritt wäre, den Ordner .github/workflows zu erstellen, in dem sich unsere Yaml-Datei befindet.
• Als nächstes erstellen Sie die Yaml-Datei. In diesem Fall nennen wir sie 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-Beschreibung

• Der erste Teil besteht darin, die Aktion zu benennen, in diesem Fall ist sie ci-test.

Workflow-Trigger

• Der zweite Abschnitt beschreibt Auslöser. Ereignisse, die die Aktion auslösen. In dieser Datei haben wir zwei Ereignisse, die die Ausführung dieser Jobs auslösen: Pushes und Pull Requests, die auf die Hauptzweige abzielen. Dadurch wird sichergestellt, dass jede für die Produktion vorgesehene Codeänderung vor der Zusammenführung getestet wird, wodurch die Integrität des Projekts gewahrt bleibt.

Umgebungsvariablen

Github-Workflows unterstützen globale und auftragsspezifische Umgebungsvariablen. Diese Variablen beschreiben Postgres-Anmeldeinformationen, die wir später in unserer Yaml-Datei verwenden werden.

Arbeit

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

Hier haben wir dem Job einen Namen zugewiesen, der die Kernaufgaben ausführt, nämlich das Erstellen und Testen unseres Codes.
Runner – beschreibt, wo der Workflow ausgeführt wird, bei dem es sich um eine virtuelle Ubuntu-Maschine handelt.

Dienstleistungen

Mit Github Actions-Workflows können Sie Dienste definieren. In diesem Fall benötigen wir eine Postgres-Datenbank, mit der wir unsere Tests ausführen können.

• Ein PostgreSQL-Container wird mit dem offiziellen PostgreSQL-Docker-Image erstellt.
• Der Container ist mit Umgebungsvariablen konfiguriert, die wir zuvor deklariert haben

Workflow-Schritte

• Der erste Schritt besteht darin, den Repository-Code auszuchecken

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

Diese Zeile ruft die neueste Version des Repositorys ab und bietet Zugriff auf alle Quelldateien.

• Der zweite Schritt besteht darin, Golang im Läufer einzurichten.

- uses: actions/checkout@v4

• Der dritte Schritt ist die Installation von dbmate auf unserem Runner. Dbmate ist ein Migrationstool, das Anwendungsmigrationen verwaltet.

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

• Viertens muss die Datenbank-URL erstellt werden

- 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

• Fünftens führen wir Datenbankmigrationen durch, um unsere Beziehungen einzurichten, die mit dem Datum versehen werden

- 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

• Die vorletzte Aktion besteht darin, die Datenbank mit Testdaten zu füllen.

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

Die Datei „seed.go“ füllt die Datenbasis mit Testdaten. Aufbau einer realitätsnahen Testumgebung. Um diese Datei weiter zu prüfen, besuchen Sie hier

Der letzte Schritt besteht darin, unseren Go-Test mit der Make-Datei auszuführen

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

Dieser Workflow wird jetzt jedes Mal ausgeführt, wenn wir eine Pull-Anfrage oder einen Push-Code an unseren Hauptzweig stellen

Einige Vorteile der Einführung von Github-Aktionen.

Wie wir gesehen haben, können Sie mit Github Action Folgendes tun:

1. Automatisierte Tests – Führen Sie Tests konsistent bei jeder Codeänderung durch.
2. Verfügen Sie über Datenbankintegrationen – stellen Sie eine echte Postgres-Umgebung zum Testen und Simulieren von Produktionsbedingungen bereit
3. Reproduzierbare Umgebung – Github-Aktionen nutzen containerisierte Dienste und vordefinierte Schritte, um konsistente Ergebnisse über alle Läufe hinweg sicherzustellen.
4. Schnelle Feedbackschleife – Sie ermöglichen Entwicklern, schnelles Feedback zu erhalten, wenn etwas kaputt geht, was eine schnellere Problemlösung ermöglicht.
5. Vereinfachte Zusammenarbeit – Sie stellen sicher, dass die Änderungen aller Mitwirkenden vor der Veröffentlichung überprüft werden, wodurch die Codequalität und die Projektstabilität erhalten bleiben

Schlussfolgerungen

Durch die Nutzung von GitHub Actions optimiert dieser Workflow das Testen und die Datenbankeinrichtung und gewährleistet so eine robuste und zuverlässige Softwareentwicklung.
Besuchen Sie das Github-Repository, um den Code anzuzeigen, der mit der oben beschriebenen Aktion getestet wird.

Das obige ist der detaillierte Inhalt vonNahtlose Integrationstests für Ihre Go-Anwendung auf GitHub-Aktionen mit PostgreSQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!