Tests d'intégration du go-zero : réalisation de tests non destructifs automatisés des services API

À mesure que les sociétés Internet continuent de croître, le développement de logiciels devient de plus en plus complexe et les tests deviennent de plus en plus importants. Afin de garantir l'exactitude et la stabilité du programme, différents types de tests doivent être effectués. Parmi eux, les tests automatisés sont un moyen très important. Ils peuvent améliorer l'efficacité du travail de test, réduire les taux d'erreur et permettre l'exécution répétée de scénarios de test pour détecter les problèmes à un stade précoce. Cependant, dans le processus opérationnel réel, nous rencontrerons également divers problèmes. , tels que des problèmes tels que la sélection des outils de test, la rédaction de cas de test et la configuration de l'environnement de test.

go-zero est un framework de langage Go open source. Il est développé sur la base de la bibliothèque standard native du langage Go et prend en charge la construction rapide de services API distribués hautes performances. une fonction de support de test très riche, peut nous aider à réaliser des tests non destructifs automatisés des services API et peut surmonter de nombreuses difficultés dans le processus de test automatisé.

Cet article commencera par la fonction de support de test de go-zero et présentera en détail comment utiliser go-zero pour mettre en œuvre des tests non destructifs automatisés des services API.

1. Fonction de support de test de go-zero

go-zero fournit une multitude de fonctions de support de test, notamment les tests unitaires, les tests HTTP, les tests d'intégration, les tests de performances et les tests côté serveur. Parmi eux, les tests d'intégration constituent une partie très importante des fonctions de support de test de go-zero. Les tests d'intégration de

go-zero adoptent une méthode enfichable et prennent en charge une variété d'outils de test. Vous pouvez choisir différents frameworks de test pour tester en fonction de besoins spécifiques. Les outils de test actuellement pris en charge incluent webtest, postman, resty, etc.

2. Utilisez go-zero pour les tests non destructifs automatisés des services API

Ensuite, nous utiliserons des exemples pour démontrer comment utiliser les tests d'intégration de go-zero pour effectuer des tests non destructifs automatisés des services API.

1. Configurer l'environnement de test

Avant d'effectuer des tests d'intégration, nous devons d'abord configurer l'environnement de test. Dans cet exemple, nous utiliserons docker-compose pour créer l'environnement. Le fichier de configuration est le suivant :

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

Dans le fichier de configuration ci-dessus, trois services sont définis, à savoir le service API, la base de données MySQL et le cache Redis. Le service API doit exposer le port 8888 et s'appuie sur la base de données MySQL et le cache Redis.

2. Rédaction de cas de test

Après avoir configuré l'environnement de test, nous devons écrire des cas de test. Dans cet exemple, nous utiliserons webtest pour les tests. Webtest est un framework de test pour les applications Web, prenant en charge le protocole HTTP et le protocole WebSocket. Il fournit une API riche qui nous permet de simuler des requêtes et des réponses HTTP et de vérifier si le contenu de la requête et de la réponse répond aux attentes.

Ce qui suit est un exemple d'utilisation de webtest pour écrire des cas de test :

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)
        }
    }
}

Dans le code ci-dessus, nous utilisons le framework testify pour les assertions. Dans la boucle for du scénario de test, nous testons respectivement les deux scénarios de test. Le résultat attendu est que le premier cas d'utilisation peut réussir à créer l'utilisateur, tandis que le deuxième cas d'utilisation échouera en raison de paramètres illégaux. Si le scénario de test est conforme aux attentes, l'assertion réussit ; si le scénario de test est incompatible avec les attentes, l'assertion échoue.

3. Exécuter le scénario de test

Après avoir écrit le scénario de test, nous pouvons utiliser la commande go test pour exécuter le scénario de test :

go test -v ./tests/users_test.go

Après avoir exécuté le scénario de test, nous pouvons voir les résultats d'exécution dans le terminal. Si le scénario de test est exécuté avec succès, le résultat OK sera affiché ; si le scénario de test échoue, des informations détaillées sur l'erreur seront affichées.

De cette manière, nous avons terminé les tests non destructifs automatisés du service API. Dans le processus, nous avons pleinement utilisé la puissante fonction de support de test de go-zero ainsi que la facilité d'utilisation et la flexibilité du cadre de test Webtest pour garantir. l'exactitude du service API et la stabilité offrent une solide garantie.

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!