Aller au contenu principal

Concepts clés

Une fois ces quatre designs assimilés, tous les protocoles et scénarios qui suivent sont simples :

  1. Le modèle à trois entités : comment Groupe / Environnement / Requête se relient
  2. Design Pre-URL de l'environnement : pourquoi les requêtes ne stockent que des chemins relatifs
  3. Le pipeline d'assemblage de l'envoi : comment un « Envoyer » transforme la configuration en requête réelle
  4. Le système de variables : d'où se résout {{variable}} et les trois couches de variables

Le modèle à trois entités​

Pourquoi l'environnement est-il lié au groupe plutôt qu'à chaque requête ? Un groupe représente généralement « toutes les API d'un module sous une même cible de déploiement ». Lier au niveau du groupe signifie que changer d'environnement bascule tout le groupe d'un coup — sans édition requête par requête. Si une requête a besoin d'un autre environnement, placez-la simplement dans un groupe lié à cet environnement.


Design Pre-URL de l'environnement​

C'est le design le plus important — et le plus mal compris.

Les requêtes stockent des chemins relatifs ; les environnements stockent des adresses de base​

Dans les outils traditionnels chaque requête stocke une URL complète (https://api.example.com/v1/users), donc passer à l'environnement de test implique de remplacer les domaines en lot. Cet outil inverse la logique :

Le scheme décide du protocole et de TLS (essentiel !)​

Les Pre-URLs sont stockées par protocole, mais le protocole réellement servi par une entrée est décidé par le scheme au début de l'URL. Le scheme exprime à la fois « quel protocole » et « chiffré ou non (TLS) » :

ProtocoleScheme en clairScheme chiffré
HTTPhttp://https://
WebSocketws://wss://
TCPtcp://tcps://
UDPudp://—
gRPCgrpc://grpcs://
MQTTmqtt://mqtts://

⚠️ Erreur fréquente : l'adresse de base d'un WebSocket doit s'écrire ws:// / wss://. Si vous tapez https://, c'est traité comme HTTP et la requête WebSocket échoue faute d'adresse de base. Gardez la ligne de protocole et le scheme cohérents.


Le pipeline d'assemblage de l'envoi​

Appuyer sur « Envoyer » ne déclenche pas directement un socket. Le pipeline assemble « requête + environnement du groupe + variables » pas à pas en une requête réelle, et insère une chaîne d'actions avant et après l'appel réseau :

Points clés :

  • Les chaînes d'actions ne s'exécutent que si « exécuter les scripts » est activé. Appuyer sur Envoyer dans l'app les exécute par défaut ; les envois automatisés / MCP doivent l'activer explicitement. Scripts désactivés, rien ne se passe : ni token injecté avant l'envoi, ni chiffrement. C'est exactement pourquoi le contrôle négatif « sans token → 401 » des recettes se comporte ainsi.
  • Les scripts de pré-envoi réécrivent la requête qui va partir ; les scripts de post-réponse réécrivent la réponse reçue. Les deux peuvent lire et écrire les variables d'exécution.

Le système de variables​

Il existe trois sortes de « variables » aux portées différentes. Les confondre est le piège le plus courant pour les débutants.

Que peut réellement résoudre {{name}} ?​

Où c'est écritVariables d'environnementVariables d'exécutionUsage typique
{{name}} (dans URL / params / headers / body)✅❌Référencer la configuration de l'environnement, remplissage dynamique
Lecture des variables dans les scripts✅✅Transmettre des tokens de connexion entre requêtes, etc.

Moyen mnémotechnique : {{}} ne voit que les variables « de configuration » ; les scripts lisent les trois couches. Les variables d'exécution sont le « tableau noir du runtime » — seuls les scripts peuvent y écrire, et {{}} ne les regarde jamais.

Pourquoi {{authToken}} ne peut-il pas lire le token enregistré au login ? Parce que le script de login l'a stocké dans la couche d'exécution, que {{}} n'interprète pas. La bonne approche est un script de pré-envoi qui le lit et injecte le header (voir recettes, scénario 1).

Variables dynamiques {{$xxx}}​

Dans {{}} il y a aussi un ensemble de variables dynamiques intégrées, régénérées à chaque évaluation, utilisables directement dans URL / params / headers / body :

VariableGénère
{{$timestamp}} / {{$timestampMs}}Horodatage Unix en secondes / millisecondes
{{$isoTimestamp}}ISO8601 UTC
{{$uuid}} / {{$guid}}UUID v4
{{$randomInt}} / {{$randomInt min,max}}Entier aléatoire (défaut 0..1000)
{{$randomBoolean}} {{$randomFullName}} {{$randomEmail}} {{$randomPhoneNumber}} {{$randomIpv4}} {{$randomIpv6}} {{$randomUrl}} {{$randomColor}} {{$randomHexadecimal}} {{$randomAlphaNumeric}} {{$randomCity}} {{$randomCountry}} {{$randomDateRecent}} {{$randomPrice}} {{$randomWord}} {{$randomLorem}} {{$randomCompanyName}} etc.Données d'exemple aléatoires variées

Exemple : GET /echo?ts={{$timestamp}}&u={{$uuid}} — en pratique, chaque envoi remplace ts/u par des valeurs réelles toutes fraîches.


Résumé​

  • Les requêtes stockent des fragments de chemin ; les environnements fournissent des adresses de base par protocole via des Pre-URLs ; le scheme décide du protocole + TLS.
  • Envoyer est un pipeline d'assemblage : assembler l'URL → interpoler → réglages de transport → chaîne de pré-envoi → réseau → chaîne de post-réponse.
  • Les variables existent sur trois couches : {{}} lit les variables de configuration, les scripts lisent les trois ; les tokens passent par les scripts, pas par {{}}.

Suivant : scripts →