Tests REST API : le guide complet pour les développeurs

Introduction

Les APIs REST (Representational State Transfer) constituent la colonne vertébrale des applications web et mobiles modernes. Qu'il s'agisse de récupérer des profils utilisateur ou de traiter des paiements, pratiquement chaque application communique avec des services backend via des endpoints d'API RESTful. Tester ces APIs est essentiel pour garantir la fiabilité, les performances et la sécurité.

Ce guide couvre tout ce que vous devez savoir sur les tests REST API, depuis les fondamentaux des méthodes HTTP jusqu'aux stratégies d'automatisation avancées. Que vous soyez un développeur rédigeant votre premier test d'API ou un ingénieur QA construisant une suite de tests complète, vous trouverez des techniques pratiques et des exemples de code que vous pouvez utiliser immédiatement.

Qu'est-ce que les tests REST API ?

Les tests REST API constituent le processus de validation des services web RESTful pour s'assurer qu'ils retournent des réponses correctes, gèrent les erreurs avec élégance, fonctionnent dans des limites acceptables et restent sécurisés contre les attaques.

Contrairement aux tests UI (qui testent ce que voient les utilisateurs), les tests API vérifient directement la couche de logique métier, les rendant plus rapides, plus fiables et plus faciles à automatiser.

Ce que vous testez dans une REST API

• Codes de statut HTTP : L'API retourne-t-elle correctement 200, 201, 400, 401, 404, 500 ?
• Corps de la réponse : Le JSON/XML correspond-il au schéma et aux valeurs attendus ?
• En-têtes : Les en-têtes content-type, cache-control et CORS sont-ils corrects ?
• Authentification : Les endpoints protégés rejettent-ils les requêtes non autorisées ?
• Performance : Quelle est la vitesse de réponse de l'API sous charge normale et élevée ?
• Gestion des erreurs : L'API retourne-t-elle des messages d'erreur significatifs ?

Méthodes HTTP et quoi tester

Les REST APIs utilisent des méthodes HTTP standard. Chaque méthode a des exigences de test spécifiques :

GET : Récupérer des ressources

# Récupérer un utilisateur unique
curl -X GET https://api.example.com/users/1 \
  -H "Authorization: Bearer YOUR_TOKEN"
# Attendu : 200 OK avec les données utilisateur
# Test : Vérifiez le schéma de réponse, les types de champs et les valeurs

Liste de vérification pour GET :

• Retourne 200 pour les ressources existantes
• Retourne 404 pour les ressources inexistantes
• La pagination fonctionne correctement (limit, offset, curseur)
• Le filtrage et le tri retournent des résultats précis
• Les en-têtes de réponse incluent les directives de mise en cache appropriées

POST : Créer des ressources

# Créer un nouvel utilisateur
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "name": "Jane Doe",
    "email": "jane@example.com",
    "role": "developer"
  }'
# Attendu : 201 Created avec la nouvelle ressource

Liste de vérification pour POST :

• Retourne 201 avec la ressource créée
• Valide les champs requis (retourne 400 pour les champs manquants)
• Rejette les doublons de manière appropriée (409 Conflit)
• Assainit les entrées pour prévenir les attaques par injection
• Retourne l'identifiant de la ressource créée dans la réponse

PUT/PATCH : Mettre à jour des ressources

# Mise à jour complète (PUT)
curl -X PUT https://api.example.com/users/1 \
  -H "Content-Type: application/json" \
  -d '{"name": "Jane Smith", "email": "jane.smith@example.com", "role": "lead"}'
# Mise à jour partielle (PATCH)
curl -X PATCH https://api.example.com/users/1 

-H "Content-Type: application/json" 

-d '{"role": "lead"}'

DELETE : Supprimer des ressources

# Supprimer un utilisateur
curl -X DELETE https://api.example.com/users/1 \
  -H "Authorization: Bearer YOUR_TOKEN"
# Attendu : 204 No Content ou 200 OK

Mise en place de votre première suite de tests REST API

Construisons une suite de tests pratique en utilisant deux approches populaires : JavaScript (Node.js) et Python.

JavaScript avec Jest et Axios

// tests/users.test.js
const axios = require('axios');
const API_URL = 'https://api.example.com';
const TOKEN = process.env.API_TOKEN;
const client = axios.create({
baseURL: API_URL,
headers: { Authorization: Bearer ${TOKEN} },
});
describe('Users API', () => {
let createdUserId;
test('POST /users crée un nouvel utilisateur', async () => {
const response = await client.post('/users', {
name: 'Test User',
email: 'test@example.com',
role: 'developer',
});
expect(response.status).toBe(201);
expect(response.data).toHaveProperty('id');
expect(response.data.name).toBe('Test User');
createdUserId = response.data.id;

});
test('GET /users/:id retourne l'utilisateur créé', async () => {
const response = await client.get(/users/${createdUserId});
expect(response.status).toBe(200);
expect(response.data.email).toBe('test@example.com');

});
test('GET /users/:id retourne 404 pour un utilisateur inexistant', async () => {
try {
await client.get('/users/99999');
} catch (error) {
expect(error.response.status).toBe(404);
}
});
test('PATCH /users/:id met à jour le rôle utilisateur', async () => {
const response = await client.patch(/users/${createdUserId}, {
role: 'lead',
});
expect(response.status).toBe(200);
expect(response.data.role).toBe('lead');
});
test('DELETE /users/:id supprime l'utilisateur', async () => {
const response = await client.delete(/users/${createdUserId});
expect(response.status).toBe(204);
});
});

Python avec pytest et requests

# tests/test_users.py
import os
import pytest
import requests
API_URL = "https://api.example.com"
HEADERS = {
"Authorization": f"Bearer {os.environ['API_TOKEN']}",
"Content-Type": "application/json",
}
class TestUsersAPI:
created_user_id = None
def test_create_user(self):
    response = requests.post(
        f"{API_URL}/users",
        json={"name": "Test User", "email": "test@example.com", "role": "developer"},
        headers=HEADERS,
    )
    assert response.status_code == 201
    data = response.json()
    assert "id" in data
    TestUsersAPI.created_user_id = data["id"]

def test_get_user(self):
    response = requests.get(
        f"{API_URL}/users/{self.created_user_id}",
        headers=HEADERS,
    )
    assert response.status_code == 200
    assert response.json()["email"] == "test@example.com"

def test_get_nonexistent_user(self):
    response = requests.get(f"{API_URL}/users/99999", headers=HEADERS)
    assert response.status_code == 404

def test_delete_user(self):
    response = requests.delete(
        f"{API_URL}/users/{self.created_user_id}",
        headers=HEADERS,
    )
    assert response.status_code == 204

Meilleures pratiques pour les tests REST API

1. Tester le contrat, pas l'implémentation

Vos tests doivent valider que l'API respecte son contrat (schéma, codes de statut, format de réponse), pas comment le backend l'implémente en interne. Cela rend les tests résistants au refactoring.

2. Utiliser des variables d'environnement pour la configuration

Ne codez jamais en dur les URL d'API, les tokens ou les informations d'identification dans vos tests. Utilisez des variables d'environnement ou des fichiers de configuration.

3. Implémenter l'isolation des données de test

Chaque test doit créer ses propres données et les nettoyer ensuite. Ne dépendez jamais de données préexistantes qu'un autre test ou utilisateur pourrait modifier.

4. Valider les schémas de réponse

Ne vérifiez pas seulement les codes de statut, validez l'ensemble de la structure de réponse en utilisant la validation de schéma JSON :

const Ajv = require('ajv');
const ajv = new Ajv();
const userSchema = {
type: 'object',
required: ['id', 'name', 'email', 'role'],
properties: {
id: { type: 'integer' },
name: { type: 'string' },
email: { type: 'string', format: 'email' },
role: { type: 'string', enum: ['developer', 'lead', 'admin'] },
},
};
test('GET /users/:id correspond au schéma', async () => {
const response = await client.get('/users/1');
const validate = ajv.compile(userSchema);
expect(validate(response.data)).toBe(true);
});

5. Tester l'authentification et l'autorisation

• Une requête sans token retourne 401
• Une requête avec un token expiré retourne 401
• Une requête avec des permissions insuffisantes retourne 403
• Une requête avec un token valide retourne les données attendues

6. Tester les réponses d'erreur

Les chemins d'erreur sont tout aussi importants que les chemins heureux. Vérifiez que votre API retourne des messages d'erreur clairs et cohérents avec des codes de statut appropriés.

