Aller au contenu
English

Tests de contrat et de compatibilité

  • Leçon 20
  • 55 min
  • Module 7 : Exploiter et maintenir l'intégration

Où nous en sommes

Dans le module 6, nous avons protégé le serveur contre le texte non fiable, les actions non approuvées et les mauvaises clés. Mais un serveur fait aussi des promesses à ses clients, et un petit changement peut en briser une sans que personne le remarque. Dans cette leçon, nous consignons le contrat du serveur et nous le testons avec chaque client et chaque génération du protocole, comme un horaire imprimé que d'autres copient.

Leçon 20 sur 22 · MCP : connecter les applications d'IA aux outils et aux donnéesTests de contrat et de compatibilité

Ce que vous saurez faire

Fixez ce que le serveur promet, et prouvez qui peut l’utiliser. Vous consignez le contrat du serveur dans un fichier. Un test compare ensuite le serveur à ce fichier après chaque changement. Puis vous créez une matrice de compatibilité : chaque client, chaque transport et chaque génération du protocole, avec les mêmes vérifications. Chaque ligne indique sa génération.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 55 minutes

Ce que vous devez savoir

Votre projet

  • ~/projects/support-mcp, avec l’environnement virtuel actif : python -m pytest -q affiche 86 passed (86 tests réussis).
  • Node.js 22.19 ou une version ultérieure, pour MCP Inspector.

Une entreprise d’autobus imprime son horaire. Des commerces, des écoles et des hôtels le copient et l’affichent sur leurs murs. Un jour, l’entreprise avance l’autobus de 8 h 10 à 8 h 05. Son personnel le sait. Personne ne prévient l’hôtel. Le lendemain matin, un client manque l’autobus.

L’autobus circule toujours, donc l’entreprise ne voit aucun problème. Le vrai problème : d’autres personnes ont copié une promesse, et cette promesse a changé sans avertissement. Une entreprise attentive garde une copie de ce qu’elle a publié. Avant tout changement, elle compare le nouveau plan à cette copie et prévient toutes les personnes qui l’ont copiée.

Le problème : un changement discret dans ce que les clients lisent

Section intitulée « Le problème : un changement discret dans ce que les clients lisent »

Un serveur MCP publie aussi une promesse. Chaque client qui se connecte lit les noms des outils, les descriptions, les schémas d’entrée et de sortie, les annotations, le modèle de ressource et la requête. Un hôte transmet les descriptions à son modèle. L’application d’un partenaire peut construire ses écrans à partir des schémas.

Voici un changement qui semble sans danger. Amira nettoie la description de get_ticket et supprime sa dernière phrase : « Le texte reprend les mots du client. » L’outil fonctionne toujours. Les 86 tests réussissent encore :

# end-of-m06, with the sentence removed from get_ticket's docstring
$ python -m pytest -q
.............. [100%]
86 passed in 11.46s

Mais cette phrase faisait partie de la défense présentée dans Entrées et sorties non fiables. Elle indique à chaque modèle que le texte du billet de soutien vient d’un client, pas du service de soutien. Maintenant, elle a disparu, et rien ne l’a détecté.

Le deuxième problème concerne les clients. « Ça fonctionne avec MCP » ne dit rien sur quel client. Vous avez exécuté MCP Inspector dans Examiner le comportement. L’équipe du cours avait d’abord noté « Inspector : réussite ». Plus tard, elle a examiné les messages. Inspector 2.10.1 s’était connecté avec l’ancienne négociation initialize, révision 2025-11-25. Cette « réussite » ne disait rien sur la révision actuelle, 2026-07-28.

L’idée : consigner la promesse et tester chaque client

Section intitulée « L’idée : consigner la promesse et tester chaque client »

Deux outils répondent à ces deux problèmes.

Un contrat contient tout ce qu’un client peut voir du serveur : les réponses de découverte, écrites dans un fichier. Un test de contrat compare le serveur en marche à ce fichier après chaque changement. Toute différence fait échouer le test, jusqu’à ce qu’une personne lise la différence et l’accepte. Ce fichier correspond à la copie de l’horaire publié que l’entreprise conserve.

