Integrationstests von Go-Zero: Realisierung automatisierter zerstörungsfreier Tests von API-Diensten

Da Internetunternehmen weiter wachsen, wird die Softwareentwicklung immer komplexer und das Testen immer wichtiger. Um die Korrektheit und Stabilität des Programms sicherzustellen, müssen verschiedene Arten von Tests durchgeführt werden. Unter diesen ist das automatisierte Testen eine sehr wichtige Möglichkeit, die Effizienz der Testarbeit zu verbessern, die Fehlerquote zu reduzieren und die wiederholte Ausführung von Testfällen zu ermöglichen, um Probleme frühzeitig zu erkennen. Im tatsächlichen Betriebsprozess werden wir jedoch auch auf verschiedene Probleme stoßen , wie z. B. Probleme wie die Auswahl von Testtools, das Schreiben von Testfällen und die Einrichtung einer Testumgebung.

go-zero ist ein Open-Source-Go-Sprachframework. Es basiert auf der nativen Standardbibliothek der Go-Sprache und unterstützt den schnellen Aufbau leistungsstarker, verteilter API-Dienste Eine sehr umfangreiche Testunterstützungsfunktion kann uns dabei helfen, automatisierte zerstörungsfreie Tests von API-Diensten zu realisieren und viele Schwierigkeiten im automatisierten Testprozess zu überwinden.

Dieser Artikel beginnt mit der Testunterstützungsfunktion von Go-Zero und stellt detailliert vor, wie man Go-Zero zur Implementierung automatisierter zerstörungsfreier Tests von API-Diensten verwendet.

1. Testunterstützungsfunktion von go-zero

go-zero bietet eine Fülle von Testunterstützungsfunktionen, darunter Unit-Tests, HTTP-Tests, Integrationstests, Leistungstests und serverseitige Tests. Unter diesen ist der Integrationstest ein sehr wichtiger Teil der Testunterstützungsfunktionen von Go-Zero. Die Integrationstests von

go-zero verwenden eine steckbare Methode und unterstützen eine Vielzahl von Testtools. Sie können je nach Bedarf verschiedene Testframeworks zum Testen auswählen. Zu den derzeit unterstützten Testtools gehören Webtest, Postman, Resty usw.

2. Verwenden Sie Go-Zero für automatisierte zerstörungsfreie Tests von API-Diensten.

Konfigurieren Sie die Testumgebung

1. Bevor wir Integrationstests durchführen, müssen wir zuerst die Testumgebung konfigurieren. In diesem Beispiel verwenden wir Docker-Compose, um die Umgebung zu erstellen. Die Konfigurationsdatei lautet wie folgt:

version: '3'

services:
  api:
    image: your-api-image:latest
    ports:
      - "8888:8888"
    environment:
      - MYSQL_DSN=root:@tcp(mysql:3306)/test
      - REDIS_DSN=redis:6379
      - REDIS_KEY_PREFIX=test
      - SERVICE_PORT=8888
    depends_on:
      - mysql
      - redis

  mysql:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: ''
    volumes:
      - ./docker/mysql:/docker-entrypoint-initdb.d
      - ./docker/mysql/data:/var/lib/mysql

  redis:
    image: redis:3.2
    restart: always
    volumes:
      - ./docker/redis:/data
    command: redis-server --appendonly yes

In der obigen Konfigurationsdatei sind drei Dienste definiert, nämlich API-Dienst, MySQL-Datenbank und Redis-Cache. Der API-Dienst muss Port 8888 verfügbar machen und ist auf die MySQL-Datenbank und den Redis-Cache angewiesen.

Testfälle schreiben

Nachdem wir die Testumgebung konfiguriert haben, müssen wir Testfälle schreiben. In diesem Beispiel verwenden wir Webtest zum Testen. Webtest ist ein Testframework für Webanwendungen, das das HTTP-Protokoll und das WebSocket-Protokoll unterstützt. Es bietet eine umfangreiche API, die es uns ermöglicht, HTTP-Anfragen und -Antworten zu simulieren und zu überprüfen, ob der Inhalt der Anfrage und Antwort den Erwartungen entspricht.

Das Folgende ist ein Beispiel für die Verwendung von Webtest zum Schreiben von Testfällen:

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/franktrue/grpc-demo/api"
    "github.com/franktrue/grpc-demo/internal/config"
    "github.com/franktrue/grpc-demo/internal/server"
    "github.com/franktrue/grpc-demo/internal/svc"
)

func TestCreateUser(t *testing.T) {
    cfg := config.TestConfig()
    s := server.NewServer(cfg)
    defer s.Stop()

    testCases := []struct {
        name      string
        req       *api.CreateUserRequest
        expectErr bool
    }{
        {
            name: "test createUser success",
            req: &api.CreateUserRequest{
                Name: "testUser",
                Age:  20,
            },
            expectErr: false,
        }, 
        {
            name: "test createUser failed",
            req: &api.CreateUserRequest{
                Name: "",
                Age:  20,
            },
            expectErr: true,
        },
    }

    for _, tc := range testCases {
        resp, err := s.CreateUser(nil, tc.req)
        if tc.expectErr {
            assert.NotNil(t, err, tc.name)
        } else {
            assert.Nil(t, err, tc.name)
            assert.NotNil(t, resp, tc.name)
        }
    }
}

Im obigen Code verwenden wir das Testify-Framework für Behauptungen. In der for-Schleife des Testfalls testen wir jeweils die beiden Testfälle. Das erwartete Ergebnis ist, dass der erste Anwendungsfall den Benutzer erfolgreich erstellen kann, während der zweite Anwendungsfall aufgrund illegaler Parameter fehlschlägt. Wenn der Testfall mit den Erwartungen übereinstimmt, ist die Behauptung erfolgreich; wenn der Testfall nicht mit den Erwartungen übereinstimmt, schlägt die Behauptung fehl.

Führen Sie den Testfall aus

Nachdem wir den Testfall geschrieben haben, können wir den Befehl go test verwenden, um den Testfall auszuführen:

go test -v ./tests/users_test.go

Nachdem wir den Testfall ausgeführt haben, können wir die Ausführungsergebnisse im Terminal sehen. Wenn der Testfall erfolgreich ausgeführt wird, wird das OK-Ergebnis ausgegeben. Wenn der Testfall fehlschlägt, werden detaillierte Fehlerinformationen ausgegeben.

Auf diese Weise haben wir das automatisierte zerstörungsfreie Testen des API-Dienstes abgeschlossen. Dabei haben wir die leistungsstarke Testunterstützungsfunktion von go-zero sowie die Benutzerfreundlichkeit und Flexibilität des Webtest-Testframeworks voll ausgenutzt Die Korrektheit des API-Dienstes und die Stabilität bieten eine solide Garantie.

Das obige ist der detaillierte Inhalt vonIntegrationstests von Go-Zero: Realisierung automatisierter zerstörungsfreier Tests von API-Diensten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!