@open3cl/engine 1.6.1 → 1.7.0

package/dpe-sanitizer.service.spec.js

@@ -0,0 +1,138 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler `DpeSanitizerService` :
+ * - `lodash-es` : `has`/`set` contrôlés pour observer la création des collections
+ *   manquantes ;
+ * - `ObjectUtil.deepObjectTransform` : mocké pour capturer la fonction de
+ *   transformation des valeurs et la tester unitairement, sans parcourir un vrai DPE.
+ */
+vi.mock('lodash-es', () => ({
+  has: vi.fn(),
+  set: vi.fn()
+}));
+
+vi.mock('./core/util/infrastructure/object-util.js', () => ({
+  ObjectUtil: {
+    deepObjectTransform: vi.fn()
+  }
+}));
+
+const { default: DpeSanitizerService } = await import('./dpe-sanitizer.service.js');
+const { has, set } = await import('lodash-es');
+const { ObjectUtil } = await import('./core/util/infrastructure/object-util.js');
+
+/** Liste des collections dont l'absence doit être compensée par un tableau vide. */
+const COLLECTIONS = [
+  'logement.enveloppe.mur_collection.mur',
+  'logement.enveloppe.plancher_bas_collection.plancher_bas',
+  'logement.enveloppe.plancher_haut_collection.plancher_haut',
+  'logement.ventilation_collection.ventilation',
+  'logement.climatisation_collection.climatisation',
+  'logement.enveloppe.baie_vitree_collection.baie_vitree',
+  'logement.enveloppe.porte_collection.porte',
+  'logement.enveloppe.pont_thermique_collection.pont_thermique'
+];
+
+let service;
+
+beforeEach(() => {
+  vi.mocked(has).mockReset();
+  vi.mocked(set).mockReset();
+  vi.mocked(ObjectUtil.deepObjectTransform).mockReset();
+  vi.mocked(ObjectUtil.deepObjectTransform).mockImplementation((dpe) => dpe);
+  service = new DpeSanitizerService();
+});
+
+describe('DpeSanitizerService.execute - collections manquantes', () => {
+  test('crée un tableau vide pour chaque collection absente', () => {
+    vi.mocked(has).mockReturnValue(false);
+    const dpe = {};
+
+    service.execute(dpe);
+
+    expect(set).toHaveBeenCalledTimes(COLLECTIONS.length);
+    for (const path of COLLECTIONS) {
+      expect(set).toHaveBeenCalledWith(dpe, path, []);
+    }
+  });
+
+  test('ne recrée pas les collections déjà présentes', () => {
+    vi.mocked(has).mockReturnValue(true);
+
+    service.execute({});
+
+    expect(set).not.toHaveBeenCalled();
+  });
+
+  test('délègue la transformation profonde et retourne son résultat', () => {
+    vi.mocked(has).mockReturnValue(true);
+    const transforme = { transforme: true };
+    vi.mocked(ObjectUtil.deepObjectTransform).mockReturnValue(transforme);
+
+    const resultat = service.execute({ brut: true });
+
+    expect(ObjectUtil.deepObjectTransform).toHaveBeenCalledOnce();
+    expect(resultat).toBe(transforme);
+  });
+});
+
+/**
+ * Récupère la fonction de transformation des valeurs passée en 3e argument de
+ * `deepObjectTransform` après un appel à `execute`.
+ */
+function getValueTransform() {
+  vi.mocked(has).mockReturnValue(true);
+  service.execute({});
+  return vi.mocked(ObjectUtil.deepObjectTransform).mock.calls[0][2];
+}
+
+describe('DpeSanitizerService - transformation des valeurs', () => {
+  test('encapsule dans un tableau les nœuds simples à cardinalité multiple', () => {
+    const valueTransform = getValueTransform();
+    const generateur = { id: 1 };
+    // `generateur_ecs` fait partie des nœuds à transformer en tableau
+    expect(valueTransform(generateur, 'generateur_ecs')).toEqual([generateur]);
+  });
+
+  test('ne ré-encapsule pas un nœud déjà sous forme de tableau', () => {
+    const valueTransform = getValueTransform();
+    const deja = [{ id: 1 }];
+    // déjà un tableau => traité comme une valeur non numérique et renvoyé tel quel
+    expect(valueTransform(deja, 'generateur_ecs')).toBe(deja);
+  });
+
+  test("convertit les valeurs d'énumération en chaîne de caractères", () => {
+    const valueTransform = getValueTransform();
+    expect(valueTransform(12, 'enum_type_generateur_ch_id')).toBe('12');
+    expect(valueTransform(5, 'original_enum_type_generateur_ch_id')).toBe('5');
+  });
+
+  test('une énumération nulle donne une valeur indéfinie (optional chaining)', () => {
+    const valueTransform = getValueTransform();
+    expect(valueTransform(null, 'enum_type_generateur_ch_id')).toBeUndefined();
+  });
+
+  test('remplace les valeurs vides ou nulles par une chaîne vide', () => {
+    const valueTransform = getValueTransform();
+    expect(valueTransform('', 'surface_paroi_opaque')).toBe('');
+    expect(valueTransform(null, 'surface_paroi_opaque')).toBe('');
+  });
+
+  test('conserve les tableaux vides tels quels', () => {
+    const valueTransform = getValueTransform();
+    const vide = [];
+    expect(valueTransform(vide, 'mur')).toBe(vide);
+  });
+
+  test('conserve les chaînes non numériques telles quelles', () => {
+    const valueTransform = getValueTransform();
+    expect(valueTransform('maison', 'description')).toBe('maison');
+  });
+
+  test('convertit les chaînes numériques en nombres', () => {
+    const valueTransform = getValueTransform();
+    expect(valueTransform('40.94', 'surface_paroi_opaque')).toBe(40.94);
+    expect(valueTransform('12', 'quantite')).toBe(12);
+  });
+});

