@open3cl/engine 1.6.1 → 1.6.2

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.spec.js

@@ -5,6 +5,7 @@ import { ContexteBuilder } from '../../contexte.builder.js';
 import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
 import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
 import { beforeEach, describe, expect, test } from 'vitest';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionMurService} **/
 let service;
@@ -333,6 +334,121 @@ describe('Calcul de déperdition des murs', () => {
       expect(di.umur0).toBeCloseTo(0.81545);
       expect(di.umur).toBeCloseTo(0.81545);
     });
+
+    test('Isolation inconnue (méthode 2) : umur est plafonné par la valeur forfaitaire de la table', () => {
+      // enum_methode_saisie_u_id = '2' => on prend le min entre umur_nu et la valeur tabulée.
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {MurDE} */
+      const de = {
+        enum_materiaux_structure_mur_id: '12',
+        enum_methode_saisie_u_id: '2',
+        enum_methode_saisie_u0_id: '2',
+        epaisseur_structure: 25,
+        enum_type_doublage_id: '2',
+        enum_type_isolation_id: '2'
+      };
+
+      const di = service.execute(ctx, de);
+      // Valeurs de référence de régression
+      expect(di.umur0).toBeCloseTo(2.3);
+      expect(di.umur).toBeCloseTo(2.3);
+    });
+
+    test("Épaisseur d'isolation saisie mais manquante (méthode 4) : repli sur min(umur0, 2.5)", () => {
+      // Sans epaisseur_isolation, un avertissement est émis et umur = min(umur0, 2.5).
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {MurDE} */
+      const de = {
+        enum_materiaux_structure_mur_id: '12',
+        enum_methode_saisie_u_id: '4',
+        enum_methode_saisie_u0_id: '2',
+        epaisseur_structure: 25,
+        enum_type_doublage_id: '2',
+        enum_type_isolation_id: '2',
+        description: 'mur sans épaisseur isolation'
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.umur0).toBeCloseTo(2.3);
+      expect(di.umur).toBeCloseTo(2.3);
+    });
+
+    test("Résistance d'isolation saisie (méthode 5) : umur calculé à partir de la résistance", () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {MurDE} */
+      const de = {
+        enum_materiaux_structure_mur_id: '12',
+        enum_methode_saisie_u_id: '5',
+        enum_methode_saisie_u0_id: '2',
+        epaisseur_structure: 25,
+        enum_type_doublage_id: '2',
+        enum_type_isolation_id: '3',
+        resistance_isolation: 2.5
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.umur0).toBeCloseTo(2.3);
+      // 1 / (1 / 2.3 + 2.5) => valeur de référence de régression
+      expect(di.umur).toBeCloseTo(0.34074);
+    });
+
+    test('umur0 via matériau seul (méthode u0 = 1) sans épaisseur de structure', () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {MurDE} */
+      const de = {
+        enum_materiaux_structure_mur_id: '12',
+        enum_methode_saisie_u_id: '1',
+        enum_methode_saisie_u0_id: '1',
+        enum_type_doublage_id: '2',
+        enum_type_isolation_id: '2'
+      };
+
+      const di = service.execute(ctx, de);
+      // Matériau seul => valeur forfaitaire plafonnée à 2.5
+      expect(di.umur0).toBeCloseTo(2.5);
+      expect(di.umur).toBeCloseTo(2.5);
+    });
+
+    test('umur0 saisi directement via une méthode u0 non gérée (défaut)', () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {MurDE} */
+      const de = {
+        enum_methode_saisie_u_id: '1',
+        enum_methode_saisie_u0_id: '9',
+        umur0_saisi: 1.234,
+        enum_type_doublage_id: '2',
+        enum_type_isolation_id: '2'
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.umur0).toBeCloseTo(1.234);
+      expect(di.umur).toBeCloseTo(1.234);
+    });
   });
 
   test.each([
@@ -396,7 +512,7 @@ describe('Calcul de déperdition des murs', () => {
     }
   );
 
-  describe("Test d'intégration de mur", () => {
+  describeIntegration("Test d'intégration de mur", () => {
     test.each(corpus)('vérification des DI des murs pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/engine/domain/enveloppe/plancher_bas/deperdition-plancher-bas.service.spec.js

@@ -5,6 +5,7 @@ import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normaliz
 import { DeperditionPlancherBasService } from './deperdition-plancher-bas.service.js';
 import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
 import { beforeEach, describe, expect, test } from 'vitest';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionPlancherBasService} **/
 let service;
@@ -180,6 +181,138 @@ describe('Calcul de déperdition des planchers bas', () => {
       expect(di.upb0).toBeUndefined();
       expect(di.upb_final).toBeCloseTo(1.25);
     });
+
+    test('Isolation inconnue (méthode 2) : upb plafonné par la valeur forfaitaire de la table', () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '6',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherBasDE} */
+      const de = {
+        enum_type_adjacence_id: '21',
+        enum_type_plancher_bas_id: '2',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_methode_saisie_u_id: '2',
+        enum_periode_isolation_id: '6',
+        calcul_ue: 0
+      };
+
+      const di = service.execute(ctx, de, []);
+      expect(di.upb0).toBeCloseTo(1.45);
+      // Valeur de référence de régression
+      expect(di.upb).toBeCloseTo(0.5);
+      expect(di.upb_final).toBeCloseTo(0.5);
+    });
+
+    test.each([
+      // Méthodes 7 (année d'isolation) et 8 (année de construction) : même table forfaitaire.
+      { enumMethodeSaisieUId: '7' },
+      { enumMethodeSaisieUId: '8' }
+    ])(
+      'upb via table forfaitaire pour la méthode de saisie $enumMethodeSaisieUId',
+      ({ enumMethodeSaisieUId }) => {
+        /** @type {Contexte} */
+        const ctx = {
+          effetJoule: false,
+          enumPeriodeConstructionId: '6',
+          zoneClimatique: { id: '3' }
+        };
+        /** @type {PlancherBasDE} */
+        const de = {
+          enum_type_adjacence_id: '21',
+          enum_type_plancher_bas_id: '2',
+          enum_methode_saisie_u0_id: '2',
+          enum_type_isolation_id: '3',
+          enum_methode_saisie_u_id: enumMethodeSaisieUId,
+          enum_periode_isolation_id: '6',
+          calcul_ue: 0
+        };
+
+        const di = service.execute(ctx, de, []);
+        expect(di.upb0).toBeCloseTo(1.45);
+        // Valeur de référence de régression
+        expect(di.upb).toBeCloseTo(0.5);
+      }
+    );
+
+    test("Résistance d'isolation saisie (méthode 6) : upb calculé à partir de la résistance", () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '6',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherBasDE} */
+      const de = {
+        enum_type_adjacence_id: '21',
+        enum_type_plancher_bas_id: '2',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_methode_saisie_u_id: '6',
+        resistance_isolation: 2.5,
+        calcul_ue: 0
+      };
+
+      const di = service.execute(ctx, de, []);
+      expect(di.upb0).toBeCloseTo(1.45);
+      // 1 / (1 / 1.45 + 2.5) => valeur de référence de régression
+      expect(di.upb).toBeCloseTo(0.31351);
+    });
+
+    test("Résistance d'isolation saisie (méthode 5) : upb calculé à partir de la résistance", () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '6',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherBasDE} */
+      const de = {
+        enum_type_adjacence_id: '21',
+        enum_type_plancher_bas_id: '2',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_methode_saisie_u_id: '5',
+        resistance_isolation: 2.5,
+        calcul_ue: 0
+      };
+
+      const di = service.execute(ctx, de, []);
+      expect(di.upb0).toBeCloseTo(1.45);
+      // 1 / (1 / 1.45 + 2.5) => valeur de référence de régression
+      expect(di.upb).toBeCloseTo(0.31351);
+    });
+
+    test('Calcul Ue avec repli sur surface de paroi et périmètre nul (dsp par défaut = 1)', () => {
+      // Adjacence terre-plein, calcul_ue = 0 : le upb_final passe par la table Ue.
+      // Le plancher n'a ni surface_ue ni perimetre_ue => on retombe sur surface_paroi_opaque
+      // et un dsp forfaitaire de 1.
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '6',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherBasDE} */
+      const de = {
+        enum_type_adjacence_id: '5',
+        enum_type_plancher_bas_id: '9',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '2',
+        enum_methode_saisie_u_id: '1',
+        calcul_ue: 0,
+        surface_paroi_opaque: 40
+      };
+
+      const di = service.execute(ctx, de, [{ donnee_entree: de }]);
+      expect(di.upb0).toBeCloseTo(2);
+      expect(di.upb).toBeCloseTo(2);
+      // Valeur de référence de régression (Ue table, dsp = 1)
+      expect(di.upb_final).toBeCloseTo(0.74421);
+    });
   });
 
   test.each([
@@ -267,7 +400,7 @@ describe('Calcul de déperdition des planchers bas', () => {
     }
   );
 
-  describe("Test d'intégration de plancher bas", () => {
+  describeIntegration("Test d'intégration de plancher bas", () => {
     test.each(corpus)('vérification des DI des pb pour dpe %s', (ademeId) => {
       /**
        * @type {Dpe}

package/features/engine/domain/enveloppe/plancher_haut/deperdition-plancher-haut.service.spec.js

@@ -5,6 +5,7 @@ import { DeperditionPlancherHautService } from './deperdition-plancher-haut.serv
 import corpus from '../../../../../../test/corpus-sano.json';
 import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
 import { beforeEach, describe, expect, test } from 'vitest';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionPlancherHautService} **/
 let service;
@@ -193,6 +194,130 @@ describe('Calcul de déperdition des planchers haut', () => {
       expect(di.uph0).toBeCloseTo(2.5);
       expect(di.uph).toBeCloseTo(0.4);
     });
+
+    test('Plancher non isolé (méthode 1) : uph vaut uph_nu', () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherHautDE} */
+      const de = {
+        enum_type_adjacence_id: '1',
+        enum_type_plancher_haut_id: '10',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '2',
+        enum_methode_saisie_u_id: '1'
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.uph0).toBeCloseTo(2.3);
+      expect(di.uph).toBeCloseTo(2.3);
+    });
+
+    test("Épaisseur d'isolation saisie (méthode 4) : uph calculé à partir de l'épaisseur", () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherHautDE} */
+      const de = {
+        enum_type_adjacence_id: '1',
+        enum_type_plancher_haut_id: '10',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_methode_saisie_u_id: '4',
+        epaisseur_isolation: 10
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.uph0).toBeCloseTo(2.3);
+      // 1 / (1 / 2.3 + (10 * 0.01) / 0.04) => valeur de référence de régression
+      expect(di.uph).toBeCloseTo(0.34074);
+    });
+
+    test("Résistance d'isolation saisie (méthode 6) : uph calculé à partir de la résistance", () => {
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherHautDE} */
+      const de = {
+        enum_type_adjacence_id: '1',
+        enum_type_plancher_haut_id: '10',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_methode_saisie_u_id: '6',
+        resistance_isolation: 2.5
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.uph0).toBeCloseTo(2.3);
+      // 1 / (1 / 2.3 + 2.5) => valeur de référence de régression
+      expect(di.uph).toBeCloseTo(0.34074);
+    });
+
+    test.each([
+      // Isolation inconnue via table forfaitaire (méthode 2) et variantes épaisseur/résistance.
+      { enumMethodeSaisieUId: '2', uphExpected: 0.75 },
+      { enumMethodeSaisieUId: '3', epaisseurIsolation: 10, uphExpected: 0.34074 },
+      { enumMethodeSaisieUId: '5', resistanceIsolation: 2.5, uphExpected: 0.34074 }
+    ])(
+      'uph pour la méthode de saisie $enumMethodeSaisieUId',
+      ({ enumMethodeSaisieUId, epaisseurIsolation, resistanceIsolation, uphExpected }) => {
+        /** @type {Contexte} */
+        const ctx = {
+          effetJoule: false,
+          enumPeriodeConstructionId: '2',
+          zoneClimatique: { id: '3' }
+        };
+        /** @type {PlancherHautDE} */
+        const de = {
+          enum_type_adjacence_id: '1',
+          enum_type_plancher_haut_id: '10',
+          enum_methode_saisie_u0_id: '2',
+          enum_type_isolation_id: '3',
+          enum_periode_isolation_id: '3',
+          enum_methode_saisie_u_id: enumMethodeSaisieUId,
+          epaisseur_isolation: epaisseurIsolation,
+          resistance_isolation: resistanceIsolation
+        };
+
+        const di = service.execute(ctx, de);
+        expect(di.uph0).toBeCloseTo(2.3);
+        // Valeurs de référence de régression
+        expect(di.uph).toBeCloseTo(uphExpected);
+      }
+    );
+
+    test("Adjacence 'locaux non chauffés non accessible' (7) : uph_tab pris en catégorie terrasse", () => {
+      // @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.2.3.1
+      /** @type {Contexte} */
+      const ctx = {
+        effetJoule: false,
+        enumPeriodeConstructionId: '2',
+        zoneClimatique: { id: '3' }
+      };
+      /** @type {PlancherHautDE} */
+      const de = {
+        enum_type_adjacence_id: '7',
+        enum_type_plancher_haut_id: '1',
+        enum_methode_saisie_u0_id: '2',
+        enum_type_isolation_id: '3',
+        enum_periode_isolation_id: '6',
+        enum_methode_saisie_u_id: '8'
+      };
+
+      const di = service.execute(ctx, de);
+      expect(di.uph0).toBeCloseTo(2.5);
+      // Valeur de référence de régression (catégorie terrasse)
+      expect(di.uph).toBeCloseTo(0.4);
+    });
   });
 
   test.each([
@@ -256,7 +381,7 @@ describe('Calcul de déperdition des planchers haut', () => {
     }
   );
 
-  describe("Test d'intégration de plancher haut", () => {
+  describeIntegration("Test d'intégration de plancher haut", () => {
     test.each(corpus)('vérification des DI des ph pour dpe %s', (ademeId) => {
       /**
        * @type {Dpe}

package/features/engine/domain/enveloppe/pont_thermique/deperdition-pont-thermique.service.spec.js

@@ -8,6 +8,7 @@ import { PontThermiqueTvStore } from '../../../../dpe/infrastructure/enveloppe/p
 import { DeperditionMurService } from '../mur/deperdition-mur.service.js';
 import { DeperditionPlancherHautService } from '../plancher_haut/deperdition-plancher-haut.service.js';
 import { DeperditionPlancherBasService } from '../plancher_bas/deperdition-plancher-bas.service.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionPontThermiqueService} **/
 let service;
@@ -421,6 +422,22 @@ describe('Calcul de déperdition des ponts thermiques', () => {
       expect(tvStore.getKForMurById).not.toHaveBeenCalled();
       expect(tvStore.getKForMenuiserie).toHaveBeenCalledWith(5, 'iti', 3, 0, 5);
     });
+
+    test('Pont thermique nul pour une paroi en brique de verre (vitrage 5)', () => {
+      // @see Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.4.5 Menuiserie / mur
+      // Les liaisons avec des parois en brique de verre (type_vitrage 5) sont prises nulles.
+      vi.spyOn(tvStore, 'getKForMenuiserie').mockReturnValue(0.25);
+
+      const pontThermiqueDE = { reference_1: 'reference' };
+      const enveloppe = {
+        baie_vitree_collection: {
+          baie_vitree: [{ donnee_entree: { reference: 'reference', enum_type_vitrage_id: '5' } }]
+        }
+      };
+
+      expect(service.pontThermiqueMenuiserieMur(pontThermiqueDE, enveloppe, 3)).toBe(0);
+      expect(tvStore.getKForMenuiserie).not.toHaveBeenCalled();
+    });
   });
 
   describe("Calcul de l'isolation du mur", () => {
@@ -616,7 +633,7 @@ describe('Calcul de déperdition des ponts thermiques', () => {
     });
   });
 
-  describe("Test d'intégration des ponts thermiques", () => {
+  describeIntegration("Test d'intégration des ponts thermiques", () => {
     test.each(corpus)('vérification des DI des ponts thermiques pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/engine/domain/enveloppe/porte/deperdition-porte.service.spec.js

@@ -3,6 +3,7 @@ import corpus from '../../../../../../test/corpus-sano.json';
 import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 import { beforeEach, describe, expect, test } from 'vitest';
 import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionPorteService} **/
 let service;
@@ -99,7 +100,7 @@ describe('Calcul de déperdition des portes', () => {
     });
   });
 
-  describe("Test d'intégration de porte", () => {
+  describeIntegration("Test d'intégration de porte", () => {
     test.each(corpus)('vérification des DI des portes pour dpe %s', (ademeId) => {
       const dpeRequest = getAdemeFileJson(ademeId);
       /** @type {Contexte} */

package/features/engine/domain/enveloppe/ventilation/deperdition-ventilation.service.spec.js

@@ -7,6 +7,8 @@ import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
 import { ContexteBuilder } from '../../contexte.builder.js';
 import { DeperditionEnveloppeService } from '../deperdition-enveloppe.service.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
+import { logger } from '../../../../../core/util/logger/log-service.js';
 
 /** @type {DeperditionVentilationService} **/
 let service;
@@ -87,6 +89,17 @@ describe('Calcul de déperdition des portes', () => {
         expectedIsolationSurface: '1',
         expectedPresenceJointsMenuiserie: undefined
       },
+      {
+        // 1948-1974 mais moins de 50% de surface isolée => isolationSurface '0'
+        q4paConvSaisi: undefined,
+        enumPeriodeConstructionId: '2',
+        surfaceIsolee: 100,
+        surfaceNonIsolee: 200,
+        surfaceMenuiserieAvecJoint: 0,
+        surfaceMenuiserieSansJoint: 0,
+        expectedIsolationSurface: '0',
+        expectedPresenceJointsMenuiserie: undefined
+      },
       {
         q4paConvSaisi: undefined,
         enumPeriodeConstructionId: '3',
@@ -408,7 +421,60 @@ describe('Calcul de déperdition des portes', () => {
     );
   });
 
-  describe("Test d'intégration des ventilations", () => {
+  describe('execute (agrégation des déperditions et consommations de ventilation)', () => {
+    /** @type {Contexte} */
+    const ctx = {
+      surfaceHabitable: 100,
+      hauteurSousPlafond: 2.5,
+      typeHabitation: TypeHabitation.MAISON,
+      enumPeriodeConstructionId: '3'
+    };
+
+    test('assemble hvent, hperm et la consommation des auxiliaires', () => {
+      vi.spyOn(tvStore, 'getDebitsVentilation').mockReturnValue({
+        qvarep_conv: 10,
+        qvasouf_conv: 5,
+        smea_conv: 2
+      });
+      vi.spyOn(tvStore, 'getQ4paConv').mockReturnValue({ q4pa_conv: 1.7 });
+
+      /** @type {VentilationDE} */
+      const de = {
+        enum_type_ventilation_id: '4',
+        ventilation_post_2012: true,
+        plusieurs_facade_exposee: false
+      };
+
+      const di = service.execute(ctx, de, 120, 80, 40, 10, 5);
+
+      expect(tvStore.getDebitsVentilation).toHaveBeenCalledWith('4');
+      // hvent = 0.34 * qvarep_conv * surfaceHabitable
+      expect(di.hvent).toBeCloseTo(340, 5);
+      // pventMoy (SF auto, maison, post 2012) = 35 => conso = 8.76 * 35
+      expect(di.pvent_moy).toBe(35);
+      expect(di.conso_auxiliaire_ventilation).toBeCloseTo(306.6, 5);
+      // hperm : valeur de référence de régression
+      expect(di.hperm).toBeCloseTo(0.10692928032279153, 9);
+    });
+
+    test('conso des auxiliaires nulle sans type de ventilation ni indicateur post 2012', () => {
+      vi.spyOn(tvStore, 'getDebitsVentilation').mockReturnValue({});
+      vi.spyOn(tvStore, 'getQ4paConv').mockReturnValue({ q4pa_conv: 1.7 });
+      const errorSpy = vi.spyOn(logger, 'error').mockImplementation(() => {});
+
+      /** @type {VentilationDE} */
+      const de = { plusieurs_facade_exposee: false };
+
+      const di = service.execute(ctx, de, 0, 0, 0, 0, 0);
+
+      expect(errorSpy).toHaveBeenCalledOnce();
+      // La consommation retournée vaut 0 (nombre), les clés conso ne sont donc pas ajoutées
+      expect(di.conso_auxiliaire_ventilation).toBeUndefined();
+      expect(di.pvent_moy).toBeUndefined();
+    });
+  });
+
+  describeIntegration("Test d'intégration des ventilations", () => {
     test.each(corpus)('vérification des DI de la ventilation pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/normalizer/domain/dpe-normalizer.service.js

@@ -1,4 +1,4 @@
-import { DpePreProcessor } from '../../../../../preprocessor/index.js';
+import { DpePreProcessor } from '../../../preprocessor/index.js';
 
 /**
  * Service de normalisation du DPE d'entrée

package/features/normalizer/domain/dpe-normalizer.service.spec.js

@@ -1,3 +1,54 @@
-import { describe } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 
-describe.skip('Normalisation des DPE', () => {});
+// Isolation : on mocke le pré-processeur importé par le service afin de tester
+// uniquement la logique de normalisation (clonage + délégation), sans dépendre
+// du comportement réel de `DpePreProcessor` (testé dans son propre spec).
+const preprocessMock = vi.fn();
+vi.mock('../../../preprocessor/index.js', () => ({
+  DpePreProcessor: vi.fn().mockImplementation(() => ({
+    preprocess: preprocessMock
+  }))
+}));
+
+const { DpeNormalizerService } = await import('./dpe-normalizer.service.js');
+const { DpePreProcessor } = await import('../../../preprocessor/index.js');
+
+describe('Normalisation des DPE (DpeNormalizerService)', () => {
+  beforeEach(() => {
+    preprocessMock.mockReset();
+    vi.mocked(DpePreProcessor).mockClear();
+  });
+
+  test("clone le DPE d'entrée sans le muter puis délègue au pré-processeur", () => {
+    const dpeOrigine = { logement: { enveloppe: { mur: [{ id: 1 }] } } };
+    const service = new DpeNormalizerService();
+
+    const normalise = service.normalize(dpeOrigine);
+
+    // Le pré-processeur est instancié et reçoit le clone à normaliser.
+    expect(DpePreProcessor).toHaveBeenCalledTimes(1);
+    expect(preprocessMock).toHaveBeenCalledTimes(1);
+    expect(preprocessMock).toHaveBeenCalledWith(normalise);
+
+    // Le résultat est structurellement égal à l'entrée...
+    expect(normalise).toEqual(dpeOrigine);
+    // ...mais c'est bien un clone profond (aucune référence partagée).
+    expect(normalise).not.toBe(dpeOrigine);
+    expect(normalise.logement).not.toBe(dpeOrigine.logement);
+    expect(normalise.logement.enveloppe.mur).not.toBe(dpeOrigine.logement.enveloppe.mur);
+  });
+
+  test("ne modifie pas le DPE d'origine même si le pré-processeur mute le clone", () => {
+    // Le pré-processeur mocké mute le DPE reçu : l'original doit rester intact.
+    preprocessMock.mockImplementation((dpe) => {
+      dpe.ajoute = 'valeur';
+    });
+    const dpeOrigine = { a: 1 };
+    const service = new DpeNormalizerService();
+
+    const normalise = service.normalize(dpeOrigine);
+
+    expect(normalise).toEqual({ a: 1, ajoute: 'valeur' });
+    expect(dpeOrigine).toEqual({ a: 1 });
+  });
+});

package/ficheTechnique.spec.js

@@ -156,6 +156,32 @@ describe('FicheTechnique service tests', () => {
     expect(fiche.valeur).toBe('aucune');
   });
 
+  test('should normalize a single sous_fiche_technique into an array when filtering on classifications', async () => {
+    // sous_fiche_technique est un objet unique (et non un tableau) : il doit être normalisé
+    const dpeSingleSousFiche = {
+      fiche_technique_collection: {
+        fiche_technique: {
+          enum_categorie_fiche_technique_id: '10',
+          sous_fiche_technique_collection: {
+            sous_fiche_technique: {
+              description: 'Type de ventilation: VMC SF',
+              valeur: 'VMC SF'
+            }
+          }
+        }
+      }
+    };
+
+    // la classification 'VMC SF' correspond => la fiche est retournée
+    const fiche = getFicheTechnique(dpeSingleSousFiche, '10', 'ventilation', ['VMC SF']);
+    expect(fiche).not.toBeNull();
+    expect(fiche.valeur).toBe('VMC SF');
+
+    // une classification absente => aucune fiche
+    const aucune = getFicheTechnique(dpeSingleSousFiche, '10', 'ventilation', ['absente']);
+    expect(aucune).toBeNull();
+  });
+
   test('should not return a non existing fiche technique', async () => {
     let fiche = getFicheTechnique(dpe, '40', 'exposées');
     expect(fiche).toBeNull();