Postman pour les Ingénieurs QA: Du Premier Request à la Suite de Tests API

Postman envoie des requêtes HTTP, inspecte les réponses et exécute des assertions JavaScript. On peut aussi chaîner les requêtes et organiser tout ça dans des collections exécutables, sans écrire de code de framework.

Qu'est-ce que Postman ?

Postman est un outil graphique pour envoyer des requêtes HTTP. Au lieu d'écrire des commandes curl ou du code, on renseigne une URL, on choisit une méthode (GET, POST, etc.), et on clique sur Envoyer. La réponse apparaît immédiatement.

Au-delà des simples requêtes, Postman prend aussi en charge :

• Écrire des assertions de test en JavaScript
• Chaîner les requêtes (utiliser la réponse de la requête A dans la requête B)
• Exécuter automatiquement des collections de requêtes
• Partager des collections avec les coéquipiers
• Générer de la documentation API

Configuration

1. Téléchargez depuis postman.com

2. Créez un compte gratuit (nécessaire pour la synchronisation et la collaboration)

3. Ouvrez l'application et vous verrez un espace de travail avec un éditeur de requêtes

Votre première requête

1. Cliquez sur l'onglet + pour ouvrir une nouvelle requête

2. Laissez la méthode sur GET

3. Entrez l'URL : https://jsonplaceholder.typicode.com/users

4. Cliquez sur Send

Vous récupérez un tableau JSON de 10 utilisateurs. C'est tout : vous venez d'envoyer une requête API.

• Body : les données réelles retournées
• Status : code de statut HTTP (200 OK, 404 Not Found, etc.)
• Time : durée de la requête
• Size : taille de la réponse en octets

Collections et dossiers

Les collections organisent les requêtes. Voyez-les comme des dossiers pour les appels API.

1. Cliquez sur Collections dans la barre latérale gauche

2. Cliquez sur + puis Nouvelle collection

3. Nommez-la (ex. : "BecomeQA API Tests")

1. Ouvrez un onglet de requête

2. Cliquez sur Save et choisissez votre collection

3. Nommez la requête (ex. : "Obtenir tous les utilisateurs")

Variables d'environnement

Coder en dur des URLs et des tokens rend les collections fragiles. Utilisez plutôt des variables d'environnement.

1. Cliquez sur Environments dans la barre latérale gauche

2. Cliquez sur + puis Nouvel environnement

3. Nommez-le "Local" ou "Staging"

4. Ajoutez les variables :

| Variable | Valeur |

|----------|--------|

| baseUrl | http://localhost:3000 |

| userEmail | admin@test.com |

| userPassword | AdminPass1 |

| authToken | (laisser vide — rempli par la requête de connexion) |

{{baseUrl}}/api/users

La syntaxe {{variableName}} substitue la valeur à l'exécution.

Authentification

La plupart des APIs nécessitent une authentification. Le flux courant : se connecter d'abord, obtenir un token, l'utiliser dans les requêtes suivantes.

• Méthode : POST
• URL : {{baseUrl}}/api/auth/login
• Body (JSON) :

{
  "email": "{{userEmail}}",
  "password": "{{userPassword}}"
}

Dans l'onglet Tests de la requête de connexion (JavaScript) :

const response = pm.response.json();
pm.environment.set('authToken', response.token);

Désormais, à chaque exécution de la requête de connexion, le token est sauvegardé dans l'environnement.

Dans l'onglet Authorization de la requête :

• Type : Bearer Token
• Token : {{authToken}}

Ou dans l'onglet Headers :

Authorization: Bearer {{authToken}}

Écrire des tests

L'onglet Tests de chaque requête accueille des assertions JavaScript. Postman fournit l'objet pm avec tout ce dont vous avez besoin.

Vérifications du code de statut

pm.test('Statut est 200', function() {
  pm.response.to.have.status(200);
});

pm.test('Statut est 201 Created', function() {
  pm.response.to.have.status(201);
});

Vérifications du corps de la réponse

