From 828d930d3627d7af177f248e35eaf84740309d42 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:19:08 -0300 Subject: [PATCH 01/12] =?UTF-8?q?test(US-221):=20parcours=20dor=C3=A9s=20?= =?UTF-8?q?=C2=AB=20r=C3=A9servation=20=C2=BB=20PA=20et=20PY=20sous=20les?= =?UTF-8?q?=20r=C3=B4les=20de=20production?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Trois segments par pays (USD, PYG sans décimale) dans apps/api/test/int : A. inscription, recherche, fiche, devis figé, checkout, capacité bloquante absente refusée avant T1, ordre au PSP FAKE avec chaque jambe explicite (transaction annulée, interrupteurs par la procédure à deux personnes) ; B. paiement prouvé par webhook signé, FAKE hostile (API non signée, doublons), trip BOOKED, notifications, « Mis viajes » ; défauts D1 (capture du checkout jamais portée sur les soldes par jambe) et D2 (rapprochement aveugle) en it.fails ; C. annulation par l'ops, vrai processeur, remboursement par jambe (PSP en panne puis vrai ordonnanceur), insurer_ledger, reçus, rapprochement FIN et oracle C12 à 0 écart. Fixture 9937 : ville propre à l'annonce du parcours (recherche publique). Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 1275 +++++++++++++++++ .../9937_test_us221_golden_fixtures.sql | 37 + 2 files changed, 1312 insertions(+) create mode 100644 apps/api/test/int/parcours-dores-reservation.int.test.ts create mode 100644 packages/db/test-migrations/9937_test_us221_golden_fixtures.sql diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts new file mode 100644 index 00000000..0662db4a --- /dev/null +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -0,0 +1,1275 @@ +/** + * US-221 — parcours dorés « réservation » de bout en bout, sur PostgreSQL réel, sous les rôles de + * PRODUCTION (`connectAs` : assertion L0-05 en tête de chaque test), dans chaque pays configuré : + * USD (deux décimales) et PYG (sans décimale). Écrits par l'agent QA depuis 16, 19 et les oracles, + * sans prendre le code testé comme oracle : chaque montant attendu vient de l'export des oracles + * (`docs/specs/tools/golden_vectors.json`, `@rueda/money/golden-vectors`) ou, pour le devis du + * checkout, d'une dérivation écrite ici depuis 08 et la configuration du dépôt (voir `CHECKOUT`). + * + * Trois segments par pays, enchaînés dans l'ordre du fichier (état partagé par pays) : + * + * A. « Avant le paiement » (transaction ANNULÉE sous app_api : les interrupteurs + * `p2p_private_hosts_enabled` et `insurer_contract_active` ne s'ouvrent que là, par la VRAIE + * procédure à deux personnes d'US-125, tête d'audit puis verrou comme `golive.ts`) : + * inscription (vraie commande) et conducteur vérifié (fixture 9967) → recherche publique (vrai + * magasin de CAT) → fiche (prix et conditions) → devis figé (moteur de PRC, commande de gel) → + * checkout (hold posé) → capacité bloquante absente : paiement refusé AVANT T1 (critère 2) → + * paiement par le vrai `CheckoutPaymentService` : T1, ordre envoyé au PSP FAKE avec le montant + * EXPLICITE de chaque jambe, T2 ; Σ jambes = total. + * B. « Du paiement au trip » (données VALIDÉES, horloge virtuelle 2052, aucun interrupteur) : même + * voyageur inscrit, hold posé par la vraie commande, devis engagé au checkout posé par la fixture + * 9969 (seule couture : le gel et le checkout réels exigent les interrupteurs) aux jambes de la + * capture de l'oracle (TJ01 / TJ08a) → T1 / T2 par le vrai service → FAKE hostile : SUCCEEDED + * de réponse d'API (non signé) ⇒ NOT_PROVEN ; webhook signé ⇒ preuve ; conversion ⇒ trip BOOKED, + * version de prix n° 1, `booking.trip.booked` une fois ; rejeux ⇒ DUPLICATE / REPLAY → + * notifications (parties) → « Mis viajes » → interrupteurs toujours fermés. Défauts trouvés : + * D1 et D2 (`it.fails`, voir la passation). + * C. « Annulation, remboursement, registres, reçus, rapprochement » (données VALIDÉES, 2052) : trip + * capturé aux jambes de l'oracle sur le trip (seule entrée qui alimente les soldes par jambe, à + * cause de D1) → demande de la console (OPS) → VRAI `TripCancellationProcessor` (trip du moteur + * = trip du vecteur : la fixture du trip ne porte aucun devis) → règlement v1 (TJ02b / TJ08b) → + * remboursement par jambe : PSP en panne ⇒ WAITING, puis VRAI `RefundScheduler` ⇒ SENT, preuve + * signée ⇒ CONFIRMED, REPORTED → soldes par jambe (TJ01 + TJ02b = TJ02a) → S10 du voyageur et de + * l'hôte → `insurer_ledger` (+prime, −prime) → reçus de l'hôte et du voyageur (T03 / T27) → + * faits de l'invariant par jambe → rapprochement nocturne (FIN) et oracle C12 : 0 écart. + * + * Vecteurs : TJ01, TJ02a, TJ02b, T03 (USD) ; TJ08a, TJ08b, T27 (PYG) ; TJ09c (jambe HOST du devis + * du checkout en PYG) ; C6 / C13 / C14 / C20 sont prouvés par leurs L0 propres (l0-us223-*, + * l0-us224-*), ce fichier enchaîne les modules. + */ +import { createHash, randomBytes, randomUUID } from 'node:crypto'; +import { commandCallSql, setSessionContext } from '@rueda/db'; +import { connectAs, releaseClient, withTestTransaction } from '@rueda/db/testing'; +// types du contexte fourni par le globalSetup du banc (inject('ruedaBench')) +import type {} from '@rueda/db/testing/global-setup'; +import { money } from '@rueda/money'; +import { legVector, loadGoldenVectors, settlementVector } from '@rueda/money/golden-vectors'; +import { toTrip } from '@rueda/money/testing'; +import type pg from 'pg'; +import { afterEach, describe, expect, it } from 'vitest'; +import { + CheckoutPaymentService, + PgCheckoutPaymentStore, + PgCheckoutStore, + type HostedPaymentProvider, +} from '../../src/modules/avl/index.js'; +import type { + AlertChannel, + OpsAlert, + SqlClient, + WorkerTransactions, +} from '../../src/modules/bus/index.js'; +import { PgSearchStore } from '../../src/modules/cat/index.js'; +import { CountryConfigService } from '../../src/modules/cfg/index.js'; +import { reconciliationReportJson, runMoneyReconciliation } from '../../src/modules/fin/index.js'; +import { + PaymentError, + PgRefundOrders, + type CreateHostedPaymentRequest, + type HostedPayment, + type OperationResult, + type PaymentConnectorRegistry, + type PaymentProvider, + type RefundRequest, +} from '../../src/modules/pay/index.js'; +import { + freezeQuote, + PgQuoteStore, + QuoteService, + searchQuotePricer, +} from '../../src/modules/prc/index.js'; +import { + RefundScheduler, + TripCancellationProcessor, + type CancellationFacts, +} from '../../src/modules/stl/index.js'; +import { countryCases } from '../support/countries.js'; + +const golden = loadGoldenVectors(); +const LEGS = ['HOST', 'INSURER', 'TAX_THIRD_PARTY', 'PLATFORM'] as const; +type LegName = (typeof LEGS)[number]; +type Legs = Record; +type Json = Record; +const MINUTE = 60_000; +const DAY = 24 * 60 * MINUTE; +const SIGNUP = '[{"kind":"TOS_GUEST","version":1},{"kind":"PRIVACY","version":1}]'; +const PHC = + '$argon2id$v=19$m=65536,t=3,p=1$c2FsdHNhbHRzYWx0c2FsdA$aGFzaGhhc2hoYXNoaGFzaGhhc2hoYXNoaGFzaGhhc2g'; +const SWITCHES = [ + 'p2p_private_hosts_enabled', + 'insurer_contract_active', + 'funds_holding_enabled', + 'payouts_enabled', +] as const; +const iso = (ms: number): string => new Date(ms).toISOString(); +const sum = (l: Legs): bigint => LEGS.reduce((s, k) => s + l[k], 0n); +const legsText = (l: Legs): Record => + Object.fromEntries(LEGS.map((k) => [k, l[k].toString()])); +const negate = (l: Legs): Legs => + Object.fromEntries(LEGS.map((k) => [k, -l[k]])) as unknown as Legs; +const plus = (a: Legs, b: Legs): Legs => + Object.fromEntries(LEGS.map((k) => [k, a[k] + b[k]])) as unknown as Legs; +const legsOf = (id: string): Legs => ({ ...legVector(golden, id).legsMinor }) as Legs; + +/** + * Parcours par devise (jamais par pays : le pays est celui que la configuration associe à la + * devise du vecteur, ADR-024). Trip A de 08 (USD) : capture TJ01, annulation du voyageur T03 + * (variation TJ02b, jambes retenues TJ02a). Trip D (PYG) : capture TJ08a, T27, variation TJ08b. + */ +const JOURNEYS = [ + { settlement: 'T03', capture: 'TJ01', variation: 'TJ02b', kept: 'TJ02a' }, + { settlement: 'T27', capture: 'TJ08a', variation: 'TJ08b', kept: null }, +] as const; + +/** + * Devis du checkout (segment A) par exposant de la devise, configuration du dépôt (grille de + * protection et parts de TEST : BASICA 1/4 du prix journalier, part de l'assureur 7/10, plan + * ESTÁNDAR 3/4 ; barème du trip fee du pays) — mêmes lignes que pg-checkout.int.test.ts : + * - exposant 2 (trip A de 08 sans ses lignes hors devis : 40,00 × 3 j) : P 120,00 ; F 18,00 + * (15 %) ; taxe 7 % de P et F = 8,40 + 1,26 ; BASICA 30,00 ; total 177,66. Jambes (08 E7 + * règle 2) : HOST = 3/4 × 120,00 = 90,00 (exact) ; INSURER = 7/10 × 30,00 = 21,00 ; TAX 0 ; + * PLATFORM = complément 66,66 ; + * - exposant 0 (D2 de 08 : 333 334 × 3 j) : P 1 000 002 ; F 150 000 ; taxe 10 % = 100 000 + + * 15 000 ; BASICA roundHalfUp(83 333,5) = 83 334 × 3 = 250 002 ; total 1 515 004. HOST = jambe + * HOST de l'oracle TJ09c (D2, même loyer) = 750 001 ; INSURER = roundHalfUp(175 001,4) = + * 175 001 ; TAX 0 ; PLATFORM = 590 002. + */ +interface CheckoutExpected { + readonly daily: string; + readonly lines: Readonly>; + readonly taxes: Readonly>; + readonly total: string; + readonly legs: Legs; +} +const CHECKOUT: Readonly> = { + 2: { + daily: '4000', + lines: { TRIP_PRICE: '12000', TRIP_FEE: '1800', PROTECTION: '3000' }, + taxes: { TRIP_PRICE: '840', TRIP_FEE: '126', PROTECTION: '0' }, + total: '17766', + legs: { HOST: 9000n, INSURER: 2100n, TAX_THIRD_PARTY: 0n, PLATFORM: 6666n }, + }, + 0: { + daily: '333334', + lines: { TRIP_PRICE: '1000002', TRIP_FEE: '150000', PROTECTION: '250002' }, + taxes: { TRIP_PRICE: '100000', TRIP_FEE: '15000', PROTECTION: '0' }, + total: '1515004', + legs: { + HOST: legVector(golden, 'TJ09c').legsMinor.HOST, + INSURER: 175001n, + TAX_THIRD_PARTY: 0n, + PLATFORM: 590002n, + }, + }, +}; + +const CASES = JOURNEYS.map((j, i) => { + const v = settlementVector(golden, j.settlement); + const c = countryCases().find((x) => x.currency === v.currency); + if (c === undefined) throw new Error(`aucun pays configuré en ${v.currency}`); + return { country: c.country, currency: v.currency, index: i, journey: j }; +}); +type Case = (typeof CASES)[number]; + +// --- connexions et transactions ------------------------------------------------------------------ + +const opened: pg.Client[] = []; +afterEach(async () => { + for (const c of opened.splice(0)) await releaseClient(c); +}); +async function open(role: 'app_api' | 'app_worker'): Promise { + const client = await connectAs(role); // assertion L0-05 + opened.push(client); + return client; +} + +interface TxOptions { + readonly at?: string; + readonly worker?: string; + readonly commit?: boolean; +} +async function inTx( + client: pg.ClientBase, + o: TxOptions, + fn: (tx: pg.ClientBase) => Promise, +): Promise { + return withTestTransaction( + client, + { + ...(o.at !== undefined ? { virtualNow: o.at } : {}), + ...(o.commit !== undefined ? { commit: o.commit } : {}), + }, + async (tx) => { + if (o.worker !== undefined) await asWorker(tx, o.worker); + return fn(tx); + }, + ); +} +async function asWorker(tx: pg.ClientBase, workerName: string): Promise { + await setSessionContext(tx, { kind: 'WORKER', workerName }); +} +const sqlOf = (client: pg.ClientBase): SqlClient => ({ + query: async (text: string, params?: readonly unknown[]) => { + const r = await client.query(text, params as unknown[] | undefined); + return { rows: r.rows as R[], rowCount: r.rowCount }; + }, +}); +/** Transactions du travailleur (app_worker), VALIDÉES, à l'instant virtuel `atMs`. */ +function committing(atMs: number): WorkerTransactions { + return { + async run(worker, fn) { + const client = await open('app_worker'); + return inTx(client, { at: iso(atMs), worker, commit: true }, (tx) => fn(sqlOf(tx))); + }, + }; +} +class Alerts implements AlertChannel { + readonly sent: OpsAlert[] = []; + send(alert: OpsAlert): Promise { + this.sent.push(alert); + return Promise.resolve(); + } +} + +// --- personnes, sessions, interrupteurs ---------------------------------------------------------- + +const sha = (): Buffer => createHash('sha256').update(randomBytes(32)).digest(); + +/** Personne inscrite par la VRAIE commande (consentements de l'inscription), compte ACTIVE. */ +async function register( + tx: pg.ClientBase, + country: string, + id: string = randomUUID(), + first = 'Ana', + last = 'Pérez', +): Promise { + const r = await tx.query<{ ok: boolean }>( + `SELECT core.iam_cmd_register_with_consents($1, $2, $3, $4, $5, 'es', $6, $7, 86400, NULL, + $8, $9::jsonb, false) AS ok`, + [ + id, + `us221-${id}@example.test`, + PHC, + first, + last, + randomUUID(), + randomBytes(32), + country, + SIGNUP, + ], + ); + if (r.rows[0]?.ok !== true) throw new Error('inscription de test refusée'); + await tx.query('SELECT test_fixture.iam_set_account_status($1, $2)', [id, 'ACTIVE']); + return id; +} + +/** Session ouverte par la VRAIE commande. */ +async function openSession(tx: pg.ClientBase, userId: string): Promise { + const hash = sha(); + const s = await tx.query<{ expires_at: Date | null }>( + `SELECT core.iam_cmd_open_session($1, $2, $3, 86400, 'NONE', NULL, 'vitest') AS expires_at`, + [randomUUID(), userId, hash], + ); + if (!s.rows[0]?.expires_at) throw new Error('session refusée'); + return hash; +} + +/** Membre du personnel inscrit, rôle interne du pays (fixture 9200). */ +async function staffMember(tx: pg.ClientBase, role: string, country: string): Promise { + const id = await register(tx, country, randomUUID(), 'Staff', 'Test'); + await tx.query(`SELECT test_fixture.iam_grant_staff_role($1, $2, $3, $4::text[], NULL, NULL)`, [ + randomUUID(), + id, + role, + [country], + ]); + return id; +} + +/** Session élevée (fixture 9650), ouverte À l'instant de la transaction de l'appelant. */ +async function elevated(tx: pg.ClientBase, id: string): Promise<{ id: string; hash: Buffer }> { + const hash = sha(); + await tx.query('SELECT test_fixture.iam_open_elevated_session($1, $2)', [id, hash]); + return { id, hash }; +} + +async function staffOf( + tx: pg.ClientBase, + role: string, + country: string, +): Promise<{ id: string; hash: Buffer }> { + return elevated(tx, await staffMember(tx, role, country)); +} + +/** + * Interrupteur ouvert par la procédure à deux personnes d'US-125, dans la transaction ANNULÉE de + * l'appelant : tête de chaîne d'audit AVANT le verrou consultatif (même ordre que + * packages/db/test/support/golive.ts, PR #200 ; jamais l'ordre inverse : 40P01). + */ +async function openSwitch(tx: pg.ClientBase, key: string, country: string): Promise { + const as = async (who: { id: string; hash: Buffer }) => + setSessionContext(tx, { + kind: 'STAFF', + actorId: who.id, + countryScope: [country], + sessionTokenHash: who.hash.toString('hex'), + }); + const requester = await staffOf(tx, 'ADMIN', country); + const approver = await staffOf(tx, 'SUPERADMIN', country); + await tx.query('SELECT test_fixture.audit_chain_head_lock()'); + await as(requester); + const r = await tx.query<{ outcome: string; request_id: string | null }>( + 'SELECT outcome, request_id FROM core.config_cmd_request_go_live_switch($1, $2, $3, $4, $5, $6)', + [requester.hash, randomUUID(), key, country, true, 'DEC-FONDATEUR-15'], + ); + if (r.rows[0]?.outcome !== 'REQUESTED') throw new Error(`demande : ${r.rows[0]?.outcome}`); + await as(approver); + const a = await tx.query<{ outcome: string }>( + 'SELECT outcome FROM core.config_cmd_approve_go_live_switch($1, $2)', + [approver.hash, r.rows[0].request_id], + ); + if (a.rows[0]?.outcome !== 'APPLIED') throw new Error(`approbation : ${a.rows[0]?.outcome}`); +} + +/** Valeur lue de chaque interrupteur de mise en service du pays (fail-closed : false). */ +async function switches(tx: pg.ClientBase, country: string): Promise> { + const out: Record = {}; + for (const key of SWITCHES) { + const { rows } = await tx.query<{ on: boolean }>('SELECT core.config_go_live($1, $2) AS "on"', [ + key, + country, + ]); + out[key] = rows[0]?.on === true; + } + return out; +} +const ALL_CLOSED = Object.fromEntries(SWITCHES.map((k) => [k, false])); + +/** Capacités bloquantes du catalogue (FAKE, pays) au statut voulu, à partir de `from`. */ +async function capabilities( + tx: pg.ClientBase, + country: string, + from: string, + only?: string, + status: 'VALIDATED_SANDBOX' | 'UNKNOWN' = 'VALIDATED_SANDBOX', +): Promise { + const { rows } = await tx.query<{ capability: string; kind: string }>( + `SELECT capability, kind FROM core.payment_psp_capability_catalog WHERE blocking <> 'NO'`, + ); + for (const r of rows) { + if (only !== undefined && r.capability !== only) continue; + const value = r.kind === 'bool' ? true : r.kind === 'int' ? 1 : 'FAKE_HMAC_SHA256'; + await tx.query( + `SELECT test_fixture.us024_set_capability('FAKE', $1, '*', $2, $3::jsonb, $4, + $5::timestamptz)`, + [country, r.capability, JSON.stringify(value), status, from], + ); + } +} + +/** PSP FAKE de la page hébergée : garde chaque ordre reçu (montant et jambes explicites). */ +class FakeHostedPsp implements HostedPaymentProvider { + readonly orders: CreateHostedPaymentRequest[] = []; + createHostedPayment(request: CreateHostedPaymentRequest): Promise { + this.orders.push(request); + return Promise.resolve({ + providerReference: `fake-${randomUUID()}`, + redirectUrl: 'https://psp.example.test/pay', + expiresAt: null, + }); + } + getOperation(): Promise { + return Promise.resolve(null); + } +} +const paymentService = (db: pg.ClientBase, psp: FakeHostedPsp): CheckoutPaymentService => + new CheckoutPaymentService( + new PgCheckoutPaymentStore(db), + new Map([['FAKE', psp]]), + () => undefined, + ); + +// --- état partagé des segments (par pays) -------------------------------------------------------- + +interface BookedWorld { + guest: string; + guestHash: Buffer; + org: string; + vehicle: string; + hold: string; + quote: string; + operation: string; + trip: string; +} +interface CancelledWorld { + trip: string; + guest: string; + capture: string; + cancellation: string; +} + +describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $currency)', (c: Case) => { + const capture = legsOf(c.journey.capture); + const variation = legsOf(c.journey.variation); + const vector = settlementVector(golden, c.journey.settlement); + const total = vector.trip.totalPaidMinor; + const kept = plus(capture, variation); + const refund = negate(variation); + + it('oracle : Σ jambes de la capture = total payé ; Σ remboursement = remboursement du voyageur ; retenu = retenu TTC ; HOST retenue = hostFromGuest', async () => { + await open('app_api'); // L0-05 : même un test sans requête commence par l'assertion de rôle + expect(legVector(golden, c.journey.capture).currency).toBe(c.currency); + expect(sum(capture)).toBe(total); + expect(sum(refund)).toBe(vector.expected.guestRefundMinor); + expect(sum(kept)).toBe(vector.expected.retainedMinor + vector.expected.retainedTaxMinor); + expect(kept.HOST).toBe(vector.expected.hostFromGuestMinor); + if (c.journey.kept !== null) expect(kept).toEqual(legsOf(c.journey.kept)); + for (const k of LEGS) expect(kept[k] >= 0n, k).toBe(true); + }); + + // --------------------------------------------------------------------------------------------- + describe('A — inscription, recherche, fiche, devis figé, checkout, paiement par jambes', () => { + const NOW = '2026-12-02T12:00:00.000Z'; + const START_LOCAL = '2026-12-10T10:00'; + const END_LOCAL = '2026-12-13T10:00'; + + it('chaîne réelle jusqu’à T2 : carte = fiche = devis ; hold posé ; capacité bloquante inconnue ⇒ HOST_PAYOUT_RAIL_UNAVAILABLE avant T1 ; ordre envoyé au PSP avec chaque jambe explicite ; Σ jambes = total ; interrupteurs refermés hors de la transaction', async () => { + const api = await open('app_api'); + const service = new QuoteService(new CountryConfigService()); + const exponent = service.params({ country: c.country, at: new Date(NOW) }).currency.exponent; + const want = CHECKOUT[exponent]; + if (want === undefined) throw new Error(`aucun attendu pour l'exposant ${exponent}`); + expect(sum(want.legs).toString()).toBe(want.total); + + await inTx(api, { at: NOW }, async (tx) => { + await openSwitch(tx, 'p2p_private_hosts_enabled', c.country); + await openSwitch(tx, 'insurer_contract_active', c.country); + const acc = await tx.query<{ id: string }>( + 'SELECT test_fixture.us024_psp_account($1) AS id', + [c.country], + ); + expect(acc.rows[0]?.id).toBeTruthy(); + + // annonce LISTED (fixture 9998) dans une ville propre au parcours (fixture 9937) + const { rows } = await tx.query<{ listing_id: string }>( + 'SELECT * FROM test_fixture.us208_listed_listing($1, $2, $3, $4)', + [c.country, want.daily, 'AUTOMATIC', true], + ); + const listingId = rows[0]!.listing_id; + const serial = await tx.query<{ n: string }>( + 'SELECT test_fixture.next_unique_serial()::text AS n', + ); + const city = `Villa US221 ${serial.rows[0]!.n}`; + await tx.query('SELECT test_fixture.us221_listing_city($1, $2)', [listingId, city]); + + // inscription et conducteur vérifié (KYC de fixture 9967), session du voyageur + const guest = await register(tx, c.country); + await tx.query('SELECT test_fixture.us209_driver($1, $2, $3::date, $4::date, $5)', [ + guest, + c.country, + '1990-01-01', + '2030-12-31', + c.country, + ]); + const hash = await openSession(tx, guest); + + // S01 → résultats : l'annonce est trouvée dans sa ville, aux dates locales du pays + const search = new PgSearchStore(tx); + const found = await search.search({ + country: c.country, + city, + area: null, + startLocal: START_LOCAL, + endLocal: END_LOCAL, + limit: 50, + }); + if (found.outcome !== 'OK') throw new Error(`recherche : ${found.outcome}`); + const card = found.results.find((r) => r.id === listingId); + if (card === undefined) throw new Error('annonce absente des résultats'); + expect(card).toMatchObject({ dailyPriceMinor: want.daily, currency: c.currency }); + expect(Date.parse(card.endAt) - Date.parse(card.startAt)).toBe(3 * DAY); + + // S03 : fiche (prix de l'annonce, conditions) ; carte et fiche au même total (16 SRC-042) + const pricer = searchQuotePricer((ctx) => service.params(ctx)); + const slot = await search.listingPrice(listingId); + if (slot === null) throw new Error('prix de la fiche introuvable'); + expect(await search.terms(listingId, card.startAt)).not.toBeNull(); + const priced = (dailyPriceMinor: string, quotedAt: string) => + pricer.price({ + listingId, + country: c.country, + currency: card.currency, + dailyPriceMinor, + startAt: card.startAt, + endAt: card.endAt, + quotedAt, + }); + expect(priced(slot.dailyPriceMinor, slot.quotedAt)).toEqual({ + totalMinor: want.total, + billableDays: 3, + }); + expect(priced(card.dailyPriceMinor, card.quotedAt)).toEqual({ + totalMinor: want.total, + billableDays: 3, + }); + + // S05 : devis figé (composition de CheckoutService.createQuote, prouvée par + // pg-checkout.int.test.ts) — moteur de PRC, commande de gel rejouée par la base + const checkout = new PgCheckoutStore(tx); + const listing = await checkout.listing(listingId); + if (listing === null) throw new Error('annonce du checkout introuvable'); + const params = service.params({ + country: listing.country, + at: new Date(listing.quotedAtMs), + hostPlan: listing.hostPlan, + }); + const level = params.protectionGrid?.minLevel; + expect(level).toBe('BASICA'); + const { frozen } = freezeQuote( + { + startAtMs: Date.parse(card.startAt), + endAtMs: Date.parse(card.endAt), + quotedAtMs: listing.quotedAtMs, + rateType: 'REFUNDABLE', + dailyRate: money(BigInt(listing.dailyPriceMinor), params.currency), + ...(level === undefined ? {} : { protectionLevel: level }), + mileage: { mode: 'UNLIMITED' }, + }, + params, + ); + const gel = await new PgQuoteStore(tx).freeze(hash, listingId, frozen); + expect(gel.outcome).toBe('DONE'); + const quoteId = gel.quoteId!; + const quote = await checkout.quote(hash, quoteId); + if (quote === null) throw new Error('devis figé illisible'); + expect(quote).toMatchObject({ + currency: c.currency, + billableDays: 3, + totalMinor: want.total, + protectionLevel: 'BASICA', + insurerContractActive: true, + }); + expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.amountMinor]))).toEqual( + want.lines, + ); + expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.taxMinor]))).toEqual( + want.taxes, + ); + // jambes du devis figé (08 E7 règle 2) : celles que l'ordre au PSP devra porter + const outputs = JSON.parse(frozen.outputs) as { legs: Record }; + expect(outputs.legs).toEqual(legsText(want.legs)); + + // S05 → hold posé (conducteur titulaire, versions affichées acceptées) + const placed = await checkout.checkout(hash, quoteId, { + driverFirstName: 'Ana', + driverLastName: 'Pérez', + manualTransmissionConfirmed: false, + acceptedDocuments: quote.documents.map((d) => ({ kind: d.kind, version: d.version })), + }); + expect(placed.outcome).toBe('DONE'); + const holdId = placed.holdId!; + expect(await checkout.hold(hash, holdId)).toMatchObject({ + status: 'ACTIVE', + quoteId, + totalMinor: want.total, + reviewState: 'NONE', + }); + + // critère 2 (FAKE hostile) : capacité bloquante inconnue ⇒ refus AVANT T1, aucun ordre + const at = (m: number) => iso(Date.parse(NOW) + m * MINUTE); + const psp = new FakeHostedPsp(); + const pay = paymentService(tx, psp); + await capabilities(tx, c.country, at(-3)); + await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN'); + await tx.query('SAVEPOINT us221_capability'); + await expect(pay.pay(hash, holdId, { method: 'CARD' })).rejects.toMatchObject({ + code: 'HOST_PAYOUT_RAIL_UNAVAILABLE', + }); + await tx.query('ROLLBACK TO SAVEPOINT us221_capability'); + expect(psp.orders).toEqual([]); + expect(await pay.payment(hash, holdId)).toMatchObject({ + state: 'PAYABLE', + holdStatus: 'ACTIVE', + tripId: null, + }); + + // capacité validée : T1 (jambes du devis engagé), ordre au PSP, T2 + await capabilities(tx, c.country, at(-1), 'SUPPORTS_PER_LEG_AMOUNTS'); + const started = await pay.pay(hash, holdId, { method: 'CARD' }); + expect(started.created).toBe(true); + expect(started.payment).toMatchObject({ + state: 'VERIFYING', + holdStatus: 'PAYMENT_IN_FLIGHT', + tripId: null, + }); + expect(psp.orders).toHaveLength(1); + const order = psp.orders[0]!; + expect(order).toMatchObject({ + amountMinor: BigInt(want.total), + currency: c.currency, + method: 'CARD', + capture: 'AUTO', + idempotencyKey: `hold:${holdId}:CAPTURE:a1`, + }); + // 17 NN4 : montant EXPLICITE de chaque jambe, jamais un prorata ; Σ jambes = total + expect({ ...order.legs }).toEqual(want.legs); + expect(sum({ ...order.legs } as Legs)).toBe(order.amountMinor); + // second clic : aucun second ordre (l'état fait foi) + const again = await pay.pay(hash, holdId, { method: 'CARD' }); + expect(again.created).toBe(false); + expect(psp.orders).toHaveLength(1); + }); + + // transaction annulée : aucun interrupteur ouvert ne survit (17 §0.1) + await inTx(api, { at: NOW }, async (tx) => { + expect(await switches(tx, c.country)).toEqual(ALL_CLOSED); + }); + }); + }); + + // --------------------------------------------------------------------------------------------- + describe('B — paiement prouvé par webhook signé, trip BOOKED, notifications, « Mis viajes »', () => { + const T0 = Date.UTC(2052, 2, 2, 10, 0, 0) + c.index * 7 * DAY; + const t = (m: number): string => iso(T0 + m * MINUTE); + const start = t(3 * 24 * 60); + const end = t(5 * 24 * 60); + const w: Partial = {}; + const booked = (): BookedWorld => { + if (w.trip === undefined) throw new Error('étape précédente en échec : aucun trip'); + return w as BookedWorld; + }; + + const workerSql = async ( + worker: string, + at: string | undefined, + sql: string, + params: unknown[], + ): Promise => { + const client = await open('app_worker'); + return inTx( + client, + { worker, commit: true, ...(at === undefined ? {} : { at }) }, + async (tx) => (await tx.query(sql, params)).rows, + ); + }; + const convert = async (op: string, at: string): Promise => + ( + await workerSql<{ r: Json }>( + 'booking_conversion', + at, + 'SELECT core.booking_convert_payment($1) AS r', + [op], + ) + )[0]!.r; + const webhook = async (op: string, at: string): Promise => + ( + await workerSql<{ o: string }>( + 'webhook_ingest', + at, + `SELECT core.payment_cmd_apply_operation_status($1, 'SUCCEEDED', 'WEBHOOK', + test_fixture.us049_signed_webhook($1, 'SUCCEEDED'), NULL) AS o`, + [op], + ) + )[0]!.o; + const bookedEvents = async (hold: string): Promise => + ( + await workerSql<{ n: number }>( + 'outbox_relay', + undefined, + `SELECT pg_catalog.count(*)::int AS n FROM core.outbox_outbox_event + WHERE type = 'booking.trip.booked' AND payload ->> 'hold_id' = $1`, + [hold], + ) + )[0]!.n; + + it('voyageur inscrit, hold posé par la vraie commande, devis engagé aux jambes de l’oracle ; T1 / T2 par le vrai service : ordre au PSP aux jambes EXPLICITES de la capture', async () => { + const api = await open('app_api'); + w.guest = randomUUID(); + w.org = randomUUID(); + w.vehicle = randomUUID(); + w.guestHash = await inTx(api, { at: t(0), commit: true }, async (tx) => { + await register(tx, c.country, w.guest); + await tx.query('SELECT test_fixture.l0_ensure_parties($1::uuid[], $2, $3)', [ + [w.guest], + w.org, + c.country, + ]); + await tx.query('SELECT test_fixture.register_vehicle($1, $2, $3)', [ + w.vehicle, + w.org, + c.country, + ]); + await tx.query('SELECT test_fixture.us209_driver($1, $2, $3::date, $4::date, $5)', [ + w.guest, + c.country, + '1990-01-01', + '2099-12-31', + c.country, + ]); + await capabilities(tx, c.country, t(-60)); + await tx.query('SELECT test_fixture.us024_psp_account($1)', [c.country]); + return openSession(tx, w.guest!); + }); + w.hold = await inTx(api, { at: t(0), commit: true }, async (tx) => { + const { text, values } = commandCallSql( + { kind: 'GUEST', actorId: w.guest! }, + 'core.booking_cmd_place_hold', + [ + { value: w.vehicle, type: 'uuid' }, + { value: start, type: 'timestamptz' }, + { value: end, type: 'timestamptz' }, + { value: false, type: 'boolean' }, + ], + ); + return (await tx.query<{ result: string }>(text, values)).rows[0]!.result; + }); + w.quote = await inTx(api, { at: t(0), commit: true }, async (tx) => { + const r = await tx.query<{ id: string }>( + `SELECT test_fixture.us223_checkout_acceptance($1, $2::bigint, $3, $4::jsonb, + $5::timestamptz, $6::timestamptz) AS id`, + [w.hold, total.toString(), c.currency, JSON.stringify(legsText(capture)), start, end], + ); + return r.rows[0]!.id; + }); + + const psp = new FakeHostedPsp(); + const started = await inTx(api, { at: t(1), commit: true }, (tx) => + paymentService(tx, psp).pay(w.guestHash!, w.hold!, { method: 'CARD' }), + ); + expect(started.created).toBe(true); + expect(started.payment).toMatchObject({ state: 'VERIFYING', tripId: null }); + expect(psp.orders).toHaveLength(1); + expect(psp.orders[0]).toMatchObject({ + amountMinor: total, + currency: c.currency, + capture: 'AUTO', + }); + expect({ ...psp.orders[0]!.legs }).toEqual(capture); + + const ops = await workerSql<{ id: string; amount_minor: string; status: string }>( + 'payment_command', + undefined, + `SELECT o.id, o.amount_minor::text AS amount_minor, o.status + FROM core.payment_payment_operation AS o WHERE o.hold_id = $1`, + [w.hold], + ); + expect(ops).toHaveLength(1); + expect(ops[0]).toMatchObject({ amount_minor: total.toString(), status: 'SUBMITTED' }); + w.operation = ops[0]!.id; + }); + + it('FAKE hostile : SUCCEEDED de réponse d’API (non signé) ⇒ NOT_PROVEN, aucun trip ; webhook signé ⇒ preuve ; conversion ⇒ trip BOOKED, version de prix n° 1 = devis du checkout, booking.trip.booked une fois ; rejeux ⇒ DUPLICATE et REPLAY', async () => { + const op = w.operation; + if (op === undefined) throw new Error('étape précédente en échec : aucune opération'); + const api = await open('app_api'); + expect( + ( + await workerSql<{ o: string }>( + 'payment_command', + t(2), + `SELECT core.payment_cmd_apply_operation_status($1, 'SUCCEEDED', 'API_RESPONSE', NULL, + NULL) AS o`, + [op], + ) + )[0]!.o, + ).toBe('APPLIED'); + expect(await convert(op, t(2))).toEqual({ outcome: 'NOT_PROVEN' }); + expect(await webhook(op, t(3))).toBe('DUPLICATE'); + const r = await convert(op, t(3)); + expect(r).toMatchObject({ outcome: 'CONVERTED', reacquired: false }); + w.trip = String(r['tripId']); + + const read = await inTx(api, { at: t(4) }, (tx) => + paymentService(tx, new FakeHostedPsp()).payment(w.guestHash!, w.hold!), + ); + expect(read).toMatchObject({ state: 'CONFIRMED', holdStatus: 'CONVERTED', tripId: w.trip }); + const versions = await inTx( + api, + {}, + async (tx) => + ( + await tx.query<{ version: number; quote_id: string }>( + 'SELECT * FROM test_fixture.us223_trip_price_versions($1)', + [w.trip], + ) + ).rows, + ); + expect(versions).toEqual([{ version: 1, quote_id: w.quote }]); + expect(await bookedEvents(w.hold!)).toBe(1); + + expect(await webhook(op, t(4))).toBe('DUPLICATE'); + expect(await convert(op, t(4))).toMatchObject({ outcome: 'REPLAY', tripId: w.trip }); + expect(await bookedEvents(w.hold!)).toBe(1); + }); + + it('confirmation : parties de la notification (voyageur et titulaire du compte d’hôte, identifiants seulement) ; « Mis viajes » : trip à venir, BOOKED ; interrupteurs fermés', async () => { + const b = booked(); + const api = await open('app_api'); + const holder = await inTx(api, {}, async (tx) => + String( + (await tx.query<{ h: string }>('SELECT test_fixture.us211_holder($1) AS h', [b.trip])) + .rows[0]!.h, + ), + ); + const parties = await workerSql<{ p: Json | null }>( + 'ntf_dispatcher', + t(5), + 'SELECT core.booking_notification_parties($1, $2::uuid) AS p', + ['TRIP', b.trip], + ); + expect(parties[0]!.p).toEqual({ guestUserId: b.guest, hostUserId: holder }); + + await inTx(api, { at: t(5) }, async (tx) => { + const rows = ( + await tx.query('SELECT * FROM core.booking_guest_trips($1, $2, $3::uuid, $4)', [ + b.guestHash, + null, + null, + 200, + ]) + ).rows; + const mine = rows.filter((r) => r['item_id'] === b.trip); + expect(mine).toHaveLength(1); + expect(mine[0]).toMatchObject({ + outcome: 'DONE', + kind: 'TRIP', + tab: 'UPCOMING', + status: 'BOOKED', + currency: c.currency, + contract_state: 'NONE', + }); + expect((mine[0]!['starts_at'] as Date).toISOString()).toBe(start); + expect(await switches(tx, c.country)).toEqual(ALL_CLOSED); + }); + }); + + // Défaut D1 (passation US-221) : la capture prouvée d'un hold de checkout garde trip_id NULL + // après la conversion (0116 / 0126 : `booking_convert_payment` ne rattache pas l'opération au + // trip né) et `core.settlement_cmd_apply_leg_movement` (0123) la refuse + // (`leg_movement_unsupported`) : les soldes par jambe du trip réservé ne sont jamais alimentés + // (08 E7 règle 2, 17 §2.9). Attendu : APPLIED et soldes = jambes de la capture. Transaction + // ANNULÉE : rien n'est écrit, quel que soit le résultat. + it.fails( + 'D1 (défaut) : la capture prouvée du checkout est portée sur les soldes par jambe du trip réservé (attendu : APPLIED, soldes = capture de l’oracle)', + async () => { + const b = booked(); + const worker = await open('app_worker'); + await inTx(worker, { worker: 'payment_command', at: t(6) }, async (tx) => { + let outcome: string; + try { + const moved = await tx.query<{ r: string }>( + 'SELECT core.settlement_cmd_apply_leg_movement($1) AS r', + [b.operation], + ); + outcome = String(moved.rows[0]?.r); + } catch (error) { + const e = error as { code?: string; constraint?: string }; + outcome = `${e.code ?? '?'}:${e.constraint ?? '?'}`; + } + // preuve au journal du job (aucun identifiant ni montant) : SQLSTATE et contrainte + process.stdout.write(`US-221 D1 (${c.currency}) : report de la capture = ${outcome}\n`); + expect(outcome).toBe('APPLIED'); + const bal = await tx.query<{ leg: LegName; v: string }>( + `SELECT leg, captured_minor::text AS v FROM core.settlement_trip_leg_balance + WHERE trip_id = $1 AND segment_no = 1`, + [b.trip], + ); + expect(Object.fromEntries(bal.rows.map((r) => [r.leg, BigInt(r.v)]))).toEqual(capture); + }); + }, + ); + + // Défaut D2 (conséquence de D1) : le trip payé n'a ni solde par jambe ni règlement, il est donc + // absent des faits de l'invariant par jambe (`core.finance_trip_leg_facts`, 0137) : le + // rapprochement nocturne reste vert sans voir un encaissement prouvé jamais porté. + it.fails( + 'D2 (défaut) : le trip payé et prouvé est examiné par l’invariant par jambe du rapprochement (Σ capturé = Σ encaissé = total)', + async () => { + const b = booked(); + const worker = await open('app_worker'); + await inTx(worker, { worker: 'reconciliation' }, async (tx) => { + const { rows } = await tx.query( + `SELECT captured_minor::text AS captured, collected_minor::text AS collected + FROM core.finance_trip_leg_facts() WHERE trip_id = $1::uuid`, + [b.trip], + ); + expect(rows).toEqual([{ captured: total.toString(), collected: total.toString() }]); + }); + }, + ); + }); + + // --------------------------------------------------------------------------------------------- + describe('C — annulation par l’ops, remboursement par jambe, registres, reçus, rapprochement', () => { + const REQUESTED_AT_MS = Date.UTC(2052, 5, 14, 12, 0, 0) + c.index * 7 * DAY; + const w: Partial = {}; + const cancelled = (): CancelledWorld => { + if (w.cancellation === undefined) throw new Error('étape précédente en échec'); + return w as CancelledWorld; + }; + const tripOf = (f: CancellationFacts): ReturnType => ({ + ...toTrip(vector.trip), + startAtMs: f.startAtMs, + bookedAtMs: f.bookedAtMs, + }); + + /** Lecture sous un travailleur (transaction annulée). */ + const read = async ( + worker: string, + sql: string, + params: unknown[], + ): Promise => { + const client = await open('app_worker'); + return inTx(client, { worker }, async (tx) => (await tx.query(sql, params)).rows); + }; + const balances = async (trip: string) => { + const rows = await read<{ leg: LegName; captured: string; refunded: string }>( + 'payment_command', + `SELECT leg, captured_minor::text AS captured, refunded_minor::text AS refunded + FROM core.settlement_trip_leg_balance WHERE trip_id = $1 AND segment_no = 1`, + [trip], + ); + const pick = (f: 'captured' | 'refunded') => + Object.fromEntries(rows.map((r) => [r.leg, BigInt(r[f])])) as unknown as Legs; + return { captured: pick('captured'), refunded: pick('refunded') }; + }; + + it('trip capturé (vraie commande, webhook signé, report sur les soldes) ; registre de l’assureur : +prime ; demande d’annulation de la console (OPS, vraie commande)', async () => { + const start = REQUESTED_AT_MS - (vector.event.requestedAtMinutes ?? 0) * MINUTE; + const bookedAt = start + vector.trip.bookedAtMinutes * MINUTE; + w.trip = randomUUID(); + w.guest = randomUUID(); + w.capture = randomUUID(); + const worker = await open('app_worker'); + await inTx( + worker, + { worker: 'payment_command', at: iso(bookedAt), commit: true }, + async (tx) => { + await tx.query( + `SELECT test_fixture.rls_insert_trip($1, $2, $3, $4, $5, $6, 'UTC', $7, $8)`, + [ + w.trip, + w.guest, + randomUUID(), + randomUUID(), + c.country, + c.currency, + iso(start), + iso(start + vector.trip.days * DAY), + ], + ); + const account = await tx.query<{ id: string }>( + 'SELECT test_fixture.us024_psp_account($1) AS id', + [c.country], + ); + await tx.query( + `SELECT * FROM core.payment_cmd_record_operation($1, NULL, $2, $3, 'CARD', 'CAPTURE', + 'RENT', $4, $5, 1, $6, $6, $7::jsonb, + NULL, NULL)`, + [ + w.capture, + w.trip, + account.rows[0]?.id, + total.toString(), + c.currency, + `trip:${w.trip}:capture:${w.capture}`, + JSON.stringify(legsText(capture)), + ], + ); + const status = await tx.query<{ o: string }>( + `SELECT core.payment_cmd_apply_operation_status($1, 'SUCCEEDED', 'WEBHOOK', + test_fixture.us049_signed_webhook($1, 'SUCCEEDED'), NULL) AS o`, + [w.capture], + ); + expect(status.rows[0]?.o).toBe('APPLIED'); + const moved = await tx.query<{ r: string }>( + 'SELECT core.settlement_cmd_apply_leg_movement($1) AS r', + [w.capture], + ); + expect(moved.rows[0]?.r).toBe('APPLIED'); + }, + ); + const b = await balances(w.trip); + expect(b.captured).toEqual(capture); + expect(sum(b.captured)).toBe(total); + const entries = await read<{ reason: string; amount_minor: string }>( + 'payment_command', + 'SELECT reason, amount_minor::text AS amount_minor FROM test_fixture.us227_entries($1)', + [w.trip], + ); + expect(entries.map((e) => [e.reason, BigInt(e.amount_minor)])).toEqual([ + ['COLLECTION', capture.INSURER], + ]); + + // demande de la console : agent OPS du pays, session élevée, action CANCEL_TRIP_GUEST + const api = await open('app_api'); + const opsId = await inTx(api, { commit: true }, (tx) => + staffMember(tx, 'OPS_AGENT', c.country), + ); + w.cancellation = await inTx(api, { at: iso(REQUESTED_AT_MS), commit: true }, async (tx) => { + const ops = await elevated(tx, opsId); + await setSessionContext(tx, { + kind: 'STAFF', + actorId: ops.id, + countryScope: [c.country], + sessionTokenHash: ops.hash.toString('hex'), + }); + const { rows } = await tx.query<{ outcome: string; domain_ref: string | null }>( + `SELECT outcome, domain_ref + FROM core.iam_staff_cmd_manual_action($1, $2, 'CANCEL_TRIP_GUEST', $3, $4, + '{}'::jsonb, '{}'::uuid[])`, + [ops.hash, randomUUID(), w.trip, 'Demande du voyageur au support, parcours doré'], + ); + expect(rows[0]?.outcome).toBe('DONE'); + return String(rows[0]?.domain_ref); + }); + }); + + it('vrai processeur : demande réglée (frais au voyageur) ; jambes du règlement v1 = variation de l’oracle ; ordre REFUND = −variation, montant explicite par jambe', async () => { + const x = cancelled(); + const alerts = new Alerts(); + const p = new TripCancellationProcessor({ + transactions: committing(REQUESTED_AT_MS + MINUTE), + alerts, + tripOf, + }); + expect(await p.process(x.cancellation)).toEqual({ + outcome: 'SETTLED', + costBearer: 'GUEST', + orders: 1, + }); + expect(alerts.sent).toEqual([]); + const row = await read<{ status: string; settlement_id: string | null; cost_bearer: string }>( + 'settlement', + 'SELECT status, settlement_id, cost_bearer FROM test_fixture.us215_cancellation($1)', + [x.cancellation], + ); + expect(row[0]).toMatchObject({ status: 'SETTLED', cost_bearer: 'GUEST' }); + const legs = await read<{ leg: LegName; v: string }>( + 'settlement', + `SELECT leg, variation_minor::text AS v FROM core.settlement_settlement_leg + WHERE settlement_id = $1`, + [row[0]!.settlement_id], + ); + expect(Object.fromEntries(legs.map((r) => [r.leg, BigInt(r.v)]))).toEqual(variation); + const order = await read<{ leg: LegName; v: string }>( + 'payment_command', + `SELECT l.leg, l.amount_minor::text AS v + FROM core.payment_payment_operation AS o + JOIN core.payment_payment_operation_leg AS l ON l.operation_id = o.id + WHERE o.trip_id = $1 AND o.kind = 'REFUND'`, + [x.trip], + ); + expect(Object.fromEntries(order.map((r) => [r.leg, BigInt(r.v)]))).toEqual(refund); + // rejeu : la demande n'est plus en attente, rien n'est écrit + expect(await p.process(x.cancellation)).toEqual({ outcome: 'SKIPPED' }); + }); + + it('remboursement par jambe : PSP en panne ⇒ WAITING (rien d’émis) ; vrai ordonnanceur ⇒ SENT au PSP avec chaque jambe ; preuve signée ⇒ CONFIRMED ; report ⇒ soldes = capture − remboursement (TJ02a pour le trip A) ; S10 du voyageur et de l’hôte', async () => { + const x = cancelled(); + const due = async () => { + const client = await open('app_worker'); + return inTx(client, { worker: 'payment_command' }, async (tx) => { + const all = await new PgRefundOrders(sqlOf(tx)).due(500); + const inst = await tx.query<{ id: string; status: string; operation_id: string }>( + 'SELECT id, status, operation_id FROM core.payment_refund_instance WHERE trip_id = $1', + [x.trip], + ); + expect(inst.rows).toHaveLength(1); + const i = inst.rows[0]!; + return { instance: i, due: all.find((d) => d.instanceId === i.id) }; + }); + }; + const planned = await due(); + expect(planned.instance.status).toBe('PLANNED'); + if (planned.due === undefined) throw new Error('remboursement absent de la file'); + + // FAKE hostile : PSP injoignable ⇒ transaction annulée, instance toujours PLANNED + let calls = 0; + const down = { + capabilities: () => ({ bool: (name: string) => name === 'SUPPORTS_IDEMPOTENCY_HEADER' }), + refund: (): Promise => { + calls++; + return Promise.reject(new PaymentError('PROVIDER_UNAVAILABLE', 'injoignable')); + }, + }; + const registry = (p: unknown): PaymentConnectorRegistry => ({ + get: (provider) => (provider === 'FAKE' ? (p as PaymentProvider) : undefined), + }); + const waiting = await new RefundScheduler({ + transactions: committing(REQUESTED_AT_MS + 2 * MINUTE), + alerts: new Alerts(), + connectors: registry(down), + }).process(planned.due); + expect(waiting).toEqual({ step: 'WAITING' }); + expect(calls).toBe(1); + const still = await due(); + expect(still.instance.status).toBe('PLANNED'); + if (still.due === undefined) throw new Error('remboursement sorti de la file'); + + const refunds: RefundRequest[] = []; + const accepting = { + capabilities: () => ({ + bool: (name: string) => + name === 'SUPPORTS_IDEMPOTENCY_HEADER' || name === 'SUPPORTS_LOOKUP_BY_MERCHANT_REF', + }), + refund: (req: RefundRequest): Promise => { + refunds.push(req); + return Promise.resolve({ providerReference: `psp-${randomUUID()}`, status: 'PENDING' }); + }, + }; + const alerts = new Alerts(); + const scheduler = new RefundScheduler({ + transactions: committing(REQUESTED_AT_MS + 3 * MINUTE), + alerts, + connectors: registry(accepting), + }); + expect(await scheduler.process(still.due)).toEqual({ step: 'SENT' }); + expect(refunds).toHaveLength(1); + expect(refunds[0]).toMatchObject({ amountMinor: sum(refund), currency: c.currency }); + expect({ ...refunds[0]!.legs }).toEqual(refund); + + const sent = await due(); + expect(sent.instance.status).toBe('SENT'); + const proof = await committing(REQUESTED_AT_MS + 4 * MINUTE).run('webhook_ingest', (tx) => + tx.query<{ o: string }>( + `SELECT core.payment_cmd_apply_operation_status($1, 'SUCCEEDED', 'WEBHOOK', + test_fixture.us049_signed_webhook($1, 'SUCCEEDED'), NULL) AS o`, + [sent.instance.operation_id], + ), + ); + expect(proof.rows[0]?.o).toBe('APPLIED'); + const confirmed = await due(); + expect(confirmed.instance.status).toBe('CONFIRMED'); + if (confirmed.due === undefined) throw new Error('remboursement prouvé absent de la file'); + expect(await scheduler.process(confirmed.due)).toEqual({ step: 'REPORTED' }); + expect(alerts.sent).toEqual([]); + expect(refunds).toHaveLength(1); + + const b = await balances(x.trip); + expect(b.captured).toEqual(capture); + expect(b.refunded).toEqual(refund); + expect(plus(b.captured, negate(b.refunded))).toEqual(kept); + expect((await due()).due).toBeUndefined(); + + // S10 : le voyageur lit le montant remboursé ; l'hôte, la jambe HOST seulement + const api = await open('app_api'); + await inTx(api, {}, async (tx) => { + const guestHash = await openSession(tx, x.guest); + const holder = ( + await tx.query<{ h: string }>('SELECT test_fixture.us211_holder($1) AS h', [x.trip]) + ).rows[0]!.h; + const hostHash = await openSession(tx, holder); + const READ = 'SELECT * FROM core.booking_trip_refunds($1, $2::uuid)'; + const g = (await tx.query(READ, [guestHash, x.trip])).rows; + expect(g[0]).toMatchObject({ outcome: 'OK', viewer_role: 'GUEST', currency: c.currency }); + expect(g[0]!['refunds']).toEqual([ + expect.objectContaining({ + status: 'CONFIRMED', + currency: c.currency, + amountMinor: sum(refund).toString(), + }), + ]); + const h = (await tx.query(READ, [hostHash, x.trip])).rows; + expect(h[0]).toMatchObject({ outcome: 'OK', viewer_role: 'HOST' }); + expect(h[0]!['refunds']).toEqual([ + expect.objectContaining({ status: 'CONFIRMED', hostLegMinor: refund.HOST.toString() }), + ]); + expect(JSON.stringify(h[0]!['refunds'])).not.toContain('amountMinor'); + }); + }); + + it('registre de l’assureur : +prime à l’encaissement, −prime au règlement (prime due 0) ; reçus de l’hôte (jambe HOST retenue, aucune pénalité) et du voyageur (remboursement, trip fee) ; aucune donnée de l’autre partie', async () => { + const x = cancelled(); + const entries = await read<{ reason: string; amount_minor: string }>( + 'payment_command', + 'SELECT reason, amount_minor::text AS amount_minor FROM test_fixture.us227_entries($1)', + [x.trip], + ); + const byReason = (reason: string) => + entries.filter((e) => e.reason === reason).map((e) => BigInt(e.amount_minor)); + expect(byReason('COLLECTION')).toEqual([capture.INSURER]); + expect(byReason('SETTLEMENT_VARIATION')).toEqual([variation.INSURER]); + expect(entries).toHaveLength(2); + expect(entries.reduce((s, e) => s + BigInt(e.amount_minor), 0n)).toBe(kept.INSURER); + + const api = await open('app_api'); + await inTx(api, {}, async (tx) => { + const guestHash = await openSession(tx, x.guest); + const holder = ( + await tx.query<{ h: string }>('SELECT test_fixture.us211_holder($1) AS h', [x.trip]) + ).rows[0]!.h; + const hostHash = await openSession(tx, holder); + const READ = 'SELECT * FROM core.booking_trip_receipt($1, $2::uuid)'; + const host = (await tx.query(READ, [hostHash, x.trip])).rows; + expect(host).toHaveLength(1); + expect(host[0]).toMatchObject({ outcome: 'OK', viewer_role: 'HOST', currency: c.currency }); + expect(host[0]!['receipt']).toMatchObject({ + kind: 'CXL_EARNING', + source: 'SETTLEMENT', + settlementVersion: 1, + hostLegMinor: kept.HOST.toString(), + adjustments: [], + adjustmentsMinor: '0', + netMinor: kept.HOST.toString(), + }); + const guest = (await tx.query(READ, [guestHash, x.trip])).rows; + expect(guest[0]).toMatchObject({ outcome: 'OK', viewer_role: 'GUEST' }); + const receipt = guest[0]!['receipt'] as Json; + expect(receipt).toMatchObject({ + source: 'SETTLEMENT', + settlementVersion: 1, + totalPaidMinor: total.toString(), + refundMinor: vector.expected.guestRefundMinor.toString(), + }); + const fee = receipt['tripFee'] as Json; + expect(fee['chargedMinor']).toBe(vector.trip.linesMinor.tripFee.toString()); + expect(BigInt(String(fee['refundedMinor'])) + BigInt(String(fee['retainedMinor']))).toBe( + vector.trip.linesMinor.tripFee, + ); + // minimisation : le voyageur ne voit ni jambe ni plan de l'hôte + expect(Object.keys(receipt)).not.toContain('hostLegMinor'); + expect(Object.keys(receipt)).not.toContain('hostPlanCode'); + }); + }); + + it('rapprochement nocturne : faits de l’invariant par jambe du trip (Σ capturé = Σ encaissé = total payé ; HOST du relevé = HOST attendue) ; contrôles FIN et oracle C12 sur toute la base : 0 écart ; interrupteurs fermés', async () => { + const x = cancelled(); + const worker = await open('app_worker'); + await inTx(worker, { worker: 'reconciliation' }, async (tx) => { + const facts = await tx.query( + `SELECT captured_minor::text AS captured, collected_minor::text AS collected, + collected_legs_minor::text AS collected_legs, + head_total_paid_minor::text AS head_total_paid, + expected_host_minor::text AS expected_host, + statement_host_minor::text AS statement_host + FROM core.finance_trip_leg_facts() WHERE trip_id = $1::uuid`, + [x.trip], + ); + expect(facts.rows).toEqual([ + { + captured: total.toString(), + collected: total.toString(), + collected_legs: total.toString(), + head_total_paid: total.toString(), + expected_host: kept.HOST.toString(), + statement_host: kept.HOST.toString(), + }, + ]); + const report = await runMoneyReconciliation(sqlOf(tx)); + const json = reconciliationReportJson(report); + expect(json.violations, JSON.stringify(json.checks)).toBe('0'); + expect(report.examined.trips[c.country] ?? 0).toBeGreaterThanOrEqual(1); + expect(report.examined.insurerTrips[c.country] ?? 0).toBeGreaterThanOrEqual(1); + + await asWorker(tx, 'booking_oracle'); + const c12 = await tx.query<{ check_code: string; violations: string }>( + `SELECT check_code, violations::text AS violations FROM core.booking_production_oracle()`, + ); + expect(c12.rows.length).toBeGreaterThan(0); + for (const r of c12.rows) expect(r.violations, r.check_code).toBe('0'); + expect(await switches(tx, c.country)).toEqual(ALL_CLOSED); + }); + }); + }); +}); diff --git a/packages/db/test-migrations/9937_test_us221_golden_fixtures.sql b/packages/db/test-migrations/9937_test_us221_golden_fixtures.sql new file mode 100644 index 00000000..b614763c --- /dev/null +++ b/packages/db/test-migrations/9937_test_us221_golden_fixtures.sql @@ -0,0 +1,37 @@ +-- 9937 — fixtures des parcours dorés « réservation » (US-221). TESTS SEULEMENT. +-- +-- JAMAIS appliquée hors tests : seul le harnais ajoute test-migrations/, et seulement à la base +-- jetable principale `rueda_test_*` (le schéma test_fixture est créé par 9001). +-- +-- Rôle (SECURITY DEFINER sous migrator, search_path figé ; aucun SQL dynamique) : +-- `us221_listing_city` : ville du lieu de remise du véhicule d'une annonce de fixture (9998), posée +-- à une valeur propre au test, pour que la recherche publique (US-201, au plus 50 résultats, les +-- plus récemment publiés d'abord) rende l'annonce du parcours quelle que soit la base partagée. +-- Appelée SEULEMENT dans une transaction ANNULÉE. AUCUN interrupteur de mise en service écrit +-- (17 §0.1) ; aucun montant. +-- +-- Retour arrière : DROP FUNCTION test_fixture.us221_listing_city(uuid, text). + +CREATE FUNCTION test_fixture.us221_listing_city(p_listing_id uuid, p_city text) + RETURNS void + LANGUAGE plpgsql + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + n integer; +BEGIN + UPDATE core.catalog_location AS cl + SET city = p_city + FROM core.catalog_listing AS l + JOIN core.catalog_vehicle AS cv ON cv.id = l.vehicle_id AND cv.org_id = l.org_id + WHERE l.id = p_listing_id AND cl.id = cv.home_location_id; + GET DIAGNOSTICS n = ROW_COUNT; + IF n <> 1 THEN + RAISE EXCEPTION 'us221_listing_city: listing % has no home location', p_listing_id; + END IF; +END +$fn$; + +REVOKE ALL ON FUNCTION test_fixture.us221_listing_city(uuid, text) FROM PUBLIC; +GRANT EXECUTE ON FUNCTION test_fixture.us221_listing_city(uuid, text) TO app_api; From 26fa0fd9774a15c1e3550cc4844996a911214038 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:25:29 -0300 Subject: [PATCH 02/12] =?UTF-8?q?test(US-221):=20e2e=20S01=20=E2=86=92=20S?= =?UTF-8?q?06,=20capacit=C3=A9=20inconnue=20retir=C3=A9e=20avec=20son=20po?= =?UTF-8?q?int=20de=20sauvegarde,=20attente=20du=20compte=20FAKE=20seul=20?= =?UTF-8?q?actif?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - segment A : la capacité inconnue est posée puis retirée dans le point de sauvegarde du refus (run 44379275642 : T1 restait refusé après la revalidation) ; - T1 attend que le compte FAKE soit le seul compte ACTIVE du pays : les scènes de concurrence-webhook ouvrent un compte BAC / EBANX de passage, retenu avant FAKE par booking_cmd_checkout_pay (course entre fichiers) ; refus rendu avec son code ; - e2e apps/web/e2e/parcours-dore.spec.ts (mobile-360, es) ; - docs : STRATEGIE_TESTS §3.6, README de packages/db, changelog.d. Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 44 +++++- apps/web/e2e/parcours-dore.spec.ts | 133 ++++++++++++++++++ apps/web/playwright.config.ts | 6 + changelog.d/US-221-parcours-dores.md | 5 + docs/qa/STRATEGIE_TESTS.md | 58 ++++---- packages/db/README.md | 2 + 6 files changed, 214 insertions(+), 34 deletions(-) create mode 100644 apps/web/e2e/parcours-dore.spec.ts create mode 100644 changelog.d/US-221-parcours-dores.md diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index 0662db4a..09c6ea21 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -389,6 +389,37 @@ const paymentService = (db: pg.ClientBase, psp: FakeHostedPsp): CheckoutPaymentS () => undefined, ); +/** « Pagar » par le vrai service ; un refus est rendu avec son code (diagnostic de la CI). */ +async function payOrExplain(service: CheckoutPaymentService, hash: Buffer, holdId: string) { + try { + return await service.pay(hash, holdId, { method: 'CARD' }); + } catch (error) { + const code = (error as { code?: unknown }).code; + throw new Error(`paiement refusé : ${String(code)}`, { cause: error }); + } +} + +/** + * T1 (`booking_cmd_checkout_pay`) retient le premier compte marchand ACTIVE du pays (fournisseur, + * puis identifiant). Les scènes de `concurrence-webhook.int.test.ts` VALIDENT, le temps d'un test, + * un compte ACTIVE d'un autre fournisseur du même pays (BAC, EBANX : avant FAKE dans l'ordre) puis + * le suspendent : attendre (au plus 30 s) que seul le compte FAKE du pays soit actif, sinon T1 + * viserait ce compte de passage (course entre fichiers de test, pas un défaut du produit ; + * passation US-221, constat C-1). Lecture seule, sous app_worker. + */ +async function soleFakeAccount(country: string): Promise { + const worker = await open('app_worker'); + for (let i = 0; i < 120; i++) { + const { rows } = await worker.query<{ provider: string }>( + `SELECT provider FROM core.payment_psp_account WHERE country_code = $1 AND status = 'ACTIVE'`, + [country], + ); + if (rows.length > 0 && rows.every((r) => r.provider === 'FAKE')) return; + await new Promise((resolve) => setTimeout(resolve, 250)); + } + throw new Error('un compte marchand actif d’un autre fournisseur reste ouvert dans le pays'); +} + // --- état partagé des segments (par pays) -------------------------------------------------------- interface BookedWorld { @@ -580,8 +611,10 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ const psp = new FakeHostedPsp(); const pay = paymentService(tx, psp); await capabilities(tx, c.country, at(-3)); - await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN'); + await soleFakeAccount(c.country); + // capacité inconnue posée dans un point de sauvegarde, retirée avec lui après le refus await tx.query('SAVEPOINT us221_capability'); + await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN'); await expect(pay.pay(hash, holdId, { method: 'CARD' })).rejects.toMatchObject({ code: 'HOST_PAYOUT_RAIL_UNAVAILABLE', }); @@ -593,9 +626,9 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ tripId: null, }); - // capacité validée : T1 (jambes du devis engagé), ordre au PSP, T2 - await capabilities(tx, c.country, at(-1), 'SUPPORTS_PER_LEG_AMOUNTS'); - const started = await pay.pay(hash, holdId, { method: 'CARD' }); + // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 + await soleFakeAccount(c.country); + const started = await payOrExplain(pay, hash, holdId); expect(started.created).toBe(true); expect(started.payment).toMatchObject({ state: 'VERIFYING', @@ -733,8 +766,9 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ }); const psp = new FakeHostedPsp(); + await soleFakeAccount(c.country); const started = await inTx(api, { at: t(1), commit: true }, (tx) => - paymentService(tx, psp).pay(w.guestHash!, w.hold!, { method: 'CARD' }), + payOrExplain(paymentService(tx, psp), w.guestHash!, w.hold!), ); expect(started.created).toBe(true); expect(started.payment).toMatchObject({ state: 'VERIFYING', tripId: null }); diff --git a/apps/web/e2e/parcours-dore.spec.ts b/apps/web/e2e/parcours-dore.spec.ts new file mode 100644 index 00000000..b0cb7a94 --- /dev/null +++ b/apps/web/e2e/parcours-dore.spec.ts @@ -0,0 +1,133 @@ +/** + * Parcours doré « réservation » du voyageur, de bout en bout sur le site (US-221 ; 19 US-221, §1.8 + * « Parcours dorés inter-modules ») : S01 → résultats → S03 (dates reprises de la recherche) → S05 + * → hold posé → « Pagar {total} » → page hébergée du PSP (interceptée : aucun réseau externe) → + * webhook FAKE signé joué par le double (e2e/stub-api.mjs) → S06 « confirmé ». + * + * Minimal par construction (job e2e limité à 30 min) : téléphone 360 px, espagnol (langue + * faisant foi), un seul test ; chaque écran est déjà éprouvé en quatre langues par sa spec propre + * (search, listing, checkout, checkout-payment). Textes attendus lus dans le catalogue officiel + * (`@rueda/i18n`), total TA01 (16 A.8.1 : 40,00 × 3 j + 7 % = 128,40) rendu par l'API, jamais + * recalculé par le site. Aucune capture d'écran : références et seuils inchangés. + * + * Marché sans décimale : le double ne sert la réservation que dans son marché à deux décimales + * (XTS) ; la variante PYG du parcours est prouvée de bout en bout par + * apps/api/test/int/parcours-dores-reservation.int.test.ts (trou du double, passation US-221). + */ +import { randomBytes } from 'node:crypto'; +import { createTranslator, getProfile } from '@rueda/i18n'; +import type { MessageKey, Translator } from '@rueda/i18n'; +import { LOCALE_CONFIG } from '../locale-config.ts'; +import { expect, submitAndSettle, tagOf, test } from './fixtures.ts'; +import { AREA, CITY, place, PUBLIC_ID, START } from './search-data.ts'; + +const API = `http://127.0.0.1:${process.env['RUEDA_E2E_API_PORT'] ?? '3199'}`; +const PSP = /^https:\/\/psp\.fake\.invalid\/pay\/[0-9a-f-]{36}$/; +const HOLD_URL = /\/checkout\/hold\/([0-9a-f-]{36})$/; +/** TA01 (16 A.8.1) : total 128,40, rendu par l'API. */ +const TA01_TOTAL = /128[.,]40/; +/** Trois jours facturés (TA01) : départ de la recherche, retour trois jours plus tard. */ +const END = { date: '2036-12-13', time: START.time } as const; +const MAIN = 'main:not([aria-busy])'; +const LANGUAGE = 'es' as const; +const MARK = '\u0001'; + +const translator = (): Translator => createTranslator(getProfile(LOCALE_CONFIG, tagOf(LANGUAGE))); +const fixedPart = (t: Translator, key: MessageKey, param: string): string => + t.t(key, { [param]: MARK }).split(MARK)[0] ?? ''; + +test.describe(`parcours doré « réservation » · ${LANGUAGE}`, () => { + test.use({ locale: tagOf(LANGUAGE) }); + + test('S01 → résultats → S03 → S05 → hold → « Pagar 128,40 » → PSP → webhook signé → S06 confirmé', async ({ + page, + context, + offsite, + }) => { + const t = translator(); + await context.addCookies([ + { + name: '__Host-session', + value: `G0st${LANGUAGE}${randomBytes(30).toString('base64url').slice(0, 37)}`, + domain: 'localhost', + path: '/', + httpOnly: true, + secure: true, + sameSite: 'Lax', + }, + ]); + + // S01 : lieu et dates, heures locales du pays du double + await page.goto('/'); + const form = page.locator('form[role="search"]'); + await page.locator('#s01-search-place').selectOption(place(CITY, AREA)); + await page.locator('#s01-search-startDate').fill(START.date); + await page.locator('#s01-search-startTime').selectOption(START.time); + await page.locator('#s01-search-endDate').fill(END.date); + await page.locator('#s01-search-endTime').selectOption(END.time); + await form.locator('button[type="submit"]').click(); + await expect(page).toHaveURL(/\/search\?/); + + // résultats → S03 de l'annonce, dates reprises de la recherche + await page + .locator('[data-testid="search-card"]') + .locator(`a[href^="/listings/${PUBLIC_ID}?"]`) + .first() + .click(); + await expect(page).toHaveURL(new RegExp(`/listings/${PUBLIC_ID}\\?`)); + const fiche = new URL(page.url()); + expect(fiche.searchParams.get('start')).toBe(`${START.date}T${START.time}`); + expect(fiche.searchParams.get('end')).toBe(`${END.date}T${END.time}`); + + // S03 → S05 : devis figé de la base, conducteur titulaire, documents acceptés → hold posé + await page.locator('[data-testid="s03-book"] button[type="submit"]').click(); + await expect(page).toHaveURL(/\/checkout\/[0-9a-f-]{36}$/); + await page.locator('#s05-driver-first').fill('Lucía'); + await page.locator('#s05-driver-last').fill('Gómez'); + for (const kind of ['TOS_GUEST', 'CANCELLATION_POLICY', 'GEO_TERMS']) { + await page.locator(`#s05-doc-${kind}`).check(); + } + await submitAndSettle(page, page.locator('[data-testid="s05-submit"]'), HOLD_URL); + const holdId = HOLD_URL.exec(new URL(page.url()).pathname)?.[1]; + if (holdId === undefined) throw new Error('hold non posé'); + + // « Pagar {amount} » : total de l'API ; la page hébergée du PSP est la seule sortie du site + const pay = page.locator('[data-testid="s05-pay-submit"]'); + await expect(pay).toContainText(TA01_TOTAL); + let hosted = ''; + await page.route(/^https:\/\/psp\.fake\.invalid\//, (route) => { + hosted = route.request().url(); + return route.fulfill({ + status: 200, + contentType: 'text/html', + body: 'psp
psp
', + }); + }); + await pay.click(); + await expect(page).toHaveURL(PSP); + expect(offsite).toEqual([hosted]); + offsite.splice(0); + await page.unroute(/^https:\/\/psp\.fake\.invalid\//); + + // retour du PSP : en vérification, jamais « confirmé » avant la preuve signée (UX-27) + await page.goto(`/checkout/hold/${holdId}/payment`); + const title = page.locator('[data-testid="s06-title"]'); + await expect(title).toHaveAttribute('data-state', 'VERIFYING'); + await expect(title).toHaveText(t.t('web.s06.verifying.title')); + await expect(page.locator(MAIN)).not.toContainText(t.t('web.s07.title')); + + // webhook FAKE signé et conversion (double) : trip né, S06 confirmé + const r = await fetch(`${API}/__e2e/payment/webhook?hold=${holdId}&event=SUCCEEDED`); + expect(r.status).toBe(200); + await page.goto(`/checkout/hold/${holdId}/payment`); + await expect(title).toHaveAttribute('data-state', 'CONFIRMED'); + await expect(title).toHaveText(t.t('web.s07.title')); + await expect(page.locator(MAIN)).toContainText(t.t('web.s06.confirmed.body')); + await expect(page.locator('[data-testid="s07-documents"]')).toHaveText( + t.t('web.s07.documents'), + ); + await expect(page.locator('[data-testid="s07-safety"]')).toContainText( + fixedPart(t, 'web.s07.safety', 'brand'), + ); + }); +}); diff --git a/apps/web/playwright.config.ts b/apps/web/playwright.config.ts index 4afc044b..36d7f06d 100644 --- a/apps/web/playwright.config.ts +++ b/apps/web/playwright.config.ts @@ -66,6 +66,11 @@ const GUEST_TRIPS = /guest-trips\.spec\.ts$/; * du job e2e, proche de sa limite ; les quatre langues sont prouvées par les catalogues et l'API). */ const CONSTANCIA = /trip-constancia\.spec\.ts$/; +/** + * Parcours doré « réservation » S01 → S06 (US-221) : 360 px et espagnol seulement, un test (durée + * du job e2e ; chaque écran est éprouvé en quatre langues par sa spec propre). + */ +const GOLDEN = /parcours-dore\.spec\.ts$/; /** Balayage axe + captures de chaque écran du site (US-044). */ const SCREENS = /screens\.spec\.ts$/; /** Balayage des écrans de la console interne (US-044). */ @@ -155,6 +160,7 @@ export default defineConfig({ REFUND, GUEST_TRIPS, CONSTANCIA, + GOLDEN, SCREENS, ], use: { ...phone, viewport: { width: 360, height: 780 } }, diff --git a/changelog.d/US-221-parcours-dores.md b/changelog.d/US-221-parcours-dores.md new file mode 100644 index 00000000..2f011a92 --- /dev/null +++ b/changelog.d/US-221-parcours-dores.md @@ -0,0 +1,5 @@ +lot: L2 +module: Qualité + +- Ajouté : parcours dorés de la réservation, de bout en bout, au Panama (USD) et au Paraguay (PYG sans décimale) : recherche, fiche, devis, checkout, paiement par parts (hôte, assureur, plateforme, taxe), preuve du paiement, réservation confirmée, notifications, « Mis viajes », annulation par l'ops, remboursement par part, registre de l'assureur, reçus et contrôle de nuit de l'argent, sous les rôles de production et avec les montants des oracles (US-221) +- Ajouté : parcours du voyageur sur le site, de la recherche à la confirmation du paiement, sur téléphone (US-221) diff --git a/docs/qa/STRATEGIE_TESTS.md b/docs/qa/STRATEGIE_TESTS.md index 60c5d73c..e01fb09d 100644 --- a/docs/qa/STRATEGIE_TESTS.md +++ b/docs/qa/STRATEGIE_TESTS.md @@ -22,33 +22,33 @@ Le tableau suit l'ordre des critères d'US-039. La colonne « Job CI » nomme les jobs de [`ci.yml`](../../.github/workflows/ci.yml) (à chaque PR et chaque push sur `main`) ou de [`nightly.yml`](../../.github/workflows/nightly.yml) (chaque nuit). Leur contenu détaillé est dans [`docs/ops/CI.md`](../ops/CI.md). -| Famille | Commande | Emplacement | Job CI | Quand | -| ------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------- | -| Unitaires (dont contrats d'API) | `pnpm test:unit` | `*.test.ts` à côté du code, `packages/*/test/`, `*.contract.test.ts`, `scripts/{team,ci,deploy,ops,qa}/*.test.mjs` | `qualite` | chaque PR | -| Intégration (PostgreSQL réel) | `pnpm test:int` | `packages/db/test/int/`, `apps/api/src/**/*.int.test.ts`, `apps/api/test/int/` | `base-de-donnees` | chaque PR | -| Vecteurs dorés T01–T68, TJ01–TJ21, TA01–TA11 | `pnpm test:money` | `packages/money/test/golden-vectors/`, `packages/money/test/settlement/`, export `docs/specs/tools/golden_vectors.json` | `qualite`, `argent-oracles` | chaque PR | -| Oracles Python de la spécification | `python -I -X utf8 scripts/ci/check-spec-tools.py --specs docs/specs` | `docs/specs/tools/`, registre `docs/specs/tools/registry.json` | `oracles` | chaque PR | -| Moteur d'argent comparé aux oracles (10 000) | `pnpm --filter @rueda/money test:oracle` | `packages/money/test/oracle/*.oracle.ts` | `argent-oracles`, `argent-oracles-long` | chaque PR ; 100 000 cas la nuit | -| Mutation (`Money`, règlement ; seuil 80 %) | `pnpm --filter @rueda/money test:mutation` | `packages/money/stryker.config.mjs` | `argent-mutation` | PR qui touche `packages/money/` | -| Preuves L0-01 à L0-09 | `pnpm test:l0` | `packages/db/test/l0/l0-0*.test.ts` et suivants | `base-de-donnees` | chaque PR | -| Concurrence C1–C20 | `pnpm test:l0`, puis `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/` (dont `l0-02-concurrency`, `l0-us024-conversion`, `l0-06-platform-now`), `packages/db/test/support/concurrency.ts` | `base-de-donnees`, `fuzz-c11` | chaque PR | -| Fuzz C11 et oracle C12 | `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/l0-c11-fuzz.test.ts`, `packages/db/test/support/c11.ts` | `fuzz-c11` | 1 000 à chaque PR ; 10 × 1 000 nuit | -| Isolation RLS-1 à RLS-28, matrice d'accès | `pnpm test:l0` (et `pnpm test:unit` pour la matrice des routes) | `packages/db/test/l0/l0-rls-*.test.ts`, `l0-05-roles`, `l0-pay-legs-rls`, `l0-us062-host-money`, `l0-us043-authorization-matrix`, `apps/api/src/testing/route-matrix*.ts` | `base-de-donnees`, `qualite` | chaque PR | -| Migrations montée / retour, RLS-19 | `pnpm test:l0` | `packages/db/test/l0/l0-us046-migrations.test.ts` (base `_mig`) | `base-de-donnees` | chaque PR | -| e2e web mobile et PWA | `pnpm test:e2e` | `apps/web/e2e/*.spec.ts`, `apps/web/playwright.config.ts` | `e2e-web` | chaque PR | -| Parcours doré de règlement et rapprochement de l'argent | `pnpm --filter @rueda/api test:reconciliation` | `apps/api/test/int/reconciliation.int.test.ts`, `apps/api/src/modules/fin/internal/money-reconciliation.ts` (et son `.test.ts`) | `base-de-donnees`, `rapprochement` | chaque PR (dans `pnpm test:int`) ; chaque nuit | -| Parcours dorés e2e PA / USD et PY / PYG | `pnpm test:e2e` (à venir) | **à créer** (US-221, US-312, US-539) | `e2e-web` (à venir) | voir §3.6 | -| Accessibilité | `pnpm test:e2e` et `pnpm --filter @rueda/design-tokens test:unit` | `apps/web/e2e/screens.spec.ts`, `apps/web/e2e/console.spec.ts`, `apps/web/e2e/axe.ts`, `packages/design-tokens/test/contrast.test.ts`, `packages/design-tokens/test/wcag.test.ts` | `e2e-web`, `qualite` | chaque PR (US-044, §3.7) | -| Sécurité (ASVS niveau 2, §3.9) | `pnpm test:unit`, `pnpm test:int`, `pnpm test:l0` | `apps/api/src/testing/route-matrix.test.ts`, `apps/api/src/testing/route-matrix.int.test.ts`, `packages/db/test/l0/l0-us043-authorization-matrix.test.ts`, `packages/db/test/l0/l0-us043-env-guard.test.ts` | `qualite`, `base-de-donnees`, `secrets`, `dependances` | chaque PR ; revue complète par lot | -| Données personnelles (§3.10) | `pnpm test:unit`, `pnpm test:l0` | `apps/api/src/testing/personal-data-leaks.test.ts`, `packages/db/test/l0/l0-us046-personal-data.test.ts`, `packages/db/personal-data-inventory.json` | `qualite`, `base-de-donnees` | chaque PR | -| Gabarits de notification (§3.11) | `pnpm --filter @rueda/api test:unit` | `apps/api/src/modules/ntf/internal/templates.test.ts` | `qualite` | chaque PR | -| Installation depuis zéro | `bash scripts/ci/run-install-guide.sh docs/ops/INSTALL.md` | [`docs/ops/INSTALL.md`](../ops/INSTALL.md) | `guide-installation` | chaque PR | -| Image de production, C19, retour arrière | `bash scripts/deploy/rehearsal.sh` | `scripts/deploy/` | `deploiement-local` | chaque PR | -| Restauration et rotation des secrets | `bash scripts/ops/restore-drill.sh`, `bash scripts/ops/rotation-drill.sh` | `packages/db/test/drill/` (`test:drill` de `@rueda/db`, lancé seulement par `restore-drill.sh`), `packages/db/test/portability/` (`test:portability` de `@rueda/db`, exercice de portabilité d'US-036, lancé seulement par `scripts/ops/portability-drill.sh`, appelé par `restore-drill.sh`), `scripts/ops/` | `restauration`, `rotation-secrets` | chaque PR | -| Infrastructure (OpenTofu simulé) | `tofu test` dans chaque module de `infra/opentofu/modules/` | `infra/opentofu/` | `infrastructure` | chaque PR | -| Secrets et dépendances | `node scripts/ci/audit-gate.mjs` | `docs/ops/audit-exceptions.json` | `secrets`, `dependances` | chaque PR ; historique complet nuit | -| Revues et CHANGELOG | `node scripts/ci/check-story-reviews.mjs`, `pnpm lint:changelog` | `docs/team/reviews/`, `changelog.d/` | `revues`, `changelog` | chaque PR | -| Régression de nuit et tableau de bord QA | `gh workflow run nightly.yml --ref main` | [`nightly.yml`](../../.github/workflows/nightly.yml), `scripts/qa/nightly-dashboard.mjs` | `suite-complete`, `argent-oracles-long`, `fuzz-c11`, `rapprochement`, `tableau-de-bord-qa` | chaque nuit, 03:17 UTC | +| Famille | Commande | Emplacement | Job CI | Quand | +| ------------------------------------------------------------ | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------- | +| Unitaires (dont contrats d'API) | `pnpm test:unit` | `*.test.ts` à côté du code, `packages/*/test/`, `*.contract.test.ts`, `scripts/{team,ci,deploy,ops,qa}/*.test.mjs` | `qualite` | chaque PR | +| Intégration (PostgreSQL réel) | `pnpm test:int` | `packages/db/test/int/`, `apps/api/src/**/*.int.test.ts`, `apps/api/test/int/` | `base-de-donnees` | chaque PR | +| Vecteurs dorés T01–T68, TJ01–TJ21, TA01–TA11 | `pnpm test:money` | `packages/money/test/golden-vectors/`, `packages/money/test/settlement/`, export `docs/specs/tools/golden_vectors.json` | `qualite`, `argent-oracles` | chaque PR | +| Oracles Python de la spécification | `python -I -X utf8 scripts/ci/check-spec-tools.py --specs docs/specs` | `docs/specs/tools/`, registre `docs/specs/tools/registry.json` | `oracles` | chaque PR | +| Moteur d'argent comparé aux oracles (10 000) | `pnpm --filter @rueda/money test:oracle` | `packages/money/test/oracle/*.oracle.ts` | `argent-oracles`, `argent-oracles-long` | chaque PR ; 100 000 cas la nuit | +| Mutation (`Money`, règlement ; seuil 80 %) | `pnpm --filter @rueda/money test:mutation` | `packages/money/stryker.config.mjs` | `argent-mutation` | PR qui touche `packages/money/` | +| Preuves L0-01 à L0-09 | `pnpm test:l0` | `packages/db/test/l0/l0-0*.test.ts` et suivants | `base-de-donnees` | chaque PR | +| Concurrence C1–C20 | `pnpm test:l0`, puis `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/` (dont `l0-02-concurrency`, `l0-us024-conversion`, `l0-06-platform-now`), `packages/db/test/support/concurrency.ts` | `base-de-donnees`, `fuzz-c11` | chaque PR | +| Fuzz C11 et oracle C12 | `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/l0-c11-fuzz.test.ts`, `packages/db/test/support/c11.ts` | `fuzz-c11` | 1 000 à chaque PR ; 10 × 1 000 nuit | +| Isolation RLS-1 à RLS-28, matrice d'accès | `pnpm test:l0` (et `pnpm test:unit` pour la matrice des routes) | `packages/db/test/l0/l0-rls-*.test.ts`, `l0-05-roles`, `l0-pay-legs-rls`, `l0-us062-host-money`, `l0-us043-authorization-matrix`, `apps/api/src/testing/route-matrix*.ts` | `base-de-donnees`, `qualite` | chaque PR | +| Migrations montée / retour, RLS-19 | `pnpm test:l0` | `packages/db/test/l0/l0-us046-migrations.test.ts` (base `_mig`) | `base-de-donnees` | chaque PR | +| e2e web mobile et PWA | `pnpm test:e2e` | `apps/web/e2e/*.spec.ts`, `apps/web/playwright.config.ts` | `e2e-web` | chaque PR | +| Parcours doré de règlement et rapprochement de l'argent | `pnpm --filter @rueda/api test:reconciliation` | `apps/api/test/int/reconciliation.int.test.ts`, `apps/api/src/modules/fin/internal/money-reconciliation.ts` (et son `.test.ts`) | `base-de-donnees`, `rapprochement` | chaque PR (dans `pnpm test:int`) ; chaque nuit | +| Parcours dorés « réservation » PA / USD et PY / PYG (US-221) | `pnpm test:int` ; `pnpm test:e2e` (projet `mobile-360`) | `apps/api/test/int/parcours-dores-reservation.int.test.ts` (segments A, B, C, §3.6), fixture `packages/db/test-migrations/9937`, `apps/web/e2e/parcours-dore.spec.ts` | `base-de-donnees`, `e2e-web` | chaque PR ; chaque nuit (dans `pnpm test:int`) | +| Accessibilité | `pnpm test:e2e` et `pnpm --filter @rueda/design-tokens test:unit` | `apps/web/e2e/screens.spec.ts`, `apps/web/e2e/console.spec.ts`, `apps/web/e2e/axe.ts`, `packages/design-tokens/test/contrast.test.ts`, `packages/design-tokens/test/wcag.test.ts` | `e2e-web`, `qualite` | chaque PR (US-044, §3.7) | +| Sécurité (ASVS niveau 2, §3.9) | `pnpm test:unit`, `pnpm test:int`, `pnpm test:l0` | `apps/api/src/testing/route-matrix.test.ts`, `apps/api/src/testing/route-matrix.int.test.ts`, `packages/db/test/l0/l0-us043-authorization-matrix.test.ts`, `packages/db/test/l0/l0-us043-env-guard.test.ts` | `qualite`, `base-de-donnees`, `secrets`, `dependances` | chaque PR ; revue complète par lot | +| Données personnelles (§3.10) | `pnpm test:unit`, `pnpm test:l0` | `apps/api/src/testing/personal-data-leaks.test.ts`, `packages/db/test/l0/l0-us046-personal-data.test.ts`, `packages/db/personal-data-inventory.json` | `qualite`, `base-de-donnees` | chaque PR | +| Gabarits de notification (§3.11) | `pnpm --filter @rueda/api test:unit` | `apps/api/src/modules/ntf/internal/templates.test.ts` | `qualite` | chaque PR | +| Installation depuis zéro | `bash scripts/ci/run-install-guide.sh docs/ops/INSTALL.md` | [`docs/ops/INSTALL.md`](../ops/INSTALL.md) | `guide-installation` | chaque PR | +| Image de production, C19, retour arrière | `bash scripts/deploy/rehearsal.sh` | `scripts/deploy/` | `deploiement-local` | chaque PR | +| Restauration et rotation des secrets | `bash scripts/ops/restore-drill.sh`, `bash scripts/ops/rotation-drill.sh` | `packages/db/test/drill/` (`test:drill` de `@rueda/db`, lancé seulement par `restore-drill.sh`), `packages/db/test/portability/` (`test:portability` de `@rueda/db`, exercice de portabilité d'US-036, lancé seulement par `scripts/ops/portability-drill.sh`, appelé par `restore-drill.sh`), `scripts/ops/` | `restauration`, `rotation-secrets` | chaque PR | +| Infrastructure (OpenTofu simulé) | `tofu test` dans chaque module de `infra/opentofu/modules/` | `infra/opentofu/` | `infrastructure` | chaque PR | +| Secrets et dépendances | `node scripts/ci/audit-gate.mjs` | `docs/ops/audit-exceptions.json` | `secrets`, `dependances` | chaque PR ; historique complet nuit | +| Revues et CHANGELOG | `node scripts/ci/check-story-reviews.mjs`, `pnpm lint:changelog` | `docs/team/reviews/`, `changelog.d/` | `revues`, `changelog` | chaque PR | +| Régression de nuit et tableau de bord QA | `gh workflow run nightly.yml --ref main` | [`nightly.yml`](../../.github/workflows/nightly.yml), `scripts/qa/nightly-dashboard.mjs` | `suite-complete`, `argent-oracles-long`, `fuzz-c11`, `rapprochement`, `tableau-de-bord-qa` | chaque nuit, 03:17 UTC | ## 3. Détail par famille @@ -101,7 +101,7 @@ Le tableau suit l'ordre des critères d'US-039. La colonne « Job CI » nomme le - `pnpm test:e2e` construit `apps/web` en production, puis lance Playwright (`apps/web/playwright.config.ts`) sur quatre projets : `mobile-360`, `mobile-390`, `tablette` et `pwa`. Un projet seul : `pnpm --filter @rueda/web test:e2e --project mobile-360` (le site déjà construit). - Couvert aujourd'hui (US-041, ADR-074) : coquille du site dans les **quatre langues** (es, en, fr, pt-BR), clair et sombre, hors ligne ; PWA installée (manifeste, fenêtre d'application, service worker réel). Aucune relance ; toute requête vers un autre hôte que le serveur local fait échouer le test. -- **Pas encore couvert** : les parcours dorés inter-modules **PA / USD et PY / PYG** de 19 §1.8 (recherche, hold, paiement `FAKE` normal et hostile, trip, remise et retour, annulation, règlement par jambe, versement, notifications). Ils arrivent avec les écrans qu'ils traversent : US-221, US-312, US-539. US-047 a livré le premier parcours, sous le niveau e2e : règlement v1 puis v2 dans chaque pays configuré, suivi du rapprochement et de l'oracle C12 (§3.8). Jusque-là, les variantes PA et PY sont prouvées sous le niveau e2e : vecteurs en USD et PYG (§3.3), graines PA et PY du banc et du guide d'installation, fuzz C11 sur deux pays. +- **Parcours dorés « réservation » (US-221)** : `apps/api/test/int/parcours-dores-reservation.int.test.ts`, sur PostgreSQL réel, sous `app_api` et `app_worker`, en USD et en PYG sans décimale, attendus tirés de l'export des oracles. Segment A (transaction annulée, interrupteurs ouverts par la procédure à deux personnes) : inscription, recherche, fiche, devis figé, checkout, capacité bloquante inconnue refusée avant T1, ordre au PSP FAKE avec le montant explicite de chaque jambe. Segment B (données validées) : paiement par le vrai service, FAKE hostile (succès d'API non signé, doublons), preuve par webhook signé, trip BOOKED, notifications, « Mis viajes » ; défauts D1 et D2 en `it.fails` (passation US-221). Segment C (données validées) : annulation par l'ops, vrai processeur, remboursement par jambe (PSP en panne puis vrai ordonnanceur), S10, `insurer_ledger`, reçus, faits de l'invariant par jambe, rapprochement et oracle C12 à 0 écart. L'e2e `apps/web/e2e/parcours-dore.spec.ts` (360 px, espagnol) enchaîne S01 → S06 confirmé sur le double, dans son seul marché à deux décimales (le double ne sert pas la réservation sans décimale : variante PYG prouvée par le test d'intégration). **Pas encore couvert** : remise et retour, versement (US-312, US-539) ; contrat et constancia du trip réservé, faute de devis figé rejouable dans les couches de test (passation US-221). ### 3.7 Accessibilité @@ -185,7 +185,7 @@ Règles (19 §1.4, §1.8 ; CLAUDE.md) : | Exigence de 19 §1.8 / 17 §12 | État | Porteur | | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- | -| parcours dorés e2e PA / PY, `FAKE` normal et hostile | parcours de règlement (API et base) livré, e2e inter-modules absents | US-221, US-312, US-539 | +| parcours dorés e2e PA / PY, `FAKE` normal et hostile | réservation livrée (US-221 : intégration A, B, C et e2e S01 → S06) ; remise, retour et versement à venir | US-221, US-312, US-539 | | seuils de couverture (STL, PRC, PAY, AVL, `Money` ≥ 95 % lignes…) | **PROPOSÉS, non mesurés en CI** | à attribuer (QUESTIONS) | | performance de fumée, résilience de nuit | livrées par US-045 : p95 par chemin critique à chaque passage de la CI (artefact `perf-fumee`, historique par commit), FAKE hostiles au niveau des consommateurs (`resilience-*.test.ts`), passe L0-06 en horloge réelle ([`PERFORMANCE_FUMEE.md`](PERFORMANCE_FUMEE.md), ADR-119) | charge (17 §12 « Charge ») : lot C | | rapprochement de nuit, tableau de bord QA | livrés (US-047, ADR-087) ; rapprochement par jambe avec l'export du PSP et invariant du relevé absents ; `pnpm test:nightly` pas créé (§3.8) | US-311, US-217 | diff --git a/packages/db/README.md b/packages/db/README.md index cdd502cf..750117e3 100644 --- a/packages/db/README.md +++ b/packages/db/README.md @@ -948,6 +948,8 @@ Migration `0136_booking_guest_trips_read` : une fonction de lecture AJOUTÉE, au - `core.booking_guest_trips(bytea, text, uuid, integer)` (cmd_hold_owner, EXECUTE app_api) : trips du voyageur de la SESSION (onglets UPCOMING, IN_PROGRESS, DONE, CANCELLED, partition de 0101) et ses demandes en attente (REQUESTED : hold REQUEST en `AWAITING_HOST` ou `PAYMENT_IN_FLIGHT`, heure limite de la base) ; auto sans plaque ; hôte en prénom et initiale ; nom du lieu, adresse et ville d'un trip à venir ou en cours seulement, ville seule d'une demande ; total du devis figé (jamais recalculé) ; état du contrat (`NONE`, `TO_SIGN`, `SIGNED`). Trip d'une autre personne (y compris celui que la session héberge) ou inconnu : aucune ligne. Issues : `DONE`, `AUTH_REQUIRED`, `REQUEST_INVALID`. - **Preuves** : `test/l0/l0-us214-guest-trips.test.ts` (PA USD, PY PYG ; transaction annulée sous app_api ; trips et demande de la fixture 9948, contrat signé par 9963 ; IDOR, onglets, minimisation, refus d'app_worker et d'app_anon). +**Parcours dorés « réservation » (US-221)** : aucune migration. Fixture `9937_test_us221_golden_fixtures` : `test_fixture.us221_listing_city` pose une ville propre au test sur le lieu de remise du véhicule d'une annonce de la fixture 9998 (recherche publique au plus 50 résultats sur une base partagée ; transaction annulée seulement, aucun interrupteur, aucun montant). Preuve : `apps/api/test/int/parcours-dores-reservation.int.test.ts` (`docs/qa/STRATEGIE_TESTS.md` §3.6). + ## Constancia d'arrendamiento et recherche de l'hôte (US-212 ; 16 LEG-026 ; ADR-162) Migration `0138_booking_trip_constancia_read` : deux fonctions de lecture AJOUTÉES, aucune table, aucun droit nouveau. Fixture `9946_test_us212_constancia_fixtures` (version de contrat aux faits écrits par le test ; partie nominative pseudonymisée). From d9e82649e108bebf7c98becfeef235195f73bd0b Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:50:16 -0300 Subject: [PATCH 03/12] =?UTF-8?q?test(US-221):=20segment=20A=20ind=C3=A9pe?= =?UTF-8?q?ndant=20des=20comptes=20de=20passage=20;=20strat=C3=A9gie=20de?= =?UTF-8?q?=20test=20conforme=20;=20passation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - segment A : capacités et PSP FAKE posés pour le fournisseur que T1 retiendra (run 44380398003 : compte BAC / EBANX de passage ouvert plus de 30 s) ; - STRATEGIE_TESTS : libellé de la famille « Parcours dorés e2e » et chemin complet de la fixture (scripts/qa/test-strategy.test.mjs) ; - passation docs/team/handoffs/US-221.md (parcours, défauts D1 et D2, trous). Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 46 +++++++++++----- docs/qa/STRATEGIE_TESTS.md | 54 +++++++++---------- docs/team/handoffs/US-221.md | 50 +++++++++++++++++ 3 files changed, 111 insertions(+), 39 deletions(-) create mode 100644 docs/team/handoffs/US-221.md diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index 09c6ea21..4972be1b 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -352,6 +352,7 @@ async function capabilities( from: string, only?: string, status: 'VALIDATED_SANDBOX' | 'UNKNOWN' = 'VALIDATED_SANDBOX', + providers: readonly string[] = ['FAKE'], ): Promise { const { rows } = await tx.query<{ capability: string; kind: string }>( `SELECT capability, kind FROM core.payment_psp_capability_catalog WHERE blocking <> 'NO'`, @@ -359,11 +360,13 @@ async function capabilities( for (const r of rows) { if (only !== undefined && r.capability !== only) continue; const value = r.kind === 'bool' ? true : r.kind === 'int' ? 1 : 'FAKE_HMAC_SHA256'; - await tx.query( - `SELECT test_fixture.us024_set_capability('FAKE', $1, '*', $2, $3::jsonb, $4, - $5::timestamptz)`, - [country, r.capability, JSON.stringify(value), status, from], - ); + for (const provider of providers) { + await tx.query( + `SELECT test_fixture.us024_set_capability($1, $2, '*', $3, $4::jsonb, $5, + $6::timestamptz)`, + [provider, country, r.capability, JSON.stringify(value), status, from], + ); + } } } @@ -382,10 +385,14 @@ class FakeHostedPsp implements HostedPaymentProvider { return Promise.resolve(null); } } -const paymentService = (db: pg.ClientBase, psp: FakeHostedPsp): CheckoutPaymentService => +const paymentService = ( + db: pg.ClientBase, + psp: FakeHostedPsp, + providers: readonly string[] = ['FAKE'], +): CheckoutPaymentService => new CheckoutPaymentService( new PgCheckoutPaymentStore(db), - new Map([['FAKE', psp]]), + new Map(providers.map((p) => [p, psp])), () => undefined, ); @@ -420,6 +427,22 @@ async function soleFakeAccount(country: string): Promise { throw new Error('un compte marchand actif d’un autre fournisseur reste ouvert dans le pays'); } +/** + * Fournisseurs que T1 peut retenir dans le pays, À CET INSTANT : FAKE et le premier compte ACTIVE + * dans l'ordre de `booking_cmd_checkout_pay` (environnement LIVE d'abord, fournisseur, + * identifiant). Segment A seulement (transaction annulée) : capacités et PSP FAKE posés pour chacun, + * pour que le parcours ne dépende pas d'un compte de passage d'un autre fichier (constat C-1). + */ +async function checkoutProviders(country: string): Promise { + const worker = await open('app_worker'); + const { rows } = await worker.query<{ provider: string }>( + `SELECT provider FROM core.payment_psp_account WHERE country_code = $1 AND status = 'ACTIVE' + ORDER BY (environment = 'LIVE') DESC, provider, id LIMIT 1`, + [country], + ); + return [...new Set(['FAKE', ...rows.map((r) => r.provider)])]; +} + // --- état partagé des segments (par pays) -------------------------------------------------------- interface BookedWorld { @@ -609,12 +632,12 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ // critère 2 (FAKE hostile) : capacité bloquante inconnue ⇒ refus AVANT T1, aucun ordre const at = (m: number) => iso(Date.parse(NOW) + m * MINUTE); const psp = new FakeHostedPsp(); - const pay = paymentService(tx, psp); - await capabilities(tx, c.country, at(-3)); - await soleFakeAccount(c.country); + const providers = await checkoutProviders(c.country); + const pay = paymentService(tx, psp, providers); + await capabilities(tx, c.country, at(-3), undefined, 'VALIDATED_SANDBOX', providers); // capacité inconnue posée dans un point de sauvegarde, retirée avec lui après le refus await tx.query('SAVEPOINT us221_capability'); - await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN'); + await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN', providers); await expect(pay.pay(hash, holdId, { method: 'CARD' })).rejects.toMatchObject({ code: 'HOST_PAYOUT_RAIL_UNAVAILABLE', }); @@ -627,7 +650,6 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ }); // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 - await soleFakeAccount(c.country); const started = await payOrExplain(pay, hash, holdId); expect(started.created).toBe(true); expect(started.payment).toMatchObject({ diff --git a/docs/qa/STRATEGIE_TESTS.md b/docs/qa/STRATEGIE_TESTS.md index e01fb09d..782aadb1 100644 --- a/docs/qa/STRATEGIE_TESTS.md +++ b/docs/qa/STRATEGIE_TESTS.md @@ -22,33 +22,33 @@ Le tableau suit l'ordre des critères d'US-039. La colonne « Job CI » nomme les jobs de [`ci.yml`](../../.github/workflows/ci.yml) (à chaque PR et chaque push sur `main`) ou de [`nightly.yml`](../../.github/workflows/nightly.yml) (chaque nuit). Leur contenu détaillé est dans [`docs/ops/CI.md`](../ops/CI.md). -| Famille | Commande | Emplacement | Job CI | Quand | -| ------------------------------------------------------------ | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------- | -| Unitaires (dont contrats d'API) | `pnpm test:unit` | `*.test.ts` à côté du code, `packages/*/test/`, `*.contract.test.ts`, `scripts/{team,ci,deploy,ops,qa}/*.test.mjs` | `qualite` | chaque PR | -| Intégration (PostgreSQL réel) | `pnpm test:int` | `packages/db/test/int/`, `apps/api/src/**/*.int.test.ts`, `apps/api/test/int/` | `base-de-donnees` | chaque PR | -| Vecteurs dorés T01–T68, TJ01–TJ21, TA01–TA11 | `pnpm test:money` | `packages/money/test/golden-vectors/`, `packages/money/test/settlement/`, export `docs/specs/tools/golden_vectors.json` | `qualite`, `argent-oracles` | chaque PR | -| Oracles Python de la spécification | `python -I -X utf8 scripts/ci/check-spec-tools.py --specs docs/specs` | `docs/specs/tools/`, registre `docs/specs/tools/registry.json` | `oracles` | chaque PR | -| Moteur d'argent comparé aux oracles (10 000) | `pnpm --filter @rueda/money test:oracle` | `packages/money/test/oracle/*.oracle.ts` | `argent-oracles`, `argent-oracles-long` | chaque PR ; 100 000 cas la nuit | -| Mutation (`Money`, règlement ; seuil 80 %) | `pnpm --filter @rueda/money test:mutation` | `packages/money/stryker.config.mjs` | `argent-mutation` | PR qui touche `packages/money/` | -| Preuves L0-01 à L0-09 | `pnpm test:l0` | `packages/db/test/l0/l0-0*.test.ts` et suivants | `base-de-donnees` | chaque PR | -| Concurrence C1–C20 | `pnpm test:l0`, puis `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/` (dont `l0-02-concurrency`, `l0-us024-conversion`, `l0-06-platform-now`), `packages/db/test/support/concurrency.ts` | `base-de-donnees`, `fuzz-c11` | chaque PR | -| Fuzz C11 et oracle C12 | `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/l0-c11-fuzz.test.ts`, `packages/db/test/support/c11.ts` | `fuzz-c11` | 1 000 à chaque PR ; 10 × 1 000 nuit | -| Isolation RLS-1 à RLS-28, matrice d'accès | `pnpm test:l0` (et `pnpm test:unit` pour la matrice des routes) | `packages/db/test/l0/l0-rls-*.test.ts`, `l0-05-roles`, `l0-pay-legs-rls`, `l0-us062-host-money`, `l0-us043-authorization-matrix`, `apps/api/src/testing/route-matrix*.ts` | `base-de-donnees`, `qualite` | chaque PR | -| Migrations montée / retour, RLS-19 | `pnpm test:l0` | `packages/db/test/l0/l0-us046-migrations.test.ts` (base `_mig`) | `base-de-donnees` | chaque PR | -| e2e web mobile et PWA | `pnpm test:e2e` | `apps/web/e2e/*.spec.ts`, `apps/web/playwright.config.ts` | `e2e-web` | chaque PR | -| Parcours doré de règlement et rapprochement de l'argent | `pnpm --filter @rueda/api test:reconciliation` | `apps/api/test/int/reconciliation.int.test.ts`, `apps/api/src/modules/fin/internal/money-reconciliation.ts` (et son `.test.ts`) | `base-de-donnees`, `rapprochement` | chaque PR (dans `pnpm test:int`) ; chaque nuit | -| Parcours dorés « réservation » PA / USD et PY / PYG (US-221) | `pnpm test:int` ; `pnpm test:e2e` (projet `mobile-360`) | `apps/api/test/int/parcours-dores-reservation.int.test.ts` (segments A, B, C, §3.6), fixture `packages/db/test-migrations/9937`, `apps/web/e2e/parcours-dore.spec.ts` | `base-de-donnees`, `e2e-web` | chaque PR ; chaque nuit (dans `pnpm test:int`) | -| Accessibilité | `pnpm test:e2e` et `pnpm --filter @rueda/design-tokens test:unit` | `apps/web/e2e/screens.spec.ts`, `apps/web/e2e/console.spec.ts`, `apps/web/e2e/axe.ts`, `packages/design-tokens/test/contrast.test.ts`, `packages/design-tokens/test/wcag.test.ts` | `e2e-web`, `qualite` | chaque PR (US-044, §3.7) | -| Sécurité (ASVS niveau 2, §3.9) | `pnpm test:unit`, `pnpm test:int`, `pnpm test:l0` | `apps/api/src/testing/route-matrix.test.ts`, `apps/api/src/testing/route-matrix.int.test.ts`, `packages/db/test/l0/l0-us043-authorization-matrix.test.ts`, `packages/db/test/l0/l0-us043-env-guard.test.ts` | `qualite`, `base-de-donnees`, `secrets`, `dependances` | chaque PR ; revue complète par lot | -| Données personnelles (§3.10) | `pnpm test:unit`, `pnpm test:l0` | `apps/api/src/testing/personal-data-leaks.test.ts`, `packages/db/test/l0/l0-us046-personal-data.test.ts`, `packages/db/personal-data-inventory.json` | `qualite`, `base-de-donnees` | chaque PR | -| Gabarits de notification (§3.11) | `pnpm --filter @rueda/api test:unit` | `apps/api/src/modules/ntf/internal/templates.test.ts` | `qualite` | chaque PR | -| Installation depuis zéro | `bash scripts/ci/run-install-guide.sh docs/ops/INSTALL.md` | [`docs/ops/INSTALL.md`](../ops/INSTALL.md) | `guide-installation` | chaque PR | -| Image de production, C19, retour arrière | `bash scripts/deploy/rehearsal.sh` | `scripts/deploy/` | `deploiement-local` | chaque PR | -| Restauration et rotation des secrets | `bash scripts/ops/restore-drill.sh`, `bash scripts/ops/rotation-drill.sh` | `packages/db/test/drill/` (`test:drill` de `@rueda/db`, lancé seulement par `restore-drill.sh`), `packages/db/test/portability/` (`test:portability` de `@rueda/db`, exercice de portabilité d'US-036, lancé seulement par `scripts/ops/portability-drill.sh`, appelé par `restore-drill.sh`), `scripts/ops/` | `restauration`, `rotation-secrets` | chaque PR | -| Infrastructure (OpenTofu simulé) | `tofu test` dans chaque module de `infra/opentofu/modules/` | `infra/opentofu/` | `infrastructure` | chaque PR | -| Secrets et dépendances | `node scripts/ci/audit-gate.mjs` | `docs/ops/audit-exceptions.json` | `secrets`, `dependances` | chaque PR ; historique complet nuit | -| Revues et CHANGELOG | `node scripts/ci/check-story-reviews.mjs`, `pnpm lint:changelog` | `docs/team/reviews/`, `changelog.d/` | `revues`, `changelog` | chaque PR | -| Régression de nuit et tableau de bord QA | `gh workflow run nightly.yml --ref main` | [`nightly.yml`](../../.github/workflows/nightly.yml), `scripts/qa/nightly-dashboard.mjs` | `suite-complete`, `argent-oracles-long`, `fuzz-c11`, `rapprochement`, `tableau-de-bord-qa` | chaque nuit, 03:17 UTC | +| Famille | Commande | Emplacement | Job CI | Quand | +| ----------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------- | +| Unitaires (dont contrats d'API) | `pnpm test:unit` | `*.test.ts` à côté du code, `packages/*/test/`, `*.contract.test.ts`, `scripts/{team,ci,deploy,ops,qa}/*.test.mjs` | `qualite` | chaque PR | +| Intégration (PostgreSQL réel) | `pnpm test:int` | `packages/db/test/int/`, `apps/api/src/**/*.int.test.ts`, `apps/api/test/int/` | `base-de-donnees` | chaque PR | +| Vecteurs dorés T01–T68, TJ01–TJ21, TA01–TA11 | `pnpm test:money` | `packages/money/test/golden-vectors/`, `packages/money/test/settlement/`, export `docs/specs/tools/golden_vectors.json` | `qualite`, `argent-oracles` | chaque PR | +| Oracles Python de la spécification | `python -I -X utf8 scripts/ci/check-spec-tools.py --specs docs/specs` | `docs/specs/tools/`, registre `docs/specs/tools/registry.json` | `oracles` | chaque PR | +| Moteur d'argent comparé aux oracles (10 000) | `pnpm --filter @rueda/money test:oracle` | `packages/money/test/oracle/*.oracle.ts` | `argent-oracles`, `argent-oracles-long` | chaque PR ; 100 000 cas la nuit | +| Mutation (`Money`, règlement ; seuil 80 %) | `pnpm --filter @rueda/money test:mutation` | `packages/money/stryker.config.mjs` | `argent-mutation` | PR qui touche `packages/money/` | +| Preuves L0-01 à L0-09 | `pnpm test:l0` | `packages/db/test/l0/l0-0*.test.ts` et suivants | `base-de-donnees` | chaque PR | +| Concurrence C1–C20 | `pnpm test:l0`, puis `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/` (dont `l0-02-concurrency`, `l0-us024-conversion`, `l0-06-platform-now`), `packages/db/test/support/concurrency.ts` | `base-de-donnees`, `fuzz-c11` | chaque PR | +| Fuzz C11 et oracle C12 | `pnpm --filter @rueda/db test:c11` | `packages/db/test/l0/l0-c11-fuzz.test.ts`, `packages/db/test/support/c11.ts` | `fuzz-c11` | 1 000 à chaque PR ; 10 × 1 000 nuit | +| Isolation RLS-1 à RLS-28, matrice d'accès | `pnpm test:l0` (et `pnpm test:unit` pour la matrice des routes) | `packages/db/test/l0/l0-rls-*.test.ts`, `l0-05-roles`, `l0-pay-legs-rls`, `l0-us062-host-money`, `l0-us043-authorization-matrix`, `apps/api/src/testing/route-matrix*.ts` | `base-de-donnees`, `qualite` | chaque PR | +| Migrations montée / retour, RLS-19 | `pnpm test:l0` | `packages/db/test/l0/l0-us046-migrations.test.ts` (base `_mig`) | `base-de-donnees` | chaque PR | +| e2e web mobile et PWA | `pnpm test:e2e` | `apps/web/e2e/*.spec.ts`, `apps/web/playwright.config.ts` | `e2e-web` | chaque PR | +| Parcours doré de règlement et rapprochement de l'argent | `pnpm --filter @rueda/api test:reconciliation` | `apps/api/test/int/reconciliation.int.test.ts`, `apps/api/src/modules/fin/internal/money-reconciliation.ts` (et son `.test.ts`) | `base-de-donnees`, `rapprochement` | chaque PR (dans `pnpm test:int`) ; chaque nuit | +| Parcours dorés e2e PA / USD et PY / PYG, « réservation » (US-221) | `pnpm test:int` ; `pnpm test:e2e` (projet `mobile-360`) | `apps/api/test/int/parcours-dores-reservation.int.test.ts` (segments A, B, C, §3.6), fixture `packages/db/test-migrations/9937_test_us221_golden_fixtures.sql`, `apps/web/e2e/parcours-dore.spec.ts` | `base-de-donnees`, `e2e-web` | chaque PR ; chaque nuit (dans `pnpm test:int`) | +| Accessibilité | `pnpm test:e2e` et `pnpm --filter @rueda/design-tokens test:unit` | `apps/web/e2e/screens.spec.ts`, `apps/web/e2e/console.spec.ts`, `apps/web/e2e/axe.ts`, `packages/design-tokens/test/contrast.test.ts`, `packages/design-tokens/test/wcag.test.ts` | `e2e-web`, `qualite` | chaque PR (US-044, §3.7) | +| Sécurité (ASVS niveau 2, §3.9) | `pnpm test:unit`, `pnpm test:int`, `pnpm test:l0` | `apps/api/src/testing/route-matrix.test.ts`, `apps/api/src/testing/route-matrix.int.test.ts`, `packages/db/test/l0/l0-us043-authorization-matrix.test.ts`, `packages/db/test/l0/l0-us043-env-guard.test.ts` | `qualite`, `base-de-donnees`, `secrets`, `dependances` | chaque PR ; revue complète par lot | +| Données personnelles (§3.10) | `pnpm test:unit`, `pnpm test:l0` | `apps/api/src/testing/personal-data-leaks.test.ts`, `packages/db/test/l0/l0-us046-personal-data.test.ts`, `packages/db/personal-data-inventory.json` | `qualite`, `base-de-donnees` | chaque PR | +| Gabarits de notification (§3.11) | `pnpm --filter @rueda/api test:unit` | `apps/api/src/modules/ntf/internal/templates.test.ts` | `qualite` | chaque PR | +| Installation depuis zéro | `bash scripts/ci/run-install-guide.sh docs/ops/INSTALL.md` | [`docs/ops/INSTALL.md`](../ops/INSTALL.md) | `guide-installation` | chaque PR | +| Image de production, C19, retour arrière | `bash scripts/deploy/rehearsal.sh` | `scripts/deploy/` | `deploiement-local` | chaque PR | +| Restauration et rotation des secrets | `bash scripts/ops/restore-drill.sh`, `bash scripts/ops/rotation-drill.sh` | `packages/db/test/drill/` (`test:drill` de `@rueda/db`, lancé seulement par `restore-drill.sh`), `packages/db/test/portability/` (`test:portability` de `@rueda/db`, exercice de portabilité d'US-036, lancé seulement par `scripts/ops/portability-drill.sh`, appelé par `restore-drill.sh`), `scripts/ops/` | `restauration`, `rotation-secrets` | chaque PR | +| Infrastructure (OpenTofu simulé) | `tofu test` dans chaque module de `infra/opentofu/modules/` | `infra/opentofu/` | `infrastructure` | chaque PR | +| Secrets et dépendances | `node scripts/ci/audit-gate.mjs` | `docs/ops/audit-exceptions.json` | `secrets`, `dependances` | chaque PR ; historique complet nuit | +| Revues et CHANGELOG | `node scripts/ci/check-story-reviews.mjs`, `pnpm lint:changelog` | `docs/team/reviews/`, `changelog.d/` | `revues`, `changelog` | chaque PR | +| Régression de nuit et tableau de bord QA | `gh workflow run nightly.yml --ref main` | [`nightly.yml`](../../.github/workflows/nightly.yml), `scripts/qa/nightly-dashboard.mjs` | `suite-complete`, `argent-oracles-long`, `fuzz-c11`, `rapprochement`, `tableau-de-bord-qa` | chaque nuit, 03:17 UTC | ## 3. Détail par famille diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md new file mode 100644 index 00000000..3339f74a --- /dev/null +++ b/docs/team/handoffs/US-221.md @@ -0,0 +1,50 @@ +# Passation US-221 — Parcours dorés « réservation » PA et PY + +Agent QA, claude-opus-5-5. Branche `story/US-221-parcours-dores`, partie d'`origin/main` (4b07e4a0, après US-227 #237), worktree `../wt/US-221`. PR en brouillon **#243**. Aucune migration, aucun ADR, aucun texte visible nouveau. Fixture de test **9937** (9938 à 9945 : 9939 pris par US-514, 9945 par US-701 sur leurs branches). + +Revues exigées (`node scripts/ci/check-story-reviews.mjs --branch story/US-221-parcours-dores --base origin/main --root . --author-model claude-opus-5-5`) : **architecture, argent, code, qa, securite** (argent, RLS, rôles et concurrence sur un autre modèle que l'auteur). + +## Ce qui est livré + +`apps/api/test/int/parcours-dores-reservation.int.test.ts` (dans `pnpm test:int`, job `base de données`) : PostgreSQL réel, rôles de production (`connectAs` : assertion L0-05 en tête de chaque test), dans chaque pays configuré, USD et PYG sans décimale. Les montants attendus viennent de l'export des oracles (`golden_vectors.json`) ; le devis du checkout (segment A) est dérivé dans l'en-tête du test depuis 08 et la configuration du dépôt, sa jambe HOST en PYG est celle de l'oracle TJ09c. + +| Segment | Transaction | Étapes enchaînées (vrais services ou vraies commandes) | Montants affirmés | +| ------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| A | annulée (`app_api`) ; interrupteurs ouverts par la procédure à deux personnes (tête d'audit puis verrou, comme `golive.ts`) | inscription, conducteur vérifié (fixture 9967), session ; recherche publique (`PgSearchStore`, ville propre au test, fixture 9937) ; fiche (prix, conditions, carte = fiche) ; devis figé (`freezeQuote` de PRC, `PgQuoteStore.freeze`) ; checkout (`PgCheckoutStore`, hold ACTIVE) ; **capacité bloquante inconnue ⇒ `HOST_PAYOUT_RAIL_UNAVAILABLE` avant T1, aucun ordre** ; `CheckoutPaymentService.pay` : T1, ordre au PSP FAKE, T2, second clic sans second ordre ; interrupteurs refermés après | lignes et taxes de ligne du devis, total, jambes du devis figé = jambes de l'ordre au PSP (montant explicite par jambe), Σ jambes = total | +| B | validée (`app_api`, `app_worker`), horloge virtuelle 2052 | voyageur inscrit (vraie commande), hold posé par `booking_cmd_place_hold`, devis engagé posé par la fixture 9969 aux jambes de la capture TJ01 / TJ08a ; T1 / T2 par le vrai service ; **FAKE hostile** : succès de réponse d'API non signé ⇒ `NOT_PROVEN` ; webhook signé ⇒ preuve ; conversion ⇒ trip BOOKED, version de prix n° 1, `booking.trip.booked` une fois ; rejeux ⇒ `DUPLICATE`, `REPLAY` ; parties de la notification (voyageur, titulaire) ; « Mis viajes » (trip à venir) ; interrupteurs fermés | ordre au PSP = jambes de l'oracle ; opération = total | +| C | validée, 2052 | trip capturé aux jambes TJ01 / TJ08a (vraie commande, webhook signé, report sur les soldes) ; demande de la console (OPS, session élevée) ; vrai `TripCancellationProcessor` ; **PSP en panne ⇒ WAITING**, puis vrai `RefundScheduler` ⇒ SENT, preuve signée ⇒ CONFIRMED, REPORTED ; S10 du voyageur et de l'hôte ; `insurer_ledger` ; reçus de l'hôte et du voyageur ; faits de l'invariant par jambe ; rapprochement FIN et oracle C12 sur toute la base | variation v1 = TJ02b / TJ08b ; REFUND = −variation (jambe par jambe, au PSP) ; soldes capturés = TJ01 / TJ08a, remboursés = −variation, retenus = TJ02a (USD) ; registre +prime puis −prime ; HOST retenue = `hostFromGuest` de T03 / T27 ; remboursement du voyageur ; 0 écart | + +`apps/web/e2e/parcours-dore.spec.ts` (projet `mobile-360` seul, espagnol, un test, aucune capture) : S01 → résultats → S03 → S05 → hold → « Pagar 128,40 » (TA01) → page du PSP interceptée → webhook signé du double → S06 confirmé, textes lus dans le catalogue officiel. + +Docs : `docs/qa/STRATEGIE_TESTS.md` (§2, §3.6, tableau des écarts), `packages/db/README.md` (fixture 9937), `changelog.d/US-221-parcours-dores.md`. + +## Défauts trouvés (rapportés à l'orchestrateur ; tests `it.fails`) + +- **D1 — la capture prouvée d'un hold de checkout n'est jamais portée sur les soldes par jambe du trip réservé.** `core.booking_convert_payment` (0126) crée le trip sans rattacher l'opération de capture (`payment_operation.trip_id` reste NULL) ; `core.settlement_cmd_apply_leg_movement` (dernière version 0123) refuse une opération sans `trip_id` (`leg_movement_unsupported`) ; aucun code de production n'appelle d'ailleurs ce report pour une capture (seul `RefundScheduler` l'appelle, pour un remboursement ; le consommateur `payment_command` n'est pas déclaré, `worker-tasks.ts`). Preuve : run 44379275642, job « base de données », ligne `US-221 D1 (PYG) : report de la capture = 55000:leg_movement_unsupported`. Conséquences pour un trip réservé par le vrai checkout : `trip_leg_balance` vide (08 E7 règle 2, 17 §2.9), aucune écriture `COLLECTION` au registre de l'assureur (déclencheur sur `settlement_leg_movement`, 0143), reçu de l'hôte et relevé sans source de capture. Test : « D1 (défaut) » du segment B. Correctif attendu (story argent, revue autre modèle) : rattacher la capture au trip à la conversion et la reporter dans la même transaction, ou ouvrir le report aux opérations du hold converti. +- **D2 — le rapprochement nocturne ne voit pas ce trip** (conséquence de D1) : `core.finance_trip_leg_facts` (0137) ne retient que les trips qui ont un solde par jambe ou un règlement ; un encaissement prouvé jamais porté passe donc sans écart. Test : « D2 (défaut) » du segment B. Correctif : faire partir les faits des encaissements prouvés (`payment_operation` SUCCEEDED du hold converti), pas seulement des soldes. + +## Trous (étapes non enchaînées ; le parcours s'arrête proprement avant) + +1. **Contrat généré et signé, constancia** du trip réservé : la génération rejoue le devis figé ; ni la fixture 9969 (devis à documents vides) ni `rls_insert_trip` n'en portent un rejouable. Couverts isolément par `l0-us211-*` et `l0-us212-*`. Débloqué par D1 corrigé et un banc qui valide le devis réel (interrupteurs commités interdits : voir N-195). +2. **Annulation du trip converti par le vrai chemin** (devis figé rejoué par `TripCancellationProcessor` sans `tripOf`) : bloquée par D1 et par la même couture ; le segment C part d'un trip capturé sur le trip, son moteur reçoit le trip du vecteur. +3. **e2e sans décimale** : le double (`stub-api.mjs`) ne sert la réservation que dans son marché XTS ; la variante PYG est prouvée par le test d'intégration. +4. Envoi réel des notifications : aucun canal avant le lot C (`ntf_sender` en `CHANNEL_UNAVAILABLE`) ; seules les parties sont affirmées. Remise, retour et versement : lot 3 (US-312, US-539). + +## Constats sur le banc + +- **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : capacités et PSP FAKE posés pour FAKE et pour le fournisseur que T1 retiendra à cet instant (run 44380398003 : un compte de passage est resté ouvert plus de 30 s). À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). +- Coutures assumées : A → B (gel et checkout réels exigent les interrupteurs, ouverts seulement en transaction annulée) ; B → C (D1). + +## Reste + +1. Revues architecture, argent, code, qa, sécurité. +2. Orchestrateur : verser D1 et D2 au BOARD (story argent) ; au correctif de D1, retirer `it.fails` de D1 et D2 et prolonger le segment B (report, annulation par le vrai chemin, contrat, constancia). +3. Nuit : le test tourne dans `pnpm test:int` ; l'ajouter à `nightly.yml` (`FAMILIES` d'ADR-087) touche `.github/` (revue sécurité au SHA fusionné) : suite à confier. + +## Prochaine commande exacte + +```bash +export PATH="/c/Program Files/nodejs:/c/Program Files/GitHub CLI:$PATH" +pnpm install --frozen-lockfile && pnpm lint && pnpm typecheck && pnpm test:unit +# PostgreSQL réel : CI seulement (job « base de données ») ; e2e : job « e2e web » +``` From f522c8760ccf153f2d7f071aa0a17f844127f78f Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:57:13 -0300 Subject: [PATCH 04/12] =?UTF-8?q?test(US-221):=20diagnostic=20du=20refus?= =?UTF-8?q?=20de=20T1=20au=20segment=20A=20(comptes=20actifs=20et=20capaci?= =?UTF-8?q?t=C3=A9s=20manquantes,=20sans=20identifiant)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Run 44384951568 : T1 du segment A refusé (HOST_PAYOUT_RAIL_UNAVAILABLE) dans les deux pays après le retrait de la capacité inconnue ; le refus rendra désormais les comptes ACTIVE du pays et leurs capacités bloquantes manquantes, lus avant T1. Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 37 +++++++++++++++++-- 1 file changed, 34 insertions(+), 3 deletions(-) diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index 4972be1b..c3f1da00 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -397,15 +397,44 @@ const paymentService = ( ); /** « Pagar » par le vrai service ; un refus est rendu avec son code (diagnostic de la CI). */ -async function payOrExplain(service: CheckoutPaymentService, hash: Buffer, holdId: string) { +async function payOrExplain( + service: CheckoutPaymentService, + hash: Buffer, + holdId: string, + explain: () => Promise = () => Promise.resolve(''), +) { try { return await service.pay(hash, holdId, { method: 'CARD' }); } catch (error) { const code = (error as { code?: unknown }).code; - throw new Error(`paiement refusé : ${String(code)}`, { cause: error }); + throw new Error(`paiement refusé : ${String(code)} ${await explain()}`, { cause: error }); } } +/** + * Diagnostic d'un refus de T1 (aucun identifiant ni montant) : comptes ACTIVE du pays (fournisseur, + * environnement, mode d'encaissement, lus sous app_worker) et capacités bloquantes manquantes de + * chacun, lues dans la transaction de l'appelant (`payment_missing_blocking_capabilities`). + */ +async function accountsDiagnostic(tx: pg.ClientBase, country: string): Promise { + const worker = await open('app_worker'); + const { rows } = await worker.query<{ provider: string; environment: string; mode: string }>( + `SELECT provider, environment, collection_mode AS mode FROM core.payment_psp_account + WHERE country_code = $1 AND status = 'ACTIVE' + ORDER BY (environment = 'LIVE') DESC, provider, id`, + [country], + ); + const out: string[] = []; + for (const r of rows) { + const m = await tx.query<{ missing: string[] }>( + 'SELECT core.payment_missing_blocking_capabilities($1, $2, $3) AS missing', + [r.provider, country, r.mode], + ); + out.push(`${r.provider}/${r.environment}/${r.mode} manque=[${m.rows[0]?.missing.join(',')}]`); + } + return `comptes : ${out.join(' ; ')}`; +} + /** * T1 (`booking_cmd_checkout_pay`) retient le premier compte marchand ACTIVE du pays (fournisseur, * puis identifiant). Les scènes de `concurrence-webhook.int.test.ts` VALIDENT, le temps d'un test, @@ -650,7 +679,9 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ }); // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 - const started = await payOrExplain(pay, hash, holdId); + // diagnostic lu AVANT T1 (un refus de la base annule la transaction) + const diagnostic = await accountsDiagnostic(tx, c.country); + const started = await payOrExplain(pay, hash, holdId, () => Promise.resolve(diagnostic)); expect(started.created).toBe(true); expect(started.payment).toMatchObject({ state: 'VERIFYING', From c23dd761bd02f53a7d80c77c93dfe074acf77a13 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:15:23 -0300 Subject: [PATCH 05/12] =?UTF-8?q?test(US-221):=20T1=20du=20segment=20A=20s?= =?UTF-8?q?uit=20un=20compte=20de=20passage=20ouvert=20apr=C3=A8s=20la=20l?= =?UTF-8?q?ecture=20des=20fournisseurs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Runs 44379275642 et 44384951568 : T1 du segment A refusé (HOST_PAYOUT_RAIL_UNAVAILABLE) quand une scène de concurrence-webhook ouvre un compte ACTIVE BAC / EBANX du pays, retenu avant FAKE par booking_cmd_checkout_pay ; run 44385856048 vert sans course. Chaque essai est isolé par un point de sauvegarde ; un refus relit les fournisseurs et valide seulement un fournisseur NOUVEAU (3 essais au plus) ; un refus qui persiste sur les mêmes comptes échoue avec son diagnostic (aucune assertion affaiblie). Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 29 +++++++++++++++++-- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index c3f1da00..f67ba931 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -679,9 +679,32 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ }); // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 - // diagnostic lu AVANT T1 (un refus de la base annule la transaction) - const diagnostic = await accountsDiagnostic(tx, c.country); - const started = await payOrExplain(pay, hash, holdId, () => Promise.resolve(diagnostic)); + // Compte de passage d'un autre fichier (constat C-1) : T1 peut viser un compte ACTIVE + // ouvert APRÈS la lecture des fournisseurs. Chaque essai est isolé par un point de + // sauvegarde ; un refus relit les fournisseurs, valide le nouveau et rejoue (3 essais au + // plus). Un refus qui persiste sur les mêmes comptes échoue avec son diagnostic. + let started: Awaited> | undefined; + let seen = providers; + for (let attempt = 1; started === undefined; attempt++) { + await tx.query('SAVEPOINT us221_t1'); + try { + started = await paymentService(tx, psp, seen).pay(hash, holdId, { method: 'CARD' }); + await tx.query('RELEASE SAVEPOINT us221_t1'); + } catch (error) { + await tx.query('ROLLBACK TO SAVEPOINT us221_t1'); + const code = String((error as { code?: unknown }).code); + const now = await checkoutProviders(c.country); + const fresh = now.filter((x) => !seen.includes(x)); + if (attempt >= 3 || fresh.length === 0) { + const diagnostic = await accountsDiagnostic(tx, c.country); + throw new Error(`paiement refusé : ${code} (essai ${attempt}) ${diagnostic}`, { + cause: error, + }); + } + seen = [...seen, ...fresh]; + await capabilities(tx, c.country, at(-3), undefined, 'VALIDATED_SANDBOX', fresh); + } + } expect(started.created).toBe(true); expect(started.payment).toMatchObject({ state: 'VERIFYING', From 02b5910b4034018082d70f90f7a80056a9d79a85 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:42:47 -0300 Subject: [PATCH 06/12] =?UTF-8?q?docs(US-221):=20passation=20=E2=80=94=20?= =?UTF-8?q?=C3=A9tat=20de=20la=20CI=20(run=2044389110795=20vert)=20et=20co?= =?UTF-8?q?nstat=20C-1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- docs/team/handoffs/US-221.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md index 3339f74a..ceba6d4e 100644 --- a/docs/team/handoffs/US-221.md +++ b/docs/team/handoffs/US-221.md @@ -32,9 +32,13 @@ Docs : `docs/qa/STRATEGIE_TESTS.md` (§2, §3.6, tableau des écarts), `packages ## Constats sur le banc -- **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : capacités et PSP FAKE posés pour FAKE et pour le fournisseur que T1 retiendra à cet instant (run 44380398003 : un compte de passage est resté ouvert plus de 30 s). À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). +- **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : capacités et PSP FAKE posés pour FAKE et pour le fournisseur que T1 retiendra ; chaque essai de T1 dans un point de sauvegarde, un refus relit les fournisseurs et ne valide qu'un fournisseur NOUVEAU (3 essais), sinon échec avec diagnostic (runs 44380398003 et 44384951568 rouges par cette course, 44385856048 vert sans course). À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). - Coutures assumées : A → B (gel et checkout réels exigent les interrupteurs, ouverts seulement en transaction annulée) ; B → C (D1). +## État de la CI + +Run **44389110795** vert au SHA c23dd761 (merge d'`origin/main` après #240 / #241 inclus) : test d'intégration 24 / 24 (D1 et D2 en échec attendu, journal `US-221 D1 (USD|PYG) : report de la capture = 55000:leg_movement_unsupported`), e2e `parcours-dore.spec.ts` vert en `mobile-360`. + ## Reste 1. Revues architecture, argent, code, qa, sécurité. From 11125c1468efe975a2fb5170a70046d509a221eb Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:46:45 -0300 Subject: [PATCH 07/12] =?UTF-8?q?docs(US-221):=20cinq=20revues=20ind=C3=A9?= =?UTF-8?q?pendantes=20au=20SHA=2002b5910b=20(architecture,=20argent,=20co?= =?UTF-8?q?de,=20qa,=20securite)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Contenu identique aux commits d16f1adc..f660ac23 de la branche story/US-221-parcours-dores, refait avec le pied de relecteur (revue-) : les pieds d'origine faisaient compter le relecteur comme auteur. Aucune réécriture d'historique publié. Agent-Role: revue-argent Agent-Model: claude-sonnet-5-5 Co-Authored-By: Claude Opus 5.5 --- .../reviews/US-221/architecture-2026-11-18.md | 17 +++++++++++++++++ docs/team/reviews/US-221/argent-2026-11-18.md | 17 +++++++++++++++++ docs/team/reviews/US-221/code-2026-11-18.md | 16 ++++++++++++++++ docs/team/reviews/US-221/qa-2026-11-18.md | 16 ++++++++++++++++ docs/team/reviews/US-221/securite-2026-11-18.md | 17 +++++++++++++++++ 5 files changed, 83 insertions(+) create mode 100644 docs/team/reviews/US-221/architecture-2026-11-18.md create mode 100644 docs/team/reviews/US-221/argent-2026-11-18.md create mode 100644 docs/team/reviews/US-221/code-2026-11-18.md create mode 100644 docs/team/reviews/US-221/qa-2026-11-18.md create mode 100644 docs/team/reviews/US-221/securite-2026-11-18.md diff --git a/docs/team/reviews/US-221/architecture-2026-11-18.md b/docs/team/reviews/US-221/architecture-2026-11-18.md new file mode 100644 index 00000000..ea6e0cbb --- /dev/null +++ b/docs/team/reviews/US-221/architecture-2026-11-18.md @@ -0,0 +1,17 @@ +# Revue architecture — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 243) — 2026-11-18 + +Relecteur : revue-architecture / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : f91ef0fc..02b5910b + +Contexte : diff `origin/main...02b5910b` relu, passation US-221, 19 US-221, rapports US-227 pour le format ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Périmètre** : aucune migration, aucun ADR ; un test d'intégration (`apps/api/test/int/parcours-dores-reservation.int.test.ts`), un test e2e, une fixture de test 9937 (schéma `test_fixture`, hors production), docs. Importations par les `index.ts` publics (avl, cat, cfg, fin, pay, prc, stl, bus) : aucune pénétration d'un module. Le numéro 9937 n'existe pas sur `origin/main` : pas de doublon. | +| 2 | INFO | **Couches** : le test enchaîne les vrais services et les vraies commandes (écriture de réservation uniquement par commandes) ; le seul double est le PSP `FAKE`, jamais actif en production. Les coutures assumées (A vers B, B vers C) sont écrites dans la passation et la stratégie de tests, non masquées. | +| 3 | INFO | **Deux pays de premier rang** : `countryCases` et table `CHECKOUT` clés par exposant de devise (2 et 0), pays pris de la configuration ; aucune constante propre à un pays. Parcours USD et PYG sans décimale symétriques. | +| 4 | INFO | **Défauts D1 et D2** : correctement situés (couture entre `booking_convert_payment` 0126 et `settlement_cmd_apply_leg_movement` 0123, puis faits du rapprochement 0137) ; les `it.fails` les décrivent et orientent le correctif vers une story argent séparée. Pas un motif de refus. | +| 5 | INFO | **e2e** : spec ajoutée au projet `mobile-360` seul (`playwright.config.ts` : constante `GOLDEN`, seuils et références inchangés) ; le trou du double en PYG est documenté. | +| 6 | MINEUR | **Suivi** : le test n'est pas encore dans la famille de nuit (`nightly.yml` touche `.github/`, revue sécurité au SHA fusionné) ; listé en « Reste » de la passation. Aucun changement demandé. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/argent-2026-11-18.md b/docs/team/reviews/US-221/argent-2026-11-18.md new file mode 100644 index 00000000..df6513c1 --- /dev/null +++ b/docs/team/reviews/US-221/argent-2026-11-18.md @@ -0,0 +1,17 @@ +# Revue argent — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 243) — 2026-11-18 + +Relecteur : revue-argent / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : f91ef0fc..02b5910b + +Contexte : diff `origin/main...02b5910b` relu, passation US-221, 19 US-221, rapports US-227 pour le format ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Montants hors du code testé** : segments B et C tirés de `golden_vectors.json` par `legVector` / `settlementVector` (TJ01, TJ08a, TJ02a, TJ02b, TJ08b, T03, T27, TJ09c). Segment A dérivé en en-tête depuis 08 : USD 120,00 + 18,00 + 30,00 = 168,00, taxes 8,40 + 1,26, total 177,66 ; jambes 90,00 + 21,00 + 0 + 66,66 = 177,66. PYG 1 000 002 + 150 000 + 250 002 + 115 000 = 1 515 004 ; jambes 750 001 (TJ09c) + 175 001 + 0 + 590 002 = 1 515 004. Sommes recalculées ici : exactes. | +| 2 | INFO | **Jambes explicites** : l'ordre au PSP est comparé jambe par jambe, Σ jambes = total, ordre REFUND = −variation par jambe ; aucun prorata. Capacité bloquante inconnue : `HOST_PAYOUT_RAIL_UNAVAILABLE` avant T1, `psp.orders` vide. Second clic : pas de second ordre (clé d'idempotence `hold:…:CAPTURE:a1`). | +| 3 | INFO | **FAKE hostile** : succès de réponse d'API non signé ⇒ `NOT_PROVEN`, aucun trip ; webhook signé ⇒ preuve ; rejeux ⇒ `DUPLICATE` / `REPLAY`. PSP en panne ⇒ `WAITING`, puis `SENT`, `CONFIRMED`, `REPORTED`. Rapprochement FIN et oracle C12 : 0 écart. | +| 4 | INFO | **Interrupteurs** (17 §0.1) : `p2p_private_hosts_enabled` et `insurer_contract_active` ouverts seulement par `config_cmd_request_go_live_switch` puis `config_cmd_approve_go_live_switch` (deux personnes, sessions élevées, tête d'audit avant verrou) dans une transaction ANNULÉE ; `funds_holding_enabled` et `payouts_enabled` jamais écrits ; relecture `ALL_CLOSED` en fin de segment A et au segment B. | +| 5 | INFO | **D1** (capture non portée sur les soldes par jambe, donc pas de ligne `COLLECTION` au registre de l'assureur) : défaut produit réel d'argent, déjà pris en charge par une story séparée. Le test échoue pour la bonne raison (`leg_movement_unsupported`, visible au journal du run) et n'affaiblit aucune assertion : `APPLIED` et soldes = capture de l'oracle sont intégraux. D2 idem. Non bloquant. | +| 6 | INFO | **Course C-1** : points de sauvegarde, 3 essais, relecture des fournisseurs ; seul un fournisseur NOUVEAU est validé (comme FAKE), sur refus ; un refus persistant sur les mêmes comptes échoue avec diagnostic. Aucun contrôle contourné : la capacité inconnue reste refusée par la commande (testé), la validation est une écriture de banc dans une transaction annulée. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/code-2026-11-18.md b/docs/team/reviews/US-221/code-2026-11-18.md new file mode 100644 index 00000000..38b14f40 --- /dev/null +++ b/docs/team/reviews/US-221/code-2026-11-18.md @@ -0,0 +1,16 @@ +# Revue code — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 243) — 2026-11-18 + +Relecteur : revue-code / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : f91ef0fc..02b5910b + +Contexte : diff `origin/main...02b5910b` relu, passation US-221, 19 US-221, rapports US-227 pour le format ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Lecture** du test d'intégration, du test e2e, de la fixture 9937 et de `playwright.config.ts`. Typage strict, `bigint` pour les unités mineures, aucun arrondi réimplémenté (montants des oracles ou dérivés documentés). Clients relâchés par `releaseClient` en `afterEach`. | +| 2 | INFO | **Fixture 9937** : `SECURITY DEFINER`, `search_path = pg_catalog, pg_temp`, objets qualifiés, aucun SQL dynamique, `REVOKE ALL FROM PUBLIC`, `EXECUTE` à `app_api` seul, exigence d'une ligne exacte (`GET DIAGNOSTICS`), retour arrière écrit. Aucun `now()`. | +| 3 | INFO | **Boucle de reprise de T1** : `SAVEPOINT` / `RELEASE` / `ROLLBACK TO` équilibrés, `fresh` = fournisseurs non vus, borne `attempt >= 3`, `cause` conservée. Pas de boucle infinie ni d'erreur avalée. | +| 4 | INFO | **`it.fails`** : exactement deux (D1, D2), chacun avec commentaire, journal de preuve et attendu intégral ; aucune assertion affaiblie ou retirée. Ils passent au rouge dès la correction du défaut, ce qui force leur retrait (passation, « Reste » 2). | +| 5 | MINEUR | **Taille** : un fichier de plus de 1 300 lignes ; lisible grâce aux segments A, B, C et à l'en-tête, acceptable pour un banc de parcours. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/qa-2026-11-18.md b/docs/team/reviews/US-221/qa-2026-11-18.md new file mode 100644 index 00000000..7700005d --- /dev/null +++ b/docs/team/reviews/US-221/qa-2026-11-18.md @@ -0,0 +1,16 @@ +# Revue qa — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 243) — 2026-11-18 + +Relecteur : revue-qa / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : f91ef0fc..02b5910b + +Contexte : diff `origin/main...02b5910b` relu, passation US-221, 19 US-221, rapports US-227 pour le format ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Critères d'US-221 (19)** : parcours enchaînés recherche, fiche, devis, checkout, paiement par jambes, preuve, trip BOOKED, notifications, « Mis viajes », annulation, remboursement par jambe, registre, reçus, rapprochement, dans chaque pays configuré (USD, PYG sans décimale). Trous (contrat signé, constancia, annulation par le vrai chemin, e2e sans décimale, canaux de notification) déclarés et rattachés à D1 ou au lot C, non cachés. | +| 2 | INFO | **L0-05 et rôles de production** : `connectAs` en tête de chaque test, y compris celui sans requête ; `app_api` et `app_worker`, jamais `migrator`. Transactions annulées, interrupteurs relus fermés. | +| 3 | INFO | **Preuves** : run 44389110795 vert au SHA c23dd761 d'après la passation (24 sur 24, D1 et D2 en échec attendu, e2e `mobile-360` vert) ; run du SHA de tête 02b5910b en cours à la relecture (aucune base démarrée ici). Instabilité C-1 vue sur trois runs puis traitée ; le vert au SHA de tête est la preuve attendue avant fusion. | +| 4 | INFO | **e2e** : un test, espagnol, 360 px ; textes lus dans le catalogue `@rueda/i18n`, total TA01 128,40 rendu par l'API, jamais recalculé ; aucune capture, références et seuils inchangés ; PSP intercepté (aucun réseau externe). | +| 5 | MINEUR | **Documentation** : `docs/qa/STRATEGIE_TESTS.md` §2 et §3.6 (tableau reformaté), README de `packages/db`, `changelog.d/US-221-parcours-dores.md` présents. Test absent de la famille de nuit (suite déclarée). | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/securite-2026-11-18.md b/docs/team/reviews/US-221/securite-2026-11-18.md new file mode 100644 index 00000000..b89d507a --- /dev/null +++ b/docs/team/reviews/US-221/securite-2026-11-18.md @@ -0,0 +1,17 @@ +# Revue securite — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 243) — 2026-11-18 + +Relecteur : revue-securite / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : f91ef0fc..02b5910b + +Contexte : diff `origin/main...02b5910b` relu, passation US-221, 19 US-221, rapports US-227 pour le format ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Rôles et RLS** : tout passe sous `app_api` / `app_worker`, L0-05 en tête ; aucun `migrator` ni superutilisateur. Fixture 9937 : `SECURITY DEFINER`, `search_path` figé, aucun SQL dynamique, `REVOKE ALL FROM PUBLIC`, `EXECUTE` à `app_api` seul, appelée dans une transaction annulée ; seul le harnais l'applique, à la base de test jetable. | +| 2 | INFO | **Interrupteurs** (17 §0.1) : ouverts uniquement par la commande à deux personnes (ADMIN demande, SUPERADMIN approuve, auto-approbation exclue, sessions élevées), dans une transaction annulée, jamais commités ; relus fermés. Aucune écriture directe de configuration. `funds_holding_enabled` et `payouts_enabled` intacts. | +| 3 | INFO | **Webhooks et FAKE** : succès d'API non signé jamais accepté comme preuve (`NOT_PROVEN`) ; webhook signé requis ; rejeu ⇒ `DUPLICATE` / `REPLAY`. `FAKE` hors production ; l'URL interceptée en e2e est en `.invalid`. | +| 4 | INFO | **Secrets et données personnelles** : aucun secret réel (le condensat argon2id `PHC` est factice, de banc) ; recherche des motifs secret, password, token, Bearer : aucun résultat de valeur. Notifications : identifiants seulement ; reçus et S10 sans donnée de l'autre partie. | +| 5 | INFO | **Course C-1** : le correctif ne contourne pas la capacité bloquante (refus conservé et testé), ne valide qu'un fournisseur nouveau, en transaction annulée ; aucune élévation de droit. Aucun fichier de `.github/`, `scripts/ci/`, `scripts/team/` ni `review-requirements.json` modifié : pas d'exigence de revue au SHA fusionné. | +| 6 | INFO | **D1** n'est pas une faille de sécurité mais un défaut d'argent ; hors de cette PR. | + +Verdict : APPROUVÉ From e33c943a25757f73bb6045ead2516db550f3b1d0 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:49:00 -0300 Subject: [PATCH 08/12] =?UTF-8?q?test(US-221):=20essais=20de=20T1=20du=20s?= =?UTF-8?q?egment=20A=20retenus=20seulement=20sur=20le=20compte=20FAKE=20e?= =?UTF-8?q?n=20t=C3=AAte?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Run 44393901538 (« base de données ») : le refus attendu du segment A a rendu PAYMENT_UNAVAILABLE au lieu de HOST_PAYOUT_RAIL_UNAVAILABLE : T1 a visé un compte ACTIVE de passage (BAC / EBANX) ouvert par concurrence-webhook, retenu avant FAKE par booking_cmd_checkout_pay (constat C-1, course entre fichiers, pas un défaut du produit). Chaque essai (refus attendu, paiement) n'est retenu que si FAKE est en tête des comptes actifs juste avant et juste après lui ; sinon il est annulé par son point de sauvegarde et rejoué (60 s au plus). Les assertions sont inchangées ; la relecture et la validation de fournisseurs de passage sont retirées. Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 461 +++++++++--------- docs/team/handoffs/US-221.md | 2 +- 2 files changed, 245 insertions(+), 218 deletions(-) diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index f67ba931..73a38f6d 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -456,20 +456,52 @@ async function soleFakeAccount(country: string): Promise { throw new Error('un compte marchand actif d’un autre fournisseur reste ouvert dans le pays'); } -/** - * Fournisseurs que T1 peut retenir dans le pays, À CET INSTANT : FAKE et le premier compte ACTIVE - * dans l'ordre de `booking_cmd_checkout_pay` (environnement LIVE d'abord, fournisseur, - * identifiant). Segment A seulement (transaction annulée) : capacités et PSP FAKE posés pour chacun, - * pour que le parcours ne dépende pas d'un compte de passage d'un autre fichier (constat C-1). - */ -async function checkoutProviders(country: string): Promise { +/** Fournisseur du compte que T1 retiendrait À CET INSTANT (ordre de `booking_cmd_checkout_pay`). */ +async function firstProvider(country: string): Promise { const worker = await open('app_worker'); const { rows } = await worker.query<{ provider: string }>( `SELECT provider FROM core.payment_psp_account WHERE country_code = $1 AND status = 'ACTIVE' ORDER BY (environment = 'LIVE') DESC, provider, id LIMIT 1`, [country], ); - return [...new Set(['FAKE', ...rows.map((r) => r.provider)])]; + return rows[0]?.provider ?? null; +} + +/** + * Essai de T1 sur le compte FAKE du pays (constat C-1) : les scènes de + * `concurrence-webhook.int.test.ts` ouvrent, le temps d'un test, un compte ACTIVE BAC ou EBANX du + * même pays, retenu AVANT FAKE par `booking_cmd_checkout_pay`. Un essai n'est retenu (réussite OU + * refus) que si FAKE est en tête juste avant ET juste après lui ; sinon il est annulé par son point + * de sauvegarde et rejoué dès que FAKE est de nouveau en tête (au plus 60 s). Transaction ANNULÉE + * du segment A seulement ; le résultat retenu est affirmé tel quel par l'appelant. + */ +async function onFakeAccount( + tx: pg.ClientBase, + country: string, + attempt: () => Promise, +): Promise<{ ok: true; value: T } | { ok: false; error: unknown }> { + for (let i = 0; i < 240; i++) { + if ((await firstProvider(country)) === 'FAKE') { + await tx.query('SAVEPOINT us221_fake'); + let out: { ok: true; value: T } | { ok: false; error: unknown }; + try { + out = { ok: true, value: await attempt() }; + } catch (error) { + out = { ok: false, error }; + } + if ((await firstProvider(country)) === 'FAKE') { + await tx.query( + out.ok ? 'RELEASE SAVEPOINT us221_fake' : 'ROLLBACK TO SAVEPOINT us221_fake', + ); + return out; + } + await tx.query('ROLLBACK TO SAVEPOINT us221_fake'); + } + await new Promise((resolve) => setTimeout(resolve, 250)); + } + throw new Error( + `le compte FAKE n'est jamais resté en tête : ${await accountsDiagnostic(tx, country)}`, + ); } // --- état partagé des segments (par pays) -------------------------------------------------------- @@ -516,224 +548,219 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ const START_LOCAL = '2026-12-10T10:00'; const END_LOCAL = '2026-12-13T10:00'; - it('chaîne réelle jusqu’à T2 : carte = fiche = devis ; hold posé ; capacité bloquante inconnue ⇒ HOST_PAYOUT_RAIL_UNAVAILABLE avant T1 ; ordre envoyé au PSP avec chaque jambe explicite ; Σ jambes = total ; interrupteurs refermés hors de la transaction', async () => { - const api = await open('app_api'); - const service = new QuoteService(new CountryConfigService()); - const exponent = service.params({ country: c.country, at: new Date(NOW) }).currency.exponent; - const want = CHECKOUT[exponent]; - if (want === undefined) throw new Error(`aucun attendu pour l'exposant ${exponent}`); - expect(sum(want.legs).toString()).toBe(want.total); - - await inTx(api, { at: NOW }, async (tx) => { - await openSwitch(tx, 'p2p_private_hosts_enabled', c.country); - await openSwitch(tx, 'insurer_contract_active', c.country); - const acc = await tx.query<{ id: string }>( - 'SELECT test_fixture.us024_psp_account($1) AS id', - [c.country], - ); - expect(acc.rows[0]?.id).toBeTruthy(); - - // annonce LISTED (fixture 9998) dans une ville propre au parcours (fixture 9937) - const { rows } = await tx.query<{ listing_id: string }>( - 'SELECT * FROM test_fixture.us208_listed_listing($1, $2, $3, $4)', - [c.country, want.daily, 'AUTOMATIC', true], - ); - const listingId = rows[0]!.listing_id; - const serial = await tx.query<{ n: string }>( - 'SELECT test_fixture.next_unique_serial()::text AS n', - ); - const city = `Villa US221 ${serial.rows[0]!.n}`; - await tx.query('SELECT test_fixture.us221_listing_city($1, $2)', [listingId, city]); + it( + 'chaîne réelle jusqu’à T2 : carte = fiche = devis ; hold posé ; capacité bloquante inconnue ⇒ HOST_PAYOUT_RAIL_UNAVAILABLE avant T1 ; ordre envoyé au PSP avec chaque jambe explicite ; Σ jambes = total ; interrupteurs refermés hors de la transaction', + { timeout: 180_000 }, + async () => { + const api = await open('app_api'); + const service = new QuoteService(new CountryConfigService()); + const exponent = service.params({ country: c.country, at: new Date(NOW) }).currency + .exponent; + const want = CHECKOUT[exponent]; + if (want === undefined) throw new Error(`aucun attendu pour l'exposant ${exponent}`); + expect(sum(want.legs).toString()).toBe(want.total); + + await inTx(api, { at: NOW }, async (tx) => { + await openSwitch(tx, 'p2p_private_hosts_enabled', c.country); + await openSwitch(tx, 'insurer_contract_active', c.country); + const acc = await tx.query<{ id: string }>( + 'SELECT test_fixture.us024_psp_account($1) AS id', + [c.country], + ); + expect(acc.rows[0]?.id).toBeTruthy(); - // inscription et conducteur vérifié (KYC de fixture 9967), session du voyageur - const guest = await register(tx, c.country); - await tx.query('SELECT test_fixture.us209_driver($1, $2, $3::date, $4::date, $5)', [ - guest, - c.country, - '1990-01-01', - '2030-12-31', - c.country, - ]); - const hash = await openSession(tx, guest); - - // S01 → résultats : l'annonce est trouvée dans sa ville, aux dates locales du pays - const search = new PgSearchStore(tx); - const found = await search.search({ - country: c.country, - city, - area: null, - startLocal: START_LOCAL, - endLocal: END_LOCAL, - limit: 50, - }); - if (found.outcome !== 'OK') throw new Error(`recherche : ${found.outcome}`); - const card = found.results.find((r) => r.id === listingId); - if (card === undefined) throw new Error('annonce absente des résultats'); - expect(card).toMatchObject({ dailyPriceMinor: want.daily, currency: c.currency }); - expect(Date.parse(card.endAt) - Date.parse(card.startAt)).toBe(3 * DAY); - - // S03 : fiche (prix de l'annonce, conditions) ; carte et fiche au même total (16 SRC-042) - const pricer = searchQuotePricer((ctx) => service.params(ctx)); - const slot = await search.listingPrice(listingId); - if (slot === null) throw new Error('prix de la fiche introuvable'); - expect(await search.terms(listingId, card.startAt)).not.toBeNull(); - const priced = (dailyPriceMinor: string, quotedAt: string) => - pricer.price({ - listingId, + // annonce LISTED (fixture 9998) dans une ville propre au parcours (fixture 9937) + const { rows } = await tx.query<{ listing_id: string }>( + 'SELECT * FROM test_fixture.us208_listed_listing($1, $2, $3, $4)', + [c.country, want.daily, 'AUTOMATIC', true], + ); + const listingId = rows[0]!.listing_id; + const serial = await tx.query<{ n: string }>( + 'SELECT test_fixture.next_unique_serial()::text AS n', + ); + const city = `Villa US221 ${serial.rows[0]!.n}`; + await tx.query('SELECT test_fixture.us221_listing_city($1, $2)', [listingId, city]); + + // inscription et conducteur vérifié (KYC de fixture 9967), session du voyageur + const guest = await register(tx, c.country); + await tx.query('SELECT test_fixture.us209_driver($1, $2, $3::date, $4::date, $5)', [ + guest, + c.country, + '1990-01-01', + '2030-12-31', + c.country, + ]); + const hash = await openSession(tx, guest); + + // S01 → résultats : l'annonce est trouvée dans sa ville, aux dates locales du pays + const search = new PgSearchStore(tx); + const found = await search.search({ country: c.country, - currency: card.currency, - dailyPriceMinor, - startAt: card.startAt, - endAt: card.endAt, - quotedAt, + city, + area: null, + startLocal: START_LOCAL, + endLocal: END_LOCAL, + limit: 50, + }); + if (found.outcome !== 'OK') throw new Error(`recherche : ${found.outcome}`); + const card = found.results.find((r) => r.id === listingId); + if (card === undefined) throw new Error('annonce absente des résultats'); + expect(card).toMatchObject({ dailyPriceMinor: want.daily, currency: c.currency }); + expect(Date.parse(card.endAt) - Date.parse(card.startAt)).toBe(3 * DAY); + + // S03 : fiche (prix de l'annonce, conditions) ; carte et fiche au même total (16 SRC-042) + const pricer = searchQuotePricer((ctx) => service.params(ctx)); + const slot = await search.listingPrice(listingId); + if (slot === null) throw new Error('prix de la fiche introuvable'); + expect(await search.terms(listingId, card.startAt)).not.toBeNull(); + const priced = (dailyPriceMinor: string, quotedAt: string) => + pricer.price({ + listingId, + country: c.country, + currency: card.currency, + dailyPriceMinor, + startAt: card.startAt, + endAt: card.endAt, + quotedAt, + }); + expect(priced(slot.dailyPriceMinor, slot.quotedAt)).toEqual({ + totalMinor: want.total, + billableDays: 3, + }); + expect(priced(card.dailyPriceMinor, card.quotedAt)).toEqual({ + totalMinor: want.total, + billableDays: 3, }); - expect(priced(slot.dailyPriceMinor, slot.quotedAt)).toEqual({ - totalMinor: want.total, - billableDays: 3, - }); - expect(priced(card.dailyPriceMinor, card.quotedAt)).toEqual({ - totalMinor: want.total, - billableDays: 3, - }); - // S05 : devis figé (composition de CheckoutService.createQuote, prouvée par - // pg-checkout.int.test.ts) — moteur de PRC, commande de gel rejouée par la base - const checkout = new PgCheckoutStore(tx); - const listing = await checkout.listing(listingId); - if (listing === null) throw new Error('annonce du checkout introuvable'); - const params = service.params({ - country: listing.country, - at: new Date(listing.quotedAtMs), - hostPlan: listing.hostPlan, - }); - const level = params.protectionGrid?.minLevel; - expect(level).toBe('BASICA'); - const { frozen } = freezeQuote( - { - startAtMs: Date.parse(card.startAt), - endAtMs: Date.parse(card.endAt), - quotedAtMs: listing.quotedAtMs, - rateType: 'REFUNDABLE', - dailyRate: money(BigInt(listing.dailyPriceMinor), params.currency), - ...(level === undefined ? {} : { protectionLevel: level }), - mileage: { mode: 'UNLIMITED' }, - }, - params, - ); - const gel = await new PgQuoteStore(tx).freeze(hash, listingId, frozen); - expect(gel.outcome).toBe('DONE'); - const quoteId = gel.quoteId!; - const quote = await checkout.quote(hash, quoteId); - if (quote === null) throw new Error('devis figé illisible'); - expect(quote).toMatchObject({ - currency: c.currency, - billableDays: 3, - totalMinor: want.total, - protectionLevel: 'BASICA', - insurerContractActive: true, - }); - expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.amountMinor]))).toEqual( - want.lines, - ); - expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.taxMinor]))).toEqual( - want.taxes, - ); - // jambes du devis figé (08 E7 règle 2) : celles que l'ordre au PSP devra porter - const outputs = JSON.parse(frozen.outputs) as { legs: Record }; - expect(outputs.legs).toEqual(legsText(want.legs)); - - // S05 → hold posé (conducteur titulaire, versions affichées acceptées) - const placed = await checkout.checkout(hash, quoteId, { - driverFirstName: 'Ana', - driverLastName: 'Pérez', - manualTransmissionConfirmed: false, - acceptedDocuments: quote.documents.map((d) => ({ kind: d.kind, version: d.version })), - }); - expect(placed.outcome).toBe('DONE'); - const holdId = placed.holdId!; - expect(await checkout.hold(hash, holdId)).toMatchObject({ - status: 'ACTIVE', - quoteId, - totalMinor: want.total, - reviewState: 'NONE', - }); + // S05 : devis figé (composition de CheckoutService.createQuote, prouvée par + // pg-checkout.int.test.ts) — moteur de PRC, commande de gel rejouée par la base + const checkout = new PgCheckoutStore(tx); + const listing = await checkout.listing(listingId); + if (listing === null) throw new Error('annonce du checkout introuvable'); + const params = service.params({ + country: listing.country, + at: new Date(listing.quotedAtMs), + hostPlan: listing.hostPlan, + }); + const level = params.protectionGrid?.minLevel; + expect(level).toBe('BASICA'); + const { frozen } = freezeQuote( + { + startAtMs: Date.parse(card.startAt), + endAtMs: Date.parse(card.endAt), + quotedAtMs: listing.quotedAtMs, + rateType: 'REFUNDABLE', + dailyRate: money(BigInt(listing.dailyPriceMinor), params.currency), + ...(level === undefined ? {} : { protectionLevel: level }), + mileage: { mode: 'UNLIMITED' }, + }, + params, + ); + const gel = await new PgQuoteStore(tx).freeze(hash, listingId, frozen); + expect(gel.outcome).toBe('DONE'); + const quoteId = gel.quoteId!; + const quote = await checkout.quote(hash, quoteId); + if (quote === null) throw new Error('devis figé illisible'); + expect(quote).toMatchObject({ + currency: c.currency, + billableDays: 3, + totalMinor: want.total, + protectionLevel: 'BASICA', + insurerContractActive: true, + }); + expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.amountMinor]))).toEqual( + want.lines, + ); + expect(Object.fromEntries(quote.lines.map((l) => [l.type, l.taxMinor]))).toEqual( + want.taxes, + ); + // jambes du devis figé (08 E7 règle 2) : celles que l'ordre au PSP devra porter + const outputs = JSON.parse(frozen.outputs) as { legs: Record }; + expect(outputs.legs).toEqual(legsText(want.legs)); + + // S05 → hold posé (conducteur titulaire, versions affichées acceptées) + const placed = await checkout.checkout(hash, quoteId, { + driverFirstName: 'Ana', + driverLastName: 'Pérez', + manualTransmissionConfirmed: false, + acceptedDocuments: quote.documents.map((d) => ({ kind: d.kind, version: d.version })), + }); + expect(placed.outcome).toBe('DONE'); + const holdId = placed.holdId!; + expect(await checkout.hold(hash, holdId)).toMatchObject({ + status: 'ACTIVE', + quoteId, + totalMinor: want.total, + reviewState: 'NONE', + }); - // critère 2 (FAKE hostile) : capacité bloquante inconnue ⇒ refus AVANT T1, aucun ordre - const at = (m: number) => iso(Date.parse(NOW) + m * MINUTE); - const psp = new FakeHostedPsp(); - const providers = await checkoutProviders(c.country); - const pay = paymentService(tx, psp, providers); - await capabilities(tx, c.country, at(-3), undefined, 'VALIDATED_SANDBOX', providers); - // capacité inconnue posée dans un point de sauvegarde, retirée avec lui après le refus - await tx.query('SAVEPOINT us221_capability'); - await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN', providers); - await expect(pay.pay(hash, holdId, { method: 'CARD' })).rejects.toMatchObject({ - code: 'HOST_PAYOUT_RAIL_UNAVAILABLE', - }); - await tx.query('ROLLBACK TO SAVEPOINT us221_capability'); - expect(psp.orders).toEqual([]); - expect(await pay.payment(hash, holdId)).toMatchObject({ - state: 'PAYABLE', - holdStatus: 'ACTIVE', - tripId: null, - }); + // critère 2 (FAKE hostile) : capacité bloquante inconnue ⇒ refus AVANT T1, aucun ordre + const at = (m: number) => iso(Date.parse(NOW) + m * MINUTE); + const psp = new FakeHostedPsp(); + const pay = paymentService(tx, psp); + await capabilities(tx, c.country, at(-3)); + // capacité inconnue posée dans un point de sauvegarde, retirée avec lui après le refus + await tx.query('SAVEPOINT us221_capability'); + await capabilities(tx, c.country, at(-2), 'SUPPORTS_PER_LEG_AMOUNTS', 'UNKNOWN'); + const refused = await onFakeAccount(tx, c.country, () => + pay.pay(hash, holdId, { method: 'CARD' }), + ); + expect(refused.ok).toBe(false); + if (!refused.ok) { + expect(refused.error).toMatchObject({ code: 'HOST_PAYOUT_RAIL_UNAVAILABLE' }); + } + await tx.query('ROLLBACK TO SAVEPOINT us221_capability'); + expect(psp.orders).toEqual([]); + expect(await pay.payment(hash, holdId)).toMatchObject({ + state: 'PAYABLE', + holdStatus: 'ACTIVE', + tripId: null, + }); - // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 - // Compte de passage d'un autre fichier (constat C-1) : T1 peut viser un compte ACTIVE - // ouvert APRÈS la lecture des fournisseurs. Chaque essai est isolé par un point de - // sauvegarde ; un refus relit les fournisseurs, valide le nouveau et rejoue (3 essais au - // plus). Un refus qui persiste sur les mêmes comptes échoue avec son diagnostic. - let started: Awaited> | undefined; - let seen = providers; - for (let attempt = 1; started === undefined; attempt++) { - await tx.query('SAVEPOINT us221_t1'); - try { - started = await paymentService(tx, psp, seen).pay(hash, holdId, { method: 'CARD' }); - await tx.query('RELEASE SAVEPOINT us221_t1'); - } catch (error) { - await tx.query('ROLLBACK TO SAVEPOINT us221_t1'); - const code = String((error as { code?: unknown }).code); - const now = await checkoutProviders(c.country); - const fresh = now.filter((x) => !seen.includes(x)); - if (attempt >= 3 || fresh.length === 0) { - const diagnostic = await accountsDiagnostic(tx, c.country); - throw new Error(`paiement refusé : ${code} (essai ${attempt}) ${diagnostic}`, { - cause: error, - }); - } - seen = [...seen, ...fresh]; - await capabilities(tx, c.country, at(-3), undefined, 'VALIDATED_SANDBOX', fresh); + // capacités validées : T1 (jambes du devis engagé), ordre au PSP, T2 + const paid = await onFakeAccount(tx, c.country, () => + pay.pay(hash, holdId, { method: 'CARD' }), + ); + if (!paid.ok) { + const code = String((paid.error as { code?: unknown }).code); + throw new Error( + `paiement refusé : ${code} ${await accountsDiagnostic(tx, c.country)}`, + { + cause: paid.error, + }, + ); } - } - expect(started.created).toBe(true); - expect(started.payment).toMatchObject({ - state: 'VERIFYING', - holdStatus: 'PAYMENT_IN_FLIGHT', - tripId: null, - }); - expect(psp.orders).toHaveLength(1); - const order = psp.orders[0]!; - expect(order).toMatchObject({ - amountMinor: BigInt(want.total), - currency: c.currency, - method: 'CARD', - capture: 'AUTO', - idempotencyKey: `hold:${holdId}:CAPTURE:a1`, + const started = paid.value; + expect(started.created).toBe(true); + expect(started.payment).toMatchObject({ + state: 'VERIFYING', + holdStatus: 'PAYMENT_IN_FLIGHT', + tripId: null, + }); + expect(psp.orders).toHaveLength(1); + const order = psp.orders[0]!; + expect(order).toMatchObject({ + amountMinor: BigInt(want.total), + currency: c.currency, + method: 'CARD', + capture: 'AUTO', + idempotencyKey: `hold:${holdId}:CAPTURE:a1`, + }); + // 17 NN4 : montant EXPLICITE de chaque jambe, jamais un prorata ; Σ jambes = total + expect({ ...order.legs }).toEqual(want.legs); + expect(sum({ ...order.legs } as Legs)).toBe(order.amountMinor); + // second clic : aucun second ordre (l'état fait foi) + const again = await pay.pay(hash, holdId, { method: 'CARD' }); + expect(again.created).toBe(false); + expect(psp.orders).toHaveLength(1); }); - // 17 NN4 : montant EXPLICITE de chaque jambe, jamais un prorata ; Σ jambes = total - expect({ ...order.legs }).toEqual(want.legs); - expect(sum({ ...order.legs } as Legs)).toBe(order.amountMinor); - // second clic : aucun second ordre (l'état fait foi) - const again = await pay.pay(hash, holdId, { method: 'CARD' }); - expect(again.created).toBe(false); - expect(psp.orders).toHaveLength(1); - }); - // transaction annulée : aucun interrupteur ouvert ne survit (17 §0.1) - await inTx(api, { at: NOW }, async (tx) => { - expect(await switches(tx, c.country)).toEqual(ALL_CLOSED); - }); - }); + // transaction annulée : aucun interrupteur ouvert ne survit (17 §0.1) + await inTx(api, { at: NOW }, async (tx) => { + expect(await switches(tx, c.country)).toEqual(ALL_CLOSED); + }); + }, + ); }); // --------------------------------------------------------------------------------------------- diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md index ceba6d4e..a00e1919 100644 --- a/docs/team/handoffs/US-221.md +++ b/docs/team/handoffs/US-221.md @@ -32,7 +32,7 @@ Docs : `docs/qa/STRATEGIE_TESTS.md` (§2, §3.6, tableau des écarts), `packages ## Constats sur le banc -- **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : capacités et PSP FAKE posés pour FAKE et pour le fournisseur que T1 retiendra ; chaque essai de T1 dans un point de sauvegarde, un refus relit les fournisseurs et ne valide qu'un fournisseur NOUVEAU (3 essais), sinon échec avec diagnostic (runs 44380398003 et 44384951568 rouges par cette course, 44385856048 vert sans course). À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). +- **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : chaque essai de T1 (refus attendu puis paiement) n'est retenu que si FAKE est en tête des comptes ACTIVE juste avant et juste après lui ; sinon il est annulé par son point de sauvegarde et rejoué (≤ 60 s) — runs 44380398003, 44384951568 et 44393901538 rouges par cette course (T1 sur un compte de passage : refus ou `PAYMENT_UNAVAILABLE`).. À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). - Coutures assumées : A → B (gel et checkout réels exigent les interrupteurs, ouverts seulement en transaction annulée) ; B → C (D1). ## État de la CI From 6990585797d7580b31ce85cf86801825249e3928 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:51:55 -0300 Subject: [PATCH 09/12] =?UTF-8?q?docs(US-221):=20cinq=20revues=20ind=C3=A9?= =?UTF-8?q?pendantes=20du=20delta=20e33c943a=20(architecture,=20argent,=20?= =?UTF-8?q?code,=20qa,=20securite)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 Agent-Role: revue-argent Agent-Model: claude-sonnet-5-5 --- .../reviews/US-221/architecture-2026-11-18b.md | 14 ++++++++++++++ docs/team/reviews/US-221/argent-2026-11-18b.md | 14 ++++++++++++++ docs/team/reviews/US-221/code-2026-11-18b.md | 15 +++++++++++++++ docs/team/reviews/US-221/qa-2026-11-18b.md | 15 +++++++++++++++ docs/team/reviews/US-221/securite-2026-11-18b.md | 15 +++++++++++++++ 5 files changed, 73 insertions(+) create mode 100644 docs/team/reviews/US-221/architecture-2026-11-18b.md create mode 100644 docs/team/reviews/US-221/argent-2026-11-18b.md create mode 100644 docs/team/reviews/US-221/code-2026-11-18b.md create mode 100644 docs/team/reviews/US-221/qa-2026-11-18b.md create mode 100644 docs/team/reviews/US-221/securite-2026-11-18b.md diff --git a/docs/team/reviews/US-221/architecture-2026-11-18b.md b/docs/team/reviews/US-221/architecture-2026-11-18b.md new file mode 100644 index 00000000..b71d68fe --- /dev/null +++ b/docs/team/reviews/US-221/architecture-2026-11-18b.md @@ -0,0 +1,14 @@ +# Revue architecture — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta) + +Relecteur : revue-architecture / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 02b5910b..e33c943a (SHA revu : e33c943a) + +Contexte : delta `git diff 11125c14 e33c943a` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, passation US-221 C-1), comparé à 02b5910b avec `git diff -w` ; revues APPROUVÉ précédentes au SHA 02b5910b (`architecture-2026-11-18.md` et les quatre autres) reprises pour le reste du diff, inchangé. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Structure** : `checkoutProviders` et la boucle de 3 essais sont remplacés par `firstProvider` (lecture sous `app_worker`, même ordre que `booking_cmd_checkout_pay`) et `onFakeAccount` (une seule fonction de banc, appelée pour le refus attendu et pour le paiement). Le test n'appelle toujours que les services et stores publics ; aucun import interne ni écriture hors commande. | +| 2 | INFO | **Reste de la structure inchangé** : le reste du diff de test est un ré-indentage (`it(..., { timeout: 180_000 }, ...)`) ; `git diff -w` ne montre que les lignes ci-dessus. | +| 3 | MINEUR | `onFakeAccount` suppose un compte FAKE ACTIVE déjà validé hors de la transaction (la lecture passe par `app_worker`, qui ne voit pas celui que `us024_psp_account` crée dans la transaction annulée). Si aucun fichier ne l'a validé avant (base neuve, fichier seul), l'attente de 60 s échoue, fail-closed, avec le diagnostic : rouge, jamais vert à tort. À durcir (valider un compte FAKE par transaction validée avant le segment A, comme le segment B). Non bloquant. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/argent-2026-11-18b.md b/docs/team/reviews/US-221/argent-2026-11-18b.md new file mode 100644 index 00000000..74696a8d --- /dev/null +++ b/docs/team/reviews/US-221/argent-2026-11-18b.md @@ -0,0 +1,14 @@ +# Revue argent — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta) + +Relecteur : revue-argent / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 02b5910b..e33c943a (SHA revu : e33c943a) + +Contexte : delta `git diff 11125c14 e33c943a` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, passation US-221 C-1), comparé à 02b5910b avec `git diff -w` ; revues APPROUVÉ précédentes au SHA 02b5910b (`argent-2026-11-18.md` et les quatre autres) reprises pour le reste du diff, inchangé. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions d'argent inchangées** : comparées ligne à ligne à 02b5910b (`git diff -w`) : `want.total`, `want.lines`, `want.taxes`, jambes du devis figé, ordre au PSP (`amountMinor`, `currency`, `method`, `capture`, clé d'idempotence), `{...order.legs}` = `want.legs`, Σ jambes = montant, second clic sans second ordre, `psp.orders` vide après refus : toutes présentes, valeurs identiques. Aucun montant tiré du code testé. | +| 2 | INFO | **Refus produit non masqué** : pour FAKE en tête avant ET après l'essai, le résultat (réussite ou refus) est retenu tel quel ; le refus attendu reste affirmé `ok === false` avec `HOST_PAYOUT_RAIL_UNAVAILABLE`, et un refus du paiement lève l'erreur avec code et diagnostic. Seul un essai fait pendant qu'un autre fournisseur était en tête est annulé et rejoué. | +| 3 | INFO | **Aucune validation ajoutée** : la validation de capacités d'un autre fournisseur (paramètre `providers`) disparaît du segment A ; seul FAKE est validé, comme avant. Aucun interrupteur ouvert hors des commandes à deux personnes en transaction annulée ; relecture `ALL_CLOSED` conservée. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/code-2026-11-18b.md b/docs/team/reviews/US-221/code-2026-11-18b.md new file mode 100644 index 00000000..73f0211c --- /dev/null +++ b/docs/team/reviews/US-221/code-2026-11-18b.md @@ -0,0 +1,15 @@ +# Revue code — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta) + +Relecteur : revue-code / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 02b5910b..e33c943a (SHA revu : e33c943a) + +Contexte : delta `git diff 11125c14 e33c943a` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, passation US-221 C-1), comparé à 02b5910b avec `git diff -w` ; revues APPROUVÉ précédentes au SHA 02b5910b (`code-2026-11-18.md` et les quatre autres) reprises pour le reste du diff, inchangé. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 1 | INFO | **Correction de la boucle** : un échec laisse la transaction avortée ; `ROLLBACK TO SAVEPOINT us221_fake` la remet en état dans tous les cas d'échec (retenu ou non), `RELEASE` après réussite retenue. Réutilisation du même nom de point de sauvegarde sans fuite. Typage correct (`{ ok: true; value } \| { ok: false; error }`). | +| 2 | INFO | **Borne** : 240 × 250 ms = 60 s au plus de sommeil, plus la durée des essais ; le `timeout` de 180 000 ms du test couvre le pire cas, et l'échec final lève une erreur claire (« jamais resté en tête ») avec le diagnostic. | +| 3 | MINEUR | `firstProvider` lit via `app_worker` : le compte FAKE créé dans la transaction n'est pas vu. Sans compte FAKE déjà validé par un autre fichier, le test échoue après 60 s (fail-closed, non vert à tort). Non bloquant ; amélioration : valider d'abord le compte FAKE hors transaction. | +| 4 | INFO | Fenêtre résiduelle : un compte de passage ouvert puis refermé entre les deux lectures (avant et après) échapperait à la détection, mais le service ne dispose que de l'adaptateur FAKE, donc un tel essai échouerait en `PAYMENT_UNAVAILABLE` et serait rejeté par un refus inattendu, jamais pris pour un succès. Acceptable. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/qa-2026-11-18b.md b/docs/team/reviews/US-221/qa-2026-11-18b.md new file mode 100644 index 00000000..97f7241c --- /dev/null +++ b/docs/team/reviews/US-221/qa-2026-11-18b.md @@ -0,0 +1,15 @@ +# Revue qa — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta) + +Relecteur : revue-qa / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 02b5910b..e33c943a (SHA revu : e33c943a) + +Contexte : delta `git diff 11125c14 e33c943a` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, passation US-221 C-1), comparé à 02b5910b avec `git diff -w` ; revues APPROUVÉ précédentes au SHA 02b5910b (`qa-2026-11-18.md` et les quatre autres) reprises pour le reste du diff, inchangé. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** (`git diff -w` contre 02b5910b) : seules les lignes d'attente (`onFakeAccount`), le refus encapsulé (`expect(refused.ok).toBe(false)` puis code `HOST_PAYOUT_RAIL_UNAVAILABLE`) et le `timeout` changent ; le refus attendu reste obligatoire, le succès de T1 reste vérifié état par état. | +| 2 | INFO | **Pas de vert à tort** : un refus du produit pour FAKE en tête est retenu et fait échouer le test (code et diagnostic dans l'erreur) ; un essai sous compte de passage n'est jamais retenu. Si FAKE ne revient pas en tête, le test échoue après 60 s, il ne passe pas. | +| 3 | MINEUR | **Dépendance à l'ordre d'exécution** : `firstProvider` (connexion `app_worker`) ne voit qu'un compte FAKE ACTIVE déjà validé ; sur une base neuve, fichier seul, le segment A échoue après 60 s. Cela rend le test rouge, jamais vert à tort ; à durcir en validant le compte FAKE avant le segment A. Non bloquant. | +| 4 | INFO | Diagnostic (`accountsDiagnostic`) : fournisseur, environnement, mode et capacités manquantes seulement ; handoff mis à jour (C-1) avec les runs rouges cités. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/securite-2026-11-18b.md b/docs/team/reviews/US-221/securite-2026-11-18b.md new file mode 100644 index 00000000..4d9e28b7 --- /dev/null +++ b/docs/team/reviews/US-221/securite-2026-11-18b.md @@ -0,0 +1,15 @@ +# Revue securite — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta) + +Relecteur : revue-securite / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 02b5910b..e33c943a (SHA revu : e33c943a) + +Contexte : delta `git diff 11125c14 e33c943a` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, passation US-221 C-1), comparé à 02b5910b avec `git diff -w` ; revues APPROUVÉ précédentes au SHA 02b5910b (`securite-2026-11-18.md` et les quatre autres) reprises pour le reste du diff, inchangé. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Aucune validation de fournisseur ni interrupteur hors procédure** : le delta ne touche ni `us024_set_capability` pour un autre fournisseur (la validation de BAC et EBANX est supprimée), ni les interrupteurs, ouverts seulement par la commande à deux personnes en transaction annulée (inchangé). Aucun rôle ni `SECURITY DEFINER` ajouté ; les lectures du banc restent sous `app_worker`. | +| 2 | INFO | **Diagnostic** : l'erreur ne porte que fournisseur, environnement, mode et noms de capacités manquantes ; aucun identifiant de compte, référence de secret, jeton ni donnée personnelle. Borne de 60 s et `timeout` de 180 s : pas de boucle sans fin. | +| 3 | INFO | Le rejeu par point de sauvegarde annule les écritures d'un essai non retenu ; un refus du produit pour FAKE en tête est retenu et fait échouer le test (aucun refus de sécurité du produit n'est avalé). | +| 4 | MINEUR | Dépendance à un compte FAKE validé hors transaction (échec fail-closed sinon). Non bloquant. | + +Verdict : APPROUVÉ From b11aba6539a12863623a18b3b4faeee93c469aa1 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:13:38 -0300 Subject: [PATCH 10/12] =?UTF-8?q?test(US-221):=20attente=20du=20compte=20F?= =?UTF-8?q?AKE=20en=20t=C3=AAte=20sur=20UNE=20connexion=20;=20compte=20FAK?= =?UTF-8?q?E=20valid=C3=A9=20hors=20de=20la=20transaction=20du=20segment?= =?UTF-8?q?=20A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Run 44395485499 (« base de données », « guide d'installation ») : segment A en échec après ~50 s, « remaining connection slots are reserved for roles with the SUPERUSER attribute » : firstProvider ouvrait une connexion app_worker par lecture (toutes les 250 ms), libérées seulement par afterEach. onFakeAccount ouvre désormais une seule connexion pour toute son attente. Revue MINOR : le compte FAKE ACTIVE du pays est validé dans une transaction VALIDÉE avant le segment A (comme le segment B), pour que la lecture des comptes, faite sur une autre connexion, le voie. Assertions inchangées. Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../int/parcours-dores-reservation.int.test.ts | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index 73a38f6d..f2523247 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -457,8 +457,7 @@ async function soleFakeAccount(country: string): Promise { } /** Fournisseur du compte que T1 retiendrait À CET INSTANT (ordre de `booking_cmd_checkout_pay`). */ -async function firstProvider(country: string): Promise { - const worker = await open('app_worker'); +async function firstProvider(worker: pg.ClientBase, country: string): Promise { const { rows } = await worker.query<{ provider: string }>( `SELECT provider FROM core.payment_psp_account WHERE country_code = $1 AND status = 'ACTIVE' ORDER BY (environment = 'LIVE') DESC, provider, id LIMIT 1`, @@ -480,8 +479,10 @@ async function onFakeAccount( country: string, attempt: () => Promise, ): Promise<{ ok: true; value: T } | { ok: false; error: unknown }> { + // UNE connexion app_worker pour toute l'attente (libérée par afterEach), jamais une par lecture + const worker = await open('app_worker'); for (let i = 0; i < 240; i++) { - if ((await firstProvider(country)) === 'FAKE') { + if ((await firstProvider(worker, country)) === 'FAKE') { await tx.query('SAVEPOINT us221_fake'); let out: { ok: true; value: T } | { ok: false; error: unknown }; try { @@ -489,7 +490,7 @@ async function onFakeAccount( } catch (error) { out = { ok: false, error }; } - if ((await firstProvider(country)) === 'FAKE') { + if ((await firstProvider(worker, country)) === 'FAKE') { await tx.query( out.ok ? 'RELEASE SAVEPOINT us221_fake' : 'ROLLBACK TO SAVEPOINT us221_fake', ); @@ -560,6 +561,11 @@ describe.each(CASES)('US-221 — parcours dorés « réservation » ($country, $ if (want === undefined) throw new Error(`aucun attendu pour l'exposant ${exponent}`); expect(sum(want.legs).toString()).toBe(want.total); + // compte FAKE ACTIVE du pays VALIDÉ hors de la transaction annulée (comme le segment B) : + // la lecture des comptes de `onFakeAccount` (autre connexion) doit le voir + await inTx(api, { commit: true }, async (tx) => { + await tx.query('SELECT test_fixture.us024_psp_account($1)', [c.country]); + }); await inTx(api, { at: NOW }, async (tx) => { await openSwitch(tx, 'p2p_private_hosts_enabled', c.country); await openSwitch(tx, 'insurer_contract_active', c.country); From 956753821bf8ba4478d2f18ac1b36b008ce0a37f Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:35:40 -0300 Subject: [PATCH 11/12] =?UTF-8?q?docs(US-221):=20cinq=20revues=20ind=C3=A9?= =?UTF-8?q?pendantes=20du=20delta=20b11aba65=20(architecture,=20argent,=20?= =?UTF-8?q?code,=20qa,=20securite)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 Agent-Role: revue-argent Agent-Model: claude-sonnet-5-5 --- .../team/reviews/US-221/architecture-2026-11-18c.md | 13 +++++++++++++ docs/team/reviews/US-221/argent-2026-11-18c.md | 13 +++++++++++++ docs/team/reviews/US-221/code-2026-11-18c.md | 13 +++++++++++++ docs/team/reviews/US-221/qa-2026-11-18c.md | 13 +++++++++++++ docs/team/reviews/US-221/securite-2026-11-18c.md | 13 +++++++++++++ 5 files changed, 65 insertions(+) create mode 100644 docs/team/reviews/US-221/architecture-2026-11-18c.md create mode 100644 docs/team/reviews/US-221/argent-2026-11-18c.md create mode 100644 docs/team/reviews/US-221/code-2026-11-18c.md create mode 100644 docs/team/reviews/US-221/qa-2026-11-18c.md create mode 100644 docs/team/reviews/US-221/securite-2026-11-18c.md diff --git a/docs/team/reviews/US-221/architecture-2026-11-18c.md b/docs/team/reviews/US-221/architecture-2026-11-18c.md new file mode 100644 index 00000000..2c3fda75 --- /dev/null +++ b/docs/team/reviews/US-221/architecture-2026-11-18c.md @@ -0,0 +1,13 @@ +# Revue architecture — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta 2) + +Relecteur : revue-architecture / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 69905857..b11aba65 (SHA revu : b11aba65) + +Contexte : delta `git diff 69905857 b11aba65` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, 10 lignes ajoutées, 4 retirées), comparé avec `git diff -w` ; revues précédentes APPROUVÉ aux SHA 02b5910b et e33c943a (`architecture-2026-11-18.md`, `architecture-2026-11-18b.md`) reprises pour le reste. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** : le delta ne touche aucune assertion ; `firstProvider` reçoit la connexion en paramètre et `onFakeAccount` en ouvre une seule (`open('app_worker')`, rôle de production, assertion L0-05 de `connectAs`) pour toute l'attente, libérée par l'`afterEach` existant : plus une connexion par lecture (cause du run 44395485499). | +| 2 | INFO | **Compte FAKE validé hors transaction** : `inTx(api, { commit: true }, ...)` appelle seulement `test_fixture.us024_psp_account(pays)`, fixture idempotente (relit le compte FAKE/SANDBOX ACTIVE existant, `ON CONFLICT DO NOTHING`), même motif que le segment B. Résout la réserve MINEUR de la revue précédente (dépendance à l'ordre des fichiers). | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/argent-2026-11-18c.md b/docs/team/reviews/US-221/argent-2026-11-18c.md new file mode 100644 index 00000000..590fe81f --- /dev/null +++ b/docs/team/reviews/US-221/argent-2026-11-18c.md @@ -0,0 +1,13 @@ +# Revue argent — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta 2) + +Relecteur : revue-argent / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 69905857..b11aba65 (SHA revu : b11aba65) + +Contexte : delta `git diff 69905857 b11aba65` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, 10 lignes ajoutées, 4 retirées), comparé avec `git diff -w` ; revues précédentes APPROUVÉ aux SHA 02b5910b et e33c943a (`argent-2026-11-18.md`, `argent-2026-11-18b.md`) reprises pour le reste. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** : le delta ne touche aucune assertion ; `firstProvider` reçoit la connexion en paramètre et `onFakeAccount` en ouvre une seule (`open('app_worker')`, rôle de production, assertion L0-05 de `connectAs`) pour toute l'attente, libérée par l'`afterEach` existant : plus une connexion par lecture (cause du run 44395485499). | +| 2 | INFO | **Aucun montant ni capacité touchés** : la fixture crée au plus le compte marchand FAKE de SANDBOX (aucun fonds, aucune jambe, aucune capacité validée) ; les capacités restent posées dans la transaction annulée. Aucun interrupteur ouvert : `openSwitch` n'est appelé que dans la transaction annulée suivante, et la relecture `ALL_CLOSED` est conservée. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/code-2026-11-18c.md b/docs/team/reviews/US-221/code-2026-11-18c.md new file mode 100644 index 00000000..613dc7e9 --- /dev/null +++ b/docs/team/reviews/US-221/code-2026-11-18c.md @@ -0,0 +1,13 @@ +# Revue code — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta 2) + +Relecteur : revue-code / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 69905857..b11aba65 (SHA revu : b11aba65) + +Contexte : delta `git diff 69905857 b11aba65` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, 10 lignes ajoutées, 4 retirées), comparé avec `git diff -w` ; revues précédentes APPROUVÉ aux SHA 02b5910b et e33c943a (`code-2026-11-18.md`, `code-2026-11-18b.md`) reprises pour le reste. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** : le delta ne touche aucune assertion ; `firstProvider` reçoit la connexion en paramètre et `onFakeAccount` en ouvre une seule (`open('app_worker')`, rôle de production, assertion L0-05 de `connectAs`) pour toute l'attente, libérée par l'`afterEach` existant : plus une connexion par lecture (cause du run 44395485499). | +| 2 | INFO | **Pas de fuite de connexion** : `open` enregistre le client dans `opened`, vidé par `afterEach` ; la boucle de 240 lectures réutilise le même client. La transaction validée est refermée par `withTestTransaction`. Réserve MINEUR précédente levée : le compte FAKE est visible de la connexion `app_worker`. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/qa-2026-11-18c.md b/docs/team/reviews/US-221/qa-2026-11-18c.md new file mode 100644 index 00000000..8f59e052 --- /dev/null +++ b/docs/team/reviews/US-221/qa-2026-11-18c.md @@ -0,0 +1,13 @@ +# Revue qa — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta 2) + +Relecteur : revue-qa / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 69905857..b11aba65 (SHA revu : b11aba65) + +Contexte : delta `git diff 69905857 b11aba65` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, 10 lignes ajoutées, 4 retirées), comparé avec `git diff -w` ; revues précédentes APPROUVÉ aux SHA 02b5910b et e33c943a (`qa-2026-11-18.md`, `qa-2026-11-18b.md`) reprises pour le reste. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** : le delta ne touche aucune assertion ; `firstProvider` reçoit la connexion en paramètre et `onFakeAccount` en ouvre une seule (`open('app_worker')`, rôle de production, assertion L0-05 de `connectAs`) pour toute l'attente, libérée par l'`afterEach` existant : plus une connexion par lecture (cause du run 44395485499). | +| 2 | INFO | **Indépendance de l'ordre** : le test valide lui-même le compte FAKE du pays avant le segment A ; fichier seul sur base neuve, il ne dépend plus d'un autre fichier. Le compte FAKE/SANDBOX est celui que les autres fichiers créent ou relisent de la même façon (idempotent) ; il ne rend pas ces fichiers verts à tort (compte déjà exigé par eux, aucune capacité ni interrupteur laissés). Un refus produit pour FAKE en tête échoue toujours. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/securite-2026-11-18c.md b/docs/team/reviews/US-221/securite-2026-11-18c.md new file mode 100644 index 00000000..d8e4c573 --- /dev/null +++ b/docs/team/reviews/US-221/securite-2026-11-18c.md @@ -0,0 +1,13 @@ +# Revue securite — US-221 « parcours dorés réservation PA / USD et PY / PYG » (PR n° 245) — 2026-11-18 (delta 2) + +Relecteur : revue-securite / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 69905857..b11aba65 (SHA revu : b11aba65) + +Contexte : delta `git diff 69905857 b11aba65` relu (`apps/api/test/int/parcours-dores-reservation.int.test.ts`, 10 lignes ajoutées, 4 retirées), comparé avec `git diff -w` ; revues précédentes APPROUVÉ aux SHA 02b5910b et e33c943a (`securite-2026-11-18.md`, `securite-2026-11-18b.md`) reprises pour le reste. Aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Assertions inchangées** : le delta ne touche aucune assertion ; `firstProvider` reçoit la connexion en paramètre et `onFakeAccount` en ouvre une seule (`open('app_worker')`, rôle de production, assertion L0-05 de `connectAs`) pour toute l'attente, libérée par l'`afterEach` existant : plus une connexion par lecture (cause du run 44395485499). | +| 2 | INFO | **Écriture validée du delta** : un seul appel de fixture (`SECURITY DEFINER` de test, propriétaire migrator, base de test) qui crée un compte FAKE de SANDBOX avec des références de secrets fictives (`vault:psp/test/...`) ; aucun identifiant réel, aucun secret, aucun interrupteur (17 §0.1), aucun rôle ni droit ajouté. Le compte FAKE est inactif en production (fixture de test non migrée en production). | + +Verdict : APPROUVÉ From f8ca03ff6e5008bdd8ee7e2e8853ebec41c236d4 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:07:28 -0300 Subject: [PATCH 12/12] test(US-221): porte de la caution (US-701) au service de paiement des segments A et B MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Run 44403097010 (ref de fusion avec main eb90f895, US-701 #242) : TS2345 et 8 échecs des segments A et B : CheckoutPaymentService exige désormais la porte de la caution (DepositGatePort). Porte « aucune caution » locale, forme de FakeDepositGate d'AVL (avl/testing n'est pas public) : la vraie porte lit la classe de valeur du véhicule et le devis figé du hold, absents des fixtures 9998 et 9969 (non déterministe ici) ; la caution reste prouvée par l0-us701-deposit-hold et checkout-deposit.contract. Merge d'origin/main. Assertions et montants (oracles) inchangés ; passation mise à jour. Agent-Role: qa Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../parcours-dores-reservation.int.test.ts | 21 +++++++++++++++++++ docs/team/handoffs/US-221.md | 1 + 2 files changed, 22 insertions(+) diff --git a/apps/api/test/int/parcours-dores-reservation.int.test.ts b/apps/api/test/int/parcours-dores-reservation.int.test.ts index f2523247..911acdf8 100644 --- a/apps/api/test/int/parcours-dores-reservation.int.test.ts +++ b/apps/api/test/int/parcours-dores-reservation.int.test.ts @@ -66,6 +66,8 @@ import { PaymentError, PgRefundOrders, type CreateHostedPaymentRequest, + type DepositEnforcement, + type DepositGuestView, type HostedPayment, type OperationResult, type PaymentConnectorRegistry, @@ -393,9 +395,28 @@ const paymentService = ( new CheckoutPaymentService( new PgCheckoutPaymentStore(db), new Map(providers.map((p) => [p, psp])), + new NoDepositGate(), () => undefined, ); +/** + * Porte de la caution (US-701) : décision « aucune caution », comme `FakeDepositGate` des contrats + * d'AVL (avl/testing, non public). Couture assumée : la vraie porte lit la classe de valeur du + * véhicule et le devis figé du hold, que les fixtures 9998 (sans classe de valeur) et 9969 (devis à + * documents vides) ne portent pas ; la caution est prouvée par `l0-us701-deposit-hold` et + * `checkout-deposit.contract.test.ts`. Les montants du paiement restent ceux des oracles. + */ +class NoDepositGate { + readonly enforced: string[] = []; + view(): Promise { + return Promise.resolve(null); + } + enforce(_proof: Buffer, holdId: string): Promise { + this.enforced.push(holdId); + return Promise.resolve({ kind: 'ACCEPTED', view: { status: 'NONE' } }); + } +} + /** « Pagar » par le vrai service ; un refus est rendu avec son code (diagnostic de la CI). */ async function payOrExplain( service: CheckoutPaymentService, diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md index a00e1919..2efd0a38 100644 --- a/docs/team/handoffs/US-221.md +++ b/docs/team/handoffs/US-221.md @@ -33,6 +33,7 @@ Docs : `docs/qa/STRATEGIE_TESTS.md` (§2, §3.6, tableau des écarts), `packages ## Constats sur le banc - **C-1 (course entre fichiers)** : `booking_cmd_checkout_pay` retient le premier compte ACTIVE du pays par fournisseur puis identifiant ; les scènes de `concurrence-webhook.int.test.ts` ouvrent pendant un test un compte ACTIVE BAC ou EBANX du même pays (avant FAKE dans l'ordre). Run 44379275642 : T1 du segment B (PA) refusé pendant une scène. Segment B (validé) : attente (≤ 30 s, lecture seule) que FAKE soit le seul compte actif avant T1. Segment A (annulé) : chaque essai de T1 (refus attendu puis paiement) n'est retenu que si FAKE est en tête des comptes ACTIVE juste avant et juste après lui ; sinon il est annulé par son point de sauvegarde et rejoué (≤ 60 s) — runs 44380398003, 44384951568 et 44393901538 rouges par cette course (T1 sur un compte de passage : refus ou `PAYMENT_UNAVAILABLE`).. À noter pour le lot C : avec plusieurs PSP actifs dans un pays, le choix du compte est alphabétique (question de PSP, pas de la bêta). +- Caution (US-701, #242) : `CheckoutPaymentService` exige la porte de la caution ; le test lui passe une porte « aucune caution » (forme de `FakeDepositGate`). La vraie porte lit la classe de valeur du véhicule et le devis figé du hold, absents des fixtures 9998 et 9969 ; la caution est prouvée par `l0-us701-deposit-hold` et `checkout-deposit.contract.test.ts`. - Coutures assumées : A → B (gel et checkout réels exigent les interrupteurs, ouverts seulement en transaction annulée) ; B → C (D1). ## État de la CI