Aller au contenu
Meubles Morinière

Le projetCompétences et preuves4 min de lecture

Qualité

Chaque garantie se prouve là où elle s’applique : sur une vraie base Postgres, avec des tests qui lisent le code, avec une chaîne d’empreintes que la veille recalcule, et avec une porte qui vérifie chaque commit avant la prod.

Un test qui simule la base ne prouve pas ce que la base garantit. Du coup, chaque règle se prouve là où elle s’applique. Une contrainte Postgres se teste sur Postgres. Une règle d’architecture se vérifie dans le code source. Et une règle de calcul se teste par balayage, parce que trois exemples ne suffisent pas.

suites de tests jouées sur une vraie base Postgres
111
apps/*/test/db/*.db.test.ts
contraintes CHECK écrites à la main, relues sur la base à chaque migration appliquée
169
apps/erp/scripts/constants/db-invariants.ts#EXPECTED_CHECKS
tests de régression, dont la plupart lisent le code source et refusent tout écart à une règle
92
apps/*/test/*.regression.test.ts
Mesuré dans le dépôt à chaque build de cette documentation.

Les garanties de la base se prouvent sur une vraie base

Le total d’une commande, l’état de son paiement, le sens d’un mouvement de stock : tout ce qui touche à l’argent et à la loi est garanti par des contraintes CHECK, écrites à la main dans les migrations. Sauf qu’une contrainte qu’on n’a jamais essayée peut très bien ne rien refuser du tout.

Chaque contrainte a donc son test sur Postgres. Il tente l’écriture interdite et vérifie que la base la refuse. Souvent, il vérifie aussi qu’elle accepte exactement ce que le code calcule. Un autre test lit les migrations et refuse une contrainte qui n’a pas ce cas de refus. Et après chaque migration appliquée, pnpm db:invariants relit sur la base la liste des contraintes attendues. S’il en manque une, ou s’il y en a une que la liste ne connaît pas, la mise en prod de la migration échoue.

test « Order_total_check REFUSE un total qui n'est pas articles + livraison »apps/erp/test/db/checks.db.test.ts · lignes 198–218
it("Order_total_check REFUSE un total qui n'est pas articles + livraison", async () => {
	await expect(
		db.order.create({
			data: {
				amountVatCents: 0,
				amountItemsCents: 1_000,
				amountShippingCents: 200,
				amountTotalCents: 1_199,
				termsVersion: "test",
				termsAcceptedAt: new Date(),
				email: `total-${Date.now()}@comportement.test`,
				shippingName: "Cas",
				shippingLine1: "1 rue du Test",
				shippingZip: "44000",
				shippingCity: "Nantes",
				shippingCountryCode: "FR",
				shippingMethodKind: ShippingMethodKind.PARCEL,
			},
		}),
	).rejects.toThrow(/Order_total_check/);
});

Pour aller plus loin : Tests, Migrations Prisma, ADR 0009.

Si on retouche un encaissement, ça se voit, même avec tous les droits

La loi demande qu’un logiciel de caisse rende visible toute modification. La base refusait déjà qu’on modifie ou qu’on efface un encaissement. Sauf qu’un trigger, ça se désactive sans laisser de trace.

Du coup, quand un encaissement est créé, la base lui donne un numéro sans trou et une empreinte SHA-256 de son contenu, chaînée à celle du précédent. C’est un trigger qui fait ce calcul, l’application n’y touche pas. Une requête recalcule les deux chaînes chaque matin, et à chaque migration jouée en prod. Si quelqu’un touche une ligne, la chaîne casse à partir de cette ligne.

cash_chain_hashpackages/db/prisma/migrations/20261025000100_encaissements_chaines/migration.sql · lignes 32–37
-- L'empreinte d'un maillon : celle du précédent, puis le contenu du maillon. Les dates sont
-- écrites en UTC, au millième, pour ne pas dépendre du fuseau de la session.
CREATE FUNCTION "cash_chain_hash"(previous text, payload text) RETURNS text
LANGUAGE sql IMMUTABLE AS $$
  SELECT encode(sha256(convert_to(coalesce(previous, '') || '|' || payload, 'UTF8')), 'hex')
$$;

Pour aller plus loin : Des encaissements qui ne se retouchent pas, ADR 0008.

Des tests lisent le code et refusent tout écart à une règle

Il y a des règles qu’on ne peut pas vérifier en exécutant une fonction : « chaque action qui change ce que le site affiche invalide son cache », « chaque bloc différé a son filet », « chaque action serveur s’ouvre sur sa garde ». En revue de code, on finit par en oublier une.

Du coup, ces règles sont des tests. Ils lisent le code source et échouent à chaque écart, avec un message qui dit quoi faire. Ils vérifient aussi qu’ils ne tournent pas à vide, et que leurs motifs attrapent bien ce qu’ils sont censés attraper. Ils tournent tous à chaque push sur main.

test « %s périme une entrée de cache »apps/erp/test/cache-invalidation.regression.test.ts · lignes 357–366
it.each(INVALIDENT)("%s périme une entrée de cache", (name) => {
	expect(
		INVALIDATION_CALL.test(withoutComments(read(name))),
		`${name} écrit une donnée que lit un scope \`"use cache"\` sans appeler de ` +
			"helper d'invalidation : les entrées en cache serviraient l'ancienne valeur, " +
			"sans un rouge nulle part. Si le geste a cessé de changer une surface cachée, " +
			"DÉPLACER le fichier dans `SANS_INVALIDATION` avec sa raison — jamais retirer " +
			"la ligne.",
	).toBe(true);
});

Il y a d’autres exemples : les actions gardées, les droits du site, les blocs différés. Dans l’étude de cas Des tests qui lisent le code à la place du relecteur, je raconte d’où ils viennent et ce qu’ils ne voient pas.

Ce qui part sur main est vérifié avant la prod

Un push sur main déploie la prod. Et le projet n’a pas d’intégration continue hébergée, parce que ses minutes étaient facturées. Sans porte, un commit rouge partirait en prod.

C’est donc le hook pre-push qui vérifie le commit poussé. Il le fait dans un worktree détaché, comme ça des fichiers locaux non commités ne peuvent pas le faire passer. Il contrôle les secrets, les paquets, les jumeaux, les types des deux applications, ESLint, les tests des fichiers touchés et tous les tests qui lisent le code. Quand le changement touche quelque chose que seule la base peut prouver, la suite Postgres tourne sur une base locale. Quand le site change, le hook fait son build et compare le poids de son JavaScript à un plafond. Et il faut que les variables de production soient au complet.

Cette porte a ses limites. Elle est locale, donc git push --no-verify la saute. Certaines gardes cèdent si on fournit une attestation. Elle est notée, mais rien ne l’empêche. Et les tests e2e ne se lancent qu’à la main. Qualité et livraison liste ces limites.

Pour aller plus loin : Contrôles Git, ADR 0010.

Sur cette page