Le fichier de contrat contient les structures. Il ne contient pas les erreurs. Un deuxième test fixe donc les structures d’erreur : ce qu’un client reçoit lors d’un échec de validation, d’un outil inconnu ou d’une ressource absente.

Une matrice de compatibilité est un tableau. Chaque ligne représente un client, un transport et une génération du protocole. Chaque ligne exécute les mêmes vérifications : découverte, appel valide, échec de validation, lecture d’une ressource et requête. Une ligne réussit seulement si toutes ses vérifications réussissent. Chaque ligne indique aussi sa génération, car une réussite dans une génération ne prouve rien pour l’autre.

  1. Copiez le script de contrat et ses tests depuis l’instantané end-of-m07 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C28/snapshots/end-of-m07
    cp "$S/scripts/contract.py" scripts/
    cp "$S/tests/test_contract.py" tests/
  2. Comparez le serveur à son contrat. Il n’y a pas encore de fichier de contrat, donc chaque ligne est nouvelle :

    Fenêtre de terminal
    python -m scripts.contract
    --- contract
    +++ server
    @@ -0,0 +1,317 @@
    +{
    + "prompts": [
    …

    Le script se termine avec le code 1 : le serveur et le fichier diffèrent.

  3. Lisez les 317 lignes une fois. Elles contiennent exactement ce qu’un client reçoit. Acceptez-les ensuite :

    Fenêtre de terminal
    python -m scripts.contract --write
    Wrote capabilities.json: 3 tools, 1 resource template, 1 prompt
  4. Comparez de nouveau :

    Fenêtre de terminal
    python -m scripts.contract
    The server matches contract/capabilities.json.
  5. Exécutez les trois nouveaux tests :

    Fenêtre de terminal
    python -m pytest -q tests/test_contract.py
    ... [100%]
    3 passed in 0.21s

Le script demande au serveur ses réponses de découverte, dans le même processus, avec le client de la trousse SDK. Il les écrit en JSON trié, pour que le même serveur produise toujours le même fichier :

scripts/contract.py (the contract)
async def current() -> dict:
async with Client(build_server()) as c:
tools = (await c.list_tools()).tools
templates = (await c.list_resource_templates()).resource_templates
prompts = (await c.list_prompts()).prompts
return {
"protocol": c.protocol_version,
"tools": [t.model_dump(mode="json", by_alias=True, exclude_none=True) for t in tools],
"resourceTemplates": [t.model_dump(mode="json", by_alias=True, exclude_none=True) for t in templates],
"prompts": [p.model_dump(mode="json", by_alias=True, exclude_none=True) for p in prompts],
}

Votre fichier est identique au fichier contract/capabilities.json de l’instantané, octet par octet. Enregistrez-le avec le code dans un commit (enregistrement des changements). Désormais, chaque révision montre tout changement au contrat sous forme de différences dans ce fichier.

Supprimez maintenant la phrase de nouveau. Ouvrez support_mcp/server.py, trouvez get_ticket et supprimez « Le texte reprend les mots du client. » de sa chaîne de documentation. Comparez ensuite :

Fenêtre de terminal
python -m scripts.contract
--- contract
+++ server
@@ -123,7 +123,7 @@
"openWorldHint": false,
"readOnlyHint": true
},
- "description": "Get one support ticket of this organization by its ID (for example T-30002): the customer's first name, subject, text, status and the last 3 messages. The text is the customer's words.",
+ "description": "Get one support ticket of this organization by its ID (for example T-30002): the customer's first name, subject, text, status and the last 3 messages.",
"inputSchema": {

Les 86 anciens tests n’ont pas détecté ce changement. Le script de contrat montre l’ancienne ligne et la nouvelle, puis se termine avec le code 1. Le test échoue aussi :

$ python -m pytest -q tests/test_contract.py
F.. [100%]
FAILED tests/test_contract.py::test_the_server_matches_the_recorded_contract
1 failed, 2 passed in 0.23s

Remettez la phrase, et le script affiche de nouveau The server matches contract/capabilities.json. (le serveur correspond à contract/capabilities.json).

L’échec ne signifie pas « vous avez brisé quelque chose ». Il signifie « vous avez changé une promesse : décidez ». Parfois, le changement est justifié. Exécutez alors --write, et les différences de contract/capabilities.json feront partie de la révision. Chez Larkfield, Kwame lit toutes ces différences. Il pose une question : quels clients voient ce changement, et faut-il les prévenir?

Le fichier de contrat ne contient aucune erreur. Le troisième test fixe leurs structures :

tests/test_contract.py (the error shapes)
def test_error_shapes_are_stable():
async def go():
async with Client(build_server()) as c:
out = {
"validation": (await c.call_tool("get_ticket", {"ticket_id": "x"})).is_error,
"unknown_tool": (await c.call_tool("nope", {})).is_error,
}
with pytest.raises(MCPError) as e:
await c.read_resource("policy://larkfield/no-such-policy")
out["resource_not_found"] = e.value.error.code
return out
assert anyio.run(go) == {"validation": True, "unknown_tool": True, "resource_not_found": -32602}

Pourquoi est-ce important? L’équipe du cours a essayé de changer un seul mot dans server.py : ResourceError plutôt que ResourceNotFoundError pour une politique absente. Le script de contrat a indiqué The server matches contract/capabilities.json. Le test des structures d’erreur a échoué :

E AssertionError: assert {'validation'...ound': -32603} == {'validation'...ound': -32602}
E Differing items:
E {'resource_not_found': -32603} != {'resource_not_found': -32602}

Dans les messages transmis, le message et data.uri sont restés identiques. Seul le code a changé : −32603, « erreur interne », plutôt que −32602, « paramètres invalides ». Un client qui affiche « cette politique n’existe pas » pour −32602 afficherait maintenant « le serveur est défectueux ».

Le test fixe aussi une différence connue. Pour un outil inconnu, la spécification demande une erreur de protocole, −32602. La trousse SDK 2.3.0 répond avec un résultat d’outil, isError: true, « Outil inconnu : nope ». Le test consigne ce que ce serveur fait aujourd’hui. Si une mise à niveau de la trousse SDK change ce comportement, le test échoue. Vous le découvrez avant vos clients.

Un tableau avec deux changements et deux vérifications. Premier changement : la description de get_ticket perd la phrase Le texte reprend les mots du client; les 86 anciens tests réussissent tous. Le fichier de contrat le détecte, sortie 1, et les différences montrent l'ancienne et la nouvelle description. Le test des structures d'erreur ne le voit pas : il réussit, car aucune erreur n'a changé. Deuxième changement : ResourceError plutôt que ResourceNotFoundError pour une politique absente, dans server.py. Le fichier de contrat ne le voit pas : sortie 0, The server matches contract/capabilities.json. Le test des structures d'erreur le détecte, 1 test échoué : resource_not_found vaut -32603 plutôt que -32602, avec le même message et le même data.uri; seul le code a changé. Une note : chaque vérification voit un type de changement; exécutez les deux après chaque changement; python -m pytest -q les exécute.
Deux changements réels et deux vérifications. Chaque vérification voit un type de changement, donc exécutez les deux après chaque changement.
Description textuelle du diagramme
Le changement Fichier de contrat (python -m scripts.contract) Test des structures d’erreur
La description de get_ticket perd « Le texte reprend les mots du client. » (les 86 anciens tests réussissent) détecté : sortie 1, l’ancienne et la nouvelle description non détecté : réussite
ResourceError plutôt que ResourceNotFoundError pour une politique absente non détecté : « Le serveur correspond à contract/capabilities.json. » détecté : −32603 plutôt que −32602, même message et data.uri

Une génération ne couvre pas toutes les générations

Section intitulée « Une génération ne couvre pas toutes les générations »

Revenons à Inspector. L’équipe du cours a exécuté deux fois la même commande Inspector sur le serveur stdio : un appel à get_ticket. La deuxième exécution ajoutait --protocol-era modern. Le fichier scripts/tee.py du projet, que vous découvrirez dans la prochaine leçon, a enregistré chaque message :

Deux colonnes de messages enregistrés pour la même commande Inspector, tools/call get_ticket T-30002. À gauche, Inspector 2.10.1 avec son réglage par défaut, l'ancienne négociation, révision 2025-11-25 : à 0,3 ms initialize, 278 octets, vers le serveur; à 256,1 ms le résultat, 514 octets; notifications/initialized, 55 octets; tools/list, 47 octets; son résultat, 4 315 octets; tools/call, 114 octets; son résultat, 1 213 octets. À droite, Inspector 2.10.1 avec --protocol-era modern, la révision actuelle 2026-07-28 : à 0,2 ms server/discover, 395 octets; à 266,6 ms son résultat, 629 octets; subscriptions/listen, 481 octets; notifications/subscriptions/acknowledged, 239 octets, depuis le serveur; tools/list, 409 octets; son résultat, 4 460 octets; tools/call, 465 octets; son résultat, 1 325 octets; et à 287,5 ms erreur -32000, le flux d'écoute fermé quand Inspector s'est déconnecté. Une note : les deux réussissent les mêmes vérifications; sans --protocol-era modern, une réussite teste seulement la révision 2025-11-25; indiquez la génération dans chaque ligne de la matrice.
La même commande Inspector, enregistrée dans les deux générations. Par défaut, elle utilise l'ancienne négociation.
Description textuelle du diagramme
  • Par défaut (ancienne négociation, 2025-11-25) : initialize, son résultat, notifications/initialized, tools/list et tools/call. Aucune requête ne contient _meta. La liste d’outils fait 4 315 octets; le résultat de l’appel fait 1 213 octets.
  • --protocol-era modern (2026-07-28) : server/discover, puis subscriptions/listen (un flux de notifications de changement, voir Fonctionnalités optionnelles et évolutives), puis tools/list et tools/call avec _meta. La liste d’outils fait 4 460 octets, et le résultat de l’appel fait 1 325 octets. Chaque résultat contient en effet resultType et le nom du serveur. Quand Inspector se déconnecte, le flux d’écoute se termine avec l’erreur −32000.

Les deux exécutions réussissent. Mais elles testent des protocoles différents. La matrice doit donc avoir une ligne pour chaque génération, et chaque ligne doit indiquer laquelle.

  1. Copiez le script de compatibilité, son test et la liste de vérification :

    Fenêtre de terminal
    cp "$S/scripts/compat.py" scripts/
    cp "$S/tests/test_compat.py" tests/
    cp "$S/docs/compatibility.md" docs/
  2. Exécutez la matrice. Le script démarre le serveur dans le même processus, comme processus enfant stdio et sur Streamable HTTP, dans les deux générations. Les lignes de journal du serveur vont vers stderr; masquez-les avec 2>/dev/null (PowerShell : 2>$null) :

    Fenêtre de terminal
    python -m scripts.compat 2>/dev/null
    MCP Python SDK 2.3.0 Client
    transport | mode | protocol | discovery | valid_call | validation_failure | resource_read | prompt | host_answer | no_token_refused
    in-process | auto | 2026-07-28 | pass | pass | pass | pass | pass | pass | -
    stdio | auto | 2026-07-28 | pass | pass | pass | pass | pass | pass | -
    Streamable HTTP | auto | 2026-07-28 | pass | pass | pass | pass | pass | pass | pass
    in-process | legacy | 2025-11-25 | pass | pass | pass | pass | pass | pass | -
    stdio | legacy | 2025-11-25 | pass | pass | pass | pass | pass | pass | -
    Streamable HTTP | legacy | 2025-11-25 | pass | pass | pass | pass | pass | pass | pass

    Il y a six lignes, et la colonne protocol (protocole) indique la révision de chaque connexion. host_answer exécute l’hôte du cours avec le modèle simulé sur la même connexion. Sur HTTP, no_token_refused vérifie la réponse 401 sans jeton.

  3. Exécutez Inspector dans sa génération par défaut, l’ancienne négociation :

    Fenêtre de terminal
    npx @modelcontextprotocol/inspector@2.10.1 --cli python -m support_mcp -- --method tools/call --tool-name get_ticket --tool-arg ticket_id=T-30002
    {
    "content": [
    {
    "type": "text",
    "text": "{\n \"ticket_id\": \"T-30002\",\n \"customer_name\": \"Hugo\", …"
    }
    ],
    "structuredContent": {
    "ticket_id": "T-30002",
    …
  4. Exécutez-le de nouveau dans la génération actuelle :

    Fenêtre de terminal
    npx @modelcontextprotocol/inspector@2.10.1 --cli python -m support_mcp -- --protocol-era modern --method tools/call --tool-name get_ticket --tool-arg ticket_id=T-30002
    {
    "_meta": {
    "io.modelcontextprotocol/serverInfo": {
    "name": "support-mcp",
    "version": "1.0.0"
    }
    },
    "content": [
    …

    Le bloc _meta en haut est le signe visible de la révision 2026-07-28 : chaque résultat nomme le serveur. Répétez les autres vérifications de Examiner le comportement dans les deux générations : tools/list, l’échec de validation avec --tool-arg 'ticket_id="30002"' (code de sortie 5, tool_is_error), resources/read et prompts/get.

  5. Exécutez tous les tests :

    Fenêtre de terminal
    python -m pytest -q
    90 passed in 12.30s

    Quatre tests sont nouveaux : trois dans test_contract.py, et test_compat.py, qui exécute les six lignes.

Les guillemets de --tool-arg 'ticket_id="30002"' s’utilisent différemment dans PowerShell, et le cours ne l’a pas testé sur Windows.

Tenir compte des versions promettait un test avec un client plus ancien. Le mode legacy de la trousse SDK utilise l’ancienne négociation, mais son code reste celui de la trousse SDK 2.3.0. Un véritable hôte plus ancien est livré avec une bibliothèque plus ancienne. L’équipe du cours a donc installé l’ancienne série de la trousse SDK, version 1.30.0, dans un environnement virtuel distinct. Elle a connecté son ClientSession à support-mcp et exécuté les cinq mêmes vérifications. C’est une véritable bibliothèque plus ancienne, pas une bibliothèque construite :

client: MCP Python SDK 1.30.0 ClientSession (stdio)
protocol: 2025-11-25
server: support-mcp 1.0.0
discovery: pass
valid_call: pass
validation_failure: pass
resource_read: pass
prompt: pass

Sur Streamable HTTP, avec un jeton valide, le résultat était identique : cinq réussites. Le journal du serveur affichait Created new transport with session ID … (nouveau transport créé avec l’identifiant de session…). L’ancienne génération sur HTTP utilise une session; la révision 2026-07-28 n’en a pas. Vous n’avez pas besoin de répéter cette exécution. Pour l’essayer, créez un deuxième environnement virtuel et installez-y mcp==1.30.0. Ne mélangez jamais les deux séries de la trousse SDK dans un même environnement.

docs/compatibility.md rassemble toutes les lignes : les six automatiques, le client plus ancien, Inspector dans les deux générations et l’hôte du cours. Le cours ne teste pas les assistants de bureau et les éditeurs de code : il montre seulement leur configuration.

La matrice de compatibilité de support-mcp 1.0.0, MCP Python SDK 2.3.0, révision 2026-07-28. Colonnes : client, transport, génération, les cinq vérifications (découverte, appel valide, échec de validation, ressource, requête) et méthode de test. Lignes : SDK 2.3.0 Client en mode auto, dans le même processus et stdio, génération actuelle 2026-07-28, 5 réussites sur 5, scripts.compat. SDK 2.3.0 Client en mode auto, Streamable HTTP, génération actuelle, 5 réussites sur 5 et sans jeton 401, scripts.compat. SDK 2.3.0 Client en mode legacy, dans le même processus et stdio, ancienne négociation 2025-11-25, 5 réussites sur 5, scripts.compat. Le même sur Streamable HTTP, 5 réussites sur 5 et sans jeton 401. SDK 1.30.0 ClientSession, un client plus ancien, stdio et Streamable HTTP, ancienne négociation 2025-11-25, 5 réussites sur 5, manuellement, une fois. Inspector 2.10.1 CLI avec son réglage par défaut, stdio, ancienne négociation 2025-11-25, 5 réussites sur 5, manuellement, une fois. Inspector 2.10.1 CLI avec --protocol-era modern, stdio, génération actuelle 2026-07-28, 5 réussites sur 5, manuellement, une fois. L'hôte du cours, python -m host, stdio et Streamable HTTP, 2026-07-28 et 2025-11-25 avec --legacy, un appel, des refus et les deux générations, pytest. Assistants de bureau et éditeurs de code : aucune génération, non testés par le cours, configuration seulement. Une note : les révisions 2024-11-05, 2025-03-26 et 2025-06-18 utilisent la même négociation; la trousse SDK 2.3.0 les accepte, mais le cours n'a pas testé de client avec ces révisions.
La matrice de compatibilité. Bleu : la génération actuelle. Gris en pointillés : l'ancienne négociation.
Description textuelle du diagramme
Client Transport Génération Vérifications Méthode de test
SDK 2.3.0 Client, auto dans le même processus, stdio, Streamable HTTP actuelle, 2026-07-28 5 réussites sur 5; sans jeton : 401 scripts.compat
SDK 2.3.0 Client, legacy dans le même processus, stdio, Streamable HTTP ancienne négociation, 2025-11-25 5 réussites sur 5; sans jeton : 401 scripts.compat
SDK 1.30.0 ClientSession (client plus ancien) stdio, Streamable HTTP ancienne négociation, 2025-11-25 5 réussites sur 5 manuellement, une fois
Inspector 2.10.1 CLI, par défaut stdio ancienne négociation, 2025-11-25 5 réussites sur 5 manuellement, une fois
Inspector 2.10.1 CLI, --protocol-era modern stdio actuelle, 2026-07-28 5 réussites sur 5 manuellement, une fois
L’hôte du cours stdio, Streamable HTTP 2026-07-28; 2025-11-25 avec --legacy appel, refus, les deux générations pytest
Assistants de bureau, éditeurs de code — — non testés par le cours configuration seulement

Les révisions 2024-11-05, 2025-03-26 et 2025-06-18 utilisent la même négociation. La trousse SDK 2.3.0 les accepte, mais aucun client utilisant ces révisions n’a été testé. La matrice le précise et ne prétend pas les couvrir.

Utilisez un test de contrat pour chaque serveur auquel quelqu’un d’autre se connecte. Il demande un fichier et un test, et s’exécute en une fraction de seconde. Le vrai coût est la discipline : n’exécutez jamais --write sans lire les différences. Sinon, le test ne fait que consigner vos erreurs.

Le fichier de contrat change aussi quand vous mettez la trousse SDK à niveau, même si votre code ne change pas. Une nouvelle trousse SDK peut écrire un schéma différemment. Cet échec est utile : il montre exactement ce que vos clients verront après la mise à niveau.

La matrice coûte plus cher. scripts.compat prend quelques secondes et s’exécute avec vos tests. Les lignes manuelles, le client plus ancien et Inspector, peuvent devenir désuètes. Elles restent vraies pour les versions de la ligne, et rien de plus. Chaque ligne indique donc la version du client et la génération. Quand une version change, exécutez la ligne de nouveau.

N’ajoutez pas de lignes que vous ne pouvez pas tester. « Fonctionne avec tous les clients MCP » est une promesse que personne ne peut vérifier. Une matrice courte et honnête aide davantage un partenaire qu’une longue matrice pleine d’espoir.

Erreur courante

Le test de contrat échoue après une mise à jour de la trousse SDK, sans changement dans votre code

Symptôme : test_the_server_matches_the_recorded_contract échoue après un changement de version de la trousse SDK.

Cause : la nouvelle trousse SDK présente les mêmes outils sous une forme légèrement différente : un champ ajouté, un titre différent, un autre ordre.

Solution : exécutez python -m scripts.contract et lisez les différences. Si seule la forme produite par la trousse SDK a changé, acceptez-la avec --write. Indiquez la version de la trousse SDK dans le message du commit (enregistrement des modifications). Si une description ou une limite a changé, trouvez pourquoi avant de l’accepter.

Erreur courante

Les vérifications avec Inspector réussissent, mais un client actuel échoue

Symptôme : vos vérifications avec Inspector réussissent, mais un client utilisant la révision 2026-07-28 reçoit une erreur.

Cause : Inspector 2.10.1 utilise par défaut l’ancienne procédure d’initialisation. Vos vérifications ont testé uniquement la révision 2025-11-25.

Solution : refaites chaque vérification avec Inspector en ajoutant --protocol-era modern. Cherchez le bloc _meta dans la sortie : il montre que la génération actuelle du protocole a été utilisée.

Réinitialisation. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m06 comme dans La place de MCP. Remplacez start par end-of-m06, puis reprenezz les étapes de cette leçon. Ensuite, python -m pytest -q affiche 90 passed (90 tests réussis).

Vérifiez votre compréhension

Amira retire une phrase de la description d'un outil, et les 86 anciens tests réussissent. Quelle vérification échoue, que montre sa sortie et que doit faire Amira ensuite?

Afficher la réponse

Le test de contrat échoue. python -m scripts.contract se termine avec le code 1. Il affiche les différences entre l’ancienne et la nouvelle description (description) de l’outil, et test_the_server_matches_the_recorded_contract échoue. Les anciens tests ont réussi, car aucun ne fixe le texte d’une description. Amira lit les différences et décide. Si la phrase faisait partie d’une défense, comme « Le texte reprend les mots du client. », elle la remet. Si le changement est voulu, elle exécute --write, et les différences de contract/capabilities.json passent à la révision. Kwame peut alors demander qui doit être informé.

Vérifiez votre compréhension

Un collègue écrit « Inspector 2.10.1 : réussite » dans la liste de vérification de compatibilité. Que manque-t-il et comment compléter la ligne?

Afficher la réponse

Il manque la génération du protocole. Inspector 2.10.1 se connecte avec l’ancienne procédure d’initialisation initialize (initialiser), révision 2025-11-25, sauf si vous ajoutez --protocol-era modern. La ligne a donc testé uniquement 2025-11-25. Écrivez deux lignes : la procédure d’initialisation par défaut, ancienne, 2025-11-25, et --protocol-era modern, actuelle, 2026-07-28. Exécutez les cinq mêmes vérifications pour chacune : découverte, appel valide, échec de validation, lecture d’une ressource et requête. La sortie indique la génération du protocole. Un résultat de la génération actuelle commence par un bloc _meta qui nomme le serveur.

Récapitulatif

  • Un contrat représente ce que les clients voient après la découverte. contract/capabilities.json l’enregistre. Un test échoue à chaque différence, jusqu’à ce qu’une personne lise les différences et les accepte.
  • Les formats d’erreur ont besoin de leur propre test. Un changement d’un seul mot a transformé −32602 en −32603, sans modifier le fichier de contrat.
  • Une matrice de compatibilité exécute les mêmes vérifications pour chaque client, transport et génération du protocole. Chaque ligne nomme sa génération.
  • Inspector 2.10.1 utilise l’ancienne procédure d’initialisation par défaut : testez-le avec les deux générations du protocole. Un ancien client, SDK 1.30.0, a réussi avec la révision 2025-11-25 sur stdio et HTTP.
  • Votre projet affiche maintenant 90 passed.

Ensuite, vous rendez le serveur sûr pour une journée entière : des limites à chaque couche, et des journaux qui expliquent chaque refus.

Leçon suivante : Limites de ressources et observabilité