Comparaison de requêtes

« Pourquoi ça a réussi cette fois et échoué la dernière fois ? » « Pour le même point de terminaison, quelle ligne exactement diffère entre la requête réussie et celle qui a échoué ? » Alignez deux requêtes / réponses côte à côte et la réponse saute aux yeux immédiatement. C’est le moyen le plus rapide d’investiguer les problèmes intermittents en production, de reproduire des différences et de vérifier des modifications.

1. Comment l’utiliser : réglé en deux étapes

Faites un clic droit sur n’importe quel morceau de trafic et choisissez « Marquer comme comparaison A ».
Faites un clic droit sur un autre morceau de trafic et choisissez « Comparer avec A ».

Une fenêtre de comparaison côte à côte apparaît immédiatement, marquant chaque différence entre les deux, ligne par ligne.

2. Quoi regarder : requêtes comme réponses peuvent être comparées

En haut de la fenêtre, vous pouvez commuter en un geste entre la comparaison de la requête ou de la réponse. Les deux côtés sont A et B, chacun avec une étiquette (méthode · hôte · statut), pour voir d’un coup d’œil lesquels vous comparez. La comparaison couvre l’intégralité du message :

Ligne de départ : la ligne de requête (méthode / adresse / protocole) ou la ligne de réponse (protocole / code de statut)
Tous les en-têtes de requête / en-têtes de réponse
Corps de requête / corps de réponse (embelli automatiquement, puis comparé ligne par ligne, avec JSON, XML et formulaires tous faciles à lire)

3. Les différences d’un coup d’œil

D’abord l’embellissement, puis la comparaison ligne par ligne : JSON, XML et formulaires sont d’abord formatés puis comparés ligne par ligne, de sorte que les champs qui ont réellement changé ressortent d’un coup d’œil, sans être noyés sous le bruit de format comme les sauts de ligne et l’indentation.
Code couleur ligne par ligne : les ajouts (+), les suppressions (−) et les modifications (~) sont chacun surlignés, le côté A marqué en rouge et le côté B en vert, les lignes modifiées affichées côte à côte.
Nombre de différences : le haut donne un récapitulatif du nombre de lignes « ajoutées / supprimées / modifiées », pour que vous en connaissiez l’ampleur.
Il vous dit quand ils sont identiques : lorsque les deux correspondent, il indique clairement « identiques », pour que vous n’ayez pas à confirmer vous-même ligne par ligne ; lorsqu’un côté n’a pas de contenu ou n’est pas encore déchiffré, il le dit directement plutôt que de vous laisser attendre.
Avec numéros de ligne : chaque côté a ses propres numéros de ligne pour localiser la position exacte.

Fenêtre de comparaison côte à côte : commutation requête / réponse en haut, A / B chacun avec une étiquette et des numéros de ligne, code couleur ligne par ligne, et un récapitulatif du nombre de lignes ajoutées / supprimées / modifiées dans le coin supérieur droit

4. Là où elle brille vraiment : comparer d’une session à l’autre et d’une source à l’autre

Les deux enregistrements comparés n’ont pas besoin de provenir de la même session de capture, ni d’avoir été capturés au même moment ; du moment que vous les avez vus dans l’interface, vous pouvez les amener pour les comparer :

Succès vs. échec : alignez une requête réussie et une qui a échoué et voyez immédiatement quel en-tête, quel paramètre ou quelle partie du corps diffère.
Fabriqué à la main vs. réel : comparez une requête rejouée / envoyée puis capturée dans le Compositeur de requêtes à une requête réelle capturée plus tôt, pour vérifier « si je l’ai bien construite » et « si la signature est calculée de façon cohérente ».
Avant et après une modification : après avoir modifié le serveur / le client, comparez l’ancienne et la nouvelle requêtes pour confirmer si la modification a pris effet et s’il y a des effets de bord.
D’un environnement à l’autre : consultez côte à côte les retours du même point de terminaison dans l’environnement de test et l’environnement de production pour localiser rapidement les différences de configuration ou de données.

C’est aussi là qu’elle est bien plus puissante que l’inspection d’une seule requête : les différences sont exposées par la comparaison plutôt qu’en s’appuyant sur la mémoire et l’œil nu. Les outils ordinaires ne peuvent souvent comparer qu’au sein de la même session, à l’œil, morceau par morceau.

5. Scénarios typiques

Investiguer des échecs intermittents : requête réussie vs. requête échouée, pour cerner le champ qui diffère.
Aligner une intégration : la requête que le client a réellement envoyée vs. la documentation de l’API / la requête attendue.
Vérification de régression : confirmer la différence dans la même requête / réponse avant et après une modification.
Débogage de signature : une requête signée fabriquée à la main vs. une requête réelle, pour vérifier si chaque partie est cohérente.

Retour à Capture par proxy · Voir aussi : Composition et rejeu de requêtes