# Tests de contrat

## Ce que c'est

Les tests de contrat vérifient que deux composants s'accordent sur les requêtes, réponses ou
messages qu'ils échangent. Un écran de suivi de colis et un service de suivi peuvent tous deux
passer leurs tests isolés. Pourtant l'écran échoue s'il attend un champ `status` et que le
service envoie `state`. Un test d'interface formule ce que l'écran utilise puis vérifie que le
service sait le fournir.

Pact présente une méthode dans laquelle le consommateur échange avec un substitut contrôlé du
fournisseur. Le test enregistre les interactions dans un contrat. Le fournisseur vérifie ensuite
ce contrat en exécutant sa propre implémentation dans des conditions précises. Lors d'un échange
de messages, la vérification porte sur le message produit et consommé. Les équipes peuvent
travailler et livrer à des rythmes différents, pourvu que les preuves concernent les versions
qu'elles utiliseront ensemble.

Le terme s'emploie aussi pour la vérification d'un fournisseur par rapport à sa documentation
publiée, par exemple une description OpenAPI. Cette méthode sert quand la spécification écrite
est l'accord partagé. Elle peut définir les champs, les codes d'état et les valeurs permises. Les
exemples établis par le consommateur indiquent quelles combinaisons un appelant exploite et sur
quelles hypothèses il s'appuie. Les deux méthodes peuvent coexister. Un parcours dans
l'intégration réelle permet de vérifier ce qui dépasse l'échange, notamment le routage et la
configuration.

## Pourquoi c'est important

Une interface dure souvent plus longtemps que le code qui l'a introduite. L'équipe du service
peut renommer un champ et adapter ses propres tests sans modifier un appelant maintenu ailleurs.
Une application mobile peut rester sur une ancienne version plusieurs mois. Un simple changement
de type compte s'il détermine le texte affiché. Un contrat vérifiable rend ces dépendances
visibles avant publication.

Lorsque les mises en service ont des rythmes distincts, il faut savoir quelles versions sont
compatibles. Un client ancien peut comprendre peu de valeurs d'état et un service récent vouloir
ajouter une étape intermédiaire. Les équipes peuvent adapter le consommateur d'abord, accepter
les deux formes pendant la transition et retirer l'ancien comportement après avoir vérifié les
versions dont elles dépendent. L'ordre sûr dépend des contrats, de l'usage réel et de la
politique de diffusion. La réussite d'une combinaison récente ne couvre pas tous les clients
encore présents.

Les contrôles doivent exprimer les véritables points d'accord. Si toute référence bien formée
convient, vérifions le format sans imposer la valeur exacte de l'exemple. Si un champ détermine
un comportement visible, contrôlons son type et les valeurs comprises par le client. Un bon cas
protège l'accord tout en laissant le fournisseur faire évoluer les détails internes.

## À quoi cela ressemble en pratique

Imaginons une application de suivi de colis. Elle demande un colis par sa référence. Lorsque le
colis existe et est en transit, l'écran attend une réponse de succès, la référence et un texte
qu'il sait associer à une étiquette. Lorsqu'il ne trouve pas le colis, il attend une autre
réponse et propose de revoir la référence. Chaque interaction est associée à une condition
préalable, par exemple l'existence d'un colis en transit ou l'absence de toute référence
correspondante.

Faisons passer la requête par le vrai code du consommateur en utilisant le substitut contrôlé.
Vérifions l'affichage qui résulte de chaque échange. Exerçons ensuite les mêmes interactions sur
le chemin réel de réponse du fournisseur. Créons des données déterministes pour chaque état et
réinitialisons-les entre les essais. Si la base de données ou le transporteur est remplacé,
gardons dans le test l'analyse de la requête, la logique du service et la construction de la
réponse dont dépend le consommateur.

Remplaçons provisoirement le champ `status` par `state` sans modifier le client. La vérification
devrait signaler le champ manquant et permettre d'identifier l'échange. Un champ facultatif
ignoré par le consommateur reste acceptable si l'accord le permet. Relions chaque preuve à sa
version. Mélanger le résultat d'un nouveau fournisseur et une copie non identifiée d'un ancien
contrat empêche de savoir ce qui a été mis à l'épreuve.

Notre [note sur l'ouverture d'une application dans les portefeuilles mobiles
Solana](/fr/notes/solana-mobile-wallet-deeplinks/) montre des intégrations qui attendent chacune
un chemin de lien et un encodage distincts. Elle expose ces différences et propose des essais sur
appareil. Un test de la forme des liens générés pourrait préserver ces accords. Un essai sur un
véritable appareil permet de voir si le navigateur transmet le lien à l'application installée et
si le parcours aboutit. Les deux observations ne couvrent pas la même chose.

## Où les problèmes surviennent

Un contrat se rigidifie si chaque octet doit correspondre à un exemple enregistré. Le fournisseur
peut être libre d'ajouter un champ ignoré ou de reformater un message auxiliaire. Rendons un
champ obligatoire lorsqu'un appelant l'utilise ou lorsque la spécification publique l'exige.
Fixons l'ordre, les unités et les mots exacts aux endroits où l'accord en dépend.

Un test perd aussi sa force s'il contourne la limite réelle. Vérifier un objet JSON écrit à la
main peut laisser le sérialiseur hors du parcours. Constater que le substitut a produit le
résultat préparé ne montre pas que le consommateur sait le lire. Exécutons le vrai code de
requête ou de réponse de la partie vérifiée et notons ce que fournissent les dépendances
remplacées.

Enfin, un exemple réussi couvre peu de choses sur les données manquantes, les références
inconnues ou les anciennes versions. Recensons les erreurs traitées par le client et les
compatibilités promises par le fournisseur. Gardons des essais d'intégration qui exercent la
configuration et le routage. Le contrat apporte une preuve ciblée et assez rapide pour
accompagner chaque évolution pertinente.

## Pour aller plus loin

- [Pact et la définition des tests de contrat](https://docs.pact.io/#what-is-contract-testing)
- [Vérification du consommateur et du fournisseur dans
  Pact](https://docs.pact.io/getting_started/how_pact_works)
- [Documentation de Pact sur les états du
  fournisseur](https://docs.pact.io/getting_started/provider_states)
- [Spécification OpenAPI pour les interfaces HTTP](https://spec.openapis.org/oas/latest.html)

<https://engineer.company/fr/glossary/contract-testing/>
