Comment utiliser GitLab pour les tests et la simulation d'API

Comment utiliser GitLab pour les tests et la simulation d'API

Introduction :
Dans le processus de développement logiciel, les tests et la simulation d'API (Application Programming Interface, interface de programmation d'application) sont une étape très importante, ils peuvent aider les développeurs à vérifier l'API l'exactitude et les performances, et les problèmes potentiels peuvent être découverts à l'avance. GitLab est une plateforme d'hébergement de code très populaire qui implémente des fonctions telles que le contrôle de version et la collaboration en équipe. Cet article explique comment utiliser GitLab pour les tests et la simulation d'API et fournit des exemples de code spécifiques.

1. Créer un entrepôt de tests
Créez un nouvel entrepôt de tests dans GitLab pour stocker le code et les fichiers de configuration liés aux tests d'API. Vous pouvez créer un nouveau référentiel en cliquant sur le bouton "Nouveau projet" sur l'interface GitLab, ou en exécutant la commande suivante via l'outil de ligne de commande :

$ git clone http://gitlab.example.com/your-username/your-project.git
$ cd your-project
$ touch README.md
$ git add README.md
$ git commit -m "initial commit"
$ git push -u origin master

La commande ci-dessus clonera le référentiel distant et créera un fichier README.md localement .et poussez-le vers l'entrepôt distant. Ensuite, nous pouvons créer des répertoires et des fichiers sur cette base pour stocker le code et les fichiers de configuration liés aux tests API.

2. Installer les dépendances nécessaires
Avant d'effectuer des tests et une simulation d'API, nous devons installer certaines dépendances nécessaires. Créez un fichier nommé "requirements.txt" dans le répertoire racine de l'entrepôt et ajoutez le contenu suivant au fichier :

python-gitlab
flask
pytest

Exécutez ensuite la commande suivante pour installer ces dépendances :

$ pip install -r requirements.txt

3. Écrivez le code de test de l'API
Créez un Fichier Python nommé "api_test.py" dans l'entrepôt et écrivez-y le code de test de l'API. Voici un exemple simple :

from flask import Flask
from flask import jsonify

app = Flask(__name__)

@app.route('/api/hello')
def hello():
    return jsonify(message='Hello, world!')

if __name__ == '__main__':
    app.run()

Dans le code ci-dessus, nous utilisons le framework Flask pour créer une API simple et définir une route "/api/hello". Lorsque la route est demandée, une réponse au format JSON est renvoyée. Nous pouvons écrire du code de test API plus complexe en fonction des besoins réels.

4. Écrivez le code de simulation API
Créez un fichier Python nommé "api_mock.py" dans l'entrepôt et écrivez-y le code de simulation API. Voici un exemple simple :

from flask import Flask
from flask import jsonify

app = Flask(__name__)

@app.route('/api/hello')
def hello():
    return jsonify(message='Mock Hello!')

if __name__ == '__main__':
    app.run()

Dans le code ci-dessus, nous avons créé une simulation d'API simple à l'aide du framework Flask et défini une route "/api/hello" qui est la même que l'API précédente, mais la réponse renvoyée est " Moquez Bonjour!". Nous pouvons écrire du code de simulation API plus complexe en fonction des besoins réels.

5. Écrivez un script de test
Créez un fichier Python nommé "test_api.py" dans l'entrepôt et écrivez-y le script de test de l'API. Voici un exemple simple :

import pytest
import requests

def test_api_hello():
    response = requests.get('http://localhost:5000/api/hello')
    assert response.status_code == 200
    assert response.json()['message'] == 'Hello, world!'

if __name__ == '__main__':
    pytest.main()

Dans le code ci-dessus, nous avons écrit un simple script de test d'API à l'aide de la bibliothèque pytest et défini un scénario de test nommé "test_api_hello" qui envoie une requête GET à l'API frontale pour vérifier si la réponse renvoyée le code d'état et le contenu du message sont conformes aux attentes. Nous pouvons rédiger davantage de cas de test en fonction des besoins réels.

6. Écrivez un script de simulation
Créez un fichier Python nommé "mock_api.py" dans l'entrepôt et écrivez-y le script de simulation de l'API. Voici un exemple simple :

import os
from subprocess import Popen, PIPE

def start_mock_api():
    process = Popen(['python', 'api_mock.py'], cwd=os.getcwd())
    return process

def stop_mock_api(process):
    process.terminate()
    process.wait()

if __name__ == '__main__':
    mock_api_process = start_mock_api()
    input('Press any key to stop the mock API...')
    stop_mock_api(mock_api_process)

Dans le code ci-dessus, nous utilisons la bibliothèque de sous-processus pour ouvrir un nouveau processus afin de démarrer la simulation d'API, puis attendons dans la console que l'utilisateur entre n'importe quelle clé pour arrêter la simulation. Nous pouvons écrire des scripts de simulation plus complexes en fonction des besoins réels.

7. Soumettez le code à GitLab
Après avoir terminé l'écriture du code de test et de simulation de l'API, nous pouvons le soumettre à l'entrepôt GitLab. Exécutez la commande suivante pour soumettre le code à l'entrepôt distant :

$ git add .
$ git commit -m "add API test and mock code"
$ git push

8. Configuration CI/CD dans GitLab
Afin de réaliser des tests et une simulation automatisés de l'API, nous pouvons configurer CI/CD (Continuous Integration/Continuous Deployment) dans GitLab . Créez un fichier nommé ".gitlab-ci.yml" dans le référentiel et ajoutez-y le contenu suivant :

stages:
  - test
  - mock

api_test:
  stage: test
  script:
    - pip install -r requirements.txt
    - pytest

api_mock:
  stage: mock
  script:
    - pip install -r requirements.txt
    - python mock_api.py

Dans la configuration ci-dessus, nous définissons d'abord deux étapes : "test" est utilisé pour les tests d'API, "mock" est utilisé pour la simulation API. Ensuite, une tâche est définie dans "api_test", qui sera exécutée dans la phase "test". Dans le script de cette tâche, nous installons d'abord les dépendances, puis exécutons la commande pytest pour exécuter le script de test de l'API. De même, une autre tâche est définie dans "api_mock", qui sera exécutée lors de la phase "mock". Dans le script de cette tâche, nous installons d'abord les dépendances puis exécutons le script de simulation personnalisé.

9. Exécuter les tests et la simulation de l'API
Lorsque nous soumettons le code à GitLab, la configuration CI/CD déclenchera automatiquement les tâches de test et de simulation de l'API. Nous pouvons afficher les résultats d'exécution des tâches correspondantes et la sortie du journal via l'interface GitLab. Si tout fonctionne correctement, nous pouvons alors continuer à développer et maintenir le code pour les tests et les simulations de l'API, et réexécuter les tests et les simulations si nécessaire.

Résumé :
En utilisant GitLab pour les tests et la simulation des API, nous pouvons mieux effectuer le contrôle qualité pendant le processus de développement logiciel et évaluer la stabilité et les performances de l'interface API. Cet article explique comment utiliser GitLab pour créer un référentiel de test, installer des dépendances, écrire du code pour les tests et la simulation d'API, écrire des scripts de test et des scripts de simulation et effectuer une configuration CI/CD dans GitLab. J'espère que les lecteurs pourront mieux comprendre et appliquer les techniques de test et de simulation d'API grâce à l'introduction et à l'exemple de code de cet article.

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!