Vincent/TaxActes

Fork 0

Files

T

Vincent faf7429b03 Premier commit du projet

2026-05-16 00:48:50 +02:00

26 KiB

Raw Permalink Blame History

TaxActe - Analyse des Gaps de Tests

Date : 2026-05-15 Auditeur : Agent Tests Phase : 0 (Diagnostic)

Resume Executif

Type de Test	Actuel	Objectif	Gap	Priorite
Unitaires	132	160+	28+	P1
E2E	0	12+	12	P1 (CRITIQUE)
Integration API	0	35+	35	P1 (CRITIQUE)
Charge	0	3	3	P2
AI/LLM	0	8+	8	P2

Coverage actuel : ~55% (uniquement src/lib/calculs/) Coverage objectif : 80% (calculs + API + auth + AI)

Effort estime Phase 3 : 22-25 jours-homme

CRITIQUE : 0 test E2E et 0 test d'integration = BLOQUANT pour production. Les calculs sont fiables (132/132 tests passent) mais les flows utilisateur et API ne sont pas testes.

1. Etat Actuel (Phase 0)

1.1 Tests Unitaires (132 tests - TOUS PASSENT)

Modules couverts :

vente-ancien.test.ts : 63 tests (baremes, TPF, primo, avant-contrats, edge cases)
succession.test.ts : 17 tests (emoluments, assiette, elements fixes)
usufruit.test.ts : 15 tests (bareme Art. 669 CGI, 10/10 conformes Notafrais)
pret-hypothecaire.test.ts : 15 tests (emoluments, TPF, CSI, accessoires)
plus-values.test.ts : 15 tests (duree detention, abattements IR/PS, surtaxe)
donation-immo.test.ts : 7 tests (emoluments, usufruit, TPF/CSI)

Conformite Notafrais :

Vente : +0.50€ (toutes valeurs de reference valides)
Pret : +1€ (accessoires 10%)
Succession : -40€ constant (tranches basses - ecart connu)
Usufruit : 10/10 parfait
Plus-values : conformite calculee (pas de reference Notafrais)
Donation : +1€

Pattern observe : AAA (Arrange-Act-Assert), data-driven tests avec test.each(), helpers pour creer inputs par defaut.

Qualite : EXCELLENTE (tests exhaustifs, edge cases couverts, invariants verifies).

1.2 Fichiers Critiques NON TESTES

src/lib/ (0% coverage hors calculs) :

auth.ts (102 lignes) : JWT sign/verify, sessions, cookies - CRITIQUE
ai.ts (226 lignes) : analyse IA, extraction parametres, mock fallback
ai-schemas.ts (138 lignes) : validation Zod, mapping module->schema
db.ts : connexion Prisma/PgBouncer
pdf-export.ts : generation PDF (@react-pdf/renderer)
settings.ts : gestion settings office

src/lib/calculs/ (modules non testes) :

bareme.ts (159 lignes) : baremes officiels, fonctions utilitaires (calculerEmolumentsProportionnels, getUsufruitPourcentage) - CRITIQUE
vente-ancien-pret.ts (143 lignes) : calcul combine vente+pret (pas de test dedie)

API Routes (22 routes, 0% testees) :

Auth (4) : /api/auth/{login,register,logout,session}
Calculs (7) : /api/calcul/{vente-ancien,pret-hypothecaire,succession,usufruit,plus-values,donation-immo,vente-ancien-pret}
Dossiers (1) : /api/dossiers (CRUD)
AI (2) : /api/ai/{analyze,chat}
PDF (1) : /api/pdf/generate
Admin (2) : /api/admin/{users,offices}
Superadmin (3) : /api/superadmin/{stats,offices,logs}
Settings (2) : /api/settings/{office,detect-branding}
Email (1) : /api/email/send

Middleware : src/middleware.ts (68 lignes) - protection routes, injection headers - CRITIQUE

Composants React : src/components/ (30+ fichiers .tsx) - 0% testes

2. Gaps Critiques par Type

2.1 Tests E2E (0 actuellement - BLOQUANT PRODUCTION)