pm.test('La réponse contient l\'objet utilisateur', function() {
  const body = pm.response.json();
  pm.expect(body).to.have.property('id');
  pm.expect(body).to.have.property('email');
  pm.expect(body.role).to.equal('member');
});

Réponse en tableau

pm.test('Retourne un tableau d\'utilisateurs', function() {
  const users = pm.response.json();
  pm.expect(users).to.be.an('array');
  pm.expect(users.length).to.be.greaterThan(0);
});

pm.test('Chaque utilisateur a les champs requis', function() {
  const users = pm.response.json();
  users.forEach(user => {
    pm.expect(user).to.have.property('id');
    pm.expect(user).to.have.property('email');
  });
});

Temps de réponse

pm.test('Temps de réponse sous 500ms', function() {
  pm.expect(pm.response.responseTime).to.be.below(500);
});

En-têtes de réponse

pm.test('Content-Type est JSON', function() {
  pm.response.to.have.header('Content-Type', 'application/json; charset=utf-8');
});

Scripts de pré-requête

Les scripts de pré-requête s'exécutent AVANT l'envoi de la requête. Utiles pour générer des données dynamiques.

// Générer un e-mail unique à chaque exécution
const email = `test_${Date.now()}@example.com`;
pm.environment.set('testEmail', email);
pm.environment.set('testPassword', 'ValidPass1');

Le corps de la requête peut ensuite utiliser {{testEmail}} :

{
  "email": "{{testEmail}}",
  "password": "{{testPassword}}"
}

Chaînage de requêtes

Utiliser la sortie d'une requête comme entrée de la suivante.

Onglet Tests :

const user = pm.response.json();
pm.environment.set('createdUserId', user.id);

URL : {{baseUrl}}/api/users/{{createdUserId}}

Postman remplace automatiquement l'ID de la requête précédente.

URL : {{baseUrl}}/api/users/{{createdUserId}}

Méthode : DELETE

Exécuter des collections

Le Collection Runner exécute automatiquement toutes les requêtes d'une collection.

1. Cliquez sur votre collection puis Run collection

2. Choisissez l'environnement (Local, Staging, etc.)

3. Définissez le nombre d'itérations

4. Cliquez sur Run [Nom de la collection]

Les résultats affichent le statut pass/fail pour chaque test de chaque requête.

Newman : le CLI Postman

Newman exécute les collections Postman en ligne de commande. Indispensable pour les pipelines CI.

npm install -g newman

Collection → trois points → Export → sauvegarder en api-tests.json

Environments → trois points → Export → sauvegarder en local-env.json

newman run api-tests.json -e local-env.json

newman run api-tests.json -e local-env.json --reporters html --reporter-html-export results.html

Un workflow de test réaliste

Voici comment un ingénieur QA utilise Postman sur un vrai projet.

Postman vs tests API Playwright

| | Postman | Tests API Playwright |

|---|---|---|

| Courbe d'apprentissage | Plus faible | Plus élevée (code) |

| Intégration CI | CLI Newman | Natif |

| Réutilisation de code | Limitée | TypeScript complet |

| UI + API combinés | Non | Oui |

| Partage en équipe | Cloud Postman | Git |

Pour l'exploration API simple et les tests manuels : Postman. Pour les suites de régression automatisées qui partagent du code avec les tests UI, préférez Playwright.

Beaucoup d'équipes utilisent les deux : Postman pour l'exploration et la documentation, Playwright pour la régression automatisée.

Récapitulatif

• Les collections organisent les requêtes liées en suite de tests
• Les environnements permettent de basculer entre local/staging/production
• Les scripts de pré-requête génèrent des données de test dynamiques
• L'onglet Tests exécute des assertions JavaScript sur les réponses
• Le chaînage de requêtes transfère des données entre les requêtes
• Le CLI Newman exécute les collections dans les pipelines CI

Commencez par l'exploration manuelle dans Postman, puis ajoutez des tests à chaque requête. En une après-midi, vous pouvez avoir une collection qui couvre toute votre API, exécutable manuellement ou en CI.