Qu'est-ce que le test de concurrence dans les tests de logiciels ?

⚡ Résumé intelligent

Les tests de concurrence détectent les défauts qui n'apparaissent que lorsque plusieurs utilisateurs agissent simultanément sur la même application, révélant ainsi les blocages, les pertes de mises à jour et les problèmes de verrouillage que les contrôles fonctionnels séquentiels ne mettent jamais en évidence.

  • 👥 Aussi appelé: Tests multi-utilisateurs, car le déclencheur est l'accès simultané plutôt qu'un volume important de données.
  • (I.e. Ce qu'il vise : Enregistrements de base de données partagés, modules partagés et code d'application partagé accessibles par plusieurs sessions.
  • (I.e. Ce qu'il mesure : Niveaux d'interblocage, de verrouillage, de code monothread et d'accès restreint aux ressources partagées.
  • 🧭 Fonctionnement : Identifiez les flux sujets à la concurrence, définissez un objectif de concurrence, programmez des actions concrètes, puis augmentez progressivement le nombre d'utilisateurs.
  • 🐞 Classes de défauts : Conditions de concurrence, blocages, mises à jour perdues, corruption de données et famine de threads.
  • ⚠️ Limites honnêtes : Le non-déterminisme, les rappels asynchrones et une pile d'appels peu informative rendent les échecs difficiles à reproduire.

Qu’est-ce qu’un test de concurrence dans le cadre des tests logiciels avec plusieurs utilisateurs simultanés ?

Qu'est-ce que les tests de concurrence ?

Tests de concurrence Il s'agit d'une technique de test utilisée pour détecter les défauts d'une application lorsque plusieurs utilisateurs sont connectés. Autrement dit, elle surveille l'effet lorsque plusieurs utilisateurs effectuent la même action simultanément.

Les tests de concurrence sont également appelés tests multi-utilisateursTester un programme concurrent est plus complexe que tester un programme séquentiel, en raison du non-déterminisme et des problèmes de synchronisation : un même test peut réussir une exécution et échouer la suivante sans qu’une seule ligne de code ne soit modifiée.

Le schéma ci-dessous illustre l'idée : plusieurs utilisateurs accèdent à la même ressource applicative au même instant, et le test observe ce que l'application fait de ce chevauchement.

Diagramme de test de concurrence montrant plusieurs utilisateurs accédant simultanément à la même ressource applicative

Pourquoi les tests de concurrence

Deux questions justifient cet effort, et toutes deux sont invisibles lors des exécutions fonctionnelles mono-utilisateur.

  • Il permet d'identifier les effets d'un accès simultané aux mêmes enregistrements de base de données, modules ou code d'application.
  • Il identifie et mesure le niveau d'interblocage, de verrouillage, d'utilisation de code monothread et d'accès restreint aux ressources partagées.

Une fonctionnalité peut être parfaitement correcte pour un utilisateur et pourtant entraîner une perte de données pour le second utilisateur qui arrive une milliseconde plus tard ; c’est pourquoi cette technique est utilisée en complément. Test de performance plutôt que des tests fonctionnels internes.

Comment effectuer des tests de concurrence

Les tests de concurrence suivent une séquence reproductible. Les étapes ci-dessous partent du niveau de la concurrence.ping à la résolution.

  • Étape 1) Identifier les flux sujets à la concurrence. Recherchez les états partagés : connexions simultanées, réservations de sièges ou d’actions, mises à jour de solde, traitements par lots écrivant dans la même table et tout composant monothread dans le chemin.
  • Étape 2) Définir un objectif de concurrence. Déterminez le nombre d'utilisateurs qui doivent agir simultanément, en vous basant sur les pics d'utilisation réels plutôt que sur un nombre rond.
  • Étape 3) Concevoir les cas de test. Chaque projet récompensé par un cas de test associe la ressource partagée, les actions concurrentes et l'état final attendu — par exemple, deux sessions de retrait d'un même compte ne doivent pas réussir simultanément.
  • Étape 4) Script et sélection de l'outil. Un générateur de charge qui crée des utilisateurs virtuels configurables est requis ; JMeter est le choix open-source courant, et ses paramètres de groupe de threads correspondent directement aux scénarios de concurrence.
  • Étape 5) Ramp progressivement. Augmenter le nombre d'utilisateurs simultanés par étapes plutôt que d'un coup.ping à la cible, de sorte que le niveau auquel la contention commence soit visible.
  • Étape 6) Surveiller et analyser. Surveillez simultanément les temps d'attente des verrous, la dispersion du temps de réponse, les taux d'erreur et le blocage de la base de données : un défaut de concurrence se manifeste souvent par une anomalie de synchronisation avant de se manifester par une erreur.
  • Étape 7) Résolvez et relancez. Corrigez la cause de la synchronisation, de l'indexation ou du verrouillage, puis répétez la même opération pour confirmer que le comportement a changé plutôt que d'être simplement déplacé.

Défauts de concurrence courants

Les défauts de concurrence se répartissent en un petit nombre de classes identifiables, et nommer correctement la classe permet généralement de trouver directement la solution.

Défaut Ce qui se produit Symptômes typiques
Condition de course Le résultat dépend de la session qui s'est terminée en premier. Totaux corrects sur certains essais, erronés sur d'autres.
Deadlock Deux sessions, chacune détenant un verrou dont l'autre a besoin Les transactions se bloquent au lieu de renvoyer une erreur.
Mise à jour perdue Une seconde écriture écrase la première sans la lire. Une modification enregistrée disparaît silencieusement.
Corruption de données Une structure partagée n'est écrite que partiellement. Des enregistrements dans un état où aucune transaction valide ne peut être créée
Famine Une session n'obtient jamais la ressource qu'elle attend. Un seul chemin utilisateur expire alors que le système semble fonctionner correctement.

