@open3cl/engine 1.0.7 → 1.0.8

package/features/engine/domain/enveloppe/baie_vitree/deperdition-baie-vitree.service.spec.js

@@ -0,0 +1,484 @@
+import corpus from '../../../../../../test/corpus-sano.json';
+import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { ContexteBuilder } from '../../contexte.builder.js';
+import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normalizer.service.js';
+import { DeperditionBaieVitreeService } from './deperdition-baie-vitree.service.js';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/baieVitreeTv.store.js';
+
+/** @type {DeperditionBaieVitreeService} **/
+let service;
+
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {BaieVitreeTvStore} **/
+let tvStore;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
+describe('Calcul de déperdition des baies vitrées', () => {
+  beforeEach(() => {
+    tvStore = new BaieVitreeTvStore();
+    service = new DeperditionBaieVitreeService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+  });
+
+  describe('Determination du coefficient sw', () => {
+    test('Doit retourner sw_saisi directement', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '1',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3',
+          sw_saisi: 4.5
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).not.toHaveBeenCalled();
+      expect(sw).toBe(4.5);
+    });
+
+    test('Ne doit pas utiliser vitrage_vir et enum_type_pose_id si enum_type_materiaux_menuiserie_id = 1 ou 2', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '1',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3'
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenCalledWith('2', '6', '1', undefined, undefined);
+      expect(sw).toBe(18.8);
+    });
+
+    test('Doit utiliser vitrage_vir et enum_type_pose_id si enum_type_materiaux_menuiserie_id != 1 et != 2', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3'
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenCalledWith('2', '6', '4', '1', '3');
+      expect(sw).toBe(18.8);
+    });
+
+    test('Doit prendre en compte le survitrage si présent', () => {
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_vitrage_id: '2',
+          enum_type_baie_id: '6',
+          vitrage_vir: '1',
+          enum_type_pose_id: '3',
+          double_fenetre: 1
+        },
+        baie_vitree_double_fenetre: {
+          donnee_entree: {
+            enum_type_materiaux_menuiserie_id: '4',
+            enum_type_vitrage_id: '2',
+            enum_type_baie_id: '6',
+            vitrage_vir: '1',
+            enum_type_pose_id: '3'
+          }
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenNthCalledWith(2, '2', '6', '4', '1', '3');
+      expect(sw).toBe(18.8 * 18.8);
+    });
+  });
+
+  describe('Determination du coefficient uw', () => {
+    test('Doit retourner uw_saisi directement', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+
+      let uw = service.uw({ donnee_entree: { uw_saisi: 16.4 } }, 2.4);
+
+      expect(tvStore.getUw).not.toHaveBeenCalled();
+      expect(uw).toBe(16.4);
+    });
+
+    test('Doit appeler tvStore', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+
+      let uw = service.uw(
+        { donnee_entree: { enum_type_baie_id: '10', enum_type_materiaux_menuiserie_id: '1' } },
+        2.4
+      );
+
+      expect(tvStore.getUw).toHaveBeenCalledWith('10', '1', 2.4);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit prendre en compte le survitrage si présent', () => {
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(18.8);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          ug_saisi: 2.5,
+          enum_type_materiaux_menuiserie_id: '4',
+          enum_type_baie_id: '6',
+          double_fenetre: 1
+        },
+        baie_vitree_double_fenetre: {
+          donnee_entree: {
+            ug_saisi: 2.5,
+            enum_type_materiaux_menuiserie_id: '4',
+            enum_type_baie_id: '6'
+          }
+        }
+      };
+
+      let uw = service.uw(bv, 2.4);
+      expect(tvStore.getUw).toHaveBeenNthCalledWith(2, '6', '4', 2.5);
+      expect(uw).toBe(1 / (1 / 18.8 + 1 / 18.8 + 0.07));
+    });
+  });
+
+  describe('Determination du coefficient ug', () => {
+    test('Doit retourner ug_saisi directement', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      let ug = service.ug({ ug_saisi: 16.4 });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBe(16.4);
+    });
+
+    test('Ne retourne aucune valeur pour les parois en brique ou polycarbonate', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      let ug = service.ug({ enum_type_baie_id: '1' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+
+      ug = service.ug({ enum_type_baie_id: '2' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+
+      ug = service.ug({ enum_type_baie_id: '3' });
+
+      expect(tvStore.getUg).not.toHaveBeenCalled();
+      expect(ug).toBeUndefined();
+    });
+
+    test('Doit appeler tvStore sans epaisseur, enum_type_gaz_lame_id, enum_inclinaison_vitrage_id, vitrage_vir pour les simples vitrages', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '1',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '1',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('1', undefined, undefined, undefined, undefined);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit appeler tvStore avec epaisseur, enum_type_gaz_lame_id, enum_inclinaison_vitrage_id, vitrage_vir pour les doubles vitrages', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '2',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '2',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', 18);
+      expect(uw).toBe(18.8);
+    });
+
+    test("Doit appeler tvStore avec l'epaisseur la plus proche dans celles qui sont disponibles", () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+      vi.spyOn(tvStore, 'getEpaisseurAvailableForUg').mockReturnValue([2, 4, 8]);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '2',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '2',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '18'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', 8);
+      expect(uw).toBe(18.8);
+    });
+
+    test('Doit appeler tvStore avec un équivalent double vitrage pour un sur vitrage avec majoration de 0.1', () => {
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '4',
+        vitrage_vir: '0',
+        enum_inclinaison_vitrage_id: '3',
+        enum_type_gaz_lame_id: '1',
+        epaisseur_lame: '20'
+      };
+
+      let uw = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '3', '0', 20);
+      expect(uw).toBe(18.8 + 0.1);
+    });
+  });
+
+  describe('Determination du facteur d’ensoleillement', () => {
+    test('Doit retourner fe1 = 1 et fe2 = 1 si aucun masque', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({});
+
+      expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+      expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1);
+      expect(fe2).toBe(1);
+    });
+
+    test('Doit utiliser tvStore pour les masques proches', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({ tv_coef_masque_proche_id: '1' });
+
+      expect(tvStore.getMasqueProche).toHaveBeenCalledWith('1');
+      expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1.2);
+      expect(fe2).toBe(1);
+    });
+
+    test('Doit utiliser tvStore pour les masques lointains homogènes', () => {
+      vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+      vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+      vi.spyOn(tvStore, 'getOmbre').mockReturnValue(0.5);
+
+      let [fe1, fe2] = service.fe({ tv_coef_masque_lointain_homogene_id: '2' });
+
+      expect(tvStore.getMasqueLointainHomogene).toHaveBeenCalledWith('2');
+      expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+      expect(tvStore.getOmbre).not.toHaveBeenCalled();
+      expect(fe1).toBe(1);
+      expect(fe2).toBe(3.4);
+    });
+
+    test.each([
+      {
+        label: 'collection masque_lointain_non_homogene_collection undefined',
+        masqueLointainNonHomogene: undefined,
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection vide',
+        masqueLointainNonHomogene: { masque_lointain_non_homogene: undefined },
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection vide',
+        masqueLointainNonHomogene: { masque_lointain_non_homogene: [] },
+        tvStoreMasqueLointainNonHomogene: undefined,
+        fe1Expected: 1,
+        fe2Expected: 1
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection non array',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: { tv_coef_masque_lointain_non_homogene_id: '1' }
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        fe1Expected: 1,
+        fe2Expected: 0.8
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection array',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: [
+            { tv_coef_masque_lointain_non_homogene_id: '1' },
+            { tv_coef_masque_lointain_non_homogene_id: '2' }
+          ]
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        fe1Expected: 1,
+        fe2Expected: 0.6
+      },
+      {
+        label: 'collection masque_lointain_non_homogene_collection array and fe2 min 0',
+        masqueLointainNonHomogene: {
+          masque_lointain_non_homogene: [
+            { tv_coef_masque_lointain_non_homogene_id: '1' },
+            { tv_coef_masque_lointain_non_homogene_id: '2' }
+          ]
+        },
+        tvStoreMasqueLointainNonHomogene: '1',
+        tvStoreGetOmbreValue: 60,
+        fe1Expected: 1,
+        fe2Expected: 0
+      }
+    ])(
+      'Doit utiliser tvStore pour les masques lointains non homogènes pour $label',
+      ({
+        masqueLointainNonHomogene,
+        tvStoreMasqueLointainNonHomogene,
+        tvStoreGetOmbreValue = undefined,
+        fe1Expected,
+        fe2Expected
+      }) => {
+        vi.spyOn(tvStore, 'getMasqueProche').mockReturnValue(1.2);
+        vi.spyOn(tvStore, 'getMasqueLointainHomogene').mockReturnValue(3.4);
+        vi.spyOn(tvStore, 'getOmbre').mockReturnValue(tvStoreGetOmbreValue || 20);
+
+        let bvDE = {
+          masque_lointain_non_homogene_collection: masqueLointainNonHomogene
+        };
+        let [fe1, fe2] = service.fe(bvDE);
+
+        if (tvStoreMasqueLointainNonHomogene === undefined) {
+          expect(tvStore.getOmbre).not.toHaveBeenCalled();
+        } else {
+          expect(tvStore.getOmbre).toHaveBeenCalledWith(tvStoreMasqueLointainNonHomogene);
+        }
+
+        expect(tvStore.getMasqueLointainHomogene).not.toHaveBeenCalled();
+        expect(tvStore.getMasqueProche).not.toHaveBeenCalled();
+
+        expect(fe1).toBeCloseTo(fe1Expected, 2);
+        expect(fe2).toBeCloseTo(fe2Expected, 2);
+      }
+    );
+  });
+
+  test('Récupération du coefficient ujn', () => {
+    vi.spyOn(tvStore, 'getUjn').mockReturnValue(18.8);
+
+    let ujn = service.ujn({ ujn_saisi: 16.4 }, 2.4);
+
+    expect(tvStore.getUjn).not.toHaveBeenCalled();
+    expect(ujn).toBe(16.4);
+
+    ujn = service.ujn({ enum_type_fermeture_id: 1 }, 2.4);
+
+    expect(tvStore.getUjn).toHaveBeenCalledWith(1, 2.4);
+    expect(ujn).toBe(18.8);
+  });
+
+  test("Récupération de l'ombre apportée par un masque lointain", () => {
+    vi.spyOn(tvStore, 'getOmbre').mockReturnValue(12.4);
+
+    const ombre = service.calcOmbre({ tv_coef_masque_lointain_non_homogene_id: 16.4 });
+
+    expect(tvStore.getOmbre).toHaveBeenCalledWith(16.4);
+    expect(ombre).toBe(12.4);
+  });
+
+  test('u_menuiserie est définit par ujn seulement pour les baie vitrée avec fermeture', () => {
+    let bvDI = service.execute(
+      {},
+      { donnee_entree: { ujn_saisi: 5.6, enum_type_fermeture_id: 1 } }
+    );
+    expect(bvDI.u_menuiserie).toBeUndefined();
+
+    bvDI = service.execute({}, { donnee_entree: { ujn_saisi: 5.6, enum_type_fermeture_id: 2 } });
+    expect(bvDI.u_menuiserie).toBe(5.6);
+  });
+
+  describe("Test d'intégration des baies vitrées", () => {
+    test.each(corpus)('vérification des DI des baies vitrées pour dpe %s', (ademeId) => {
+      let dpeRequest = getAdemeFileJson(ademeId);
+      dpeRequest = normalizerService.normalize(dpeRequest);
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      const bvs = dpeRequest.logement.enveloppe.baie_vitree_collection?.baie_vitree || [];
+
+      bvs.forEach((bv) => {
+        const di = service.execute(ctx, bv);
+
+        expect(di.b).toBeCloseTo(bv.donnee_intermediaire.b, 2);
+
+        if (bv.donnee_intermediaire.ug) {
+          expect(di.ug).toBeCloseTo(bv.donnee_intermediaire.ug, 2);
+        } else {
+          expect(di.ug).toBeUndefined();
+        }
+
+        expect(di.uw).toBeCloseTo(bv.donnee_intermediaire.uw, 2);
+
+        if (bv.donnee_intermediaire.ujn) {
+          expect(di.ujn).toBeCloseTo(bv.donnee_intermediaire.ujn, 2);
+        } else {
+          expect(di.ujn).toBeUndefined();
+        }
+
+        expect(di.u_menuiserie).toBeCloseTo(bv.donnee_intermediaire.u_menuiserie, 2);
+        expect(di.sw).toBeCloseTo(bv.donnee_intermediaire.sw, 2);
+        expect(di.fe1).toBeCloseTo(bv.donnee_intermediaire.fe1, 2);
+        expect(di.fe2).toBeCloseTo(bv.donnee_intermediaire.fe2, 2);
+      });
+    });
+  });
+});

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