package/engine.js

@@ -3,6 +3,7 @@ import calc_deperdition from './3_deperdition.js';
 import calc_apport_et_besoin from './apport_et_besoin.js';
 import calc_clim from './10_clim.js';
 import calc_ecs from './11_ecs.js';
+import { conso_aux_distribution_ecs } from './15_conso_aux.js';
 import calc_besoin_ch from './9_besoin_ch.js';
 import calc_chauffage, { tauxChargeForGenerator } from './9_chauffage.js';
 import calc_confort_ete from './2021_04_13_confort_ete.js';
@@ -31,7 +32,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.6.1';
+const LIB_VERSION = '1.7.0';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -90,6 +91,7 @@ export function calcul_3cl(inputDpe, options) {
 
   const cg = logement.caracteristique_generale;
   const map_id = cg.enum_methode_application_dpe_log_id;
+  const dpeGenereImmeuble = ['10', '11', '12', '13', '33', '34', '38', '39', '40'].includes(map_id);
   const th = calc_th(map_id);
 
   if (logement.enveloppe === undefined) {
@@ -435,6 +437,20 @@ export function calcul_3cl(inputDpe, options) {
       dpe.logement.caracteristique_generale.nombre_appartement,
       isImmeubleSystemEcsIndividuels
     );
+
+    if (!dpeGenereImmeuble) {
+      conso_aux_distribution_ecs(
+        ecs,
+        ecs.donnee_entree,
+        ecs.donnee_intermediaire,
+        Sh,
+        cg.surface_habitable_immeuble,
+        ca_id,
+        zc_id,
+        apport_et_besoin.nadeq,
+        dpe.logement.caracteristique_generale.nombre_niveau_immeuble
+      );
+    }
   });
 
   /**
@@ -612,6 +628,9 @@ export function calcul_3cl(inputDpe, options) {
   );
 
   // get all baie_vitree orientations
+  // repli défensif inatteignable : la garde en amont réinitialise plancher_haut_collection
+  // à { plancher_haut: [] } (tableau vide truthy), donc plancher_haut est toujours défini
+  /* c8 ignore next */
   const ph_list = env.plancher_haut_collection.plancher_haut || [];
   logement.sortie = {
     deperdition,