Vérification objective (vérificateurs)
Cette page est générée depuis docs/guide.fr.md · Modifier cette page sur GitLab
Une review dit ce qu'elle pense du code. Un vérificateur dit ce qui se passe quand on le lance : ce sont tes commandes de tests, Mergerie prépare les dépôts et lit leur verdict. Les deux se complètent — une note de 9/10 sur une MR dont les tests d'intégration cassent ne veut plus rien dire une fois qu'on le sait.
Ce que ça change concrètement : un badge sur chaque merge request (✓ vérifié, ✗ 2 tests cassés, ⚠ base rouge, ⟳ périmé), et surtout la possibilité de vérifier ensemble des MR de dépôts différents qui ne valent qu'ensemble — la MR du front et celle de l'API qui ne passent que réunies.
Ce qu'est un vérificateur
Tu donnes une liste de commandes (npm ci, puis npm test), Mergerie la lance dans le dépôt préparé et le verdict vient des codes de sortie. Rien à écrire, rien à installer.
Une seconde famille a existé jusqu'à la 1.2 : un exécutable s'engageant sur un contrat JSON. Elle a été retirée — elle demandait d'écrire et de maintenir un programme pour obtenir ce que trois lignes de commandes donnent. Un vérificateur de cette famille encore enregistré reste visible dans les réglages, marqué comme tel, et refuse de tourner : réécris-le en liste de commandes, puis supprime-le.
L'ordre compte — npm ci avant npm test — et se corrige d'un clic : chaque ligne porte son rang et deux flèches pour la déplacer.
Une ligne peut tourner une seule fois. Devant chaque commande, une portée : dans chaque dépôt (le défaut) ou une fois — docker compose up -d une fois les dépôts positionnés n'a pas à tourner trois fois. Une ligne une fois dit aussi dans quel dépôt elle tourne (son worktree, ou son répertoire in place), choisi avec recherche ; vide, c'est le premier dépôt de la vérification. L'ordre de la liste est respecté, les dépôts à l'intérieur : npm ci dans chacun, puis compose up une fois, puis npm test dans chacun, puis compose down. Une ligne une fois qui échoue arrête tout ; elle est sautée si une commande a déjà échoué avant elle (le journal le dit) ; et si elle désigne un dépôt qui ne fait pas partie de la vérification, c'est une erreur avec son nom, pas un dossier deviné. Le rapport et le journal marquent la ligne et le dépôt où elle a tourné, la carte porte un badge 1×, et l'endroit où elle tourne fait partie de ce qu'on approuve (voir plus bas) — la ligne voyage avec le vérificateur partagé.
Un tel vérificateur peut couvrir plusieurs dépôts. Attention à ce que « couvrir » veut dire : déclarer un dépôt annonce seulement que ce vérificateur sait le tester. À l'exécution, la liste ne tourne que dans les dépôts réellement visés par la vérification — lancée sur une seule merge request, elle ne touche que son dépôt, même si le vérificateur en couvre cinq. Sur un lot, elle est rejouée dans chacun, l'un après l'autre, et le verdict est le ET — tout doit passer. C'est ce qu'on veut quand plusieurs projets se testent de la même façon : un seul vérificateur au lieu d'un identique par dépôt. Dans un dépôt, la première commande en échec arrête les suivantes (elles en dépendent) ; d'un dépôt à l'autre on continue, parce qu'ils sont indépendants et que savoir que deux cassent vaut mieux que de s'arrêter au premier.
Quand plusieurs dépôts sont testés, les échecs sont préfixés du dépôt (grp/lib › panier › remise) : sans ça, deux projets ayant chacun un test du même nom seraient indiscernables — et la comparaison base/tête les confondrait.
Ce qu'un vérificateur sait dire, et ce qu'il ne sait pas dire
La liste s'arrête à la première commande qui échoue : après un npm ci raté, la sortie de npm test n'est que du bruit. Le rapport montre alors le déroulé — quelle commande, quel code, combien de temps, et sa sortie.
Reste la question des noms de tests, qui est ce qui rend le verdict causal. Mergerie les cherche dans cet ordre, sans jamais deviner :
- Le fichier de rapport JUnit, si tu en déclares un (champ Rapport JUnit, chemin relatif au dépôt — donc lu dans chacun quand plusieurs sont testés). C'est le format pivot :
pytest --junitxml,jest-junit,phpunit --log-junit, Surefire,go-junit-report… Le plus fiable, et il ne subit pas la troncature du journal. - Le TAP dans la sortie, reconnu tout seul — voir plus bas.
- Rien. Alors c'est la commande qui est imputée : le badge affiche
✗ échec : npm testau lieu d'annoncer un nombre de tests qu'on ne connaît pas. Et comme la clé du delta devient la commande, une commande déjà rouge sur la base donne toujours⚠ base rouge— la dégradation reste juste.
Dans ce dernier cas, le rapport affiche en plus ce qui est nouveau par rapport à la base : les lignes présentes à la tête et absentes du run base. Ça ne coûte rien — les deux sorties existent déjà — et ça pointe souvent directement la régression, y compris derrière un make test opaque.
Enfin, si le code de sortie et le rapport de tests se contredisent (sortie 0 avec des tests rouges, ou l'inverse), le verdict suit le code de sortie et le rapport signale la contradiction. C'est presque toujours un vrai défaut de la commande de test, et le masquer rendrait un mauvais service.
TAP : rien à déclarer
Beaucoup de runners écrivent du TAP dès que leur sortie n'est pas un terminal — ce qui est toujours le cas ici, Mergerie lançant les commandes à travers des tubes. Il est alors reconnu et analysé sans aucun réglage : node --test, mocha (--reporter tap), vitest (--reporter=tap), pytest-tap, prove…
Les pièges sont traités : les sous-tests ne sont pas comptés deux fois (seules les feuilles en échec sont retenues, avec leur nom complet suite › test), un # TODO est un échec attendu et ne compte pas, un # SKIP n'est ni l'un ni l'autre, un Bail out! donne une erreur et non « zéro échec », et le plan (1..43) sert de contrôle : si la sortie a été tronquée, le rapport le dit au lieu de présenter une liste partielle comme exhaustive.
L'interrupteur Interpréter le TAP existe pour le jour où une sortie exotique déclencherait la détection à tort.
npm: command not found
L'environnement des commandes est minimal (PATH, HOME, LANG, MERGERIE_VERIFY=1, sans aucun jeton), et le PATH est celui du processus serveur. Lancé depuis un terminal où nvm est chargé, tout marche. Lancé par un service ou un lanceur de bureau, npm sera introuvable — c'est à ça que sert le champ Variables d'environnement : une ligne CLE=valeur, par exemple un PATH complet.
Le partage des rôles
Mergerie fait tout le git. Tes commandes ne font aucun checkout et ne connaissent aucune branche : elles tournent dans des répertoires déjà positionnés sur les bons commits et répondent « les tests passent-ils ». C'est ce qui permet à la même liste de servir en worktree jetable comme dans ton propre répertoire de travail.
Couverture déclarative ≠ checkout effectif. Dans Réglages → Vérificateurs, déclarer un dépôt dit seulement « ce vérificateur sait tester ce dépôt-là ». Seuls les dépôts effectivement visés par une vérification sont préparés. Les autres dépôts couverts et configurés in place sont lus en lecture seule et apparaissent comme contexte dans le rapport (avec un ⚠ s'ils sont hors de leur branche par défaut ou modifiés) : un vert obtenu grâce à un voisin resté sur une vieille branche ne doit pas passer inaperçu.
Deux modes, dépôt par dépôt
- worktree (par défaut) — Mergerie crée un
git worktreedétaché sousdata/worktrees/, le supprime après le run, et ramasse les orphelins au démarrage. Rien de ce que tu as sur ta machine n'est touché. - in place — le run a lieu dans ton répertoire de travail. Utile quand l'environnement de test ne se recrée pas (base de données locale, containers déjà chauds,
node_modulesinstallés). Trois garde-fous, dans cet ordre : consentement explicite à cocher, identité du dépôt vérifiée (leorigindu répertoire doit être celui du dépôt), et refus net si des fichiers SUIVIS ont été modifiés — jamais destashautomatique. Des fichiers non suivis ne bloquent pas : ils ne sont dans aucun commit, le checkout détaché ne les touche pas et la restauration les laisse où ils sont — exiger le contraire interdisait le mode in place à tout répertoire portant un.env.localou un dossier d'artefacts, c'est-à-dire à presque tous. Ils sont comptés et notés au journal du run : ils restent là pendant les tests et peuvent peser sur le résultat. (Si l'un d'eux porte le nom d'un fichier de la branche à tester, git refuse le checkout de lui-même : la vérification échoue au lieu d'écraser ton fichier.) Pendant le run, ton répertoire est sur un commit détaché : ne développe pas dessus. Il est remis sur sa ref d'origine dans tous les cas, y compris sur timeout ou plantage du job ; si la restauration échoue, le rapport porte un bandeau « Restauration manuelle requise » — ça ne se noie jamais dans un journal.
Le répertoire se choisit plutôt qu'il ne se tape : si tu as déclaré des répertoires locaux (Réglages → Dépôts), un sélecteur liste tous leurs projets git — avec recherche à la frappe, parce qu'une racine en contient couramment des dizaines — et remplit le chemin absolu. Un chemin tapé à la main reste possible pour un répertoire hors de toute racine déclarée, mais c'est une faute de frappe qui ne se découvre qu'au premier run, et qui coûte le run.
Le bouton « Tester le répertoire » répond pendant que le formulaire est encore sous tes yeux : répertoire reconnu, branche courante, et les deux réserves possibles — des modifications suivies (qui feraient refuser le run) et des fichiers non suivis (qui ne bloquent pas, mais seront là pendant les tests).
node_modules, et pourquoi la base est parfois rouge
Stratégie node_modules. Un worktree neuf n'a pas de dépendances installées. Deux réponses : un symlink depuis un cache partagé (rapide, mais suppose que le lock n'a pas changé), ou une installation dans le worktree (lente, mais fidèle). Le choix t'appartient — il vit dans tes commandes. Un ln -s "$CACHE/node_modules" "$dir/node_modules" fait l'affaire tant que tu invalides le cache sur changement de package-lock.json.
FAQ.
- Pourquoi ma base est rouge ? Le run base rejoue la même suite sur les branches cibles, avant tes changements. S'il échoue déjà, le verdict est
⚠ base rougeet rien n'est imputé à ta branche — c'est le but. Décocher « Lancer aussi la base » supprime ce second run : le verdict tombe quand même, mais il n'est plus causal, et le rapport le dit. - La base est-elle rejouée à chaque fois ? Oui, même quand aucun commit n'a bougé. Un cache par jeu de SHAs a existé et faisait gagner du temps ; il supposait que l'environnement n'avait pas bougé non plus, ce que rien ne permet de vérifier — et il se trompait dans les deux sens : un rouge de base corrigé hors git (un service redémarré, une migration appliquée) restait collé et bloquait la MR sur un « base rouge » périmé ; à l'inverse, un vert de base devenu faux faisait imputer à ta branche un échec qui ne venait pas d'elle. Une vérification coûte donc deux runs — c'est le prix d'un verdict qui ne ment pas. Pour n'en payer qu'un, décoche « Lancer aussi la base » : le verdict est alors marqué non causal.
- git ne marche pas dans mon container de test. Dans un worktree,
.gitest un fichier pointeur vers le dépôt principal, pas un dossier. Monte aussi le clone (data/clones/…) dans le container, ou n'appelle pas git depuis les tests. - « Restauration manuelle requise ». Le mode in place n'a pas pu remettre ton répertoire sur sa branche : il est resté sur un commit détaché. Le message dit quel répertoire et quelle ref attendre — un
git checkout <ref>suffit une fois ce qui bloquait levé. - Le verdict est
⟳ périmé. Il porte sur des commits qui ne sont plus ceux de la branche. Il est conservé, pas effacé (il est daté) : relance la vérification.
Vérifier ensemble, et corriger
Le bouton Vérifier est présent sur les merge requests à traiter comme sur celles déjà reviewées (dans la liste et dans le panneau de rapport) : une review est un avis, un verdict est un fait, et le second garde tout son intérêt une fois le premier rendu. Un clic ouvre une confirmation qui annonce ce qui va tourner — les commandes, le dépôt, le mode, le délai — avant de lancer quoi que ce soit. Elle apparaît même quand un seul vérificateur couvre le dépôt : exécuter des commandes sur sa machine mérite un écran, pas un clic silencieux.
Une batterie qui part toute seule. Une case Lancer sur toute nouvelle merge request des dépôts couverts sur un vérificateur : dès qu'une MR apparaît à la découverte, tous les vérificateurs automatiques qui couvrent son dépôt partent, sans clic. Seule une MR nouvelle déclenche — une MR déjà connue est revue à chaque synchronisation, la relancer à chaque fois ferait tourner la batterie sur tout le monde en permanence.
Relancer quand le verdict se périme. Une seconde case, Relancer quand une merge request vérifiée reçoit de nouveaux commits : un vert rendu sur des commits qui ne sont plus les derniers ne vaut rien. Elle est SÉPARÉE de la première parce que c'est un appétit différent — sur une branche qui bouge dix fois par jour, ça fait dix batteries. Décochée, le badge dit simplement « périmé » et c'est toi qui relances.
⚠ Cinq vérifications au maximum par tour de découverte, et ce plafond se règle (Réglages → Vérificateurs, juste au-dessus de la liste — à côté de la case qui les déclenche). Un lundi matin, la découverte peut ramener quinze merge requests ; quinze batteries fonctionnelles saturent la machine pour une heure et bloquent la file partagée avec les reviews. Au-delà, les MR gardent leur bouton Vérifier, et le journal du serveur dit ce qui n'est pas parti — un plafond silencieux se lirait comme « tout a été vérifié ». 0 signifie « sans limite », et c'est un choix qui doit pouvoir s'assumer. Les vérifications d'un même dépôt s'empilent dans la file au lieu d'être refusées : elles ne tourneront jamais en même temps, mais aucune n'est perdue.
Publier le verdict sur la merge request
Deux chemins, et ils ne se confondent pas.
À la main, après relecture. Depuis le rapport, Publier en commentaire ouvre le corps pré-rempli — exactement celui que la publication automatique enverrait — dans un champ modifiable. Une confirmation nomme la merge request avant l'envoi, et une fois publié l'écran le dit (date, destinataires) au lieu de reproposer le bouton comme si de rien n'était : c'est ce qui évite de poster deux fois le même verdict chez quelqu'un. Si la publication échoue, le texte reste sous les yeux — on ne perd jamais ce qu'on vient d'écrire.
Tout seul, si la case Publier le verdict en commentaire est cochée sur le vérificateur — à condition que le run base soit vert. C'est lui qui donne son sens au verdict :
| Base | Tête | Publié ? |
|---|---|---|
| verte | rouge | oui — « ça passait avant, cette branche casse » |
| verte | verte | oui — « vérifié, et ça tient » : sur une MR qu'on va relire, un vert écrit vaut mieux qu'un badge à aller chercher |
| rouge | — | non — ce n'est pas imputable à cette branche ; l'écrire sur SA merge request reviendrait à l'accuser de ce que quelqu'un d'autre a cassé |
| absente | — | non — sans run base, on ne SAIT PAS si c'était déjà rouge, et publier serait affirmer ce qu'on n'a pas vérifié |
Le journal du serveur dit pourquoi rien n'est parti : un silence se lit comme « publié ». Décochée par défaut : écrire chez les autres est une décision. La publication à la main reste possible dans tous les cas — là, c'est un humain qui décide, avec le texte sous les yeux.
Et le ticket Jira, si tu le demandes. Le commentaire de forge s'adresse à qui relit le code ; le ticket, lui, est lu par la QA, le chef de projet, le support — ceux qui demandent « c'est testé ? » sans jamais ouvrir la forge. Une case dans Réglages → Jira (décochée par défaut, comme « Prévenir Jira ») fait commenter le ticket de la merge request quand une vérification casse. Mêmes gardes que le commentaire de forge : uniquement « la base passait, la branche casse », jamais sur un vert ni sur une base déjà rouge, et une seule fois par ticket même si le lot porte cinq merge requests du même. Jira injoignable ne remet pas en cause un verdict acquis : l'échec est noté dans le journal du job.
Et quand la merge request est mergée. Une seconde case dans Réglages → Jira, décochée par défaut elle aussi, fait commenter le ticket dès que Mergerie voit la merge request mergée — par la découverte ou par Mettre à jour depuis la forge. Le texte est celui du gabarit de l'équipe ({url} obligatoire, plus {iid}, {project}, {title}, {branch}, {target}, {key}) ou, vide, le message livré dans la langue de l'interface. Un commentaire par ticket : la première merge request mergée le poste, chaque suivante du même ticket le réécrit avec la liste complète (une entrée du gabarit par merge request, dans l'ordre des fusions) — cinq merge requests d'un même ticket ne font pas cinq commentaires. Si Jira ne laisse plus modifier ce commentaire (supprimé, ou plus le vôtre), un nouveau reprend la liste et devient celui qui est suivi. Une merge request n'est annoncée qu'une fois, quel que soit le nombre de chemins qui voient le même merge ; rien pour une merge request fermée sans merge, rien sans clé de ticket dans la branche ou le titre, et rien depuis le rattrapage d'une Période — dix jours de tickets n'ont pas à apprendre d'un coup ce que l'équipe sait déjà. Jira qui refuse : le marqueur est relâché et le tour de découverte suivant réessaie.
Un verdict rouge laisse une todo. La notification passe et s'oublie ; le badge suppose qu'on rouvre Reviews. Entre les deux, rien ne portait « il y a un test cassé sur !218 » jusqu'au lendemain matin. Une todo est donc posée par merge request (relancer trois fois la même vérification met à jour la même ligne, elle n'en empile pas trois), et un vert la referme — cochée, jamais supprimée : ce qui a été réparé aujourd'hui se relit dans les faites.
Ce que le rapport dit d'autre. Quand la sortie des tests porte des durées (# time= de vitest, duration_ms de node, l'attribut time de JUnit — jusque-là jetées avec le reste du commentaire), le rapport replie en bas les cinq tests les plus lents : un test lent est presque toujours VERT, c'est même pour ça qu'on ne le remarque jamais. Et un test rouge déjà vert sur ce même code à un autre run porte la mention instable : il ne s'agit alors pas de chercher ce que la branche a cassé. Il faut au moins deux runs sur les mêmes commits pour le dire — un seul ne prouve rien, et douter d'un test qui n'a jamais menti coûterait plus cher que le silence.
Et « Enquêter » depuis le rouge. Le rapport d'une vérification en échec porte un bouton Enquêter à côté de Corriger : les deux ne s'adressent pas au même moment — un test rouge dont on ne comprend pas la trace ne se corrige pas, il se cherche d'abord. Il ouvre l'enquêteur d'incident avec les tests cassés et leurs extraits de journal en demande. Le même bouton existe sur la console d'un build Jenkins, à l'endroit exact où l'on LIT la trace, et n'apparaît que si la console en contient bien une.
Le gabarit du commentaire se modifie (il apparaît sous la case). Ce que contient chaque champ :
| Champ | Ce qu'il produit |
|---|---|
{verdict} | la ligne de verdict, avec le nom du vérificateur — **integ** : ✗ 2 test(s) cassé(s) par cette branche. Sur une vérification de branche, « par cette branche » disparaît |
{tests} | les tests cassés, un par ligne, avec leur message quand la sortie en donne un. Coupé au-delà de vingt, et il le dit. Vide si tout passe |
{commandes} | les commandes qui ont échoué, avec leur code de sortie (préfixées du dépôt s'il y en a plusieurs). Elle répond à ce que {tests} laisse ouvert quand la sortie nomme les tests : lesquels cassent, oui — mais laquelle des commandes. Vide si rien n'a échoué |
{commits} | les commits réellement testés : un par dépôt, dépôt · branche @ sha. C'est ce qui rend le verdict vérifiable |
{mentions} | les personnes déclarées sur le vérificateur (champ Personnes à prévenir quand ça casse), uniquement sur un verdict rouge. Vide sur un vert |
{verificateur} | le nom du vérificateur, seul — utile si tu écris ta propre phrase de verdict |
{date} | la date de publication du commentaire (17/08/2026), pas celle du run |
{heure} | l'heure de publication (14:12) |
Prévenir quelqu'un. Le champ Personnes à prévenir quand ça casse prend des handles (@amady @bruno) ou un groupe (@mon-equipe, qui vieillit mieux qu'une liste de personnes), repris tels quels là où tu places {mentions}. C'est la forge qui résout la mention et envoie le mail — Mergerie ne fait que l'écrire. Deux choses à savoir : il faut le handle, pas l'identifiant numérique (GitLab ne résout pas @42), et tu ne seras pas notifié de tes propres mentions, le commentaire étant posté avec ton jeton. Rien n'est mentionné sur un verdict vert : prévenir quelqu'un pour dire que tout va bien est le plus sûr moyen de finir dans un filtre.
Tout le reste est écrit tel quel, et un champ inconnu reste visible au lieu de disparaître : une faute de frappe doit se voir dans l'aperçu, pas se traduire par un trou dans le commentaire. Un bloc vide ne laisse pas de ligne blanche en trop. Sous le champ, « Voir un exemple de commentaire » montre le rendu de TON gabarit sur des données d'exemple — composé par le même moteur que le vrai commentaire, sinon l'aperçu finirait par mentir. Laissé vide, c'est le gabarit par défaut qui sert, et il profite alors des améliorations à venir.
Vérifier une branche — ou un tag —, sans merge request
Au retour de congés, plusieurs merge requests ont été mergées : la question n'est plus « qu'est-ce que cette branche casse ? » mais « est-ce que develop est encore vert ? ». Le bouton Vérifier une branche vit dans l'onglet Git et sur la carte de chaque vérificateur. Une ligne par dépôt couvert, chacune sur sa branche par défaut, choisie dans un sélecteur à recherche — un dépôt actif en aligne des centaines. La dernière branche vérifiée est mémorisée. Lancer répond aussitôt : clone ou fetch de chaque dépôt, lecture du tag et résolution du commit se font dans le job, ligne par ligne dans le journal — une ref inconnue met la vérification en erreur avec son nom et son dépôt, dans le journal et le rapport, au lieu de retenir la fenêtre.
Un tag aussi bien qu'une branche. Devant la ref, un sélecteur Branche / Tag : « la 3.2.0 livrée vendredi passe-t-elle encore avec les services d'aujourd'hui ? » est la même question, posée sur une ref qui ne bouge pas. Le vérificateur se positionne sur le commit pointé par le tag de chaque dépôt coché (pas sur l'objet du tag annoté, qui a son propre SHA), et le rapport, le brief et le commentaire annoncent la cible comme un tag. Le genre est mémorisé par dépôt, avec le dernier tag et la dernière branche chacun de leur côté : revenir sur Branche retrouve la branche d'avant. Un rouge sur un tag ne propose pas Corriger : un tag ne bouge pas, il n'y a pas de branche où poser une correction.
On coche les dépôts qu'on veut, pas toute la couverture. Chaque ligne porte une case, cochée d'emblée : un vérificateur qui couvre cinq dépôts peut donc n'en vérifier qu'un, sans avoir à donner les quatre autres branches — et une ligne dont la branche par défaut ne se lit pas (dépôt injoignable) ne bloque plus le lancement des autres. La sélection est mémorisée par vérificateur : « seulement api-core » est une habitude, pas une envie du jour. Le filtre au-dessus de la liste masque des lignes sans jamais les décocher — ce qui est coché part, visible ou non.
Deux choses changent de sens, et l'outil les déduit de l'absence de merge request :
- le double run causal s'éteint — sur une branche d'intégration, la branche EST la base ; le laisser actif ferait tourner la batterie deux fois pour comparer
developàdevelop; - l'imputabilité disparaît : rien n'est « cassé par cette branche », ce qui est rouge est rouge. Le rapport et le commentaire l'écrivent autrement.
Il n'y a pas de carte de MR pour porter le badge : le résultat vit dans l'historique des vérifications et dans le brief du matin, où la ligne s'écrit « dépôt · branche ».
Voir ce qui a tourné, même quand c'est vert. Un bouton Voir le résultat des vérificateurs sur la merge request ouvre le détail de chaque vérificateur passé dessus — verdict, commits testés, tests cassés, et le déroulé des commandes avec leur code de sortie et leur sortie. Il apparaît dès qu'un résultat existe, pas seulement en rouge : « c'est vert, mais qu'est-ce qui a tourné exactement ? » est une question légitime, surtout quand on n'a pas vu passer le lancement. Un résultat périmé (le SHA de la MR a bougé depuis) le dit. Chaque bloc rouge garde son bouton Corriger (session IA) — avec plusieurs rapports, un bouton unique en pied de fenêtre ne dirait pas lequel il corrige.
Pendant qu'elle tourne, ça se voit. Une vérification dure des minutes : le bouton devient Vérification… avec son spinner, désactivé — un second clic ne peut donc pas relancer la même —, et la carte porte le repère « en cours » (le liseré qui bat), le même que pendant une review. L'état vient du serveur, pas de la page : il survit à un changement d'onglet, au re-tri de la liste et à un rechargement, et il retombe tout seul à la fin, la liste se rafraîchissant pour afficher le verdict. ⚠ Une review sur la même MR marque bien la carte, mais ne fait pas tourner le bouton Vérifier : un spinner désignant la mauvaise commande vaudrait moins que pas de spinner du tout.
Dans Reviews, coche plusieurs merge requests : la barre d'actions propose Vérifier ensemble et Créer un lot (un lot est nommé, persisté, et re-vérifiable d'un bouton depuis Dev IA). Deux MR du même dépôt sont refusées — on ne saurait pas quel code a été testé.
Sur un verdict ✗, le rapport propose « Corriger (session IA) » : une seule session de codage couvrant tous les dépôts du lot — pas seulement celui où le test a cassé, parce que la cause d'un échec d'intégration est souvent ailleurs. Le prompt porte les faits (tests cassés, messages, extraits, commits testés) et les branches de travail sont celles des MR : le push les met à jour en place. Après le push, tu relances la vérification à la main — aucune chaîne automatique.
Deux vérifications en même temps ?
Ça dépend de ce qui tourne. Une vérification mono-dépôt est contenue dans son répertoire : une autre peut partir en parallèle, tant qu'elle ne vise pas le même dépôt — relancer la même chose ne donnerait pas un second avis, seulement un run qui attend le premier pour dire la même chose.
Une vérification multi-dépôts, elle, est un run d'intégration : elle monte un environnement complet, souvent des containers sur des ports et des bases fixes. Celle-là bloque tout le monde, et se fait bloquer par tout le monde — deux en parallèle rendraient des rouges qui n'apprennent rien.
Dans les deux cas le refus est immédiat et dit laquelle des deux raisons s'applique.
Mode dry-run : il ne concerne que l'agent IA. Une vérification, elle, reste réelle si elle est configurée. En mode démo, en revanche, aucune commande n'est lancée : le verdict est simulé.