@open3cl/engine 1.6.1 → 1.6.2

package/features/engine/domain/apport_et_besoin/surface-sud-equivalente.service.spec.js

@@ -5,6 +5,7 @@ import { ContexteBuilder } from '../contexte.builder.js';
 import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
 import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
 import { BaieVitreeTvStore } from '../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
+import { describeIntegration } from '../../../../../test/helpers/integration-test.js';
 
 /** @type {SurfaceSudEquivalenteService} **/
 let service;
@@ -206,7 +207,7 @@ describe('Calcul de la surface sud équivalente du logement', () => {
     });
   });
 
-  describe("Test d'intégration pour surface sud équivalente", () => {
+  describeIntegration("Test d'intégration pour surface sud équivalente", () => {
     test.each(corpus)(
       'vérification des DI de la surface sud équivalente pour dpe %s',
       (ademeId) => {

package/features/engine/domain/ch/generateur-ch.service.js

@@ -79,6 +79,8 @@ export class GenerateurChService {
         generateurChauffage.donnee_utilisateur.generateur = this.#chTvStore.getGenerateurCombustion(
           generateurChauffageDE.enum_type_generateur_ch_id,
           generateurChauffage.donnee_intermediaire.pn /
+            /* c8 ignore next 2 -- repli défensif inatteignable : donnee_utilisateur.ratio_virtualisation
+               est déjà défini juste au-dessus (valeur de l'installation ou 1), donc toujours truthy ici. */
             ((generateurChauffage.donnee_utilisateur.ratio_virtualisation || 1) * 1000)
         );
 

package/features/engine/domain/ch/generateur-ch.service.spec.js

@@ -4,11 +4,12 @@ import { GenerateurChService } from './generateur-ch.service.js';
 import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
 import corpus from '../../../../../test/corpus-sano.json';
 import { getAdemeFileJson } from '../../../../../test/test-helpers.js';
-import { TypeGenerateur } from '../../../dpe/domain/models/installation-chauffage.model.js';
+import { TypeGenerateur } from '../../../dpe/domain/models/type-generateur.model.js';
 import { ChTvStore } from '../../../dpe/infrastructure/ch/chTv.store.js';
 import { ContexteBuilder } from '../contexte.builder.js';
 import { TvStore } from '../../../dpe/infrastructure/tv.store.js';
 import { EmetteurChService } from './emetteur-ch.service.js';
+import { describeIntegration } from '../../../../../test/helpers/integration-test.js';
 
 /** @type {GenerateurChService} **/
 let service;
@@ -563,7 +564,121 @@ describe('Calcul des caractéristiques des générateurs de chauffage', () => {
     });
   });
 
-  describe("Test d'intégration des installations de chauffage", () => {
+  test('Générateur à combustion sans pn : calcul de la puissance nominale et filtrage des émetteurs', () => {
+    // Type 76 (chaudière fioul) : générateur à combustion ET chaudière, pour que le calcul
+    // des températures de fonctionnement (utilisant les émetteurs filtrés) soit exécuté.
+    vi.spyOn(chTvStore, 'getCombustionGenerateurs').mockReturnValue([76]);
+    vi.spyOn(chTvStore, 'getPacGenerateurs').mockReturnValue([2]);
+    vi.spyOn(chTvStore, 'getGenerateurCombustion').mockReturnValue({});
+    // pn absent dans donnee_intermediaire -> execute doit appeler this.pn(ctx, logement).
+    const pnSpy = vi.spyOn(service, 'pn').mockReturnValue(20000);
+    vi.spyOn(emetteurChService, 'temperatureFonctionnement').mockReturnValue({
+      temp_fonc_30: 18,
+      temp_fonc_100: 25
+    });
+
+    /** @type {GenerateurChauffage} */
+    const generateurChauffage = {
+      donnee_entree: {
+        enum_methode_saisie_carac_sys_id: 4,
+        enum_type_generateur_ch_id: 76,
+        enum_lien_generateur_emetteur_id: 'L1',
+        presence_ventouse: 1
+      },
+      // pas de pn : oblige au calcul de la puissance nominale
+      donnee_intermediaire: { rpn: 0.95, rpint: 0.68, qp0: 125 }
+    };
+
+    // Deux émetteurs : un seul est lié au générateur (même enum_lien_generateur_emetteur_id).
+    const emetteurLie = {
+      donnee_entree: { enum_lien_generateur_emetteur_id: 'L1', surface_chauffee: 80 },
+      donnee_intermediaire: { rendement_emission: 0.86 }
+    };
+    const emetteurNonLie = {
+      donnee_entree: { enum_lien_generateur_emetteur_id: 'L2', surface_chauffee: 40 },
+      donnee_intermediaire: { rendement_emission: 0.9 }
+    };
+
+    const installationChauffage = {
+      donnee_entree: { ratio_virtualisation: 1 },
+      generateur_chauffage_collection: { generateur_chauffage: [generateurChauffage] },
+      emetteur_chauffage_collection: { emetteur_chauffage: [emetteurLie, emetteurNonLie] }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_chauffage_collection: { installation_chauffage: [installationChauffage] },
+      sortie: { deperdition: { deperdition_enveloppe: 300 } }
+    };
+
+    /** @type {Contexte} */
+    const ctx = { altitude: { id: 1 }, zoneClimatique: { id: 1 } };
+
+    service.execute(ctx, logement, installationChauffage);
+
+    // La puissance nominale a été calculée puis affectée
+    expect(pnSpy).toHaveBeenCalledWith(ctx, logement);
+    expect(generateurChauffage.donnee_intermediaire.pn).toBe(20000);
+
+    // getGenerateurCombustion utilise pn / (ratio * 1000) = 20000 / 1000 = 20
+    expect(chTvStore.getGenerateurCombustion).toHaveBeenCalledWith(76, 20);
+
+    // Seul l'émetteur lié est transmis au calcul des températures de fonctionnement
+    expect(emetteurChService.temperatureFonctionnement).toHaveBeenCalledWith(
+      ctx,
+      generateurChauffage.donnee_entree,
+      [emetteurLie]
+    );
+  });
+
+  test('execute : installation sans collection de générateurs ne fait rien', () => {
+    // Valeur de repli [] quand generateur_chauffage_collection est absente.
+    const combustionSpy = vi.spyOn(chTvStore, 'getCombustionGenerateurs');
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    expect(() => service.execute(ctx, {}, { donnee_entree: {} })).not.toThrow();
+    expect(combustionSpy).not.toHaveBeenCalled();
+  });
+
+  test('execute : ratio de virtualisation par défaut à 1 quand non renseigné', () => {
+    vi.spyOn(chTvStore, 'getCombustionGenerateurs').mockReturnValue([1]);
+    vi.spyOn(chTvStore, 'getPacGenerateurs').mockReturnValue([2]);
+    vi.spyOn(chTvStore, 'getGenerateurCombustion').mockReturnValue({});
+
+    /** @type {GenerateurChauffage} */
+    const generateurChauffage = {
+      donnee_entree: {
+        enum_methode_saisie_carac_sys_id: 4,
+        enum_type_generateur_ch_id: 1,
+        presence_ventouse: 1
+      },
+      donnee_intermediaire: { rpn: 0.95, rpint: 0.68, qp0: 125, pn: 15000 }
+    };
+
+    const installationChauffage = {
+      // donnee_entree sans ratio_virtualisation : repli sur 1
+      donnee_entree: {},
+      generateur_chauffage_collection: { generateur_chauffage: [generateurChauffage] }
+    };
+
+    /** @type {Logement} */
+    const logement = {
+      installation_chauffage_collection: { installation_chauffage: [installationChauffage] }
+    };
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    service.execute(ctx, logement, installationChauffage);
+
+    expect(generateurChauffage.donnee_utilisateur.ratio_virtualisation).toBe(1);
+    // pn / (ratio * 1000) = 15000 / 1000 = 15
+    expect(chTvStore.getGenerateurCombustion).toHaveBeenCalledWith(1, 15);
+  });
+
+  describeIntegration("Test d'intégration des installations de chauffage", () => {
     test.each(corpus)('vérification des DI qp0 des installations CH pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/engine/domain/ch/installation-ch.service.spec.js

@@ -38,4 +38,18 @@ describe('Calcul des installations de chauffage', () => {
     service.execute(ctx, logement);
     expect(generateurChService.execute).toHaveBeenCalledWith(ctx, logement, installationCh);
   });
+
+  test("Aucun générateur traité en l'absence d'installation de chauffage", () => {
+    vi.spyOn(generateurChService, 'execute').mockReturnThis();
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 } };
+
+    // Collection absente : la valeur de repli [] doit être utilisée (aucun appel au service générateur)
+    service.execute(ctx, {});
+    // Collection présente mais sans tableau d'installations
+    service.execute(ctx, { installation_chauffage_collection: {} });
+
+    expect(generateurChService.execute).not.toHaveBeenCalled();
+  });
 });

package/features/engine/domain/conso/froid/conso-froid.service.spec.js

@@ -5,6 +5,7 @@ import corpus from '../../../../../../test/corpus-sano.json';
 import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
 import { FrTvStore } from '../../../../dpe/infrastructure/froid/frTv.store.js';
 import { ConsoFroidService } from './conso-froid.service.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {ConsoFroidService} **/
 let service;
@@ -117,7 +118,87 @@ describe('Calcul des consos en froid du logement', () => {
     }
   );
 
-  describe("Test d'intégration pour le besoin en froid", () => {
+  test('consoFroid : données intermédiaires absentes -> EER lu dans la table (repli {})', () => {
+    // climatisation.donnee_intermediaire absente : repli sur {} puis lecture de l'EER forfaitaire.
+    vi.spyOn(tvStore, 'getEer').mockReturnValue(90);
+
+    /** @type {Contexte} */
+    const contexte = { zoneClimatique: { id: 1 }, surfaceHabitable: 100 };
+
+    /** @type {Climatisation} */
+    const climatisation = {
+      donnee_entree: { enum_methode_saisie_carac_sys_id: 6, enum_periode_installation_fr_id: 2 }
+    };
+
+    /** @type {ApportEtBesoin} */
+    const apportEtBesoin = { besoin_fr: 1000, besoin_fr_depensier: 1500 };
+
+    const consoFroid = service.consoFroid(contexte, apportEtBesoin, climatisation);
+
+    expect(tvStore.getEer).toHaveBeenCalledWith(1, 2);
+    // conso = 0.9 * besoin / eer
+    expect(consoFroid.conso_fr).toBeCloseTo((0.9 * 1000) / 90, 5);
+    expect(consoFroid.conso_fr_depensier).toBeCloseTo((0.9 * 1500) / 90, 5);
+  });
+
+  test('execute : renseigne les données intermédiaires de chaque climatisation', () => {
+    // On isole execute du calcul détaillé : consoFroid est doublée pour ne vérifier que
+    // l'itération sur les climatisations et l'affectation des champs (dont l'initialisation ??=).
+    vi.spyOn(service, 'consoFroid').mockReturnValue({
+      besoin_fr: 10,
+      besoin_fr_depensier: 15,
+      conso_fr: 2,
+      conso_fr_depensier: 3
+    });
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 }, surfaceHabitable: 100 };
+
+    // Première climatisation sans donnee_intermediaire (branche ??= {}),
+    // seconde avec un objet préexistant (branche ??= conservée).
+    const climSansDI = { donnee_entree: {} };
+    const climAvecDI = { donnee_entree: {}, donnee_intermediaire: { eer: 42 } };
+
+    /** @type {Logement} */
+    const logement = {
+      sortie: { apport_et_besoin: { besoin_fr: 1000, besoin_fr_depensier: 1500 } },
+      climatisation_collection: { climatisation: [climSansDI, climAvecDI] }
+    };
+
+    service.execute(ctx, logement);
+
+    expect(service.consoFroid).toHaveBeenCalledTimes(2);
+    expect(service.consoFroid).toHaveBeenCalledWith(
+      ctx,
+      logement.sortie.apport_et_besoin,
+      climSansDI
+    );
+
+    for (const clim of [climSansDI, climAvecDI]) {
+      expect(clim.donnee_intermediaire).toMatchObject({
+        besoin_fr: 10,
+        besoin_fr_depensier: 15,
+        conso_fr: 2,
+        conso_fr_depensier: 3
+      });
+    }
+    // L'objet préexistant a été conservé (eer non écrasé par ??=)
+    expect(climAvecDI.donnee_intermediaire.eer).toBe(42);
+  });
+
+  test("execute : aucune conso calculée en l'absence de climatisation", () => {
+    // Valeur de repli [] quand climatisation_collection est absente.
+    vi.spyOn(service, 'consoFroid');
+
+    /** @type {Contexte} */
+    const ctx = { zoneClimatique: { id: 1 }, surfaceHabitable: 100 };
+
+    service.execute(ctx, { sortie: { apport_et_besoin: {} } });
+
+    expect(service.consoFroid).not.toHaveBeenCalled();
+  });
+
+  describeIntegration("Test d'intégration pour le besoin en froid", () => {
     test.each(corpus)('vérification des sorties besoin_fr et conso_fr pour dpe %s', (ademeId) => {
       /**
        * @type {Dpe}

package/features/engine/domain/constants.spec.js

@@ -0,0 +1,14 @@
+import { describe, expect, test } from 'vitest';
+import { PRECISION } from './constants.js';
+
+describe('Constantes du moteur', () => {
+  test('PRECISION vaut 100000', () => {
+    expect(PRECISION).toBe(100000);
+  });
+
+  test('PRECISION est un entier positif utilisable comme facteur d’arrondi', () => {
+    expect(typeof PRECISION).toBe('number');
+    expect(Number.isInteger(PRECISION)).toBe(true);
+    expect(PRECISION).toBeGreaterThan(0);
+  });
+});

package/features/engine/domain/contexte.builder.spec.js

@@ -160,6 +160,27 @@ describe('Generateur du contexte du calcul', () => {
     });
   });
 
+  test("DPE appartement généré à partir des données d'un DPE immeuble", () => {
+    // Méthode 10 : appartement issu des données immeuble.
+    // -> typeDpe APPARTEMENT_A_PARTIR_IMMEUBLE et surface habitable = celle de l'immeuble.
+    const dpe = {
+      logement: {
+        meteo: {},
+        caracteristique_generale: {
+          enum_methode_application_dpe_log_id: '10',
+          surface_habitable_logement: 48.9,
+          surface_habitable_immeuble: 105
+        }
+      }
+    };
+
+    expect(contexteBuilder.fromDpe(dpe)).toMatchObject({
+      typeHabitation: TypeHabitation.APPARTEMENT,
+      typeDpe: TypeDpe.APPARTEMENT_A_PARTIR_IMMEUBLE,
+      surfaceHabitable: 105
+    });
+  });
+
   test('Contexte avec calcul ilpa', () => {
     const dpe = {
       logement: {

package/features/engine/domain/ecs/generateur-ecs.service.spec.js

@@ -121,6 +121,17 @@ describe('Calcul des informations techniques des générateurs ECS', () => {
     });
   });
 
+  test("execute ne fait rien quand l'installation n'a pas de collection de générateurs", () => {
+    // Valeur de repli [] quand generateur_ecs_collection est absente : aucune mutation.
+    const pertesStockageSpy = vi.spyOn(service, 'pertesStockage');
+
+    /** @type {InstallationEcs} */
+    const installationEcs = {};
+    expect(() => service.execute(installationEcs)).not.toThrow();
+    expect(installationEcs).toStrictEqual({});
+    expect(pertesStockageSpy).not.toHaveBeenCalled();
+  });
+
   test("Determination du type d'énergie électrique du générateur", () => {
     vi.spyOn(tvStore, 'getElectriqueEcsGenerateurs').mockReturnValue([1]);
     expect(service.generateurElectrique({ enum_type_generateur_ecs_id: 1 })).toBeTruthy();

package/features/engine/domain/ecs/installation-ecs.service.spec.js

@@ -1,10 +1,11 @@
-import { beforeEach, describe, expect, test } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { GenerateurEcsService } from './generateur-ecs.service.js';
 import { InstallationEcsService } from './installation-ecs.service.js';
 import corpus from '../../../../../test/corpus-sano.json';
 import { expect_or, getAdemeFileJson } from '../../../../../test/test-helpers.js';
 import { DpeNormalizerService } from '../../../normalizer/domain/dpe-normalizer.service.js';
 import { ContexteBuilder } from '../contexte.builder.js';
+import { describeIntegration } from '../../../../../test/helpers/integration-test.js';
 
 /** @type {InstallationEcsService} **/
 let service;
@@ -247,7 +248,59 @@ describe('Calcul des besoins et des pertes des installations ECS', () => {
     expect(service.isInstallationIndividuelle({ enum_type_installation_id: 4 })).toBeFalsy();
   });
 
-  describe("Test d'intégration des installations ECS", () => {
+  test('execute : parcourt les installations ECS et renseigne besoins et pertes', () => {
+    // Le calcul des Qgw par générateur est délégué au GenerateurEcsService : on le double
+    // pour isoler la logique d'orchestration de l'installation.
+    vi.spyOn(generateurEcsService, 'execute').mockReturnValue(undefined);
+
+    /** @type {Contexte} */
+    const ctx = { surfaceHabitable: 100 };
+
+    /** @type {InstallationEcs} */
+    const installationEcs = {
+      donnee_entree: { enum_type_installation_id: 1, surface_habitable: 100 },
+      generateur_ecs_collection: {
+        generateur_ecs: [
+          {
+            donnee_entree: { position_volume_chauffe_stockage: 1 },
+            donnee_utilisateur: { Qgw: 500 }
+          }
+        ]
+      }
+    };
+
+    /** @type {Logement} */
+    const logement = { installation_ecs_collection: { installation_ecs: [installationEcs] } };
+
+    service.execute(ctx, logement, { besoin_ecs: 1000, besoin_ecs_depensier: 1500 });
+
+    // Délégation du calcul par générateur
+    expect(generateurEcsService.execute).toHaveBeenCalledWith(installationEcs);
+
+    // Besoins proratisés (surface installation === surface logement -> ratio 1)
+    expect(installationEcs.donnee_intermediaire).toStrictEqual({
+      besoin_ecs: 1000,
+      besoin_ecs_depensier: 1500
+    });
+
+    // Pertes de distribution individuelle : 0.1 * besoin (en Wh) ; installation individuelle -> QdwCol* = 0
+    expect(installationEcs.donnee_utilisateur.QdwIndVc.conventionnel).toBeCloseTo(100000, 5);
+    expect(installationEcs.donnee_utilisateur.QdwIndVc.depensier).toBeCloseTo(150000, 5);
+    expect(installationEcs.donnee_utilisateur.QdwColVc.conventionnel).toBe(0);
+    // Générateur en volume chauffé -> stockage récupérable = Qgw
+    expect(installationEcs.donnee_utilisateur.QgwRecuperable).toBe(500);
+  });
+
+  test('execute : aucune installation traitée quand la collection ECS est absente', () => {
+    // Valeur de repli [] quand installation_ecs_collection est absente.
+    const generateurSpy = vi.spyOn(generateurEcsService, 'execute');
+
+    service.execute({ surfaceHabitable: 100 }, {}, { besoin_ecs: 0, besoin_ecs_depensier: 0 });
+
+    expect(generateurSpy).not.toHaveBeenCalled();
+  });
+
+  describeIntegration("Test d'intégration des installations ECS", () => {
     test.each(corpus)('vérification des DI des installations ECS pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

package/features/engine/domain/engine.service.spec.js

@@ -1,7 +1,230 @@
-import { describe, test } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { EngineService } from './engine.service.js';
+import { logger } from '../../../core/util/logger/log-service.js';
 
-describe.skip('Application de la méthode 3CL', () => {
-  test('test complet de calcul (validation ADEME?)', () => {
-    // const dpe = EngineService.execute(originalDpe);=
+/**
+ * Tests unitaires isolés de `EngineService`.
+ *
+ * Les quatre services injectés (`DeperditionEnveloppeService`,
+ * `ApportEtBesoinService`, `ConsoService` et `ContexteBuilder`) sont remplacés
+ * par des doubles de test (spies `vi.fn`) afin de n'exercer que la logique
+ * d'orchestration du moteur : nettoyage des données calculées, construction du
+ * contexte, délégation aux services et agrégation des sorties. Aucune donnée
+ * réelle (tables, DPE complet) n'est nécessaire.
+ */
+
+/** @type {{ deperditions: import('vitest').Mock }} */
+let deperditionService;
+
+/** @type {{ execute: import('vitest').Mock }} */
+let apportEtBesoinService;
+
+/** @type {{ execute: import('vitest').Mock }} */
+let consoService;
+
+/** @type {{ fromDpe: import('vitest').Mock }} */
+let contextBuilder;
+
+/** @type {EngineService} */
+let service;
+
+/**
+ * Construit une enveloppe minimale : toutes les collections existent mais leurs
+ * tableaux internes sont absents (exerce le court-circuit des `?.`).
+ */
+function enveloppeMinimale() {
+  return {
+    mur_collection: {},
+    baie_vitree_collection: {},
+    ets_collection: {},
+    plancher_bas_collection: {},
+    plancher_haut_collection: {},
+    pont_thermique_collection: {},
+    porte_collection: {}
+  };
+}
+
+/**
+ * Construit un DPE minimal : collections présentes mais vides. Utilisé pour
+ * exercer les branches « tableau absent » de `#removeComputedData`.
+ */
+function dpeMinimal() {
+  return {
+    numero_dpe: 'DPE-MIN',
+    logement: {
+      caracteristique_generale: {},
+      enveloppe: enveloppeMinimale(),
+      climatisation_collection: {},
+      ventilation_collection: {},
+      installation_ecs_collection: {},
+      installation_chauffage_collection: {}
+    }
+  };
+}
+
+/**
+ * Construit un DPE complet : chaque collection possède un tableau peuplé avec
+ * des `donnee_intermediaire`. Exerce la branche « tableau présent » de
+ * `#removeComputedData` ainsi que les `?.` imbriqués.
+ */
+function dpeComplet() {
+  return {
+    numero_dpe: 'DPE-FULL',
+    logement: {
+      caracteristique_generale: {},
+      sortie: { deperdition: 'ancienne valeur' },
+      enveloppe: {
+        mur_collection: { mur: [{ donnee_intermediaire: {} }] },
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_intermediaire: {},
+              baie_vitree_double_fenetre: { donnee_intermediaire: {} }
+            },
+            // baie sans double fenêtre : exerce la branche falsy du `?.`
+            { donnee_intermediaire: {} }
+          ]
+        },
+        ets_collection: { ets: { donnee_intermediaire: {} } },
+        plancher_bas_collection: { plancher_bas: [{ donnee_intermediaire: {} }] },
+        plancher_haut_collection: { plancher_haut: [{ donnee_intermediaire: {} }] },
+        pont_thermique_collection: { pont_thermique: [{ donnee_intermediaire: {} }] },
+        porte_collection: { porte: [{ donnee_intermediaire: {} }] }
+      },
+      climatisation_collection: { climatisation: [{ donnee_intermediaire: {} }] },
+      ventilation_collection: { ventilation: [{ donnee_intermediaire: {} }] },
+      installation_ecs_collection: {
+        installation_ecs: [
+          {
+            donnee_intermediaire: {},
+            generateur_ecs_collection: {
+              generateur_ecs: [{ donnee_intermediaire: {} }]
+            }
+          }
+        ]
+      },
+      installation_chauffage_collection: {
+        installation_chauffage: [
+          {
+            donnee_intermediaire: {},
+            emetteur_chauffage_collection: {
+              emetteur_chauffage: [{ donnee_intermediaire: {} }]
+            }
+          }
+        ]
+      },
+      production_elec_enr: { donnee_intermediaire: {} }
+    }
+  };
+}
+
+describe('EngineService (orchestration de la méthode 3CL)', () => {
+  beforeEach(() => {
+    deperditionService = { deperditions: vi.fn().mockReturnValue('DEPERDITION') };
+    apportEtBesoinService = { execute: vi.fn().mockReturnValue('APPORT_ET_BESOIN') };
+    consoService = { execute: vi.fn() };
+    contextBuilder = { fromDpe: vi.fn().mockReturnValue('CTX') };
+    service = new EngineService(
+      deperditionService,
+      apportEtBesoinService,
+      consoService,
+      contextBuilder
+    );
+    vi.spyOn(logger, 'info').mockImplementation(() => {});
+  });
+
+  test('trace le numéro de DPE traité', () => {
+    service.execute(dpeMinimal());
+    expect(logger.info).toHaveBeenCalledWith('Process DPE DPE-MIN');
+  });
+
+  test('construit le contexte à partir du DPE nettoyé puis délègue aux services', () => {
+    const resultat = service.execute(dpeMinimal());
+
+    // Le contexte est construit une fois à partir du DPE traité
+    expect(contextBuilder.fromDpe).toHaveBeenCalledTimes(1);
+    const dpeTraite = contextBuilder.fromDpe.mock.calls[0][0];
+
+    // Les services reçoivent le contexte construit et le logement traité
+    expect(deperditionService.deperditions).toHaveBeenCalledWith('CTX', dpeTraite.logement);
+    expect(apportEtBesoinService.execute).toHaveBeenCalledWith('CTX', dpeTraite.logement);
+    expect(consoService.execute).toHaveBeenCalledWith('CTX', dpeTraite.logement);
+
+    // Les résultats des services sont agrégés dans la sortie
+    expect(resultat.logement.sortie.deperdition).toBe('DEPERDITION');
+    expect(resultat.logement.sortie.apport_et_besoin).toBe('APPORT_ET_BESOIN');
+  });
+
+  test('initialise la structure de sortie avec toutes les clés attendues', () => {
+    const resultat = service.execute(dpeMinimal());
+
+    expect(resultat.logement.sortie).toEqual({
+      deperdition: 'DEPERDITION',
+      apport_et_besoin: 'APPORT_ET_BESOIN',
+      ef_conso: undefined,
+      ep_conso: undefined,
+      emission_ges: undefined,
+      cout: undefined,
+      production_electricite: undefined,
+      sortie_par_energie_collection: undefined,
+      confort_ete: undefined,
+      qualite_isolation: undefined
+    });
+  });
+
+  test('supprime les données de calcul intermédiaires du DPE retourné', () => {
+    const resultat = service.execute(dpeMinimal());
+    expect(resultat.logement.donnees_de_calcul).toBeUndefined();
+  });
+
+  test("n'altère pas le DPE d'entrée (travail sur une copie profonde)", () => {
+    const original = dpeComplet();
+    const resultat = service.execute(original);
+
+    // L'entrée conserve ses données calculées d'origine
+    expect(original.logement.sortie).toEqual({ deperdition: 'ancienne valeur' });
+    expect(original.logement.enveloppe.mur_collection.mur[0].donnee_intermediaire).toBeDefined();
+    // La sortie est bien un nouvel objet
+    expect(resultat).not.toBe(original);
+  });
+
+  test('nettoie toutes les données intermédiaires quand les collections sont peuplées', () => {
+    const resultat = service.execute(dpeComplet());
+    const env = resultat.logement.enveloppe;
+
+    expect(env.mur_collection.mur[0].donnee_intermediaire).toBeUndefined();
+    expect(env.baie_vitree_collection.baie_vitree[0].donnee_intermediaire).toBeUndefined();
+    expect(
+      env.baie_vitree_collection.baie_vitree[0].baie_vitree_double_fenetre.donnee_intermediaire
+    ).toBeUndefined();
+    expect(env.ets_collection.ets.donnee_intermediaire).toBeUndefined();
+    expect(env.plancher_bas_collection.plancher_bas[0].donnee_intermediaire).toBeUndefined();
+    expect(env.plancher_haut_collection.plancher_haut[0].donnee_intermediaire).toBeUndefined();
+    expect(env.pont_thermique_collection.pont_thermique[0].donnee_intermediaire).toBeUndefined();
+    expect(env.porte_collection.porte[0].donnee_intermediaire).toBeUndefined();
+
+    expect(
+      resultat.logement.climatisation_collection.climatisation[0].donnee_intermediaire
+    ).toBeUndefined();
+    expect(
+      resultat.logement.ventilation_collection.ventilation[0].donnee_intermediaire
+    ).toBeUndefined();
+
+    const ecs = resultat.logement.installation_ecs_collection.installation_ecs[0];
+    expect(ecs.donnee_intermediaire).toBeUndefined();
+    expect(ecs.generateur_ecs_collection.generateur_ecs[0].donnee_intermediaire).toBeUndefined();
+
+    const ch = resultat.logement.installation_chauffage_collection.installation_chauffage[0];
+    expect(ch.donnee_intermediaire).toBeUndefined();
+    expect(
+      ch.emetteur_chauffage_collection.emetteur_chauffage[0].donnee_intermediaire
+    ).toBeUndefined();
+
+    expect(resultat.logement.production_elec_enr.donnee_intermediaire).toBeUndefined();
+  });
+
+  test('reste robuste lorsque les collections ne contiennent aucun élément', () => {
+    // Aucun tableau interne ni production_elec_enr : les `?.` court-circuitent
+    expect(() => service.execute(dpeMinimal())).not.toThrow();
   });
 });