Définition d'une interface

Une interface, ou API (Application Programming Interface), est un point d'accès défini permettant à des composants logiciels de communiquer entre eux sans connaissance des implémentations internes. On peut la caractériser par trois aspects principaux :

• Elle encapsule une fonctionnalité (code exécutable).
• Elle masque les détails d'implémentation.
• Elle fournit un point d'accès (adresse) et des règles d'utilisation (format de requête) pour obtenir des informations ou effectuer des opérations.

D'un point de vue pratique, une interface expose :

1. Ses fonctionnalités.
2. Une adresse pour y accéder.
3. Un format de requête et des paramètres attendus.
4. Un mécanisme de réponse (données ou statut).

Dans un système logiciel, une interface sert de médiateur entre différents modules ou services, facilitant l'intégration et le travail en équipe.

Objectifs et périmètre des tests d'interfaces

Les tests d'interfaces (ou tests d'API) valident les interactions entre composants systèmes. Ils vérifient l'échange de données, la gestion de flux et les dépendances logiques entre services.

Pourquoi les pratiquer ?

• Ils se situent entre les tests unitaires (développement) et les tests de système.
• Les interfaces sont le fondement des fonctionnalités ; une défalilance peut affecter de nombreux modules.
• Détecter les défauts tôt réduit les coûts de correction.
• Les interfaces sont généralement plus stables que l'interface graphique, ce qui les rend adaptées à l'automatisation et à l'intégration continue.

Compétences clés :

• Compréhension des modèles réseau (OSI, TCP/IP) et des protocoles (HTTP/HTTPS, RPC, REST).
• Maîtrise d'outils comme Postman, JMeter ou curl.
• Connaissance des outils de capture réseau (Wireshark, Fiddler).
• Compétences en programmation (Python, Java) et en manipulation de bases de données.

Fondamentaux réseau : IP, ports et résolution de noms

Adresse IP : Identifiant unique attribué à un appareil sur un réseau. Elle se présente sous la forme de quatre octets (ex: 192.168.1.1).

Exemple de validation Python d'une adresse IPv4 :

def valider_adresse_ip(adresse):
    segments = adresse.split('.')
    if len(segments) != 4:
        return False
    for seg in segments:
        if not seg.isdigit():
            return False
        valeur = int(seg)
        if not 0 <= valeur <= 255:
            return False
    return True

Port : Point de terminaison logique pour la communication (0 à 65535). Les ports standard sont associés à des services (80 pour HTTP, 443 pour HTTPS, 3306 pour MySQL, etc.).

Nom de domaine et DNS : Un nom de domaine (ex: www.example.com) est un alias mémorable pour une adresse IP. Le système DNS (Domain Name System) assure la correspondance entre les noms de domaines et les adresses IP.

Le modèle OSI et les protocoles de transport

Le modèle OSI décrit la communication réseau en 7 couches. Pour les tests d'interfaces, les couches supérieures (Application, Présentation, Session) et la couche Transport sont primordiales.

Protocoles TCP et UDP :

• TCP (Transmission Control Protocol) : Fiable, orienté connexion, garantit l'ordre et l'intégrité des données.
• UDP (User Datagram Protocol) : Plus rapide, sans connexion, ne garantit pas la livraison ou l'ordre des paquets.

Protocole HTTP : Détail d'une transaction

HTTP (HyperText Transfer Protocol) est un protocole sans état pour la communication web. Une transaction comprend une requête et une réponse.

Anatomie d'une requête HTTP (GET) :

GET /chemin/ressource?param1=valeur1 HTTP/1.1
Host: www.serveur.com
User-Agent: MonClient/1.0
Accept: application/json

Le corps (body) est vide pour une requête GET.

Anatomie d'une requête HTTP (POST) :

POST /api/utilisateur HTTP/1.1
Host: www.serveur.com
Content-Type: application/json
Content-Length: 56

{"nom": "Dupont", "email": "dupont@exemple.com"}

URL (Uniform Resource Locator) :

Structure : schema://hote:port/chemin?parametres

Les paramètres sont encodés (ex: espace devient %20 ou +).

Méthodes HTTP courantes :

En-têtes de requête (Headers) : Métadonnées envoyées avec la requête. Content-Type définit le format des données dans le corps (application/json, application/x-www-form-urlencoded, etc.).

Réponse HTTP :

HTTP/1.1 200 OK
Date: Lun, 01 Jan 2024 12:00:00 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 42

{"id": 123, "statut": "success"}

Codes de statut HTTP :

• 2xx Succès : 200 OK, 201 Créé.
• 3xx Redirection : 301 Déplacé de manière permanente, 302 Trouvé.
• 4xx Erreur client : 400 Requête incorrecte, 401 Non autorisé, 404 Non trouvé, 405 Méthode non autorisée.
• 5xx Erreur serveur : 500 Erreur interne du serveur, 502 Passerelle incorrecte, 504 Délai d'attente de la passerelle.

HTTP vs HTTPS : HTTPS ajoute une couche de chiffrement (SSL/TLS) à HTTP, garantissant la confidentialité et l'intégrité des données. Il utilise le port 443 par défaut.

Authentification et mécanismes de session

Cookies et Sessions :

• Cookie : Donnée stockée sur le client (navigateur), envoyée automatiquement avec chaque requête au domaine correspondant.
• Session : Mécanisme côté serveur qui stocke des informations liées à l'utilisateur. Un identifiant de session (session ID) est généralement stocké dans un cookie.

Schémas d'authentification courants :

1. Basé sur Session/Cookie : Utilisé pour les interfaces internes après une étape de login.
2. Token d'accès (JWT, OAuth2) : Un jeton unique est émis après authentification et passé dans l'en-tête Authorization des requêtes. Adapté aux APIs publiques.
3. Signature de requête : Paramètres signés avec une clé secrète (ex: HMAC) pour garantir leur intégrité et l'authenticité de l'appelant.

Considérations pour les tests d'interface

• Variables dynamiques : Les paramètres (timestamps, tokens) doivent être générés ou extraits de réponses précédentes.
• Dépendances entre requêtes : Une réponse peut contenir des identifiants nécessaires à la requête suivante.
• Validation des réponses : Vérifier le code de statut, les en-têtes et le corps (schéma JSON, valeurs précises).
• Cas asynchrones : Pour les opérations longues, implémenter des mécanismes de polling ou de callback.
• Gestion du cache : Lors du debug ou des tests de performance, prendre en compte la politique de cache (Cache-Control, ETag).