Retour au blog
IngénierieNovember 6, 20267 min de lecture

Un robot a cliqué sur chaque bouton. Il a trouvé huit failles de sécurité.

Nous avons arrêté de tester des morceaux pour tester des pages. Vrai navigateur, vrai serveur, vrais clics, sur chaque endpoint qu'un client peut toucher.

Notre code passait le typage, le lint et les tests unitaires. Il livrait quand même des bugs. Rien d'exotique : un formulaire de réinitialisation qui ignorait la confirmation du mot de passe, des liens de facture qui ne menaient nulle part, un fil d'actualité qui affichait des discussions supprimées.

Tous ces bugs vivaient dans l'interstice entre les briques. La fonction était correcte. La page autour, non. Nous avons donc construit un framework de test qui ne s'intéresse qu'à une chose : ce qu'un client voit et envoie réellement.

Pourquoi tester la vraie page ?

Chaque niveau de test attrape une catégorie de bugs différente. Seul le dernier voit ce que voient vos utilisateurs.

Test unitaire

Vérifie une fonction

Rapide et pas cher. Aveugle au câblage : mauvaise URL, mauvais nom de champ, un bouton qui n'envoie jamais rien.

Test d'API

Vérifie une requête

Prouve que le serveur répond. Ne prouve jamais que la page envoie cette requête, ni qu'elle affiche la réponse.

Bout en bout

Vérifie tout le trajet

Ouvre la page dans Chromium, tape comme une personne, clique sur envoyer, lit la réponse sur le réseau. Si ça marche ici, ça marche pour les clients.

Comment fonctionne le harnais

Playwright piloté depuis bun test, construit sur les définitions d'endpoints de next-vibe. La définition connaît déjà chaque champ, donc le test n'a pas besoin de les connaître.

1

Ouvrir la vraie page

Le test ouvre la page client (/user/login, /story/framework), pas un bouchon de test. Il attend que React ait pris la main sur le formulaire avant de taper.

2

Remplir avec des valeurs typées

Vous passez des valeurs, pas des sélecteurs. Les pilotes de champs lisent la définition et manipulent l'interface visible : saisir du texte, choisir une option par son libellé, joindre un fichier.

3

Capturer l'appel sur le réseau

L'envoi renvoie la vérité : le corps de la requête, le statut et la réponse. Le harnais vérifie que la requête contenait exactement ce qui a été tapé.

4

Enregistrer une fois, rejouer à l'infini

Les fournisseurs payants (modèles d'IA, image, musique, vidéo) sont enregistrés par test au premier passage, puis rejoués ensuite. Pas de facture surprise, des exécutions déterministes.

5

Mesurer la couverture

Un rapport de couverture compte chaque endpoint public : un succès et un rejet pour chacun. Les trous sont visibles, pas devinés.

contact.e2e.test.ts
describe("E2E: contact form", () => {
  const e2e = useE2E("contact");

  e2e.it("sends a message", async ({ open, uniqueEmail }) => {
    const form = await open(contactEndpoints.POST, {
      path: "/story/framework",
    });
    await form.fill({
      name: "E2E",
      email: uniqueEmail("contact"),
      subject: ContactSubject.BUG_REPORT,
      message: "...",
    });
    const result = await form.submit();
    expect(result.sent).toBe(true);
  });
});

Une spec complète. Pas de sélecteurs, pas de mocks.

Le tableau des scores

50
suites de tests
47/56
endpoints publics entièrement couverts
8
failles de sécurité corrigées

Les endpoints restants ont besoin de clés de fournisseurs payants pour la recherche, le scraping et la voix avant de pouvoir être enregistrés.

Les failles de sécurité trouvées

Aucune n'est apparue au typage ni dans les tests unitaires. Toutes sont apparues dès qu'un vrai navigateur a parcouru le vrai parcours.

Redirection ouverte sur /track

N'importe qui pouvait fabriquer un lien qui rebondissait par notre domaine vers n'importe quel site. Les cibles externes exigent désormais une signature HMAC.

SSRF via des URL fournies par l'utilisateur

Les URL transmises à l'IA pouvaient pointer vers des adresses internes. Une protection résout désormais le DNS et vérifie chaque étape de redirection.

Cache serveur partagé entre requêtes

Le cache de requêtes du rendu serveur pouvait faire passer les données d'un utilisateur dans le rendu d'une autre page. Il est désormais isolé par requête.

Le débogage du prompt système lisait n'importe quel fil

Un endpoint de débogage ne vérifiait pas à qui appartenait le fil. Maintenant, si.

Le fil public listait des discussions masquées

Des discussions masquées et supprimées apparaissaient dans le fil public. Elles sont maintenant filtrées.

Les options de connexion trahissaient les comptes

La réponse des options de connexion révélait si un e-mail avait un compte. Ce n'est plus le cas.

La réinitialisation ignorait la confirmation

L'étape de confirmation de réinitialisation du mot de passe ignorait le champ de confirmation. Les non-correspondances sont désormais rejetées.

Fichiers privés mis en cache publiquement

Les fichiers privés étaient servis avec Cache-Control: public, donc les caches partagés pouvaient les conserver. Ils sont désormais privés.

Et ce qui était simplement cassé

Rien de dangereux, juste des échecs silencieux pour de vraies personnes :

  • Les URL des pièces jointes du chat et les rapports d'erreurs client renvoyaient 404.
  • Les permissions racine n'étaient jamais chargées : les clients ne pouvaient pas publier dans Shared.
  • Le montage du widget intégrable était mort.
  • Les liens des e-mails de facture renvoyaient 404.
  • La page des modèles était inutilisable.
  • La génération de musique sur OpenRouter échouait.
  • La portée des fixtures de test laissait passer des appels payants en direct.
  • Les bases PGlite locales renvoyaient les mauvaises lignes sur INSERT…RETURNING.
  • La pagination pour les visiteurs sur /tools était cassée.
Plus une longue liste de textes non traduits et de corrections de widgets.

Ce que ça change pour vous

Chaque page que vous utilisez pour vous inscrire, vous connecter, payer, discuter, générer ou vous abonner a maintenant un test qui l'ouvre dans un vrai navigateur et fait ce que vous faites. Quand nous changeons quelque chose, le robot la reparcourt avant vous.

Le framework est livré avec next-vibe. Si vous construisez dessus, vos endpoints profitent gratuitement du même harnais.

Lisez le harnais. Utilisez-le sur votre propre code.

Le framework E2E est open source et fait partie de next-vibe. Un fichier de spec par fonctionnalité, placé à côté de la définition.

Retour au blog