Étant donné que ces défaillances sont intermittentes, chaque exécution doit faire l'objet d'un enregistrement des journaux et des horodatages ; à défaut, le défaut ne peut être signalé de manière crédible. processus de gestion des défauts.

Exemple de test de concurrence

Imaginez une boutique en ligne qui détient le dernier exemplaire d'un produit en stock. Deux clients ouvrent l'article au même instant et appuient tous deux sur le bouton. Acheter.

  • Scénario: Deux sessions lisent stock = 1, les deux réussissent le contrôle de disponibilité et les deux écrivent stock = 0.
  • Résultat attendu: Une commande est confirmée, l'autre reçoit un message de rupture de stock, et le stock ne devient jamais négatif.
  • Indicateur de défaut : Les deux commandes se confirment, ou le stock tombe à -1, ce qui montre que la vérification de disponibilité et la décrémentation ne sont pas exécutées en une seule étape atomique.
  • Variantes intéressantes à tester : Deux sessions identiques modifiant un enregistrement de profil, deux approbations de la même demande et un traitement par lots mettant à jour la table pendant qu'un utilisateur enregistre.

Le même schéma se généralise : trouver une ressource, deux rédacteurs et aucune garantie d’ordonnancement. Exécuter le scénario pendant test du système, avant l'ajout de charge, maintient le diagnostic propre.

Avantages des tests de concurrence

  • Cela réduit considérablement l'effort nécessaire pour tester une application en limitant la portée des interactions simultanées à quelques composants largement utilisés et bien testés.
  • L'encapsulation permet d'analyser le comportement d'une partie d'un programme sans avoir à examiner l'intégralité du code source.
  • Cela contribue à améliorer la fiabilité et la robustesse des programmes exécutés simultanément.
  • Elle permet de détecter rapidement les limites de verrouillage et de blocage, de sorte que les décisions relatives à la capacité reposent sur une contention mesurée plutôt que sur des estimations.

Inconvénients des tests de concurrence

Les inconvénients ci-dessous sont généralement rencontrés par les testeurs lors de l'exécution de tests de concurrence.

  • L'application doit être testée sur plusieurs plateformes.
  • Les scénarios de concurrence nécessitent des tests plus approfondis que les scénarios séquentiels.
  • Les fonctions ne renvoient pas immédiatement leur résultat à l'appelant ; celui-ci peut être transmis ultérieurement par le biais de notifications, de blocs, de fonctions de rappel ou de mécanismes similaires, ce qui rend les tests plus difficiles.
  • Les informations ou le flux du programme ne sont pas reflétés dans la pile d'appels.
  • Le nombre de chemins d'exécution dans le système peut être extrêmement élevé, car les processus d'un système concurrent interagissent entre eux pendant leur exécution.
  • Les programmes concurrents ont un taux d'échec plus élevé que les programmes séquentiels.
  • Le débogage des programmes concurrents est difficile, car l'ajout d'un débogueur modifie le timing qui a provoqué la défaillance.

FAQ

Non. Test de charge Ce test mesure le comportement du système en fonction du volume de données attendu au fil du temps. Les tests de concurrence ciblent le même instant ; un défaut peut donc apparaître avec seulement deux utilisateurs s’ils accèdent tous deux à un enregistrement partagé.

La moitié multithread de test de thread cela se chevauche. Les tests de threads vérifient si un chemin métier survit à l'intégration ; les tests de concurrence vérifient ce que donne un accès simultané une fois que ce chemin est déjà fonctionnel.

Déduisez ce chiffre de l'utilisation maximale observée, et non d'une valeur arrondie. Commencez par deux sessions pour vérifier la fiabilité du raisonnement, puis augmentez progressivement jusqu'à la valeur maximale mesurée, en prévoyant une marge au-dessus.

Les modèles d'apprentissage automatique classent les modules selon leur historique de défauts et la complexité de leurs états partagés, indiquant ainsi aux testeurs les flux les plus susceptibles de dysfonctionner en cas de chevauchement. Le regroupement des journaux d'exécution permet ensuite d'isoler l'entrelacement ayant précédé chaque défaillance.

Copilote GitHub Il génère rapidement des scripts d'utilisateurs virtuels, des barrières et des fonctions d'aide à l'assertion. Le testeur doit néanmoins définir les ressources partagées et l'état final attendu, car les tests générés imposent rarement un chevauchement réel.

Le niveau d'isolation, le délai d'expiration du verrouillage, la taille du pool de connexions et l'indexation influent tous sur l'apparence des conflits. Il est essentiel de les consigner à chaque exécution, car un résultat obtenu avec un niveau d'isolation donné n'est pas pertinent pour un autre niveau.

Répétez le même scénario plusieurs fois à partir de données vierges, conservez des journaux horodatés et réduisez l'intervalle entre les deux actions concurrentes. L'utilisation d'un débogueur permet souvent de masquer l'erreur en modifiant le timing.

Oui, pour les conflits d'accès sensibles au volume. Les petites tables permettent à la base de données de tout conserver en mémoire et de verrouiller brièvement, de sorte que les blocages qui apparaissent en production restent invisibles. Adaptez au mieux le nombre de lignes et la taille des index en fonction de l'environnement.

Résumez cet article avec :