Guide complet sur les tests d'intégration d'API (code prêt à l'emploi disponible)

Les tests d'intégration d'API garantissent que différentes API fonctionnent ensemble comme prévu. Ces tests valident la manière dont divers composants interagissent, notamment :

Authentification API
Pagination
Limitation du débit
Corps de réponse

Conseil de pro : Pour des tests d'intégration d'API transparents, Apidog est votre plateforme de référence. Elle simplifie le processus de simulation des flux de travail réels, ce qui vous permet de tester efficacement l'interaction de plusieurs API.

button

Principaux avantages des tests d'intégration d'API

Fiabilité et exactitude des données : garantit que les données sont transférées correctement entre les systèmes et que les API fonctionnent de manière fiable.
Gestion des erreurs : aide à identifier et à résoudre les erreurs, améliorant ainsi la façon dont le système réagit aux réponses d'API problématiques.
Optimisation des performances : aide à repérer les goulets d'étranglement des performances, en particulier lors du traitement de grandes quantités de données.
Maintenance de la compatibilité : garantit que les nouvelles mises à jour de l'API ne cassent pas le système.
Sécurité : aide à détecter les vulnérabilités et à protéger les échanges de données.

Tests d'intégration d'API vs tests unitaires

Tests unitaires : teste les composants ou fonctions individuels de manière isolée.
Tests d'intégration : teste le fonctionnement conjoint de différents composants (y compris les API). Il vérifie que l'intégration des API fonctionne dans son ensemble.

Étapes clés des tests d'intégration d'API

Élaborer un plan de test : définir les objectifs et les scénarios à tester.
Créer des cas de test : créer différents cas pour couvrir divers cas d'utilisation.
Exécuter les tests : exécuter les tests d'intégration.
Suivre, signaler et résoudre les problèmes : identifier les problèmes liés aux tests, les résoudre et suivre les progrès.
Tester à nouveau : s'assurer que les corrections résolvent le problème sans en introduire de nouveaux.
Répéter : améliorer continuellement l'intégration jusqu'à ce qu'elle soit exempte de bogues.

Tests d'intégration d'API avec Apidog

Apidog rationalise considérablement les tests d'intégration d'API en permettant aux ingénieurs d'assurance qualité de concevoir et d'exécuter des scénarios de test complexes qui simulent des flux de travail réels impliquant plusieurs API.

Par exemple, dans un processus d'achat d'animaux de compagnie, où diverses API interagissent (par exemple, la navigation dans les listes d'animaux de compagnie, l'ajout d'articles à un panier, la passation d'une commande, le paiement et l'interrogation des détails de la commande), Apidog facilite la configuration de ces tests interconnectés.

using Apidog for API integration testing

Les ingénieurs d'assurance qualité peuvent créer des scénarios en reliant des points de terminaison d'API et en transférant des données entre eux, par exemple en transmettant un ID de commande entre les points de terminaison « Créer une commande » et les points de terminaison de paiement et d'interrogation de commande ultérieurs. La gestion robuste des données d'Apidog le permet soit en enregistrant l'ID de commande en tant que variable, soit en référençant directement la valeur de retour de l'étape précédente, ce qui rationalise le processus de test.

Pour les opérations plus complexes, telles que les actions en masse comme l'ajout de plusieurs animaux de compagnie à un panier, la boucle ForEach d'Apidog simplifie la tâche en insérant automatiquement les ID d'animaux de compagnie d'un tableau dans chaque requête d'API.

Apidog ForEach loop for API integration testing

Une fois les scénarios de test créés et exécutés, Apidog génère des rapports de test détaillés, qui aident les ingénieurs d'assurance qualité à identifier et à corriger rapidement les problèmes, en s'assurant que toutes les API fonctionnent correctement dans un flux de travail unifié.

api-integration-report-generated-by-apidog

Grâce aux capacités de test d'intégration d'Apidog, les développeurs peuvent simuler efficacement les actions réelles des utilisateurs, tester plusieurs points de terminaison ensemble et garantir des échanges de données transparents entre les API, ce qui en fait la plateforme de référence pour le développement, les tests et l'intégration d'API.

Découvrez comment Apidog améliore les tests d'API et améliore l'efficacité des tests pour les ingénieurs d'assurance qualité.

Meilleures pratiques pour les tests d'intégration d'API

Utiliser des bibliothèques de simulation : utiliser des bibliothèques comme requests_mock pour simuler les interactions réseau. Cela isole le test et accélère les tests en évitant les appels d'API réels.
Gestion des erreurs : tester la façon dont votre système répond à diverses erreurs d'API (par exemple, 404, 500) pour s'assurer qu'il ne se casse pas.
Tester les valeurs limites : utiliser des valeurs extrêmes pour tester la façon dont le système les gère.
Compatibilité descendante : s'assurer que les modifications de l'API ne cassent pas vos fonctionnalités existantes.
Données réalistes : utiliser des scénarios réalistes (par exemple, données réelles des utilisateurs, prix précis) pour tester le comportement du système dans le monde réel.
Maintenir les tests à jour : à mesure que les API évoluent, mettez à jour vos tests pour qu'ils restent précis et fiables.

Exemple de test d'intégration d'API

Voici un exemple pratique de test d'intégration d'API à l'aide de Python et de la bibliothèque requests_mock.

Étape 1 : Installer les bibliothèques requises

pip install requests requests_mock

Étape 2 : Exemple de code d'intégration d'API

Cet exemple montre comment intégrer deux API publiques : une pour la conversion de devises et une pour vérifier la disponibilité des produits en fonction d'un code postal.

import requests

def get_converted_price(product_price: int, conversion_currency: str) -> float:
    converted_price = None
    base_currency = "usd"
    api_url = f"https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies/{base_currency}/{conversion_currency.lower()}.json"

    try:
        resp = requests.get(api_url)
        if resp.ok:
            currency_data = resp.json()
            converted_price = product_price * currency_data[conversion_currency]
            print(f"Converted price: {round(converted_price, 2)} {conversion_currency.upper()}")
        else:
            print(f"Error: {resp.text}")
    except Exception as ex:
        print(f"Exception: {ex}")
    finally:
        return converted_price

def get_product_availability(zipcode: int) -> bool:
    availability = None
    api_url = f"https://api.zippopotam.us/us/{zipcode}"

    try:
        resp = requests.get(api_url)
        if resp.ok:
            zip_data = resp.json()
            state = zip_data["places"][0]["state"]
            availability = False if state in ["Texas", "California"] else True
            print(f"Availability in {state}: {availability}")
        else:
            print(f"Error: {resp.text}")
    except Exception as ex:
        print(f"Exception: {ex}")
    finally:
        return availability

Étape 3 : Tester les intégrations d'API

Vous pouvez créer des tests unitaires pour valider l'intégration à l'aide de unittest et requests_mock :

import unittest
import requests_mock
from api_integration import get_converted_price, get_product_availability

class TestAPIIntegrations(unittest.TestCase):

    def test_get_converted_price(self):
        test_data = {"usd": 82.6}
        expected_price = 8260
        with requests_mock.Mocker() as mock:
            mock.get("https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies/usd/inr.json", json=test_data)
            calculated_price = get_converted_price(100, "inr")
            self.assertEqual(calculated_price, expected_price)

    def test_get_converted_price_failure(self):
        with requests_mock.Mocker() as mock:
            mock.get("https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies/usd/inr.json", status_code=404)
            calculated_price = get_converted_price(100, "inr")
            self.assertIsNone(calculated_price)

    def test_get_product_availability_true(self):
        test_data = {"places": [{"state": "California"}]}
        with requests_mock.Mocker() as mock:
            mock.get("https://api.zippopotam.us/us/90210", json=test_data)
            availability = get_product_availability(90210)
            self.assertTrue(availability)

    def test_get_product_availability_false(self):
        test_data = {"places": [{"state": "Texas"}]}
        with requests_mock.Mocker() as mock:
            mock.get("https://api.zippopotam.us/us/75001", json=test_data)
            availability = get_product_availability(75001)
            self.assertFalse(availability)

    def test_get_product_availability_failure(self):
        with requests_mock.Mocker() as mock:
            mock.get("https://api.zippopotam.us/us/75001", status_code=500)
            availability = get_product_availability(75001)
            self.assertIsNone(availability)

if __name__ == '__main__':
    unittest.main(verbosity=2)

Étape 4 : Exécuter les tests d'intégration d'API

Pour exécuter les tests, utilisez la commande suivante dans votre terminal :

python api_integration_tests.py

Cela exécutera tous les tests et affichera une sortie détaillée de chacun d'eux, y compris si les réponses de l'API simulée ont été correctement gérées et si les résultats attendus ont été atteints.

Réflexions finales

Les tests d'intégration d'API garantissent que les API fonctionnent ensemble comme prévu. En utilisant des bibliothèques de simulation et des cas de test complets, vous pouvez vérifier efficacement le comportement d'intégration de votre système. Assurez-vous toujours que vos tests sont mis à jour à mesure que vos API évoluent et envisagez de mettre en œuvre des tests automatisés pour l'intégration continue.

Si vous cherchez à automatiser davantage le processus d'intégration, des outils comme Apidog offrent une API unifiée pour la mise à l'échelle et les tests rapides des intégrations.