Contexte : AUCUN test E2E n'existe. Impossible de valider les flows utilisateur reels.

Framework recommande : Playwright (deja decide selon CLAUDE.md)

Priorite 1 (bloquant production) :

Auth Flow (3 tests)
- Register : creation compte + office -> redirect dashboard
- Login : connexion -> dashboard (avec persistence session)
- Logout : deconnexion -> redirect login
Calcul Vente + Export PDF (2 tests)
- Flow complet : login -> formulaire vente -> resultats -> export PDF -> verification contenu PDF
- Validation erreurs : prix = 0, departement invalide, etc.
Chat IA -> Calcul (2 tests)
- Query IA "vente 250000€ dans l'Allier" -> extraction params -> calcul -> resultats affiches
- Query ambigue -> clarifications demandees -> re-query -> calcul

Priorite 2 :

Modification dossier existant (1 test)
- Login -> dashboard -> selectionner dossier -> modifier params -> recalculer -> sauvegarder
Admin : gestion utilisateurs (2 tests)
- Login ADMIN -> liste users -> creer user -> verifier email envoye (mock)
- Login ADMIN -> suspendre user -> verifier user ne peut plus se connecter
Gestion erreurs (2 tests)
- Session expiree : action apres 30j -> redirect login
- Calcul invalide : params hors limites -> message erreur clair

Effort estime : 5-6 jours

Setup Playwright + config CI : 0.5j
Auth flows : 1j
Calculs + PDF : 2j
IA flows : 1.5j
Admin + erreurs : 1j

2.2 Tests Integration API (0 actuellement - CRITIQUE)

Contexte : Aucune API route n'est testee. Les calculs purs fonctionnent, mais les routes HTTP (validation, mapping, sauvegarde DB) ne sont pas verifiees.

Framework recommande : Vitest + mocking Prisma (ou supertest si Next.js API routes compatibles)

Routes Auth (5 tests - CRITIQUE) :

POST /api/auth/login : credentials valides -> JWT cookie + session
POST /api/auth/login : credentials invalides -> 401
POST /api/auth/register : creation office + user -> JWT cookie
GET /api/auth/session : JWT valide -> infos user
POST /api/auth/logout : suppression cookie -> session nulle

Routes Calculs (14 tests) :

7 routes /api/calcul/{module} : 1 test OK + 1 test erreur (prix <= 0) par module
- vente-ancien, pret-hypothecaire, succession, usufruit, plus-values, donation-immo, vente-ancien-pret

Routes Dossiers (5 tests) :