7. Couvrir les cas limites

• Corps de requête vides
• Chaînes extrêmement longues
• Caractères spéciaux et Unicode
• Valeurs limites pour les champs numériques
• Valeurs nulles et indéfinies
• Requêtes concurrentes vers la même ressource

Automatisation des tests REST API dans CI/CD

Les tests d'API manuels lors du développement constituent un point de départ, mais les applications en production nécessitent des tests automatisés s'exécutant à chaque changement de code.

Exemple avec GitHub Actions

name: Tests REST API
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
jobs:
api-tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
- run: npm ci
- run: npm run start:test &
- run: npx wait-on http://localhost:3000/health
- run: npm run test:api
env:
API_URL: http://localhost:3000

Automatisation avec Qodex.ai

Si vous souhaitez éviter d'écrire du code de test manuellement, Qodex.ai peut analyser votre spécification d'API et générer automatiquement des suites de tests complètes. L'agent IA crée des tests pour les chemins heureux, les cas limites, la gestion des erreurs et les vulnérabilités de sécurité, puis s'intègre dans votre pipeline CI/CD.

Comparaison des outils de tests REST API

Pour une comparaison détaillée, consultez notre comparaison des outils de tests d'API. Résumé rapide pour les tests REST :

Techniques avancées de tests REST API

Tests de contrats

Les tests de contrats garantissent que le fournisseur et le consommateur de l'API s'accordent sur le contrat d'API. Des outils comme Pact vous permettent de définir les attentes des consommateurs et de les vérifier par rapport au fournisseur. C'est essentiel pour les tests d'intégration dans les microservices.

Tests de performance

Utilisez des outils de tests de charge comme k6 ou JMeter pour vérifier que votre REST API gère le trafic attendu. Métriques clés : latence p50/p95/p99, débit (RPS), taux d'erreur sous charge.

Tests de sécurité

Les REST APIs sont des cibles d'attaque courantes. Testez les vulnérabilités couvertes dans le guide de tests de sécurité API : injection SQL, authentification brisée, exposition excessive de données, limitation de débit et mauvaise configuration CORS.

REST vs autres architectures d'API

REST n'est pas la seule option. Selon vos besoins, vous pouvez également envisager GraphQL pour des requêtes flexibles, gRPC pour la communication inter-services à haute performance, ou SOAP pour les systèmes d'entreprise avec des contrats stricts.

Foire aux questions

Quelle est la différence entre les tests REST API et les tests UI ?

Les tests REST API valident la logique backend directement en envoyant des requêtes HTTP et en vérifiant les réponses. Les tests UI interagissent avec l'interface utilisateur via un navigateur. Les tests d'API sont plus rapides, plus stables et plus faciles à automatiser car ils ignorent la couche de rendu.

Comment tester une REST API sans écrire de code ?

Des outils comme Postman, Insomnia et Hoppscotch fournissent des interfaces visuelles pour les tests. Qodex.ai va plus loin en générant automatiquement des suites de tests à partir de votre spécification d'API, sans code requis.

Que dois-je tester dans une REST API ?

Au minimum : les codes de statut HTTP, la structure du corps de la réponse, l'authentification/autorisation, la gestion des erreurs, la validation des entrées et les performances. Consultez la liste de vérification des tests d'API pour plus de détails.

Comment automatiser les tests REST API ?

Rédigez des tests en utilisant un framework comme Jest, pytest ou REST Assured, puis intégrez-les dans votre pipeline CI/CD. Ou utilisez Qodex.ai pour générer et exécuter des tests automatiquement.

Quel est le meilleur outil pour les tests REST API ?

Cela dépend de votre stack. Pour l'exploration manuelle, Postman ou Insomnia. Pour les tests automatisés basés sur le code, REST Assured (Java) ou pytest (Python). Pour l'automatisation alimentée par IA, Qodex.ai. Consultez notre comparaison complète des outils de tests d'API.

En quoi les tests REST API diffèrent-ils des tests d'API SOAP ?

REST utilise JSON via HTTP tandis que SOAP utilise XML avec des schémas WSDL stricts. Les tests REST sont plus simples car tout client HTTP fonctionne. Les tests SOAP nécessitent souvent des outils spécialisés comme SoapUI qui comprennent les WSDL et les espaces de noms XML.