@mostajs/wagon-engine 0.0.0-stage → 0.1.0

package/src/conformite/conformite.test.mjs

@@ -0,0 +1,592 @@
+// @mostajs/wagon-engine — LA SUITE DE CONFORMITÉ : elle dit si une greffe tient.
+// La greffe jugée est celle de WAGON_GREFFE, sinon le dossier courant : sa configuration (wagon.config.mjs), sa
+// charge (charge/index.mjs) et ses textes légaux (legal/). Lancer depuis la greffe :
+//   mjs-unit node_modules/@mostajs/wagon-engine/src/conformite/conformite.test.mjs
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// Le gabarit (plan B de l'audit du 01/10/2026) : le wagon de mdseal — comptes, connexion, paliers,
+// quotas, paiement, espace client, administration, pages légales, fr/en/ar — prêt à recevoir une
+// charge utile. Cette suite tourne sur la CHARGE D'EXEMPLE (charge/) ; après une greffe, elle tourne
+// sur la vôtre. Base sqlite réelle ; signatures Stripe réelles, Stripe simulé pour le reste.
+// 08/10/2026 : elle ne suppose plus la charge d'exemple (`/outil`, palier `pro`, `transformationsParJour`) :
+// elle lit le palier payant et les limites dans wagon.config.mjs, et l'essai de quota dans
+// `charge.conformite` — sans cette description, T-WAG-3 est ignoré (« sans objet »), jamais faussement vert.
+// Écrit AVANT le code.
+import { test, expect } from '@mostajs/mjs-unit';
+import { createServer, request } from 'node:http';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import Stripe from 'stripe';
+import { creerWagon } from '../wagon.mjs';
+
+const GREFFE = resolve(process.env.WAGON_GREFFE || process.cwd());
+if (!existsSync(join(GREFFE, 'wagon.config.mjs')) || !existsSync(join(GREFFE, 'charge', 'index.mjs'))) {
+  throw new Error(`conformité : greffe introuvable dans ${GREFFE} (wagon.config.mjs et charge/index.mjs attendus ; WAGON_GREFFE la désigne)`);
+}
+const config = (await import(pathToFileURL(join(GREFFE, 'wagon.config.mjs')).href)).default;
+const charge = (await import(pathToFileURL(join(GREFFE, 'charge', 'index.mjs')).href)).default;
+
+/** Ce que la suite lit de la GREFFE au lieu de le supposer. */
+const ACTIFS = config.paliers.filter((p) => p.active !== false).sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+const PAYANT = ACTIFS.find((p) => Number(p.price) > 0) ?? null;
+const GRATUIT = ACTIFS.find((p) => p.slug === (config.planGratuit ?? 'gratuit'));
+const RESS = charge.ressources ?? [];
+const LIMITE = (RESS.find((r) => r.parPeriode) ?? RESS[0])?.limite ?? null;
+/** { route, formulaire, limite, attendu, nonCompris?: { route, json } } — l'essai de quota de la charge. */
+const ESSAI = charge.conformite?.route ? charge.conformite : null;
+/** `conformite.tarifs: false` : la charge remplace /tarifs (ex. les prix de ses voyages) — les paliers n'y sont pas. */
+const TARIFS = charge.conformite?.tarifs !== false;
+const MAIL_PAYANT = 'payant@exemple.test';
+/** Un essai sans objet pour cette greffe : ignoré AVEC son motif (mjs-unit ≥ 0.8 : il entre au rapport et au compte rendu). */
+const sansObjet = (motif) => (nom, fn) => test.skip(nom, fn, `sans objet : ${motif}`);
+
+const atelier = mkdtempSync(join(tmpdir(), 'wagon-'));
+const SECRET = 'whsec_essai';
+const vrai = new Stripe('sk_test_hors_reseau');
+const appels = { sessions: [], portails: [] };
+let n = 0;
+const stripe = {
+  webhooks: vrai.webhooks,
+  products: { create: async () => ({ id: 'prod_x' }) }, prices: { create: async () => ({ id: `price_${++n}` }) },
+  customers: { create: async () => ({ id: `cus_${++n}` }) },
+  checkout: { sessions: { create: async (p) => { appels.sessions.push(p); return { id: `cs_${++n}`, url: `https://checkout.stripe.test/${n}` }; } } },
+  billingPortal: { sessions: { create: async (p) => { appels.portails.push(p); return { url: 'https://billing.stripe.test/portail' }; } } },
+};
+const BOITE = join(atelier, 'courriels.jsonl');
+
+// 0.4 (audit du 09/10/2026) — un document légal incomplet ne se sert pas (SAAS-APP §7.2), et l'on ne vend pas sans
+// CGV complètes (DEVRULES §11.10). L'instance principale reçoit donc des documents COMPLETS (dossier d'essai) ; les
+// modèles du gabarit, qui portent encore leurs « À FAIRE TRANCHER », sont éprouvés à part (T-WAG-17).
+const LEGAL_COMPLET = join(mkdtempSync(join(tmpdir(), 'wagon-legal-')), 'legal');   // hors de l'atelier, que T-WAG-9 efface
+mkdirSync(LEGAL_COMPLET);
+for (const doc of ['mentions-legales', 'cgu', 'cgv', 'confidentialite']) {
+  writeFileSync(join(LEGAL_COMPLET, `${doc}.fr.md`), `# ${doc}\n\n{{SERVICE}} est édité par {{EDITEUR_NOM}}. Contact : {{CONTACT_EMAIL}}. Paiement : {{PAIEMENT}}.\n`);
+}
+const VALEURS_LEGALES = { EDITEUR_NOM: 'Éditeur Essai SARL' };
+
+/** 0.3 — le port de paiement simulé des banques prépayées : ce que @mostajs/payment fait, sans banque. */
+const ordres = new Map();
+const portPaiement = {
+  async createPaymentCheckout(input) {
+    ordres.set(input.orderId, { orderId: input.orderId, amount: input.amount, currency: input.currency, status: 'pending', metadata: input.metadata });
+    return { checkout: { url: `https://pay.chargily.net/test/checkouts/${input.orderId}` }, payment: ordres.get(input.orderId) };
+  },
+  async settlePaymentFromWebhook({ body }) {
+    const e = JSON.parse(body);
+    if (e.sig !== 'ok') return { ok: false, reason: 'invalid_signature' };
+    const payment = ordres.get(e.orderId) ?? null;
+    return { ok: true, orderId: e.orderId, status: e.status, payment };
+  },
+};
+const BANQUES = config.paiement?.prepaye ?? {};
+const OFFRE = PAYANT && Object.entries(BANQUES).map(([b, dev]) => [b, dev, (PAYANT.prepaid ?? {})[dev]]).find(([, , p]) => p?.month);
+
+async function demarrer(plus = {}) {
+  const w = await creerWagon({
+    config: { ...config, admins: ['admin@exemple.test'], dossierLegal: LEGAL_COMPLET, legal: { ...(config.legal ?? {}), ...VALEURS_LEGALES }, freinInscription: { capacity: 1000, refillPerSec: 100 }, ...plus },
+    charge: plus.charge ?? charge, sgbd: plus.sgbd ?? join(atelier, `w${Math.random()}.db`), baseUrl: 'http://127.0.0.1', racine: GREFFE, stripe, webhookSecret: SECRET,
+    transport: { envoyer: async (m) => { const { appendFileSync } = await import('node:fs'); appendFileSync(BOITE, `${JSON.stringify(m)}\n`); } },
+    paiement: { banques: plus.banques ?? BANQUES, port: plus.port ?? portPaiement },
+  });
+  await w.catalogue(); await w.catalogueStripe();
+  const s = createServer(w.handler);
+  await new Promise((ok) => s.listen(0, '127.0.0.1', ok)); s.unref();
+  return { w, port: s.address().port, fermer: async () => { s.closeAllConnections?.(); s.close(); await w.fermer(); } };
+}
+const A = await demarrer();
+const B = `http://127.0.0.1:${A.port}`;
+
+/** Une requête : node:http, pour poser les en-têtes qu'un navigateur poserait (Host, Sec-Fetch-Site). */
+const req = (base, chemin, { method = 'GET', form, json, headers = {}, cookie } = {}) => new Promise((ok, ko) => {
+  const corps = form ? new URLSearchParams(form).toString() : json ?? null;
+  const h = { ...(form ? { 'content-type': 'application/x-www-form-urlencoded' } : {}), ...(cookie ? { cookie } : {}), ...headers };
+  const r = request(`${base}${chemin}`, { method, headers: h }, (res) => {
+    const c = []; res.on('data', (x) => c.push(x)).on('end', () => ok({ status: res.statusCode, headers: res.headers, texte: Buffer.concat(c).toString(), cookie: (res.headers['set-cookie'] || []).map((x) => x.split(';')[0]).find((x) => /^wagon_session=./.test(x)) || '' }));
+  });
+  r.on('error', ko); if (corps) r.write(corps); r.end();
+});
+const courriels = () => (existsSync(BOITE) ? readFileSync(BOITE, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l)) : []);
+const MDP = 'Une-Phrase-Longue-2026';
+async function inscrire(base, courriel, plan = 'gratuit') {
+  const r = await req(base, '/inscription', { method: 'POST', form: { plan, nom: `Société ${courriel}`, courriel, motdepasse: MDP } });
+  return r;
+}
+const connecter = async (base, courriel) => (await req(base, '/connexion', { method: 'POST', form: { courriel, motdepasse: MDP } })).cookie;
+
+test('T-WAG-1 — la greffe démarre ; identité et charge configurées', async () => {
+  const h = (await req(B, '/')).texte;
+  expect(h.includes(config.marque.nom)).toBe(true);
+  for (const l of charge.liens) expect(h.includes(`href="${l.href}"`)).toBe(true);
+  expect(/mdseal|docme/i.test(h)).toBe(false);
+  if (TARIFS) {
+    const t = (await req(B, '/tarifs')).texte;
+    // Le prix tel que wagon-ui ≥ 0.4 l'écrit (Intl, langue par défaut) : « 9,99 € », plus « 9.99 € ».
+    const prix = (c) => new Intl.NumberFormat(config.langues?.[0] ?? 'fr', { style: 'currency', currency: 'EUR' }).format(c / 100);
+    for (const p of config.paliers.filter((x) => x.active !== false && x.price)) expect(t.includes(prix(p.price))).toBe(true);
+  }
+});
+
+let cleApi = '';
+test('T-WAG-2 — inscription, connexion, espace, déconnexion', async () => {
+  const r = await inscrire(B, 'anis@exemple.test');
+  expect(r.status).toBe(200);
+  const m = r.texte.match(/sk_(?:test|live)_[0-9a-f]{64}/);
+  expect(m !== null).toBe(true);
+  cleApi = m[0];
+  expect(r.cookie !== '').toBe(true);
+  const deja = await inscrire(B, 'anis@exemple.test');
+  expect(/existe déjà/i.test(deja.texte)).toBe(true);
+  expect((await req(B, '/connexion', { method: 'POST', form: { courriel: 'anis@exemple.test', motdepasse: 'faux-faux-faux-faux' } })).cookie).toBe('');
+  const c = await connecter(B, 'anis@exemple.test');
+  expect(c !== '').toBe(true);
+  const e = (await req(B, '/compte', { cookie: c })).texte;
+  expect(e.includes('Gratuit')).toBe(true);
+  expect(e.includes(cleApi.slice(0, 12))).toBe(true);
+  expect(e.includes(cleApi)).toBe(false);
+  const d = await req(B, '/deconnexion', { method: 'POST', cookie: c, form: {} });   // 0.5 : un POST
+  expect(d.status).toBe(303);
+  expect((await req(B, '/compte', { cookie: c })).status).toBe(303);
+});
+
+(ESSAI ? test : sansObjet('la charge ne déclare pas charge.conformite'))(`T-WAG-3 — quotas : anonyme, palier, 429, 403${ESSAI ? '' : ' (sans objet : la charge ne déclare pas charge.conformite)'}`, async () => {
+  const outil = ESSAI.route;
+  // anonyme : la part par adresse (palier « anonyme »), puis 429
+  const anon = config.paliers.find((p) => p.slug === (config.planAnonyme ?? 'anonyme')).limits[ESSAI.limite];
+  for (let i = 0; i < anon; i++) expect((await req(B, outil, { method: 'POST', form: ESSAI.formulaire })).status).toBe(200);
+  const trop = await req(B, outil, { method: 'POST', form: ESSAI.formulaire });
+  expect(trop.status).toBe(429);
+  expect(Number(trop.headers['retry-after']) > 0).toBe(true);
+  // un compte : la part de son palier (plus large que l'anonyme)
+  const c = await connecter(B, 'anis@exemple.test');
+  const ok = await req(B, outil, { method: 'POST', form: ESSAI.formulaire, cookie: c });
+  expect(ok.status).toBe(200);
+  if (ESSAI.attendu) expect(ok.texte.includes(ESSAI.attendu)).toBe(true);
+  // une ressource que le palier ne comprend pas : 403, définitif
+  if (ESSAI.nonCompris) {
+    const api = await req(B, ESSAI.nonCompris.route, { method: 'POST', json: ESSAI.nonCompris.json, headers: { 'content-type': 'application/json', authorization: `Bearer ${cleApi}` } });
+    expect(api.status).toBe(403);
+  }
+});
+
+(PAYANT ? test : sansObjet('aucun palier payant'))(`T-WAG-4 — paiement : session, webhook, rejeu, facture${PAYANT ? '' : ' (sans objet : aucun palier payant)'}`, async () => {
+  const r = await inscrire(B, MAIL_PAYANT, PAYANT.slug);
+  expect(r.texte.includes(`name="plan" value="${PAYANT.slug}"`)).toBe(true);
+  const p = await req(B, '/paiement', { method: 'POST', cookie: r.cookie, form: { plan: PAYANT.slug, banque: 'stripe' } });
+  expect(p.status).toBe(303);
+  expect(p.headers.location.startsWith('https://checkout.stripe.test/')).toBe(true);
+  const s = appels.sessions.at(-1);
+  const meta = s.metadata;
+  expect(meta.wagon_plan).toBe(PAYANT.slug);
+  const avant = (await req(B, '/compte', { cookie: r.cookie })).texte;
+  expect(avant.includes(GRATUIT.name)).toBe(true);
+  const envoyer = async (type, object, id) => {
+    const payload = JSON.stringify({ id, object: 'event', type, created: Math.floor(Date.now() / 1000), data: { object } });
+    return req(B, '/api/stripe/webhook', { method: 'POST', json: payload, headers: { 'content-type': 'application/json', 'stripe-signature': vrai.webhooks.generateTestHeaderString({ payload, secret: SECRET }) } });
+  };
+  expect((await envoyer('checkout.session.completed', { id: 'cs_p', subscription: 'sub_p', customer: s.customer, metadata: meta }, 'evt_1')).status).toBe(200);
+  expect((await envoyer('checkout.session.completed', { id: 'cs_p', subscription: 'sub_p', customer: s.customer, metadata: meta }, 'evt_1')).status).toBe(200);
+  await envoyer('invoice.paid', { id: 'in_1', subscription: 'sub_p', customer: s.customer, amount_paid: 15000, currency: 'eur', hosted_invoice_url: 'https://pay.stripe.test/in_1', subscription_details: { metadata: meta } }, 'evt_2');
+  const apres = (await req(B, '/compte', { cookie: r.cookie })).texte;
+  expect(apres.includes(PAYANT.name)).toBe(true);
+  expect(apres.includes('https://pay.stripe.test/in_1')).toBe(true);
+  expect(apres.includes('action="/compte/portail"')).toBe(true);
+  const portail = await req(B, '/compte/portail', { method: 'POST', cookie: r.cookie, form: {} });
+  expect(portail.headers.location).toBe('https://billing.stripe.test/portail');
+  expect((await req(B, '/api/stripe/webhook', { method: 'POST', json: '{}', headers: { 'stripe-signature': 't=1,v1=faux' } })).status).toBe(400);
+});
+
+// 0.4 (08/10/2026) — repris de qatrax.dev : l'avis avant prélèvement, et le retour du portail Stripe malgré le
+// cookie SameSite=Strict (une navigation venue de billing.stripe.com n'envoie pas la session).
+(PAYANT ? test : sansObjet('aucun palier payant'))(`T-WAG-14 — paiement : avis avant prélèvement (une fois), retour du portail sans perdre la session${PAYANT ? '' : ' (sans objet : aucun palier payant)'}`, async () => {
+  const retour = await req(B, '/compte/retour');
+  expect(retour.status).toBe(200);
+  expect(retour.texte.includes('http-equiv="refresh" content="0;url=/compte"')).toBe(true);
+  expect(String(retour.headers['cache-control'])).toBe('no-store');
+  expect(appels.portails.at(-1).return_url).toBe('http://127.0.0.1/compte/retour');
+  const client = appels.sessions.find((x) => x.metadata?.wagon_plan === PAYANT.slug)?.customer;
+  expect(!!client).toBe(true);
+  const envoyer = async (object, id) => {
+    const payload = JSON.stringify({ id, object: 'event', type: 'invoice.upcoming', created: Math.floor(Date.now() / 1000), data: { object } });
+    return req(B, '/api/stripe/webhook', { method: 'POST', json: payload, headers: { 'content-type': 'application/json', 'stripe-signature': vrai.webhooks.generateTestHeaderString({ payload, secret: SECRET }) } });
+  };
+  const avant = courriels().filter((m) => m.to === MAIL_PAYANT).length;
+  const echeance = Math.floor(Date.UTC(2030, 0, 15) / 1000);
+  expect((await envoyer({ customer: client, amount_due: 999, currency: 'eur', next_payment_attempt: echeance }, 'evt_avis_1')).status).toBe(200);
+  expect((await envoyer({ customer: client, amount_due: 999, currency: 'eur', next_payment_attempt: echeance }, 'evt_avis_1')).status).toBe(200);   // rejeu
+  const avis = courriels().filter((m) => m.to === MAIL_PAYANT).slice(avant);
+  expect(avis.length).toBe(1);
+  expect(avis[0].text.includes('15/01/2030') && avis[0].text.includes('9,99')).toBe(true);
+  expect(avis[0].text.includes('/compte')).toBe(true);
+  const total = courriels().length;
+  expect((await envoyer({ customer: 'cus_inconnu', amount_due: 999, currency: 'eur' }, 'evt_avis_2')).status).toBe(200);
+  expect(courriels().length).toBe(total);                                                 // client inconnu : aucun courriel
+});
+
+// 0.4 (09/10/2026) — audit : un palier inactif ou gratuit ne se vend pas ; un abonné Stripe ne s'abonne pas une
+// seconde fois (Stripe prélèverait les deux) ; il est renvoyé vers « Gérer mon abonnement ».
+(PAYANT ? test : sansObjet('aucun palier payant'))(`T-WAG-15 — paiement : ni palier inactif, ni second abonnement${PAYANT ? '' : ' (sans objet : aucun palier payant)'}`, async () => {
+  const r = await req(B, '/connexion', { method: 'POST', form: { courriel: MAIL_PAYANT, motdepasse: MDP } });
+  const avant = appels.sessions.length;
+  const inactif = await req(B, '/paiement', { method: 'POST', cookie: r.cookie, form: { plan: 'anonyme', banque: 'stripe' } });
+  expect(inactif.status).toBe(200);
+  expect(inactif.texte.includes('class="msg"')).toBe(true);
+  const second = await req(B, '/paiement', { method: 'POST', cookie: r.cookie, form: { plan: PAYANT.slug, banque: 'stripe' } });
+  expect(second.status).toBe(200);
+  expect(second.texte.includes('action="/compte/portail"')).toBe(true);
+  expect(appels.sessions.length).toBe(avant);                                              // aucune session Stripe ouverte
+});
+
+test('T-WAG-5 — API par clé, révocation bornée', async () => {
+  const moi = await req(B, '/api/v1/moi', { headers: { authorization: `Bearer ${cleApi}` } });
+  expect(moi.status).toBe(200);
+  expect(JSON.parse(moi.texte).compte.nom).toBe('Société anis@exemple.test');
+  expect((await req(B, '/api/v1/moi')).status).toBe(401);
+  const autre = await connecter(B, MAIL_PAYANT);
+  await req(B, '/compte/cles/revoquer', { method: 'POST', cookie: autre, form: { prefix: cleApi.slice(0, 16) } });
+  expect((await req(B, '/api/v1/moi', { headers: { authorization: `Bearer ${cleApi}` } })).status).toBe(200);
+  const mien = await connecter(B, 'anis@exemple.test');
+  await req(B, '/compte/cles/revoquer', { method: 'POST', cookie: mien, form: { prefix: cleApi.slice(0, 16) } });
+  expect((await req(B, '/api/v1/moi', { headers: { authorization: `Bearer ${cleApi}` } })).status).toBe(401);
+});
+
+(PAYANT && LIMITE ? test : sansObjet('pas de palier payant ou pas de limite'))(`T-WAG-6 — administration : accès, paliers, échelle, usage${PAYANT && LIMITE ? '' : ' (sans objet : pas de palier payant ou pas de limite)'}`, async () => {
+  const client = await connecter(B, 'anis@exemple.test');
+  expect((await req(B, '/admin/plans', { cookie: client })).status).toBe(404);
+  await inscrire(B, 'admin@exemple.test');
+  const adm = await connecter(B, 'admin@exemple.test');
+  expect((await req(B, '/admin/plans', { cookie: adm })).status).toBe(404);                 // déclaré, pas encore confirmé
+  await A.w.confirmerAdmin('admin@exemple.test');
+  const page = await req(B, '/admin/plans', { cookie: adm });
+  expect(page.status).toBe(200);
+  expect(page.texte.includes(`name="${PAYANT.slug}.${LIMITE}"`)).toBe(true);
+  const valeurs = Object.fromEntries(config.paliers.flatMap((p) => Object.entries(p.limits).map(([k, v]) => [`${p.slug}.${k}`, String(v)])));
+  const ok = await req(B, '/admin/plans', { method: 'POST', cookie: adm, form: { ...valeurs, [`${PAYANT.slug}.${LIMITE}`]: '777' } });
+  expect(ok.status).toBe(200);
+  if (TARIFS) expect((await req(B, '/tarifs')).texte.includes('777')).toBe(true);
+  else expect((await req(B, '/admin/plans', { cookie: adm })).texte.includes('value="777"')).toBe(true);   // la valeur tient, vue de l'administration
+  // L'échelle inversée : le gratuit donnerait PLUS que le payant.
+  const inverse = await req(B, '/admin/plans', { method: 'POST', cookie: adm, form: { ...valeurs, [`${GRATUIT.slug}.${LIMITE}`]: '2', [`${PAYANT.slug}.${LIMITE}`]: '1' } });
+  expect(/inversée|moins/i.test(inverse.texte)).toBe(true);
+  const u = await req(B, '/admin/usage', { cookie: adm });
+  expect(u.status).toBe(200);
+  expect(u.texte.includes('Société anis@exemple.test')).toBe(true);
+});
+
+test('T-WAG-7 — langues, pages légales, introuvable', async () => {
+  const ar = await req(B, '/tarifs?lang=ar');
+  expect(ar.texte.includes('<html lang="ar" dir="rtl"')).toBe(true);
+  const en = await req(B, '/', { headers: { 'accept-language': 'en-GB,en;q=0.9' } });
+  expect(en.texte.includes('<html lang="en"')).toBe(true);
+  const m = await req(B, '/mentions-legales');
+  expect(m.status).toBe(200);
+  expect(m.texte.includes('<h1')).toBe(true);
+  expect(m.texte.includes(config.marque.nom) && m.texte.includes('Éditeur Essai SARL')).toBe(true);   // {{SERVICE}}, {{EDITEUR_NOM}}
+  expect(/\{\{[A-Z_]+\}\}|\[object Object\]|à compléter|À FAIRE/.test(m.texte)).toBe(false);
+  // Sept adresses, quatre documents : les trois alias en 301 (SAAS-APP §7.1).
+  for (const [alias, cible] of [['/legal', '/mentions-legales'], ['/conditions', '/cgv'], ['/privacy', '/confidentialite']]) {
+    const r = await req(B, `${alias}?lang=en`);
+    expect([alias, r.status, r.headers.location]).toEqual([alias, 301, `${cible}?lang=en`]);
+  }
+  const aide = await req(B, '/aide');
+  expect(aide.texte.includes('<h1')).toBe(true);
+  expect(aide.texte.includes('[object Object]')).toBe(false);
+  const cgv = await req(B, '/cgv?lang=ar');
+  expect(cgv.status === 200 || cgv.status === 404).toBe(true);
+  expect((await req(B, '/nulle-part')).status).toBe(404);
+});
+
+// 0.4 (audit du 09/10/2026) — les modèles légaux du gabarit portent des « À FAIRE TRANCHER » et des jetons vides :
+// servis tels quels, ils AURAIENT L'AIR d'exister. Ils répondent 404, et la vente est fermée.
+test('T-WAG-17 — document légal incomplet : 404, et pas de vente sans CGV complètes ; paliers resynchronisés', async () => {
+  const sgbd = join(atelier, `incomplet${Math.random()}.db`);
+  const R = await demarrer({ dossierLegal: undefined, legal: {}, sgbd });
+  const br = `http://127.0.0.1:${R.port}`;
+  const m = await req(br, '/mentions-legales');
+  expect(m.status).toBe(404);
+  expect(/à compléter|\{\{|À FAIRE/.test(m.texte)).toBe(false);
+  if (PAYANT) {
+    const r = await inscrire(br, 'vente@exemple.test');
+    const p = await req(br, '/paiement', { method: 'POST', cookie: r.cookie, form: { plan: PAYANT.slug, banque: 'stripe' } });
+    expect(p.status).toBe(200);
+    expect(p.headers.location ?? '').toBe('');
+  }
+  await R.fermer();
+  // Les paliers suivent la configuration au démarrage : un palier retiré de la vente le devient en base.
+  if (PAYANT) {
+    const paliers = config.paliers.map((x) => (x.slug === PAYANT.slug ? { ...x, active: false } : x));
+    const R2 = await demarrer({ paliers, sgbd });
+    expect((await R2.w.dialect.findOne(R2.w.schemas.Plan, { slug: PAYANT.slug })).active).toBe(false);
+    await R2.fermer();
+  }
+});
+
+// 0.5 (audit du 09/10/2026) — la santé du service : le déployeur vérifie que la version EN SERVICE est celle qu'il
+// vient de copier (fichier REVISION), sans rien révéler d'autre.
+test('T-WAG-18 — /health : ok, application, commit en service, démarrage ; aucun secret, pas de cache', async () => {
+  const h = await req(B, '/health');
+  expect(h.status).toBe(200);
+  const j = JSON.parse(h.texte);
+  expect(j.ok).toBe(true);
+  expect(j.app).toBe(config.marque.nom);
+  expect('commit' in j && typeof j.demarreLe === 'string').toBe(true);
+  expect(Object.keys(j).sort()).toEqual(['app', 'commit', 'demarreLe', 'ok']);
+  expect(String(h.headers['cache-control'])).toBe('no-store');
+});
+
+// 0.8 (audit du 09/10/2026, référencement) — robots.txt, sitemap.xml (pages publiques, et celles que la charge déclare
+// par `sitemap()`), icône, image de partage. Une instance de RECETTE (`indexer: false`) ne s'indexe pas : en-tête
+// X-Robots-Tag sur toute réponse, robots.txt qui ferme tout, pas de sitemap.
+test('T-WAG-26 — référencement : robots.txt, sitemap.xml, icône, image de partage ; une recette ne s’indexe pas', async () => {
+  const r = await req(B, '/robots.txt');
+  expect([r.status, String(r.headers['content-type']).startsWith('text/plain')]).toEqual([200, true]);
+  expect(r.texte.includes('Sitemap: http://127.0.0.1/sitemap.xml') && /Disallow: \/compte/.test(r.texte)).toBe(true);
+  const s = await req(B, '/sitemap.xml');
+  expect([s.status, s.texte.includes('<loc>http://127.0.0.1/</loc>'), s.texte.includes('/compte')]).toEqual([200, true, false]);
+  for (const p of (typeof charge.sitemap === 'function' ? await charge.sitemap() : [])) expect([p, s.texte.includes(`<loc>http://127.0.0.1${p}</loc>`)]).toEqual([p, true]);
+  const f = await req(B, '/favicon.svg');
+  expect([f.status, String(f.headers['content-type'])]).toEqual([200, 'image/svg+xml']);
+  const accueil = await req(B, '/');
+  expect(accueil.texte.includes('rel="icon"')).toBe(true);
+  if (config.marque.image) expect(accueil.texte.includes('property="og:image"')).toBe(true);
+  expect(accueil.headers['x-robots-tag']).toBe(undefined);
+  const R = await demarrer({ indexer: false });
+  const b = `http://127.0.0.1:${R.port}`;
+  expect((await req(b, '/robots.txt')).texte).toBe('User-agent: *\nDisallow: /\n');
+  expect((await req(b, '/sitemap.xml')).status).toBe(404);
+  expect(String((await req(b, '/')).headers['x-robots-tag'])).toBe('noindex, nofollow');
+  await R.fermer();
+});
+
+// 0.9 — la feuille de style de l'application (`config.css`, wagon-ui ≥ 0.6) restyle aussi les pages du wagon.
+test('T-WAG-27 — `config.css` : la feuille de l’application est posée sur les pages du wagon (connexion, aide)', async () => {
+  const R = await demarrer({ css: 'main>h1:first-child{letter-spacing:.01em}' });
+  const b = `http://127.0.0.1:${R.port}`;
+  for (const c of ['/connexion', '/aide']) expect([c, (await req(b, c)).texte.includes('<style id="feuille-app">main>h1:first-child{letter-spacing:.01em}</style>')]).toEqual([c, true]);
+  await R.fermer();
+});
+
+// 0.5 (audit du 09/10/2026) — la base du wagon n'est plus figée en sqlite : `sgbd: { dialect, uri }` (le .env :
+// WAGON_DB_DIALECT, WAGON_SGBD), comme la base de la charge. La chaîne seule reste un chemin sqlite.
+test('T-WAG-19 — la base du wagon se choisit par { dialect, uri } ; la chaîne reste un chemin sqlite', async () => {
+  const W2 = await creerWagon({ config: { ...config, dossierLegal: LEGAL_COMPLET }, charge, sgbd: { dialect: 'sqlite', uri: join(atelier, `objet${Math.random()}.db`) }, baseUrl: 'http://127.0.0.1', racine: GREFFE });
+  await W2.catalogue();
+  expect((await W2.dialect.find(W2.schemas.Plan, {})).length > 0).toBe(true);
+  await W2.fermer();
+});
+
+// 0.5 (audit du 09/10/2026) — le compte du client : changer son mot de passe, le retrouver, partir avec ses
+// données, supprimer son compte (RGPD) ; la déconnexion est un POST ; les inscriptions sont freinées.
+test('T-WAG-20 — changer son mot de passe ferme les AUTRES sessions', async () => {
+  await inscrire(B, 'mdp@exemple.test');
+  const ailleurs = await connecter(B, 'mdp@exemple.test');
+  const ici = await connecter(B, 'mdp@exemple.test');
+  expect((await req(B, '/compte/mot-de-passe', { cookie: ici })).texte.includes('name="nouveau"')).toBe(true);
+  const faux = await req(B, '/compte/mot-de-passe', { method: 'POST', cookie: ici, form: { actuel: 'pas-le-bon-du-tout', nouveau: 'Une-Nouvelle-Phrase-26', confirmer: 'Une-Nouvelle-Phrase-26' } });
+  expect(faux.status).toBe(400);
+  const ok = await req(B, '/compte/mot-de-passe', { method: 'POST', cookie: ici, form: { actuel: MDP, nouveau: 'Une-Nouvelle-Phrase-26', confirmer: 'Une-Nouvelle-Phrase-26' } });
+  expect(ok.status).toBe(303);
+  expect((await req(B, '/compte', { cookie: ailleurs })).status).toBe(303);                  // l'autre session est fermée
+  expect((await req(B, '/compte', { cookie: ok.cookie })).status).toBe(200);                 // celle-ci est rouverte
+  expect((await req(B, '/connexion', { method: 'POST', form: { courriel: 'mdp@exemple.test', motdepasse: 'Une-Nouvelle-Phrase-26' } })).cookie !== '').toBe(true);
+});
+
+test('T-WAG-21 — mot de passe oublié : lien reçu par courriel ; un courriel inconnu reçoit la même réponse', async () => {
+  await inscrire(B, 'oubli@exemple.test');
+  expect((await req(B, '/connexion')).texte.includes('href="/connexion/oubli"')).toBe(true);
+  const n0 = courriels().length;
+  const connu = await req(B, '/connexion/oubli', { method: 'POST', form: { courriel: 'oubli@exemple.test' } });
+  const inconnu = await req(B, '/connexion/oubli', { method: 'POST', form: { courriel: 'personne@exemple.test' } });
+  expect(connu.status).toBe(200);
+  expect(connu.texte.replace(/oubli@exemple\.test/g, 'X')).toBe(inconnu.texte.replace(/personne@exemple\.test/g, 'X'));
+  let m = null;
+  for (let k = 0; k < 40 && !m; k++) { m = courriels().slice(n0).find((x) => x.to === 'oubli@exemple.test'); if (!m) await new Promise((r) => setTimeout(r, 50)); }
+  expect(courriels().slice(n0).some((x) => x.to === 'personne@exemple.test')).toBe(false);
+  const jeton = m.text.match(/reinitialiser\?t=([\w-]+)/)[1];
+  expect((await req(B, `/connexion/reinitialiser?t=${jeton}`)).texte.includes('name="nouveau"')).toBe(true);
+  const r = await req(B, '/connexion/reinitialiser', { method: 'POST', form: { t: jeton, nouveau: 'Retrouve-La-Phrase-2026', confirmer: 'Retrouve-La-Phrase-2026' } });
+  expect(r.status).toBe(303);
+  expect((await req(B, '/connexion', { method: 'POST', form: { courriel: 'oubli@exemple.test', motdepasse: 'Retrouve-La-Phrase-2026' } })).cookie !== '').toBe(true);
+  expect((await req(B, '/connexion/reinitialiser', { method: 'POST', form: { t: jeton, nouveau: 'Encore-Une-Phrase-2026', confirmer: 'Encore-Une-Phrase-2026' } })).status).toBe(400);   // un lien ne sert qu'une fois
+});
+
+test('T-WAG-22 — partir avec ses données (export), puis supprimer son compte', async () => {
+  await inscrire(B, 'depart@exemple.test');
+  const c = await connecter(B, 'depart@exemple.test');
+  const ex = await req(B, '/compte/export', { cookie: c });
+  expect(ex.status).toBe(200);
+  expect(String(ex.headers['content-disposition'])).toContain('attachment');
+  const j = JSON.parse(ex.texte);
+  expect(j.utilisateur.courriel).toBe('depart@exemple.test');
+  expect(Array.isArray(j.factures) && Array.isArray(j.cles)).toBe(true);
+  expect((await req(B, '/compte/supprimer', { cookie: c })).texte.includes('name="confirmation"')).toBe(true);
+  expect((await req(B, '/compte/supprimer', { method: 'POST', cookie: c, form: { confirmation: 'autre@exemple.test' } })).status).toBe(400);
+  const sup = await req(B, '/compte/supprimer', { method: 'POST', cookie: c, form: { confirmation: 'depart@exemple.test' } });
+  expect(sup.status).toBe(303);
+  expect((await req(B, '/compte', { cookie: c })).status).toBe(303);                          // plus de session
+  expect(await A.w.dialect.findOne(A.w.schemas.User, { email: 'depart@exemple.test' })).toBe(null);
+  expect((await req(B, '/connexion', { method: 'POST', form: { courriel: 'depart@exemple.test', motdepasse: MDP } })).cookie).toBe('');
+});
+
+test('T-WAG-23 — la déconnexion est un POST ; un GET (lien piégé, prélecture) ne déconnecte pas', async () => {
+  await inscrire(B, 'sortie@exemple.test');
+  const c = await connecter(B, 'sortie@exemple.test');
+  expect((await req(B, '/compte', { cookie: c })).texte.includes('action="/deconnexion"')).toBe(true);
+  await req(B, '/deconnexion', { cookie: c });
+  expect((await req(B, '/compte', { cookie: c })).status).toBe(200);
+  expect((await req(B, '/deconnexion', { method: 'POST', cookie: c, form: {} })).status).toBe(303);
+  expect((await req(B, '/compte', { cookie: c })).status).toBe(303);
+});
+
+test('T-WAG-24 — les inscriptions sont freinées par adresse (429)', async () => {
+  const F = await demarrer({ freinInscription: { capacity: 2, refillPerSec: 0.001 } });
+  const bf = `http://127.0.0.1:${F.port}`;
+  const statuts = [];
+  for (const k of [1, 2, 3]) statuts.push((await req(bf, '/inscription', { method: 'POST', form: { plan: 'gratuit', nom: `F${k}`, courriel: `frein${k}@exemple.test`, motdepasse: MDP } })).status);
+  expect(statuts[2]).toBe(429);
+  await F.fermer();
+});
+
+test('T-WAG-8 — sécurité : CSRF, en-têtes, cookie', async () => {
+  const x = await req(B, '/inscription', { method: 'POST', form: { plan: 'gratuit', nom: 'X', courriel: 'x@exemple.test', motdepasse: MDP }, headers: { 'sec-fetch-site': 'cross-site', origin: 'https://evil.example' } });
+  expect(x.status).toBe(403);
+  const h = await req(B, '/');
+  expect(/default-src/.test(h.headers['content-security-policy'] || '')).toBe(true);
+  expect(/frame-ancestors 'none'/.test(h.headers['content-security-policy'] || '')).toBe(true);
+  expect(h.headers['x-content-type-options']).toBe('nosniff');
+  const r = await inscrire(B, 'cookie@exemple.test');
+  const brut = (r.headers['set-cookie'] || []).find((c) => c.startsWith('wagon_session='));
+  expect(/HttpOnly/.test(brut) && /SameSite=Strict/.test(brut)).toBe(true);
+});
+
+// 0.11 (SaaS Prononciation, B-03 bis, 25/10/2026) — une page de la charge peut demander le micro (ou la caméra) ;
+// toutes les autres continuent de le refuser. La charge DÉCLARE ses pages, le wagon choisit les en-têtes (garde-http ≥ 0.2).
+test('T-WAG-29 — permissions par page : le micro s’ouvre aux pages déclarées par la charge, et à elles seules', async () => {
+  const W = await demarrer({ charge: { ...charge, permissions: { '/outil': { microphone: 'self' }, '/exercice/*': { microphone: 'self', camera: null } } } });
+  const base = `http://127.0.0.1:${W.port}`;
+  const pp = async (chemin) => (await req(base, chemin)).headers['permissions-policy'];
+  try {
+    for (const ferme of ['/', '/connexion', '/outil/autre', '/exercice', '/exercicex']) expect(await pp(ferme)).toBe('camera=(), microphone=(), geolocation=(), payment=()');
+    expect(await pp('/outil')).toBe('camera=(), microphone=(self), geolocation=(), payment=()');
+    expect(await pp('/exercice/12')).toBe('microphone=(self), geolocation=(), payment=()');
+    // le reste des en-têtes ne bouge pas sur une page ouverte
+    const h = (await req(base, '/outil')).headers;
+    expect(/frame-ancestors 'none'/.test(h['content-security-policy'] || '')).toBe(true);
+    expect(h['x-frame-options']).toBe('DENY');
+  } finally { await W.fermer(); }
+  // une déclaration fautive arrête le démarrage : jamais un en-tête cassé en service
+  for (const permissions of [{ 'exercice': { microphone: 'self' } }, { '/exercice': { microphone: 'self, camera=*' } }]) {
+    let err = null;
+    try { const X = await demarrer({ charge: { ...charge, permissions } }); await X.fermer(); } catch (e) { err = e; }
+    expect(err instanceof TypeError).toBe(true);
+  }
+});
+
+// 0.4 (audit du 09/10/2026) — un courriel DÉCLARÉ administrateur ne suffit pas : quiconque l'inscrirait avant son
+// titulaire prendrait l'administration. Il faut la PREUVE : une connexion par code reçu à ce courriel, ou la
+// confirmation faite sur le serveur (scripts/admin.mjs).
+test('T-WAG-16 — administration : un courriel déclaré ne vaut qu’une fois confirmé (code reçu, ou serveur)', async () => {
+  const P = await demarrer({ admins: ['chef@exemple.test'] });
+  const bp = `http://127.0.0.1:${P.port}`;
+  await inscrire(bp, 'chef@exemple.test');
+  const usurpateur = await connecter(bp, 'chef@exemple.test');
+  expect((await req(bp, '/admin/plans', { cookie: usurpateur })).status).toBe(404);
+  expect(await P.w.confirmerAdmin('inconnu@exemple.test')).toBe(false);                    // aucun compte : rien à confirmer
+  expect(await P.w.confirmerAdmin('chef@exemple.test')).toBe(true);
+  expect((await req(bp, '/admin/plans', { cookie: usurpateur })).status).toBe(200);
+  // Le mot de passe se fixe aussi depuis le serveur (mot de passe perdu, aucun courriel configuré).
+  expect(await P.w.fixerMotDePasse('chef@exemple.test', 'Une-Autre-Phrase-2026')).toBe(true);
+  expect((await req(bp, '/connexion', { method: 'POST', form: { courriel: 'chef@exemple.test', motdepasse: 'Une-Autre-Phrase-2026' } })).cookie !== '').toBe(true);
+  await P.fermer();
+  // Par la connexion par code : recevoir le code prouve qu'on détient le courriel.
+  const Q = await demarrer({ admins: ['code-admin@exemple.test'], connexion: 'code' });
+  const bq = `http://127.0.0.1:${Q.port}`;
+  await req(bq, '/inscription', { method: 'POST', form: { plan: 'gratuit', nom: 'Code Admin', courriel: 'code-admin@exemple.test' } });
+  const n0 = courriels().length;
+  await req(bq, '/connexion', { method: 'POST', form: { courriel: 'code-admin@exemple.test' } });
+  let m = null;
+  for (let k = 0; k < 40 && !m; k++) { m = courriels().slice(n0).find((x) => x.to === 'code-admin@exemple.test'); if (!m) await new Promise((r) => setTimeout(r, 50)); }
+  const s = await req(bq, '/connexion/code', { method: 'POST', form: { email: 'code-admin@exemple.test', code: m.text.match(/\b(\d{6})\b/)[1] } });
+  expect((await req(bq, '/admin/plans', { cookie: s.cookie })).status).toBe(200);
+  await Q.fermer();
+});
+
+test('T-WAG-9 — connexion par code', async () => {
+  const C = await demarrer({ connexion: 'code' });
+  const base = `http://127.0.0.1:${C.port}`;
+  const i = await req(base, '/inscription', { method: 'GET' });
+  expect(i.texte.includes('name="motdepasse"')).toBe(false);
+  await req(base, '/inscription', { method: 'POST', form: { plan: 'gratuit', nom: 'Code SA', courriel: 'code@exemple.test' } });
+  const n0 = courriels().length;
+  await req(base, '/connexion', { method: 'POST', form: { courriel: 'code@exemple.test' } });
+  let m = null;
+  for (let k = 0; k < 40 && !m; k++) { m = courriels().slice(n0).find((x) => x.to === 'code@exemple.test'); if (!m) await new Promise((r) => setTimeout(r, 50)); }
+  expect(m !== null).toBe(true);
+  const code = m.text.match(/\b(\d{6})\b/)[1];
+  const s = await req(base, '/connexion/code', { method: 'POST', form: { email: 'code@exemple.test', code } });
+  expect(s.cookie !== '').toBe(true);
+  expect((await req(base, '/compte', { cookie: s.cookie })).status).toBe(200);
+  await C.fermer(); await A.fermer();
+  rmSync(atelier, { recursive: true, force: true });
+});
+
+// 0.10 (25/10/2026) — SATIM : pas de webhook, l'ACHETEUR revient. Le retour constate le paiement puis le renvoie vers
+// /paiement/merci ou /tarifs ; une commande abandonnée se rattrape par `reprendrePaiements`. Écrit AVANT le code.
+const PRIX_DZD = PAYANT && (PAYANT.prepaid ?? {}).DZD?.month;
+(PRIX_DZD ? test : sansObjet('aucun prix prépayé en DZD'))(`T-WAG-28 — SATIM : retour de l’acheteur constaté, renvoi vers merci ou tarifs, reprise des abandons${PRIX_DZD ? '' : ' (sans objet : aucun prix prépayé en DZD)'}`, async () => {
+  const etats = new Map(); const ouverts = [];
+  const portSatim = {
+    async createPaymentCheckout(input) { ouverts.push(input); const ref = `MD-${ouverts.length}`; ordres.set(ref, { orderId: input.orderId, amount: input.amount, currency: input.currency, status: 'pending', metadata: input.metadata }); return { checkout: { url: `https://test.satim.dz/payment/merchants/x/payment.html?mdOrder=${ref}`, sessionId: ref }, payment: ordres.get(ref) }; },
+    async settlePaymentFromWebhook({ body }) { const ref = new URLSearchParams(body).get('orderId'); const payment = ordres.get(ref); if (!payment) return { ok: false, reason: 'malformed' }; return { ok: true, orderId: payment.orderId, status: etats.get(ref), payment }; },
+  };
+  const C = await demarrer({ banques: { satim: 'DZD' }, port: portSatim });
+  const base = `http://127.0.0.1:${C.port}`;
+  await inscrire(base, 'satim@exemple.test');
+  const c = await connecter(base, 'satim@exemple.test');
+  const ouvrir = async () => { const va = await req(base, '/paiement', { method: 'POST', cookie: c, form: { plan: PAYANT.slug, banque: 'satim', periode: 'month' } }); expect(va.status).toBe(303); expect(va.headers.location.startsWith('https://test.satim.dz/')).toBe(true); return `MD-${ouverts.length}`; };
+  const echec = await ouvrir();
+  expect(ouverts.at(-1).returnUrl).toBe('http://127.0.0.1/api/paiement/retour/{provider}');
+  etats.set(echec, 'failed');
+  const r1 = await req(base, `/api/paiement/retour/satim?orderId=${echec}&lang=fr`);
+  expect(r1.status).toBe(303); expect(r1.headers.location).toBe('/tarifs');
+  const paye = await ouvrir();
+  etats.set(paye, 'paid');
+  const r2 = await req(base, `/api/paiement/retour/satim?orderId=${paye}&lang=fr`);
+  expect(r2.status).toBe(303); expect(r2.headers.location).toBe('/paiement/merci');
+  expect((await req(base, '/compte', { cookie: c })).texte.includes(PAYANT.name)).toBe(true);
+  expect((await req(base, '/api/paiement/retour/inconnue?orderId=x')).headers.location).toBe('/tarifs');
+  expect(typeof C.w.reprendrePaiements).toBe('function');
+  const rep = await C.w.reprendrePaiements();
+  expect(Array.isArray(rep)).toBe(true);
+  expect(rep.map((x) => x.banque)).toEqual(['satim']);
+  await C.fermer();
+});
+
+(OFFRE ? test : sansObjet('aucune banque prépayée ni prix prépayé'))(`T-WAG-13 — vente prépayée : choix du moyen, banque, webhook, période, rejeu, CSP${OFFRE ? '' : ' (sans objet : aucune banque prépayée ni prix prépayé)'}`, async () => {
+  const [banque] = OFFRE;
+  const C = await demarrer();
+  const base = `http://127.0.0.1:${C.port}`;
+  await inscrire(base, 'prepaye@exemple.test');
+  const c = await connecter(base, 'prepaye@exemple.test');
+  const choix = await req(base, '/paiement', { method: 'POST', cookie: c, form: { plan: PAYANT.slug } });
+  expect(choix.status).toBe(200);                                                         // le choix, pas une redirection
+  expect(choix.texte.includes(`name="banque" value="${banque}"`) && choix.texte.includes('name="banque" value="stripe"')).toBe(true);
+  const va = await req(base, '/paiement', { method: 'POST', cookie: c, form: { plan: PAYANT.slug, banque, periode: 'month' } });
+  expect(va.status).toBe(303);
+  expect(va.headers.location.startsWith('https://pay.chargily.net/')).toBe(true);
+  expect(/form-action[^;]*pay\.chargily\.net/.test(va.headers['content-security-policy'] || '')).toBe(true);
+  expect((await req(base, '/compte', { cookie: c })).texte.includes(GRATUIT.name)).toBe(true);   // pas avant le webhook
+  const ordre = [...ordres.keys()].at(-1);
+  const webhook = (sig, status = 'paid') => req(base, `/api/paiement/webhook/${banque}`, { method: 'POST', json: JSON.stringify({ orderId: ordre, status, sig }), headers: { 'content-type': 'application/json' } });
+  expect((await webhook('faux')).status).toBe(400);
+  expect((await webhook('ok')).status).toBe(200);                                         // sans session ni CSRF : signé
+  const compte = (await req(base, '/compte', { cookie: c })).texte;
+  expect(compte.includes(PAYANT.name)).toBe(true);
+  expect(/payé jusqu’au/.test(compte)).toBe(true);
+  expect((await webhook('ok')).status).toBe(200);                                         // rejeu sans effet
+  expect((await req(base, '/api/paiement/webhook/inconnue', { method: 'POST', json: '{}', headers: { 'content-type': 'application/json' } })).status).toBe(404);
+  await C.fermer();
+  rmSync(atelier, { recursive: true, force: true });
+  rmSync(join(LEGAL_COMPLET, '..'), { recursive: true, force: true });
+});