Découvrez comment intégrer facilement l'analyse statique, les tests unitaires et d'autres méthodes de test de logiciels C et C++ dans votre pipeline CI/CD. Inscrivez-vous pour la démo >>

Tester rigoureusement des chaînes complexes d'API avec une approche basée sur un modèle

Par Tom Price

22 octobre 2019

3  min lire

Les API offrent aux entreprises la flexibilité nécessaire pour innover rapidement et étendre leurs offres de base aux nouveaux utilisateurs; cependant, cette flexibilité apporte également une complexité énorme pour les tests. Une approche basée sur un modèle peut être utilisée pour faire correspondre la vitesse et la variabilité de la fourniture de logiciels modernes.

Des tests d'API rigoureux doivent surmonter une complexité massive, compte tenu d'un grand nombre de cas de test possibles. Les données de message nécessaires pour atteindre les points finaux doivent «couvrir» chaque combinaison de données distincte de valeurs. Cela inclut les valeurs de données saisies par les utilisateurs, ainsi que les actions uniques qu'ils exécutent sur un système. Il inclut également les données machine générées par l'activité des utilisateurs, par exemple le type de contenu et les identifiants de session.

Les tests d'API doivent également prendre en compte les parcours par lesquels les données peuvent circuler via les API. Ils doivent couvrir les combinaisons d'actions et de méthodes d'API qui peuvent transformer les données en route pour atteindre certains points de terminaison.

Mais les API n'existent pas isolément. Ils, par définition, connectent plusieurs systèmes ou composants, de sorte que chaque test est donc un test de bout en bout dans un certain sens. Un ensemble rigoureux de tests d'API doit donc tenir compte du grand nombre d'actions ou de méthodes combinées qui peuvent transformer les données lorsqu'elles transitent par des API connectées.

Un exemple simplifié de manière irréaliste inclurait 1000 combinaisons de données entrées par l'utilisateur, 1000 combinaisons différentes de données générées par la machine et 1000 trajets distincts à travers les actions combinées:

Cela représente déjà 1 milliard de combinaisons, chacune étant candidate à un test d'API. Des tests API rigoureux doivent donc sélectionner un certain nombre de cas de test qui peuvent être exécutés en sprint, tout en conservant une couverture de test API suffisante.

Trop de tests, pas assez de temps!

Malheureusement, la techniques de test utilisées dans les tests d'API sont souvent trop manuels et non systématiques pour des tests d'API rigoureux. Les API critiques pour l'entreprise risquent d'être sous-testées à chaque étape du cycle de vie des tests :

  1. La création de tests d'API un par un dans des outils de test ou via des scripts est trop lente et ad hoc pour atteindre ne serait-ce qu'une fraction des combinaisons possibles.
  2. Les résultats attendus sont difficiles à définir à partir des définitions et des exigences des services. Le fait de se demander si une réponse est «correcte» nuit à la fiabilité des tests d'API.
  3. Les données de test manquent alors de la majorité des combinaisons nécessaires pour des tests d'API rigoureux. Les copies de faible variété des données de production se concentrent sur les scénarios prévus qui se sont produits dans le passé. Ils manquent de valeurs aberrantes et de combinaisons négatives, ainsi que de données pour tester des fonctionnalités inédites.
  4. En ce qui concerne l'exécution des tests d'API, il n'y a souvent pas d'accès aux systèmes internes et tiers. Les composants peuvent être inachevés ou utilisés par une autre équipe, ou un tiers peut ne pas fournir de sandbox pour les tests. Les contraintes environnementales sapent donc davantage l'agilité des tests API.

Tester des chaînes complexes d'API nécessite plutôt une approche intégrée et automatisée. Les testeurs d'API doivent être en mesure d'identifier le plus petit ensemble de tests d'API nécessaires à la rigueur des tests d'API, en créant systématiquement les données de test et les environnements nécessaires pour les exécuter.

Test d'API basé sur un modèle

Pour surmonter la complexité des chaînes d'appels d'API, les équipes peuvent bénéficier d'une approche basée sur un modèle pour les tests d'API, dans laquelle les testeurs peuvent générer tout le nécessaire pour des tests d'API rigoureux à partir de modèles faciles à utiliser.

Voici comment cela fonctionne:

  • Génération de tests basés sur des modèles crée des tests d'API qui «couvrent» chaque combinaison distincte de données et de méthode impliquée dans les chaînes d'API. Cela applique des algorithmes mathématiques à des modèles mathématiquement précis. Les modèles sont créés rapidement à partir de définitions de service importées et d'enregistrements de messages. Le glisser-déposer des organigrammes réutilisables assemble des tests de bout en bout pour des chaînes complexes d'API, permettant des tests rigoureux sur de courtes itérations.
  • Données de test précises et résultats attendus sont générés simultanément pour chaque test. Les résultats attendus sont simplement les blocs de fin dans les organigrammes, et Modélisateur de test en outre trouve ou crée des données «juste à temps» pour chaque test qu'il génère. Les testeurs d'API peuvent sélectionner une gamme complète de fonctions de génération de données et de processus de gestion des données de test (TDM) reproductibles au niveau du modèle. Celles-ci se résolvent «juste à temps» lors de la génération des tests, en compilant des ensembles de données cohérents conçus sur mesure pour chaque test de bout en bout.
  • Génération de données virtuelles produit les paires demande-réponse nécessaires pour simuler des composants manquants ou indisponibles. La génération de données virtuelles crée des réponses précises pour chaque demande possible. Ce processus TDM reproductible est également appelé lors de la génération ou de l'exécution des tests, garantissant que chaque test généré à partir des modèles centraux est équipé de données et d'environnements de test précis.

Grâce à cette approche intégrée, les équipes d'assurance qualité peuvent elles-mêmes générer tout le nécessaire pour des tests d'API rigoureux. La maintenance des organigrammes centraux permet d'aligner les tests, les données et les services virtuels, en testant des chaînes complexes d'API sur de courtes itérations.

Téléchargez le dernier EBook Curiosity-Parasoft pour découvrir comment cette approche peut maximiser la vitesse et la rigueur de vos tests d'API.

Automatisez les tâches de test chronophages pour les développeurs et les testeurs

Par Tom Price

Tom Pryce est un responsable de la communication technologiquement pratique chez Curiosity Software Ireland. Ses intérêts incluent les tests basés sur des modèles, la gestion des données de test et l'automatisation des processus robotiques. Il tweete sous @Curiositysoft.

Recevez les dernières nouvelles et ressources sur les tests de logiciels dans votre boîte de réception.