@open3cl/engine 1.6.1 → 1.6.2

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

@@ -5,6 +5,7 @@ import { DpeNormalizerService } from '../../../../normalizer/domain/dpe-normaliz
 import { DeperditionBaieVitreeService } from './deperdition-baie-vitree.service.js';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionBaieVitreeService} **/
 let service;
@@ -117,6 +118,32 @@ describe('Calcul de déperdition des baies vitrées', () => {
       expect(tvStore.getSw).toHaveBeenNthCalledWith(2, '2', '6', '4', '1', '3');
       expect(sw).toBe(18.8 * 18.8);
     });
+
+    test('Doit retomber sur un facteur 1 si le sw de la double-fenêtre est introuvable', () => {
+      // sw de la baie principale saisi, mais celui de la double-fenêtre indéterminé
+      // (getSw indéfini) => le facteur solaire équivalent reste celui de la baie principale.
+      vi.spyOn(tvStore, 'getSw').mockReturnValue(undefined);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          sw_saisi: 0.5,
+          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'
+          }
+        }
+      };
+
+      let sw = service.sw(bv);
+      expect(tvStore.getSw).toHaveBeenCalledOnce();
+      expect(sw).toBe(0.5);
+    });
   });
 
   describe('Determination du coefficient uw', () => {
@@ -166,6 +193,30 @@ describe('Calcul de déperdition des baies vitrées', () => {
       expect(tvStore.getUw).toHaveBeenNthCalledWith(2, '6', '4', 2.5);
       expect(uw).toBe(1 / (1 / 18.8 + 1 / 18.8 + 0.07));
     });
+
+    test('Doit retomber sur un uw de 1 pour la double-fenêtre si celui-ci est introuvable', () => {
+      // uw de la baie principale saisi, uw de la double-fenêtre indéterminé (getUw indéfini)
+      // => le terme 1/uw_double est remplacé par 1/1 dans la mise en série.
+      vi.spyOn(tvStore, 'getUw').mockReturnValue(undefined);
+      /**
+       * @type {BaieVitree}
+       */
+      let bv = {
+        donnee_entree: {
+          uw_saisi: 3,
+          double_fenetre: 1
+        },
+        baie_vitree_double_fenetre: {
+          donnee_entree: {
+            enum_type_materiaux_menuiserie_id: '4',
+            enum_type_baie_id: '6'
+          }
+        }
+      };
+
+      let uw = service.uw(bv, 2.4);
+      expect(uw).toBe(1 / (1 / 3 + 1 / 1 + 0.07));
+    });
   });
 
   describe('Determination du coefficient ug', () => {
@@ -258,6 +309,52 @@ describe('Calcul de déperdition des baies vitrées', () => {
       expect(uw).toBe(18.8);
     });
 
+    test("Ne recherche pas l'épaisseur la plus proche si l'épaisseur de lame n'est pas renseignée", () => {
+      // Double vitrage sans epaisseur_lame : e vaut NaN (falsy), la recherche de
+      // l'épaisseur tabulée la plus proche est court-circuitée.
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+      const availableSpy = vi.spyOn(tvStore, 'getEpaisseurAvailableForUg').mockReturnValue([6, 8]);
+
+      /**
+       * @type {BaieVitreeDE}
+       */
+      let bvDE = {
+        enum_type_vitrage_id: '2',
+        vitrage_vir: '1',
+        enum_inclinaison_vitrage_id: '2',
+        enum_type_gaz_lame_id: '1'
+      };
+
+      let ug = service.ug(bvDE);
+
+      expect(availableSpy).toHaveBeenCalledOnce();
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', NaN);
+      expect(ug).toBe(18.8);
+    });
+
+    test("Ignore les épaisseurs tabulées supérieures à l'épaisseur réelle en cherchant la plus proche", () => {
+      // Épaisseur réelle 18 absente de la table : on retient la plus grande épaisseur
+      // tabulée strictement inférieure (8), en ignorant les épaisseurs supérieures (25).
+      vi.spyOn(tvStore, 'getUg').mockReturnValue(18.8);
+      vi.spyOn(tvStore, 'getEpaisseurAvailableForUg').mockReturnValue([6, 8, 25]);
+
+      /**
+       * @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 ug = service.ug(bvDE);
+
+      expect(tvStore.getUg).toHaveBeenCalledWith('2', '1', '2', '1', 8);
+      expect(ug).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);
 
@@ -445,7 +542,33 @@ describe('Calcul de déperdition des baies vitrées', () => {
     expect(bvDI.u_menuiserie).toBe(5.6);
   });
 
-  describe("Test d'intégration des baies vitrées", () => {
+  test('Transmet la valeur de la zone climatique au calcul de b quand le contexte la renseigne', () => {
+    // Contexte avec zoneClimatique défini : ctx.zoneClimatique?.value est bien résolu et
+    // transmis à b (utile notamment pour les espaces tampons solarisés, adjacence 10).
+    const bSpy = vi.spyOn(service, 'b').mockReturnValue(0.85);
+
+    const bv = {
+      donnee_entree: {
+        enum_type_adjacence_id: '10',
+        surface_aiu: 8,
+        surface_aue: 20,
+        enum_cfg_isolation_lnc_id: '9',
+        ug_saisi: 2.5,
+        uw_saisi: 2.8,
+        enum_type_fermeture_id: '1'
+      }
+    };
+
+    const di = service.execute({ zoneClimatique: { value: 'h1a' } }, bv);
+
+    expect(bSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ enumTypeAdjacenceId: '10', zoneClimatique: 'h1a' })
+    );
+    expect(di.b).toBe(0.85);
+    expect(di.u_menuiserie).toBe(2.8);
+  });
+
+  describeIntegration("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);

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

@@ -8,8 +8,9 @@ import { DeperditionPorteService } from './porte/deperdition-porte.service.js';
 import { DeperditionPlancherHautService } from './plancher_haut/deperdition-plancher-haut.service.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 { beforeEach, describe, expect, test, vi } from 'vitest';
 import b from '../../../../3.1_b.js';
+import { describeIntegration } from '../../../../../test/helpers/integration-test.js';
 
 /** @type {DeperditionPorteService} **/
 let deperditionPorteService;
@@ -215,6 +216,273 @@ describe('Calcul des déperditions', () => {
     );
   });
 
+  describe('deperditions (agrégation GV + ventilation) avec des doubles de test', () => {
+    /**
+     * Construit un service avec huit doubles de test dont la méthode `execute`
+     * renvoie le `__di` (donnée intermédiaire) attaché à chaque donnée d'entrée.
+     */
+    const buildService = () => {
+      const murService = { execute: vi.fn((ctx, de) => de.__di) };
+      const porteService = { execute: vi.fn((ctx, de) => de.__di) };
+      const plancherBasService = { execute: vi.fn((ctx, de) => de.__di) };
+      const plancherHautService = { execute: vi.fn((ctx, de) => de.__di) };
+      const baieVitreeService = { execute: vi.fn((ctx, bv) => bv.donnee_entree.__di) };
+      const espaceTamponService = { execute: vi.fn(() => ({ tag: 'ets-di' })) };
+      const pontThermiqueService = { execute: vi.fn((ctx, env, de) => de.__di) };
+      const ventilationService = { execute: vi.fn((ctx, de) => de.__di) };
+
+      const service = new DeperditionEnveloppeService(
+        murService,
+        porteService,
+        plancherBasService,
+        plancherHautService,
+        baieVitreeService,
+        espaceTamponService,
+        pontThermiqueService,
+        ventilationService
+      );
+
+      return {
+        service,
+        murService,
+        porteService,
+        plancherBasService,
+        plancherHautService,
+        baieVitreeService,
+        espaceTamponService,
+        pontThermiqueService,
+        ventilationService
+      };
+    };
+
+    test('somme les contributions de chaque paroi et alimente la ventilation avec les surfaces', () => {
+      const { service, espaceTamponService, ventilationService } = buildService();
+
+      const enveloppe = {
+        mur_collection: {
+          mur: [
+            {
+              // déperditif, isolé "connu" (1) => surfaceNonIsolee
+              donnee_entree: {
+                surface_paroi_opaque: 10,
+                enum_type_adjacence_id: '1',
+                enum_type_isolation_id: '1',
+                __di: { b: 0.5, umur: 2 }
+              }
+            },
+            {
+              // b > 0 mais adjacence 22 (local non déperditif) => non compté en surface déperditive,
+              // isolation hors ['1','2'] => surfaceIsolee
+              donnee_entree: {
+                surface_paroi_opaque: 20,
+                enum_type_adjacence_id: '22',
+                enum_type_isolation_id: '3',
+                __di: { b: 0.8, umur: 1 }
+              }
+            },
+            {
+              // b = 0 => aucune surface comptée
+              donnee_entree: {
+                surface_paroi_opaque: 5,
+                enum_type_adjacence_id: '1',
+                enum_type_isolation_id: '2',
+                __di: { b: 0, umur: 3 }
+              }
+            }
+          ]
+        },
+        porte_collection: {
+          porte: [
+            {
+              donnee_entree: {
+                surface_porte: 2,
+                presence_joint: true,
+                __di: { b: 0.5, uporte: 3 }
+              }
+            },
+            {
+              donnee_entree: {
+                surface_porte: 4,
+                presence_joint: false,
+                __di: { b: 0, uporte: 2 }
+              }
+            }
+          ]
+        },
+        plancher_bas_collection: {
+          plancher_bas: [
+            {
+              donnee_entree: {
+                surface_paroi_opaque: 8,
+                __di: { b: 0.9, upb_final: 1.5 }
+              }
+            }
+          ]
+        },
+        plancher_haut_collection: {
+          plancher_haut: [
+            {
+              donnee_entree: {
+                surface_paroi_opaque: 12,
+                enum_type_adjacence_id: '1',
+                enum_type_isolation_id: '1',
+                __di: { b: 0.7, uph: 1 }
+              }
+            },
+            {
+              donnee_entree: {
+                surface_paroi_opaque: 6,
+                enum_type_adjacence_id: '22',
+                enum_type_isolation_id: '5',
+                __di: { b: 0.5, uph: 2 }
+              }
+            },
+            {
+              donnee_entree: {
+                surface_paroi_opaque: 3,
+                enum_type_adjacence_id: '1',
+                enum_type_isolation_id: '1',
+                __di: { b: 0, uph: 1 }
+              }
+            }
+          ]
+        },
+        baie_vitree_collection: {
+          baie_vitree: [
+            {
+              donnee_entree: {
+                surface_totale_baie: 5,
+                presence_joint: true,
+                __di: { b: 0.6, u_menuiserie: 2 }
+              }
+            },
+            {
+              donnee_entree: {
+                surface_totale_baie: 3,
+                presence_joint: false,
+                __di: { b: 0, u_menuiserie: 1 }
+              }
+            }
+          ]
+        },
+        ets_collection: {
+          ets: { donnee_entree: {} }
+        },
+        pont_thermique_collection: {
+          pont_thermique: [
+            {
+              // pourcentage explicite
+              donnee_entree: { l: 4, pourcentage_valeur_pont_thermique: 0.5, __di: { k: 0.2 } }
+            },
+            {
+              // pourcentage absent => 1 par défaut
+              donnee_entree: { l: 2, __di: { k: 0.3 } }
+            }
+          ]
+        }
+      };
+
+      const logement = {
+        enveloppe,
+        ventilation_collection: {
+          ventilation: [{ donnee_entree: { __di: { hvent: 100, hperm: 50 } } }]
+        }
+      };
+
+      const ctx = { zoneClimatique: { value: 'h1a' } };
+      const resultat = service.deperditions(ctx, logement);
+
+      // Contributions GV (b * surface * u)
+      expect(resultat.deperdition_mur).toBeCloseTo(0.5 * 10 * 2 + 0.8 * 20 * 1 + 0, 9); // 26
+      expect(resultat.deperdition_porte).toBeCloseTo(0.5 * 2 * 3, 9); // 3
+      expect(resultat.deperdition_plancher_bas).toBeCloseTo(0.9 * 8 * 1.5, 9); // 10.8
+      expect(resultat.deperdition_plancher_haut).toBeCloseTo(0.7 * 12 * 1 + 0.5 * 6 * 2, 9); // 14.4
+      expect(resultat.deperdition_baie_vitree).toBeCloseTo(0.6 * 5 * 2, 9); // 6
+      expect(resultat.deperdition_pont_thermique).toBeCloseTo(4 * 0.2 * 0.5 + 2 * 0.3 * 1, 9); // 1
+      expect(resultat.hvent).toBe(100);
+      expect(resultat.hperm).toBe(50);
+
+      // deperdition_enveloppe = somme GV + hvent + hperm
+      expect(resultat.deperdition_enveloppe).toBeCloseTo(
+        26 + 3 + 10.8 + 14.4 + 6 + 1 + 100 + 50,
+        9
+      );
+
+      // L'espace tampon a bien été calculé et stocké
+      expect(espaceTamponService.execute).toHaveBeenCalledOnce();
+      expect(enveloppe.ets_collection.ets.donnee_intermediaire).toStrictEqual({ tag: 'ets-di' });
+
+      // La ventilation reçoit les surfaces agrégées :
+      // déperditive = 10 (mur A) + 2 (porte A) + 12 (ph A) + 5 (baie A) = 29
+      // isolée = 20 (mur B) + 6 (ph B) = 26
+      // non isolée = 10 (mur A) + 12 (ph A) = 22
+      // menuiserie avec joint = 2 (porte A) + 5 (baie A) = 7
+      // menuiserie sans joint = 4 (porte B) + 3 (baie B) = 7
+      expect(ventilationService.execute).toHaveBeenCalledWith(
+        ctx,
+        { __di: { hvent: 100, hperm: 50 } },
+        29,
+        26,
+        22,
+        7,
+        7
+      );
+    });
+
+    test('utilise la première véranda lorsque les ETS sont dupliqués (tableau)', () => {
+      const { service, espaceTamponService } = buildService();
+
+      const premierEts = { donnee_entree: { reference: 'ets-1' } };
+      const enveloppe = {
+        mur_collection: {},
+        porte_collection: {},
+        plancher_bas_collection: {},
+        plancher_haut_collection: {},
+        baie_vitree_collection: {},
+        ets_collection: { ets: [premierEts, { donnee_entree: { reference: 'ets-2' } }] },
+        pont_thermique_collection: {}
+      };
+      const logement = { enveloppe, ventilation_collection: {} };
+
+      service.deperditions({ zoneClimatique: { value: 'h1a' } }, logement);
+
+      // Seule la première véranda est traitée
+      expect(espaceTamponService.execute).toHaveBeenCalledOnce();
+      expect(premierEts.donnee_intermediaire).toStrictEqual({ tag: 'ets-di' });
+    });
+
+    test('renvoie des déperditions nulles pour une enveloppe et une ventilation vides', () => {
+      const { service, espaceTamponService, ventilationService } = buildService();
+
+      const enveloppe = {
+        mur_collection: {},
+        porte_collection: {},
+        plancher_bas_collection: {},
+        plancher_haut_collection: {},
+        baie_vitree_collection: {},
+        pont_thermique_collection: {}
+      };
+      const logement = { enveloppe, ventilation_collection: {} };
+
+      const resultat = service.deperditions({ zoneClimatique: { value: 'h1a' } }, logement);
+
+      // Aucune paroi, aucun ETS, aucune ventilation
+      expect(espaceTamponService.execute).not.toHaveBeenCalled();
+      expect(ventilationService.execute).not.toHaveBeenCalled();
+      expect(resultat).toStrictEqual({
+        deperdition_mur: 0,
+        deperdition_plancher_bas: 0,
+        deperdition_plancher_haut: 0,
+        deperdition_baie_vitree: 0,
+        deperdition_pont_thermique: 0,
+        deperdition_porte: 0,
+        hperm: 0,
+        hvent: 0,
+        deperdition_enveloppe: 0
+      });
+    });
+  });
+
   describe.skip('Benchmark', () => {
     test('reworked', () => {
       const data = {
@@ -249,7 +517,7 @@ describe('Calcul des déperditions', () => {
     });
   });
 
-  describe("Test d'intégration de calcul des deperditions", () => {
+  describeIntegration("Test d'intégration de calcul des deperditions", () => {
     test.each(corpus)('deperditions pour dpe %s', (ademeId) => {
       let dpeRequest = getAdemeFileJson(ademeId);
       dpeRequest = normalizerService.normalize(dpeRequest);

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

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DeperditionService } from './deperdition.service.js';
+import { logger } from '../../../../core/util/logger/log-service.js';
+
+/**
+ * Tests unitaires isolés de la classe de base `DeperditionService`.
+ *
+ * Le `TvStore` est remplacé par un double de test (spies `vi.fn`) afin de
+ * n'exercer que la logique de la classe (méthodes `b` et
+ * `getEnumPeriodeIsolationId`), sans dépendre des tables de valeurs réelles.
+ */
+
+/** @type {{ getUVue: import('vitest').Mock, getB: import('vitest').Mock }} */
+let tvStore;
+
+/** @type {DeperditionService} */
+let service;
+
+describe('DeperditionService (classe de base des déperditions)', () => {
+  beforeEach(() => {
+    tvStore = {
+      getUVue: vi.fn(),
+      getB: vi.fn()
+    };
+    service = new DeperditionService(tvStore);
+    vi.restoreAllMocks();
+  });
+
+  test('conserve la référence au tvStore injecté', () => {
+    expect(service.tvStore).toBe(tvStore);
+  });
+
+  test('execute() lève une erreur (opération non supportée sur la classe de base)', () => {
+    expect(() => service.execute({}, {})).toThrow('Unsupported operation');
+  });
+
+  describe('b() - coefficient de réduction des déperditions', () => {
+    test('retourne 0 pour une adjacence sur AUE sans surface AUE renseignée', () => {
+      const resultat = service.b({ enumTypeAdjacenceId: '8', surfaceAue: 0 });
+      expect(resultat).toBe(0);
+      expect(tvStore.getB).not.toHaveBeenCalled();
+    });
+
+    test('retourne 0 pour une adjacence sur AUE avec surface AUE indéfinie', () => {
+      const resultat = service.b({ enumTypeAdjacenceId: '15' });
+      expect(resultat).toBe(0);
+    });
+
+    test('local non chauffé non accessible (cfg isolation 1) : appel getB sans adjacence ni uVue', () => {
+      tvStore.getB.mockReturnValue(0.95);
+
+      const resultat = service.b({
+        enumTypeAdjacenceId: '9',
+        surfaceAue: 20,
+        enumCfgIsolationLncId: '1'
+      });
+
+      expect(resultat).toBe(0.95);
+      expect(tvStore.getUVue).not.toHaveBeenCalled();
+      // enumTypeAdjacenceId remis à undefined, uVue et rAiuAue non calculés
+      expect(tvStore.getB).toHaveBeenCalledWith(undefined, undefined, '1', undefined, undefined);
+    });
+
+    test('adjacence sur AUE avec surfaces : calcule uVue et le ratio rAiuAue', () => {
+      tvStore.getUVue.mockReturnValue(2.5);
+      tvStore.getB.mockReturnValue(0.8);
+
+      const resultat = service.b({
+        enumTypeAdjacenceId: '8',
+        surfaceAue: 40,
+        surfaceAiu: 20,
+        enumCfgIsolationLncId: '2'
+      });
+
+      expect(resultat).toBe(0.8);
+      expect(tvStore.getUVue).toHaveBeenCalledWith('8');
+      expect(tvStore.getB).toHaveBeenCalledWith('8', 2.5, '2', 0.5, undefined);
+    });
+
+    test('adjacence sur AUE : uVue vaut 0 si le tvStore ne retourne pas de valeur', () => {
+      tvStore.getUVue.mockReturnValue(undefined);
+      tvStore.getB.mockReturnValue(0.9);
+
+      service.b({
+        enumTypeAdjacenceId: '12',
+        surfaceAue: 10,
+        surfaceAiu: 5,
+        enumCfgIsolationLncId: '2'
+      });
+
+      expect(tvStore.getB).toHaveBeenCalledWith('12', 0, '2', 0.5, undefined);
+    });
+
+    test('espace tampon solarisé (adjacence 10) sans zone climatique : avertit et retourne undefined', () => {
+      const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(() => {});
+
+      const resultat = service.b({ enumTypeAdjacenceId: '10' });
+
+      expect(resultat).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledOnce();
+      expect(tvStore.getB).not.toHaveBeenCalled();
+    });
+
+    test('espace tampon solarisé (adjacence 10) avec zone climatique : transmet la zone à getB', () => {
+      tvStore.getB.mockReturnValue(0.7);
+
+      const resultat = service.b({ enumTypeAdjacenceId: '10', zoneClimatique: 'h1a' });
+
+      expect(resultat).toBe(0.7);
+      expect(tvStore.getB).toHaveBeenCalledWith('10', undefined, undefined, undefined, 'h1a');
+    });
+
+    test('adjacence classique (hors listes) : délègue directement à getB', () => {
+      tvStore.getB.mockReturnValue(1);
+
+      const resultat = service.b({ enumTypeAdjacenceId: '1' });
+
+      expect(resultat).toBe(1);
+      expect(tvStore.getUVue).not.toHaveBeenCalled();
+      expect(tvStore.getB).toHaveBeenCalledWith('1', undefined, undefined, undefined, undefined);
+    });
+  });
+
+  describe('getEnumPeriodeIsolationId()', () => {
+    test("retourne la période d'isolation si elle est fournie", () => {
+      expect(service.getEnumPeriodeIsolationId('7', { enumPeriodeConstructionId: '1' })).toBe('7');
+    });
+
+    test("période d'isolation inconnue et construction ≤ 74 : retourne '3' (75-77)", () => {
+      expect(service.getEnumPeriodeIsolationId(undefined, { enumPeriodeConstructionId: '2' })).toBe(
+        '3'
+      );
+    });
+
+    test("période d'isolation inconnue et construction récente : reprend la période de construction", () => {
+      expect(service.getEnumPeriodeIsolationId(undefined, { enumPeriodeConstructionId: '8' })).toBe(
+        '8'
+      );
+    });
+  });
+});

package/features/engine/domain/enveloppe/espace_tampon/espace-tampon.service.spec.js

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { BaieVitreeTvStore } from '../../../../dpe/infrastructure/enveloppe/baieVitreeTv.store.js';
 import { EspaceTamponService } from './espace-tampon.service.js';
 import { getAdemeFileJson } from '../../../../../../test/test-helpers.js';
+import { describeIntegration } from '../../../../../../test/helpers/integration-test.js';
 
 /** @type {EspaceTamponService} **/
 let service;
@@ -54,7 +55,7 @@ describe('Calcul de déperdition des baies vitrées', () => {
     });
   });
 
-  describe("Test d'intégration des ets", () => {
+  describeIntegration("Test d'intégration des ets", () => {
     test.each(['2273E0303205P', '2364E0984413P', '2283E0131604Y'])(
       'vérification des DI des ets pour dpe %s',
       (ademeId) => {