@@ -4,6 +4,7 @@ import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
 import { DeperditionPlancherBasService } from './plancher_bas/deperdition-plancher-bas.service.js';
 import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.js';
 import { DeperditionVentilationService } from './ventilation/deperdition-ventilation.service.js';
+import { DeperditionBaieVitreeService } from './baie_vitree/deperdition-baie-vitree.service.js';
 
 /**
  * Calcul des déperditions de l’enveloppe
@@ -30,6 +31,11 @@ export class DeperditionEnveloppeService {
    */
   #deperditionPlancherHautService;
 
+  /**
+   * @type {DeperditionBaieVitreeService}
+   */
+  #deperditionBaieVitreeService;
+
   /**
    * @type {DeperditionVentilationService}
    */
@@ -66,6 +72,7 @@ export class DeperditionEnveloppeService {
    * @param deperditionPorteService {DeperditionPorteService}
    * @param deperditionPlancherBasService {DeperditionPlancherBasService}
    * @param deperditionPlancherHautService {DeperditionPlancherHautService}
+   * @param deperditionBaieVitreeService {DeperditionBaieVitreeService}
    * @param deperditionVentilationService {DeperditionVentilationService}
    */
   constructor(
@@ -73,12 +80,14 @@ export class DeperditionEnveloppeService {
     deperditionPorteService = inject(DeperditionPorteService),
     deperditionPlancherBasService = inject(DeperditionPlancherBasService),
     deperditionPlancherHautService = inject(DeperditionPlancherHautService),
+    deperditionBaieVitreeService = inject(DeperditionBaieVitreeService),
     deperditionVentilationService = inject(DeperditionVentilationService)
   ) {
     this.#deperditionMurService = deperditionMurService;
     this.#deperditionPorteService = deperditionPorteService;
     this.#deperditionPlancherBasService = deperditionPlancherBasService;
     this.#deperditionPlancherHautService = deperditionPlancherHautService;
+    this.#deperditionBaieVitreeService = deperditionBaieVitreeService;
     this.#deperditionVentilationService = deperditionVentilationService;
     this.#surfaceDeperditive = 0;
     this.#surfaceIsolee = 0;
@@ -135,6 +144,7 @@ export class DeperditionEnveloppeService {
       deperdition_mur: 0,
       deperdition_plancher_bas: 0,
       deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
       deperdition_porte: 0
     };
 
@@ -211,6 +221,12 @@ export class DeperditionEnveloppeService {
     });
 
     enveloppe.baie_vitree_collection.baie_vitree?.forEach((bv) => {
+      bv.donnee_intermediaire = this.#deperditionBaieVitreeService.execute(ctx, bv);
+      deperditions.deperdition_baie_vitree +=
+        bv.donnee_intermediaire.b *
+        bv.donnee_entree.surface_totale_baie *
+        bv.donnee_intermediaire.u_menuiserie;
+
       // Surface de baie vitrée déperditive si b != 0
       if (bv.donnee_intermediaire.b > 0) {
         this.#surfaceDeperditive += bv.donnee_entree.surface_totale_baie;

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

@@ -2,10 +2,24 @@ import { TvStore } from '../../../../dpe/infrastructure/tv.store.js';
 import { DeperditionVentilationService } from './deperdition-ventilation.service.js';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { TypeHabitation } from '../../../../dpe/domain/models/type-habitation.model.js';
+import corpus from '../../../../../../test/corpus-sano.json';
+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';
 
 /** @type {DeperditionVentilationService} **/
 let service;
 
+/** @type {DpeNormalizerService} **/
+let normalizerService;
+
+/** @type {DeperditionEnveloppeService} **/
+let deperditionEnveloppeService;
+
+/** @type {ContexteBuilder} **/
+let contexteBuilder;
+
 /** @type {TvStore} **/
 let tvStore;
 
@@ -13,6 +27,9 @@ describe('Calcul de déperdition des portes', () => {
   beforeEach(() => {
     tvStore = new TvStore();
     service = new DeperditionVentilationService(tvStore);
+    normalizerService = new DpeNormalizerService();
+    contexteBuilder = new ContexteBuilder();
+    deperditionEnveloppeService = new DeperditionEnveloppeService();
   });
 
   describe('Determination de q4paConv', () => {
@@ -390,4 +407,36 @@ describe('Calcul de déperdition des portes', () => {
       }
     );
   });
+
+  describe("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);
+
+      const initialVentilations = [
+        ...(dpeRequest.logement.ventilation_collection?.ventilation || [])
+      ];
+
+      /** @type {Contexte} */
+      const ctx = contexteBuilder.fromDpe(dpeRequest);
+
+      deperditionEnveloppeService.deperditions(ctx, dpeRequest.logement);
+
+      const ventilations = dpeRequest.logement.ventilation_collection?.ventilation || [];
+
+      ventilations.forEach((ventilation, index) => {
+        expect(initialVentilations[index].donnee_intermediaire.hvent).toBeCloseTo(
+          ventilation.donnee_intermediaire.hvent,
+          2
+        );
+        expect(initialVentilations[index].donnee_intermediaire.hperm).toBeCloseTo(
+          ventilation.donnee_intermediaire.hperm,
+          2
+        );
+        expect(
+          initialVentilations[index].donnee_intermediaire.conso_auxiliaire_ventilation
+        ).toBeCloseTo(ventilation.donnee_intermediaire.conso_auxiliaire_ventilation, 2);
+      });
+    });
+  });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {