@open3cl/engine 1.6.1 → 1.6.2

package/enums.spec.js

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest';
+import enums from './enums.js';
+
+/**
+ * `enums.js` est un gros mapping figé (identifiant -> libellé) issu du modèle
+ * de données ADEME. On ne fige pas l'intégralité du contenu : on vérifie
+ * uniquement des invariants structurels et la présence de quelques enums clés.
+ */
+describe('Table des enums (enums.js)', () => {
+  test('exporte un objet non vide par défaut', () => {
+    expect(enums).toBeTypeOf('object');
+    expect(enums).not.toBeNull();
+    expect(Object.keys(enums).length).toBeGreaterThan(0);
+  });
+
+  test('quelques enums clés sont présents et non vides', () => {
+    ['version', 'modele_dpe', 'usage_fonctionnel_batiment', 'consentement_formulaire'].forEach(
+      (cle) => {
+        expect(enums).toHaveProperty(cle);
+        expect(Object.keys(enums[cle]).length).toBeGreaterThan(0);
+      }
+    );
+  });
+
+  test('chaque enum est un objet dont les libellés sont des chaînes non vides', () => {
+    Object.entries(enums).forEach(([nomEnum, valeurs]) => {
+      expect(valeurs, `enum ${nomEnum}`).toBeTypeOf('object');
+      Object.values(valeurs).forEach((libelle) => {
+        expect(typeof libelle).toBe('string');
+        expect(libelle.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  test('les identifiants (clés) sont uniques au sein de chaque enum', () => {
+    Object.entries(enums).forEach(([nomEnum, valeurs]) => {
+      const cles = Object.keys(valeurs);
+      expect(new Set(cles).size, `enum ${nomEnum}`).toBe(cles.length);
+    });
+  });
+
+  test('contenu attendu pour l’enum modele_dpe', () => {
+    expect(enums.modele_dpe['1']).toBe('dpe 3cl 2021 méthode logement');
+    expect(enums.consentement_formulaire['0']).toBe('absence de consentement');
+  });
+});

package/features/dpe/domain/models/type-generateur.model.js

@@ -2,7 +2,6 @@
  * @type {{[key: string]: string}}
  */
 export const TypeGenerateur = {
-  COMBUSTION: 'COMBUSTION',
-  PAC: 'PAC',
+  CHAUDIERE: 'CHAUDIERE',
   OTHER: 'OTHER'
 };

package/features/dpe/domain/models/type-generateur.model.spec.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from 'vitest';
+import { TypeGenerateur } from './type-generateur.model.js';
+
+describe('Modèle TypeGenerateur', () => {
+  test('expose les types de générateurs attendus', () => {
+    expect(TypeGenerateur).toEqual({
+      CHAUDIERE: 'CHAUDIERE',
+      OTHER: 'OTHER'
+    });
+  });
+
+  test('chaque clé correspond à une valeur chaîne identique (auto-référence)', () => {
+    Object.entries(TypeGenerateur).forEach(([cle, valeur]) => {
+      expect(typeof valeur).toBe('string');
+      expect(valeur).toBe(cle);
+    });
+  });
+
+  test('les valeurs sont uniques et non vides', () => {
+    const valeurs = Object.values(TypeGenerateur);
+    expect(valeurs.length).toBeGreaterThan(0);
+    expect(new Set(valeurs).size).toBe(valeurs.length);
+    valeurs.forEach((valeur) => expect(valeur.length).toBeGreaterThan(0));
+  });
+});

package/features/dpe/domain/models/type-habitation.model.spec.js

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'vitest';
+import { TypeHabitation, TypeDpe } from './type-habitation.model.js';
+
+describe('Modèle TypeHabitation', () => {
+  test("expose les types d'habitation attendus", () => {
+    expect(TypeHabitation).toEqual({
+      MAISON: 'MAISON',
+      APPARTEMENT: 'APPARTEMENT',
+      IMMEUBLE: 'IMMEUBLE'
+    });
+  });
+
+  test('chaque clé est auto-référencée par sa valeur', () => {
+    Object.entries(TypeHabitation).forEach(([cle, valeur]) => {
+      expect(valeur).toBe(cle);
+    });
+  });
+});
+
+describe('Modèle TypeDpe', () => {
+  test('expose les types de DPE attendus', () => {
+    expect(TypeDpe).toEqual({
+      MAISON: 'MAISON',
+      APPARTEMENT: 'APPARTEMENT',
+      APPARTEMENT_A_PARTIR_IMMEUBLE: 'APPARTEMENT_A_PARTIR_IMMEUBLE',
+      IMMEUBLE: 'IMMEUBLE'
+    });
+  });
+
+  test('les valeurs sont uniques et non vides', () => {
+    const valeurs = Object.values(TypeDpe);
+    expect(new Set(valeurs).size).toBe(valeurs.length);
+    valeurs.forEach((valeur) => expect(valeur.length).toBeGreaterThan(0));
+  });
+
+  test('reprend les types communs avec TypeHabitation', () => {
+    expect(TypeDpe.MAISON).toBe(TypeHabitation.MAISON);
+    expect(TypeDpe.APPARTEMENT).toBe(TypeHabitation.APPARTEMENT);
+    expect(TypeDpe.IMMEUBLE).toBe(TypeHabitation.IMMEUBLE);
+  });
+});

package/features/dpe/domain/models/type-stockage.model.spec.js

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest';
+import { TypeStockage } from './type-stockage.model.js';
+
+describe('Modèle TypeStockage', () => {
+  test('expose les types de stockage attendus', () => {
+    expect(TypeStockage).toEqual({
+      INSTANTANE: 'INSTANTANE',
+      INTEGRE: 'INTEGRE',
+      INDEPENDANT: 'INDEPENDANT'
+    });
+  });
+
+  test('chaque clé est auto-référencée et les valeurs sont uniques', () => {
+    const valeurs = Object.values(TypeStockage);
+    Object.entries(TypeStockage).forEach(([cle, valeur]) => expect(valeur).toBe(cle));
+    expect(new Set(valeurs).size).toBe(valeurs.length);
+  });
+});

package/features/dpe/domain/models/type-ventilation.model.spec.js

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest';
+import { TypeVentilation } from './type-ventilation.model.js';
+
+describe('Modèle TypeVentilation', () => {
+  test('expose les types de ventilation attendus', () => {
+    expect(TypeVentilation).toEqual({
+      SIMPLE_FLUX_AUTO: 'SIMPLE_FLUX_AUTO',
+      SIMPLE_FLUX_HYGRO: 'SIMPLE_FLUX_HYGRO',
+      DOUBLE_FLUX: 'DOUBLE_FLUX'
+    });
+  });
+
+  test('chaque clé est auto-référencée et les valeurs sont uniques', () => {
+    const valeurs = Object.values(TypeVentilation);
+    Object.entries(TypeVentilation).forEach(([cle, valeur]) => expect(valeur).toBe(cle));
+    expect(new Set(valeurs).size).toBe(valeurs.length);
+    valeurs.forEach((valeur) => expect(valeur.length).toBeGreaterThan(0));
+  });
+});

package/features/dpe/infrastructure/ch/chTv.store.spec.js

@@ -33,8 +33,8 @@ describe('Lecture des tables de valeurs', () => {
       enum_type_generateur_ecs_id: '46|93',
       type_generateur: 'Chaudière gaz  classique 1981-1985',
       pn: 'Pn',
-      rpn: '84 + 2 logPn',
-      rpint: '80 + 3 logPn',
+      rpn: '84+2*log10(Pn)',
+      rpint: '80+3*log10(Pn)',
       qp0_perc: '2%',
       pveil: '150'
     });
@@ -46,8 +46,8 @@ describe('Lecture des tables de valeurs', () => {
       type_generateur: 'Chaudière fioul à condensation après 2015',
       critere_pn: '70<Pn≤400',
       pn: 'Pn',
-      rpn: '94 + logPn',
-      rpint: '100 + logPn',
+      rpn: '94+log10(Pn)',
+      rpint: '100+log10(Pn)',
       qp0_perc: '0.60%'
     });
   });

package/features/dpe/infrastructure/enveloppe/baieVitreeTv.store.js

@@ -119,15 +119,19 @@ export class BaieVitreeTvStore extends TvStore {
           (v) =>
             v.enum_type_baie_id.split('|').includes(enumTypeBaieId) &&
             v.enum_type_materiaux_menuiserie_id.split('|').includes(enumTypeMateriauxMenuiserieId)
-        ) || [];
+        ) /* c8 ignore next -- .filter renvoie toujours un tableau : fallback défensif inatteignable */ ||
+        [];
 
       let ug1, ug2;
 
       if (ugValues.length) {
         [ug1, ug2] = getRange(ug, [...new Set(ugValues.map((value) => value.ug).sort())]);
 
+        /* c8 ignore start -- getRange renvoie des bornes issues de ugValues : le find aboutit
+           toujours et le fallback `|| 0` reste défensif (inatteignable avec les données réelles). */
         const uw1 = ugValues.find((value) => value.ug === ug1)?.uw || 0;
         const uw2 = ugValues.find((value) => value.ug === ug2)?.uw || 0;
+        /* c8 ignore stop */
 
         const delta_uw = Number(uw2) - Number(uw1);
         const delta_ug = ug2 - ug1 || 0;
@@ -191,7 +195,9 @@ export class BaieVitreeTvStore extends TvStore {
      */
     const deltar = this.getDeltar(enumTypeFermetureId);
     const uwValues =
-      tv['ujn'].filter((v) => Number(v.deltar).toPrecision(2) === Number(deltar).toPrecision(2)) ||
+      tv['ujn'].filter(
+        (v) => Number(v.deltar).toPrecision(2) === Number(deltar).toPrecision(2)
+      ) /* c8 ignore next -- .filter renvoie toujours un tableau : fallback défensif inatteignable */ ||
       [];
 
     let uw1, uw2;
@@ -199,12 +205,15 @@ export class BaieVitreeTvStore extends TvStore {
     if (uwValues.length) {
       [uw1, uw2] = getRange(uw, [...new Set(uwValues.map((value) => value.uw).sort())]);
 
+      /* c8 ignore start -- getRange renvoie des bornes issues de uwValues : le find aboutit
+         toujours et le fallback `|| 0` reste défensif (inatteignable avec les données réelles). */
       const ujn1 =
         uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw1).toPrecision(2))
           ?.ujn || 0;
       const ujn2 =
         uwValues.find((value) => Number(value.uw).toPrecision(2) === Number(uw2).toPrecision(2))
           ?.ujn || 0;
+      /* c8 ignore stop */
 
       const delta_ujn = Number(ujn2) - Number(ujn1);
       const delta_uw = uw2 - uw1 || 0;
@@ -216,12 +225,15 @@ export class BaieVitreeTvStore extends TvStore {
         ujn = Number(ujn1) + (delta_ujn * (uw - uw1)) / delta_uw;
       }
 
+      /* c8 ignore start -- les valeurs ujn tabulées sont toujours strictement positives :
+         ce garde-fou `!ujn` est défensif et inatteignable avec les données réelles. */
       if (!ujn) {
         logger.error(
           `Pas de valeur forfaitaire ujn pour enumTypeFermetureId:${enumTypeFermetureId}, uw:${uw}`
         );
         return;
       }
+      /* c8 ignore stop */
 
       return parseFloat(ujn);
     }

package/features/dpe/infrastructure/enveloppe/baieVitreeTv.store.spec.js

@@ -222,6 +222,16 @@ describe('Lecture des tables de valeurs', () => {
       const ug = tvStore.getSw('0', '0', 0);
       expect(ug).toBeUndefined();
     });
+
+    test('uw non interpolé lorsque le ug fourni correspond exactement à une valeur tabulée', () => {
+      // ug passé sous forme de chaîne présente dans la table => getRange renvoie deux
+      // bornes égales, delta_ug vaut 0 et uw prend directement la valeur tabulée (uw1).
+      expect(tvStore.getUw('4', '6', '0.5')).toBeCloseTo(1.3, 2);
+    });
+
+    test("uw indéfini lorsqu'aucune ligne ne correspond au type de baie / matériau", () => {
+      expect(tvStore.getUw('9', '99', 2)).toBeUndefined();
+    });
   });
 
   describe('lecture des valeurs de ujn', () => {
@@ -252,6 +262,12 @@ describe('Lecture des tables de valeurs', () => {
       const ug = tvStore.getUjn('0', 0);
       expect(ug).toBeUndefined();
     });
+
+    test('ujn non interpolé lorsque le uw fourni correspond exactement à une valeur tabulée', () => {
+      // uw passé sous forme de chaîne présente dans la table => getRange renvoie deux
+      // bornes égales, delta_uw vaut 0 et ujn prend directement la valeur tabulée (ujn1).
+      expect(tvStore.getUjn('2', '0.8')).toBeCloseTo(0.8, 2);
+    });
   });
 
   describe('lecture des valeurs de deltar', () => {

package/features/dpe/infrastructure/tv.store.js

@@ -3,6 +3,23 @@ import { getRange } from '../../../utils.js';
 import { logger } from '../../../core/util/logger/log-service.js';
 import { TypeHabitation } from '../domain/models/type-habitation.model.js';
 
+/**
+ * Extrait la borne numérique d'un libellé de plage aiu/aue de la table
+ * `coef_reduction_deperdition`. Les bornes y sont stockées sous forme de libellés
+ * formatés à la française (ex: `'≤ 6,00'`, `'4,00 <'`) et doivent être converties
+ * en nombre pour être comparées au ratio surface_aiu / surface_aue.
+ *
+ * @param bound {string} Libellé de borne (ex: `'≤ 0,25'`, `'0,25 <'`)
+ * @return {number} Valeur numérique de la borne
+ */
+export function parseAiuAueBound(bound) {
+  return parseFloat(
+    String(bound)
+      .replace(/,/g, '.')
+      .replace(/[^\d.]/g, '')
+  );
+}
+
 /**
  * Accès aux données des tables de valeurs
  *
@@ -60,8 +77,8 @@ export class TvStore {
           !v.zone_climatique ||
           zc.toLowerCase().startsWith(v.zone_climatique.toLowerCase())) &&
         (!rAiuAue ||
-          ((!v.aiu_aue_min || v.aiu_aue_min < rAiuAue) &&
-            (!v.aiu_aue_max || v.aiu_aue_max >= rAiuAue)))
+          ((!v.aiu_aue_min || parseAiuAueBound(v.aiu_aue_min) < rAiuAue) &&
+            (!v.aiu_aue_max || parseAiuAueBound(v.aiu_aue_max) >= rAiuAue)))
     )?.b;
 
     if (!b) {
@@ -208,13 +225,14 @@ export class TvStore {
    * @return {number|undefined}
    */
   getUeByUpd(enumTypeAdjacenceId, enumPeriodeConstructionId, dsp, upb) {
-    const ueValues =
-      tv['ue'].filter(
-        (v) =>
-          parseInt(v['2s_p']) === dsp &&
-          v.enum_type_adjacence_id.split('|').includes(enumTypeAdjacenceId) &&
-          v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId)
-      ) || [];
+    const ueFiltered = tv['ue'].filter(
+      (v) =>
+        parseInt(v['2s_p']) === dsp &&
+        v.enum_type_adjacence_id.split('|').includes(enumTypeAdjacenceId) &&
+        v.enum_periode_construction_id.split('|').includes(enumPeriodeConstructionId)
+    );
+    /* c8 ignore next -- Array.filter renvoie toujours un tableau : repli || [] défensif inatteignable */
+    const ueValues = ueFiltered || [];
 
     const ueRange = [...new Set(ueValues.map((value) => value.upb).sort())];
     let ue;
@@ -223,6 +241,7 @@ export class TvStore {
     if (ueValues.length) {
       [upb1, upb2] = getRange(upb, ueRange);
 
+      /* c8 ignore next 2 -- upb1/upb2 sont toujours des bornes tabulées de ueValues : find() aboutit et ?.ue n'est jamais falsy (replis inatteignables) */
       const ue1 = ueValues.find((value) => value.upb === upb1)?.ue || 0;
       const ue2 = ueValues.find((value) => value.upb === upb2)?.ue || 0;
 

package/features/dpe/infrastructure/tv.store.spec.js

@@ -11,6 +11,23 @@ describe('Lecture des tables de valeurs', () => {
     tvStore = new TvStore();
   });
 
+  describe('lecture des valeurs de uPorte', () => {
+    test.each([
+      {
+        label: 'porte simple bois/PVC opaque pleine (id partagé 1|5)',
+        enumTypePorteId: '1',
+        expected: 3.5
+      },
+      { label: 'porte simple métal opaque pleine', enumTypePorteId: '9', expected: 5.8 }
+    ])('uPorte pour $label', ({ enumTypePorteId, expected }) => {
+      expect(tvStore.getUPorte(enumTypePorteId)).toBe(expected);
+    });
+
+    test('pas de valeur de uPorte', () => {
+      expect(tvStore.getUPorte('0')).toBeUndefined();
+    });
+  });
+
   describe('lecture des valeurs de b', () => {
     test.each([
       { enumTypeAdjacenceId: '1', label: 'extérieur', bExpected: 1 },
@@ -56,6 +73,26 @@ describe('Lecture des tables de valeurs', () => {
         expect(b).toBe(bExpected);
       }
     );
+
+    test('pas de valeur de b', () => {
+      // Aucune adjacence '0' dans la table : b introuvable -> undefined.
+      expect(tvStore.getB('0')).toBeUndefined();
+    });
+
+    test('b filtré par zone climatique (espace tampon solarisé)', () => {
+      // Adjacence 10 : les lignes portent une zone_climatique -> exerce le filtre
+      // zc.toLowerCase().startsWith(v.zone_climatique.toLowerCase()) (H1 <- h1a).
+      expect(tvStore.getB('10', undefined, '6', undefined, 'h1a')).toBe(0.95);
+    });
+
+    test.each([
+      // rAiuAue au-dessus d'une borne min : exerce parseAiuAueBound(aiu_aue_min) < rAiuAue.
+      { label: 'ratio dans un intervalle borné (min et max)', rAiuAue: 0.3, expected: 0.95 },
+      // rAiuAue très élevé : dernière ligne sans aiu_aue_max -> exerce la branche !v.aiu_aue_max.
+      { label: 'ratio au-dessus de la dernière borne (sans max)', rAiuAue: 60, expected: 0.2 }
+    ])('b filtré par le ratio aiu/aue pour $label', ({ rAiuAue, expected }) => {
+      expect(tvStore.getB('8', 3, '4', rAiuAue)).toBe(expected);
+    });
   });
 
   describe('lecture des valeurs de uVue', () => {
@@ -375,6 +412,13 @@ describe('Lecture des tables de valeurs', () => {
       }
     );
 
+    test('ue sans interpolation quand upb correspond exactement à une borne tabulée', () => {
+      // upb fourni comme borne exacte de la table ('0.83') : getRange renvoie deux bornes
+      // identiques, delta_upb vaut 0 et la valeur tabulée est retournée sans interpolation.
+      const ue = tvStore.getUeByUpd('3', '1', 4, '0.83');
+      expect(ue).toBe(0.37);
+    });
+
     test('pas de valeur de ue', () => {
       const ue = tvStore.getUeByUpd('0', '1', 0, 0);
       expect(ue).toBeUndefined();

package/features/engine/domain/apport_et_besoin/apport-et-besoin.service.spec.js

@@ -15,6 +15,7 @@ import { PRECISION_PERCENT } from '../../../../../test/constant.js';
 import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
 import { ContexteBuilder } from '../contexte.builder.js';
 import { InstallationChService } from '../ch/installation-ch.service.js';
+import { describeIntegration } from '../../../../../test/helpers/integration-test.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let surfaceSudEquivalenteService;
@@ -157,7 +158,7 @@ describe('Calcul des apports et besoin du logement', () => {
     expect(installationChService.execute).toHaveBeenCalledWith(ctx, logement);
   });
 
-  describe("Test d'intégration pour les besoins en chauffage", () => {
+  describeIntegration("Test d'intégration pour les besoins en chauffage", () => {
     test.each(corpus)(
       'Vérification de la DI besoin_ch des besoins en chauffage pour dpe %s',
       (ademeId) => {

package/features/engine/domain/apport_et_besoin/ch/besoin-ch.service.spec.js

@@ -50,6 +50,24 @@ describe('Calcul des besoins en chauffage du logement', () => {
     }
   );
 
+  test('Fraction des apports gratuits nulle quand les degrés-heures de chauffage sont nuls', () => {
+    // dh === 0 : aucun besoin de chauffage sur le mois, la fraction est court-circuitée à 0
+    // (évite aussi la division par zéro dans le calcul de Xj).
+    /** @type {Contexte} */
+    const ctx = { inertie: { id: 1 } };
+
+    /** @type { Logement } **/
+    const logement = {
+      donnees_de_calcul: {
+        apportsInterneCh: { Janvier: 102.5 },
+        apportsSolaire: { Janvier: 12.5 }
+      },
+      sortie: { deperdition: { deperdition_enveloppe: 25.9 } }
+    };
+
+    expect(service.fractionBesoinCh(ctx, logement, 'Janvier', 0)).toBe(0);
+  });
+
   test('Besoin de chauffage hors pertes récupérées et fraction des apports gratuits pour un mois', () => {
     /** @type {Contexte} */
     const ctx = { inertie: { id: 1 } };

package/features/engine/domain/apport_et_besoin/ch/perte-ch-recup.service.spec.js

@@ -9,6 +9,7 @@ import { PerteChRecupService } from './perte-ch-recup.service.js';
 import { BesoinChService } from './besoin-ch.service.js';
 import { ApportGratuitService } from '../apport_gratuit/apport-gratuit.service.js';
 import { PRECISION_PERCENT } from '../../../../../../test/constant.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {PerteChRecupService} **/
 let service;
@@ -239,7 +240,38 @@ describe('Calcul des pertes de génération de chauffage récupérées', () => {
     }
   });
 
-  describe("Test d'intégration des installations CH", () => {
+  test('Qrec vaut 0 pour un usage de générateur inconnu (aucune durée de récupération)', () => {
+    // enum_usage_generateur_id hors {1, 2, 3} : le switch ne définit pas Dperj (undefined),
+    // le produit devient NaN et la garde `|| 0` ramène la contribution à 0.
+    /** @type {GenerateurChauffage[]} */
+    const generateurs = [
+      {
+        donnee_entree: { presence_ventouse: 0, enum_usage_generateur_id: 99 },
+        donnee_intermediaire: { pn: 25000, qp0: 125 }
+      }
+    ];
+
+    expect(service.Qrec(generateurs, 12.5, 1532.9)).toBe(0);
+  });
+
+  test('Conversion en kWh des pertes de génération récupérées (execute)', () => {
+    // On isole execute de la formule mensuelle : pertesGenerateurChRecup est doublée pour
+    // ne vérifier que la conversion Wh -> kWh (division par 1000) et le mapping des 2 champs.
+    vi.spyOn(service, 'pertesGenerateurChRecup').mockImplementation((ctx, logement, depensier) =>
+      depensier ? 6000 : 3000
+    );
+
+    const res = service.execute({}, {});
+
+    expect(res).toStrictEqual({
+      pertes_generateur_ch_recup: 3,
+      pertes_generateur_ch_recup_depensier: 6
+    });
+    expect(service.pertesGenerateurChRecup).toHaveBeenCalledWith({}, {}, false);
+    expect(service.pertesGenerateurChRecup).toHaveBeenCalledWith({}, {}, true);
+  });
+
+  describeIntegration("Test d'intégration des installations CH", () => {
     test.each(corpus)('vérification des pertes de génération ch pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/engine/domain/apport_et_besoin/ecs/besoin-ecs.service.spec.js

@@ -5,6 +5,7 @@ import { ContexteBuilder } from '../../contexte.builder.js';
 import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 import { BesoinEcsService } from './besoin-ecs.service.js';
 import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {BesoinEcsService} **/
 let service;
@@ -45,7 +46,26 @@ describe('Calcul du besoin en eau chaude sanitaire', () => {
     expect(tvStore.getTefs).toHaveBeenCalledWith('400-800m', 'h1a', 'Janvier');
   });
 
-  describe("Test d'intégration pour le besoin en eau chaude sanitaire", () => {
+  test("Sommation du besoin ECS sur les douze mois de l'année", () => {
+    // On isole execute de la formule mensuelle : besoinEcsMois est doublé pour ne mesurer
+    // que la logique d'agrégation (une valeur conventionnelle, une valeur dépensière par mois).
+    vi.spyOn(service, 'besoinEcsMois').mockImplementation((ctx, mois, depensier) =>
+      depensier ? 10 : 1
+    );
+
+    /** @type {Contexte} */
+    const ctx = { altitude: { value: '400-800m' }, zoneClimatique: { value: 'h1a' }, nadeq: 2 };
+
+    const res = service.execute(ctx);
+
+    // 12 mois : conventionnel = 12 * 1, dépensier = 12 * 10
+    expect(res).toStrictEqual({ besoin_ecs: 12, besoin_ecs_depensier: 120 });
+    expect(service.besoinEcsMois).toHaveBeenCalledTimes(24);
+    expect(service.besoinEcsMois).toHaveBeenCalledWith(ctx, 'Janvier', false);
+    expect(service.besoinEcsMois).toHaveBeenCalledWith(ctx, 'Janvier', true);
+  });
+
+  describeIntegration("Test d'intégration pour le besoin en eau chaude sanitaire", () => {
     test.each(corpus)('vérification des sorties besoin_ecs pour dpe %s', (ademeId) => {
       /**
        * @type {Dpe}

package/features/engine/domain/apport_et_besoin/ecs/perte-ecs-recup.service.spec.js

@@ -9,6 +9,7 @@ import { mois_liste } from '../../../../../utils.js';
 import { EcsTvStore } from '../../../../dpe/infrastructure/ecs/ecsTv.store.js';
 import { GenerateurEcsService } from '../../ecs/generateur-ecs.service.js';
 import { InstallationEcsService } from '../../ecs/installation-ecs.service.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {PerteEcsRecupService} **/
 let service;
@@ -130,7 +131,46 @@ describe('Calcul des pertes de distribution et stockage récupérées', () => {
     }
   });
 
-  describe("Test d'intégration des installations ECS", () => {
+  test('Agrégation et conversion en kWh des pertes ECS récupérées (execute)', () => {
+    // On isole execute des formules mensuelles : les deux méthodes de calcul sont doublées
+    // pour ne vérifier que la conversion Wh -> kWh (division par 1000) et le mapping des 4 champs.
+    vi.spyOn(service, 'pertesDistributionEcsRecup').mockImplementation(
+      (ctx, logement, depensier) => (depensier ? 2000 : 1000)
+    );
+    vi.spyOn(service, 'pertesStockageEcsRecup').mockImplementation((ctx, logement, depensier) =>
+      depensier ? 4000 : 3000
+    );
+
+    const res = service.execute({}, {});
+
+    expect(res).toStrictEqual({
+      pertes_distribution_ecs_recup: 1,
+      pertes_distribution_ecs_recup_depensier: 2,
+      pertes_stockage_ecs_recup: 3,
+      pertes_stockage_ecs_recup_depensier: 4
+    });
+    expect(service.pertesDistributionEcsRecup).toHaveBeenCalledWith({}, {}, false);
+    expect(service.pertesDistributionEcsRecup).toHaveBeenCalledWith({}, {}, true);
+    expect(service.pertesStockageEcsRecup).toHaveBeenCalledWith({}, {}, false);
+    expect(service.pertesStockageEcsRecup).toHaveBeenCalledWith({}, {}, true);
+  });
+
+  test("Pertes nulles en l'absence d'installation ECS", () => {
+    // Valeur de repli [] quand installation_ecs_collection est absente : aucune installation à sommer.
+    vi.spyOn(tvStore, 'getData').mockReturnValue(1);
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { ilpa: 0 }
+    };
+
+    expect(service.pertesDistributionEcsRecup(ctx, {}, false)).toBe(0);
+    expect(service.pertesStockageEcsRecup(ctx, {}, false)).toBe(0);
+  });
+
+  describeIntegration("Test d'intégration des installations ECS", () => {
     test.each(corpus)(
       'vérification des pertes de distribution ecs recup des installations ECS pour dpe %s',
       (ademeId) => {

package/features/engine/domain/apport_et_besoin/froid/besoin-froid.service.spec.js

@@ -6,6 +6,7 @@ import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
 import { ApportGratuitService } from '../apport_gratuit/apport-gratuit.service.js';
 import { BesoinFroidService } from './besoin-froid.service.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {ApportGratuitService} **/
 let apportGratuitService;
@@ -207,7 +208,49 @@ describe('Calcul des besoins en froid du logement', () => {
     );
   });
 
-  describe("Test d'intégration pour le besoin en froid", () => {
+  test('Sommation du besoin en froid sur les douze mois en présence de climatisation', () => {
+    // Climatisation présente : execute doit agréger besoinFrMois sur les 12 mois.
+    // besoinFrMois est doublé pour n'évaluer que la logique d'agrégation.
+    vi.spyOn(service, 'besoinFrMois').mockImplementation((ctx, logement, mois, depensier) =>
+      depensier ? 5 : 2
+    );
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    /** @type {Logement} */
+    const logement = { climatisation_collection: { climatisation: [{}] } };
+
+    const res = service.execute(ctx, logement);
+
+    expect(res).toStrictEqual({ besoin_fr: 24, besoin_fr_depensier: 60 });
+    expect(service.besoinFrMois).toHaveBeenCalledTimes(24);
+  });
+
+  test('Facteur d’utilisation lorsque le ratio de bilan thermique Rbth vaut exactement 1', () => {
+    // Branche fut = a / (a + 1) : atteinte uniquement quand Rbth === 1.
+    // Rbth = (aijFr + asjFr) / (GV * (tempExtMoyClim - 28) * nref)
+    //      = 6000 / (100 * (30 - 28) * 30) = 1
+    vi.spyOn(tvStore, 'getData').mockReturnValue(30);
+    vi.spyOn(apportGratuitService, 'apportInterneMois').mockReturnValue(6000);
+    vi.spyOn(apportGratuitService, 'apportSolaireMois').mockReturnValue(0);
+
+    /** @type {Logement} **/
+    const logement = { enveloppe: {}, sortie: { deperdition: { deperdition_enveloppe: 100 } } };
+
+    /** @type {Contexte} */
+    const ctx = {
+      altitude: { value: '400-800m' },
+      zoneClimatique: { value: 'h1a' },
+      inertie: { id: 4 },
+      surfaceHabitable: 25
+    };
+
+    // Valeur de référence de régression (module réel exécuté avec ces entrées)
+    expect(service.besoinFrMois(ctx, logement, 'Janvier', false)).toBeCloseTo(9.608856088560886, 9);
+  });
+
+  describeIntegration("Test d'intégration pour le besoin en froid", () => {
     test.each(corpus)('vérification des sorties besoin_fr pour dpe %s', (ademeId) => {
       /**
        * @type {Dpe}