GET /api/dossiers : liste filtree par officeId (isolation)
GET /api/dossiers?search=ref123 : recherche par reference
POST /api/calcul/* avec officeId : verification sauvegarde en DB
Tentative acces dossier autre office : 403 (SECURITE)
Liste vide si office n'a aucun dossier

Routes IA (4 tests) :

POST /api/ai/analyze : description "vente 200k€" -> extraction params + module
POST /api/ai/analyze : description ambigue -> clarifications retournees
POST /api/ai/chat : conversation multi-tours (2 questions max)
Fallback si SCALEWAY_API_KEY manquant : mock extraction par mots-cles

Route PDF (2 tests) :

POST /api/pdf/generate : params vente -> Buffer PDF valide (verification magic bytes %PDF)
POST /api/pdf/generate : params invalides -> 400

Routes Admin (3 tests) :

GET /api/admin/users : role ADMIN -> liste users office
POST /api/admin/users : creation user -> email envoye (mock)
GET /api/admin/users : role COLLABORATEUR -> 403

Middleware (2 tests) :

Request sans JWT -> redirect /login (pages) ou 401 (API)
Request avec JWT valide -> headers x-user-id, x-office-id, x-user-role injectes

Effort estime : 8-9 jours

Setup mocking Prisma + DB test : 1j
Auth routes : 1.5j
Calculs routes : 2j
Dossiers + isolation : 1.5j
IA routes : 1.5j
PDF + Admin + Middleware : 1.5j

2.3 Tests de Charge (0 actuellement)

Contexte : Aucun test de performance/charge. Impossible de valider la capacite serverless (Scaleway Functions).

Framework recommande : k6 (plus simple qu'Artillery, syntaxe JS)

Scenarios :

Calculs en masse (50 calculs/s pendant 5 min)
- Endpoint : POST /api/calcul/vente-ancien
- Metriques : p50, p95, p99 < 200ms
- Objectif : 15 000 calculs sans erreur
Connexions simultanees (100 users concurrents)
- Flow : login -> dashboard -> 3 calculs -> logout
- Metriques : 0 erreur DB (connexion pool PgBouncer), temps total < 30s
Stress test PDF (10 generations/s pendant 2 min)
- Endpoint : POST /api/pdf/generate
- Metriques : p95 < 2s, pas de timeout

Effort estime : 2 jours

Setup k6 + scripts : 0.5j
Scenario 1 (calculs) : 0.5j
Scenario 2 (users) : 0.5j
Scenario 3 (PDF) : 0.5j

2.4 Tests Unitaires Supplementaires (28+ tests manquants)

bareme.ts (CRITIQUE - 8 tests manquants) :

calculerEmolumentsProportionnels() : verification tranches (6500, 17000, 60000, Infinity)
Edge cases : assiette = 0, assiette negative, assiette enorme (50M€)
getUsufruitPourcentage() : ages limites (0, 20, 30, 40, 50, 60, 70, 80, 90, 120)
Constantes : verification TAUX_TPF["1"] = 0.045, TAUX.TVA = 0.20, etc.

vente-ancien-pret.ts (5 tests) :

Vente 200k€ + pret 150k€ HC : verification totalGeneral = sousTotalVente + sousTotalPret
Vente 200k€ + 80k€ HC + 70k€ PPD : verification TPF pret uniquement sur HC
Primo-accedant 50% + pret : verification TPF vente reduite, TPF pret normale
Edge case : vente 1€ + pret 1€
Invariant : pourcentagePrix coherent

auth.ts (6 tests) :

createSession() : verification JWT contient user, expires in 30j
getSession() : JWT valide -> session, JWT expire -> null
destroySession() : cookie supprime
verifyToken() : token invalide -> null, token expire -> null
Securite : JWT avec secret different -> null

ai.ts (5 tests) :

analyserDossier("vente 250000€") : module = VENTE_ANCIEN, params.prix = 250000
analyserDossier("donation avec usufruit") : module = DONATION_IMMO, usufruit = true
Description ambigue : clarifications.length > 0
Mock fallback (pas de SCALEWAY_API_KEY) : extraction par mots-cles
Edge case : description vide -> fallback generique

ai-schemas.ts (4 tests) :

validateAICalculBlock() : params valides -> valid = true
validateAICalculBlock() : prix negatif -> valid = false, errors contient "prix"
Module inconnu -> valid = true (pas de schema, on laisse passer)
Bloc malformed (pas de "module") -> valid = false

Effort estime : 3 jours

3. Coverage Detaille

3.1 Par Repertoire

Repertoire	Lignes	Tests	Coverage Estime	Objectif
`src/lib/calculs/`	~900	132	90%	95%
`src/lib/*.ts` (hors calculs)	~600	0	0%	70%
`src/app/api/`	~1200	0	0%	80%
`src/components/`	~2000	0	0%	50% (E2E couvre flows)
`src/middleware.ts`	68	0	0%	90%

Total : ~4800 lignes, ~132 tests (27% lignes), coverage reel ~55% (uniquement calculs)

Objectif global : 80% (calculs 95% + API 80% + lib 70%)

3.2 Modules Non Testes (Priorite)

P1 (CRITIQUE - bloquant production) :

auth.ts - 102 lignes (JWT, sessions, cookies)
middleware.ts - 68 lignes (protection routes, headers)
bareme.ts - 159 lignes (baremes officiels, fonctions utils)
Toutes les routes Auth (/api/auth/*)
Route dossiers (/api/dossiers) - isolation par office

P2 (important pour v1) : 6. ai.ts + ai-schemas.ts - 364 lignes (extraction IA, validation) 7. vente-ancien-pret.ts - 143 lignes (calcul combine) 8. Routes calculs (/api/calcul/*) - mapping + validation 9. Routes IA (/api/ai/*) - analyse + chat

P3 (nice-to-have) : 10. pdf-export.ts - generation PDF 11. Routes admin/superadmin 12. Composants React (via E2E seulement)

4. Plan d'Action Phase 3 (Semaines 5-6)

Semaine 5 (10 jours)

Jour 1-2 : Setup + Tests E2E Auth (2j)

Installer Playwright (npm install -D @playwright/test)
Config playwright.config.ts (baseURL, timeout, viewport)
Test E2E : Register -> Login -> Dashboard
Test E2E : Logout -> redirect login
CI/CD : ajouter npm run test:e2e dans pipeline

Jour 3-4 : Tests E2E Calculs (2j)

Test E2E : Login -> formulaire vente -> resultats affiches
Test E2E : Calcul -> export PDF -> verification contenu
Test E2E : IA "vente 250k€" -> calcul -> resultats
Test E2E : erreurs formulaire (prix = 0, departement invalide)

Jour 5-6 : Tests Integration Auth + Middleware (2j)

Setup mocking Prisma (ou DB test SQLite)
Tests /api/auth/login : OK + 401
Tests /api/auth/register : creation office + user
Tests /api/auth/session + /api/auth/logout
Tests middleware.ts : redirect + headers injection
Tests isolation : tentative acces dossier autre office -> 403

Jour 7-8 : Tests Unitaires Critiques (2j)

Tests bareme.ts : calculerEmolumentsProportionnels + getUsufruitPourcentage
Tests vente-ancien-pret.ts : calcul combine
Tests auth.ts : JWT sign/verify, sessions, cookies
Verifier coverage calculs passe de 90% a 95%

Jour 9-10 : Tests Integration Calculs (2j)

Tests 7 routes /api/calcul/* : 1 OK + 1 erreur par module
Tests sauvegarde dossier en DB (avec officeId)
Tests validation inputs (prix <= 0, dept invalide)

Semaine 6 (10 jours)

Jour 11-12 : Tests Integration Dossiers (2j)

Tests GET /api/dossiers : liste + search
Tests isolation par officeId (SECURITE)
Tests pagination (limit param)
Tests erreurs (session expiree, officeId manquant)

Jour 13-14 : Tests IA (2j)

Tests ai.ts : analyserDossier + mock fallback
Tests ai-schemas.ts : validateAICalculBlock
Tests /api/ai/analyze : extraction params + clarifications
Tests /api/ai/chat : conversation multi-tours

Jour 15-16 : Tests E2E Admin + Erreurs (2j)

Test E2E : Admin -> gestion users -> creer user
Test E2E : Session expiree -> redirect login
Test E2E : Modification dossier existant
Test E2E : Gestion erreurs calcul (params invalides)

Jour 17-18 : Tests de Charge (2j)

Setup k6 + scripts
Scenario 1 : 50 calculs/s pendant 5 min (15k calculs)
Scenario 2 : 100 users concurrents (stress DB pool)
Scenario 3 : 10 PDF/s pendant 2 min
Rapport : p50, p95, p99, taux erreur

Jour 19-20 : Tests Complementaires + CI (2j)

Tests /api/pdf/generate : PDF valide + erreurs
Tests /api/admin/* : role ADMIN vs COLLABORATEUR
Coverage final : verifier 80% global
CI/CD : tous les tests (unit + integration + E2E) dans pipeline
Documentation : update PLAN-DE-TEST.md avec resultats

5. Tests Manquants Detailles (Checklist)

Auth & Securite

Login avec email/password valides -> JWT cookie + 200
Login avec password invalide -> 401
Login avec email inexistant -> 401
Register : creation office + user -> JWT cookie + 200
Register : email deja existant -> 409
Session : JWT valide -> infos user + 200
Session : JWT expire -> null
Session : JWT invalide -> null
Logout : suppression cookie -> session nulle
Middleware : request sans JWT -> redirect /login (pages) ou 401 (API)
Middleware : request avec JWT valide -> headers injectes
Middleware : JWT expire -> redirect /login
Isolation : user office A ne peut pas voir dossiers office B

Calculs (API Routes)

POST /api/calcul/vente-ancien : prix 200k€ -> resultats OK
POST /api/calcul/vente-ancien : prix <= 0 -> 400
POST /api/calcul/pret-hypothecaire : HC 150k€ -> resultats OK
POST /api/calcul/pret-hypothecaire : HC + PPD = 0 -> 400
POST /api/calcul/succession : actif 300k€ -> resultats OK
POST /api/calcul/usufruit : PP 200k€, age 65 -> resultats OK
POST /api/calcul/plus-values : PV brute 50k€, 10 ans detention -> resultats OK
POST /api/calcul/donation-immo : valeur 200k€ -> resultats OK
POST /api/calcul/vente-ancien-pret : vente 200k€ + pret 150k€ -> resultats OK
Sauvegarde dossier : avec officeId -> entry en DB
Sauvegarde dossier : sans officeId -> pas d'entry (pas d'erreur)
Mapping params : dept "2" -> 3.8%, dept "3" -> 5%
Mapping params : typeBien "1" -> terrain, "2" -> maison, "3" -> appartement

Dossiers

GET /api/dossiers : liste filtree par officeId
GET /api/dossiers?search=ref123 : recherche par reference
GET /api/dossiers?limit=10 : pagination (10 resultats max)
GET /api/dossiers : sans session -> 401
GET /api/dossiers : office sans dossiers -> []
Tentative acces dossier autre office : 403 (test securite)

IA

analyserDossier("vente 250000€") : module VENTE_ANCIEN, params.prix = 250000
analyserDossier("vente avec pret") : module VENTE_ANCIEN_PRET
analyserDossier("donation immo") : module DONATION_IMMO
analyserDossier("succession") : module DECLARATION_SUCCESSION
analyserDossier("calcul usufruit 65 ans") : module USUFRUIT, age = 65
Description ambigue : clarifications.length > 0
Mock fallback (pas de SCALEWAY_API_KEY) : extraction mots-cles
validateAICalculBlock() : params valides -> valid = true
validateAICalculBlock() : prix negatif -> valid = false
validateAICalculBlock() : module inconnu -> valid = true (pas de schema)
POST /api/ai/analyze : description -> JSON avec module + params
POST /api/ai/chat : conversation multi-tours (historique)

Calculs Unitaires (bareme.ts)

calculerEmolumentsProportionnels(6500) : tranche 1 uniquement
calculerEmolumentsProportionnels(17000) : tranches 1 + 2
calculerEmolumentsProportionnels(60000) : tranches 1 + 2 + 3
calculerEmolumentsProportionnels(200000) : toutes tranches
calculerEmolumentsProportionnels(0) : 0€
calculerEmolumentsProportionnels(-100) : 0€ (edge case)
getUsufruitPourcentage(15) : 90% usufruit
getUsufruitPourcentage(60) : 50% usufruit
getUsufruitPourcentage(120) : 10% usufruit (age > 90)

E2E Flows

Register -> creation compte -> redirect dashboard
Login -> email + password -> dashboard affiche
Login -> session persistante (refresh page -> toujours connecte)
Logout -> redirect login -> dashboard inaccessible
Calcul vente : formulaire -> submit -> resultats affiches
Calcul vente : export PDF -> fichier telecharge (verification nom + taille > 10kb)
IA chat : "vente 250k€ dans l'Allier" -> params extraits -> calcul -> resultats
IA chat : question ambigue -> clarifications -> re-query -> calcul
Dashboard : liste dossiers recents (limite 20)
Dashboard : modifier dossier existant -> recalcul -> sauvegarde
Admin : login ADMIN -> liste users office -> creer user -> email envoye
Erreurs : session expiree apres 30j -> redirect login
Erreurs : calcul prix = 0 -> message "Le prix doit etre superieur a 0"

Charge

k6 : 50 calculs/s pendant 5 min (15k calculs) -> p95 < 200ms
k6 : 100 users concurrents (login + 3 calculs) -> 0 erreur DB
k6 : 10 PDF/s pendant 2 min -> p95 < 2s

6. Outils & Frameworks

Tests Unitaires & Integration

Vitest (deja installe) :

npm run test              # Tous les tests unitaires
npm run test:watch        # Mode watch (TDD)
npx vitest run --coverage # Rapport coverage

Mocking Prisma :

Option 1 : vitest.mock('@/lib/db') + factory manuelle
Option 2 : DB test SQLite in-memory (plus realiste)
Recommandation : DB test SQLite pour tests integration

Tests E2E

Playwright (a installer) :

npm install -D @playwright/test
npx playwright install     # Install browsers
npx playwright test        # Run E2E tests
npx playwright test --ui   # Mode debug

Config : playwright.config.ts

export default defineConfig({
  testDir: './tests/e2e',
  baseURL: 'http://localhost:3000',
  use: {
    viewport: { width: 1280, height: 720 },
    screenshot: 'only-on-failure',
  },
  webServer: {
    command: 'npm run dev',
    port: 3000,
    reuseExistingServer: !process.env.CI,
  },
});

Tests de Charge

k6 (a installer) :

brew install k6           # macOS
k6 run tests/load/calculs.js

Exemple script :

import http from 'k6/http';
import { check } from 'k6';

export const options = {
  vus: 50,
  duration: '5m',
};

export default function () {
  const res = http.post('http://localhost:3000/api/calcul/vente-ancien', JSON.stringify({
    prix: 200000,
    dept: '3',
    typeBien: 'appartement',
  }), {
    headers: { 'Content-Type': 'application/json' },
  });
  check(res, { 'status 200': (r) => r.status === 200 });
}

7. Criteres de Succes

Phase 3 (Semaines 5-6)

Coverage global > 80% (vitest --coverage)
160+ tests unitaires (132 actuels + 28+ nouveaux)
35+ tests integration API (routes auth + calculs + dossiers)
12+ tests E2E (flows critiques couverts)
3 scenarios de charge valides (p95 < 200ms calculs, p95 < 2s PDF)
0 regression vs tests actuels (132/132 toujours verts)
CI/CD execute tous les tests (unit + integration + E2E)
Documentation : PLAN-DE-TEST.md mis a jour avec resultats

Pre-Production

Tous les tests passent (unit + integration + E2E + charge)
Coverage > 80% verifie
Tests de charge : 50 calculs/s pendant 5 min sans erreur
Tests E2E : tous les flows critiques valides (auth, calcul, PDF, IA)
Tests securite : isolation par office validee (tentatives acces cross-office -> 403)
0 test flaky (tests instables a re-executer)

8. Risques & Mitigations

Risques Identifies

Tests E2E lents : Playwright peut etre lent (30s-1min par test)
- Mitigation : parallelisation (workers), mocking API externe (Scaleway AI)
Mocking Prisma complexe : isolation DB entre tests
- Mitigation : DB test SQLite in-memory, ou transactions rollback
Coverage faussement eleve : lignes executees != comportement valide
- Mitigation : focus sur tests comportementaux (AAA pattern), pas seulement coverage %
Maintenance tests E2E : fragiles aux changements UI
- Mitigation : data-testid selectors, page objects pattern
Tests de charge en local : pas representatif de production (serverless)
- Mitigation : executer k6 contre environnement staging (Scaleway Functions)

Plan B

Si retard Phase 3 (> 25j) :

Priorite absolue : tests E2E auth + calcul vente (4j)
Tests integration API auth + calculs (5j)
Tests unitaires bareme.ts (1j)
Total minimal : 10j pour debloquer production

9. Metriques de Suivi

KPIs Phase 3

Metrique	Debut	Semaine 5	Semaine 6 (fin)
Tests unitaires	132	145	160+
Tests integration	0	15	35+
Tests E2E	0	6	12+
Coverage global	55%	65%	80%+
Temps exec tests	400ms	2s	5s (sans E2E)
Temps exec E2E	N/A	2min	3min

Dashboard Coverage (a generer)

npx vitest run --coverage

Resultats attendus (fin Phase 3) :

src/lib/calculs/ : 95%
src/lib/*.ts : 70%
src/app/api/ : 80%
src/middleware.ts : 90%
Global : 80%+

10. Annexes

A. Commandes Utiles

Tests unitaires :

npm run test                          # Tous les tests
npm run test:watch                    # Mode watch
npx vitest run <file>                 # Test specifique
npx vitest --coverage                 # Rapport coverage
npx vitest --coverage --reporter=html # Rapport HTML

Tests E2E :

npx playwright test                   # Tous les E2E
npx playwright test --ui              # Mode debug UI
npx playwright test --headed          # Voir le browser
npx playwright test auth.spec.ts      # Test specifique
npx playwright show-report            # Rapport HTML

Tests de charge :

k6 run tests/load/calculs.js          # Scenario calculs
k6 run --vus 100 --duration 10m       # Custom params
k6 run --out json=results.json        # Export resultats

B. Reference Notafrais

Fichier : etude-marche-notafrais/scraper/test_reference_values.json

68 valeurs de reference :

Vente : 42 tests principaux (prix 100k€ a 1M€, dept 3.8%-5%, meubles, primo)
Vente variantes : 26 tests (SAFER, revente, avant-contrats)
Pret : 15 tests (HC, PPD, accessoires)
Succession : 10 tests
Usufruit : 10 tests (ages 15-85 ans)
Plus-values : pas de reference (calcul specifique)
Donation : 8 tests

Conformite actuelle : +0.50€ vente, +1€ pret, -40€ succession (tranches basses)

C. Modules sans Reference

Ces modules n'ont pas de reference externe Notafrais :

plus-values.ts : calcul fiscal (IR + PS), pas de simulateur notaire
vente-ancien-pret.ts : combine vente + pret (valide separement)

Tests bases sur :

Reglementation officielle (CGI Art. 150 U, 150 V pour plus-values)
Invariants mathematiques (assiette, abattements, seuils)
Edge cases (duree detention limites, surtaxe)

D. Structure Tests Recommandee

taxactes/
├── src/
│   ├── lib/
│   │   ├── calculs/
│   │   │   ├── __tests__/          # 132 tests existants
│   │   │   └── *.ts
│   │   ├── __tests__/              # NOUVEAU : auth, ai, bareme
│   │   └── *.ts
│   └── app/
│       └── api/
│           └── __tests__/          # NOUVEAU : integration API
├── tests/
│   ├── e2e/                        # NOUVEAU : Playwright
│   │   ├── auth.spec.ts
│   │   ├── calculs.spec.ts
│   │   └── ia.spec.ts
│   └── load/                       # NOUVEAU : k6
│       ├── calculs.js
│       ├── users.js
│       └── pdf.js
└── vitest.config.ts                # Config coverage

Conclusion

Etat actuel : Calculs fiables (132/132 tests passent, conformite Notafrais validee) mais ZERO test E2E et ZERO test integration API = BLOQUANT pour production.

Gaps critiques :

Aucun flow utilisateur teste (auth, calcul, PDF, IA)
Aucune route API testee (mapping, validation, sauvegarde DB)
Modules critiques non testes : auth.ts, middleware.ts, bareme.ts
Pas de tests de charge (capacite serverless inconnue)

Plan Phase 3 : 22-25 jours pour atteindre 80% coverage + 12 tests E2E + 35 tests integration + 3 scenarios charge.

Priorite absolue : Tests E2E auth + calcul vente (4j) + tests integration API auth (2j) = 6j minimum pour debloquer production.

Prochaine etape : Valider ce plan avec l'equipe, puis demarrer Phase 3 Semaine 5.

26 KiB Raw Permalink Blame History