@open3cl/engine 1.6.0 → 1.6.2

package/10_besoin_fr.spec.js

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler le module :
+ * - tables de valeurs (`tvs`) : profils mensuels nref / e_fr / textmoy_clim ;
+ * - calcul des apports internes/solaires (`calc_ai_j`, `calc_as_j`) et surface sud équivalente
+ *   (`calc_sse_j`) : simples fonctions dont on contrôle le retour ;
+ * - `mois_liste` : réduite à un seul mois pour rendre la somme vérifiable.
+ */
+vi.mock('./tv.js', () => ({
+  tvs: {
+    nref26: { ca1: { Janvier: { h1a: 10 } } },
+    nref28: { ca1: { Janvier: { h1a: 10 } } },
+    e_fr_26: { ca1: { Janvier: { h1a: 100 } } },
+    e_fr_28: { ca1: { Janvier: { h1a: 100 } } },
+    textmoy_clim_26: { ca1: { Janvier: { h1a: 30 } } },
+    textmoy_clim_28: { ca1: { Janvier: { h1a: 30 } } }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  mois_liste: ['Janvier']
+}));
+
+vi.mock('./6.1_apport_gratuit.js', () => ({
+  calc_ai_j: vi.fn(),
+  calc_as_j: vi.fn()
+}));
+
+vi.mock('./6.2_surface_sud_equivalente.js', () => ({
+  calc_sse_j: vi.fn()
+}));
+
+const { default: calc_besoin_fr, calc_besoin_fr_j } = await import('./10_besoin_fr.js');
+const { calc_ai_j, calc_as_j } = await import('./6.1_apport_gratuit.js');
+const { calc_sse_j } = await import('./6.2_surface_sud_equivalente.js');
+
+/**
+ * 10. Calcul des besoins de froid (Bfr)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §10
+ */
+describe('calc_besoin_fr_j - besoin de froid journalier', () => {
+  test('retourne 0 lorsque le nombre de jours de référence est nul', () => {
+    expect(calc_besoin_fr_j(100, 300, 'moyenne', 5000, 2000, 0, 30, 28)).toBe(0);
+  });
+
+  test('retourne 0 lorsque le taux Rbth est inférieur à 1/2 (apports insuffisants)', () => {
+    // aij + asj = 0 => Rbth = 0 < 0.5
+    expect(calc_besoin_fr_j(100, 300, 'moyenne', 0, 0, 10, 30, 28)).toBe(0);
+  });
+
+  test('valeur de référence (Tint=28°C, inertie moyenne)', () => {
+    expect(calc_besoin_fr_j(100, 300, 'moyenne', 5000, 2000, 10, 30, 28)).toBeCloseTo(
+      11.312243423584366,
+      9
+    );
+  });
+
+  test('valeur de référence en mode dépensier (Tint=26°C)', () => {
+    expect(calc_besoin_fr_j(100, 300, 'moyenne', 5000, 2000, 10, 30, 26)).toBeCloseTo(
+      12.777039072730146,
+      9
+    );
+  });
+
+  test('taux Rbth exactement égal à 1 : facteur d’utilisation futj = a / (a + 1)', () => {
+    // Rbth = (aij + asj) / (GV * (textmoy - Tint) * nrefj) = 2000 / (100 * 2 * 10) = 1
+    // valeur de référence de régression
+    expect(calc_besoin_fr_j(100, 100, 'moyenne', 1000, 1000, 10, 30, 28)).toBeCloseTo(
+      3.604395604395604,
+      9
+    );
+  });
+
+  test('le besoin de froid dépensier (26°C) est supérieur au besoin conventionnel (28°C)', () => {
+    const conventionnel = calc_besoin_fr_j(100, 300, 'moyenne', 5000, 2000, 10, 30, 28);
+    const depensier = calc_besoin_fr_j(100, 300, 'moyenne', 5000, 2000, 10, 30, 26);
+    expect(depensier).toBeGreaterThan(conventionnel);
+  });
+});
+
+describe('calc_besoin_fr - agrégation mensuelle', () => {
+  beforeEach(() => {
+    vi.mocked(calc_ai_j).mockReset();
+    vi.mocked(calc_as_j).mockReset();
+    vi.mocked(calc_sse_j).mockReset();
+  });
+
+  test('agrège le besoin conventionnel et dépensier sur les mois', () => {
+    vi.mocked(calc_ai_j).mockReturnValue(5000);
+    vi.mocked(calc_as_j).mockReturnValue(2000);
+    vi.mocked(calc_sse_j).mockReturnValue(10);
+
+    const ret = calc_besoin_fr('ca1', 'h1a', 100, 3, 300, 'moyenne', [], null);
+
+    expect(ret.besoin_fr).toBeCloseTo(11.312243423584366, 9);
+    expect(ret.besoin_fr_depensier).toBeCloseTo(12.777039072730146, 9);
+  });
+
+  test('délègue le calcul de la surface sud équivalente mois par mois', () => {
+    vi.mocked(calc_ai_j).mockReturnValue(0);
+    vi.mocked(calc_as_j).mockReturnValue(0);
+    vi.mocked(calc_sse_j).mockReturnValue(0);
+
+    calc_besoin_fr('ca1', 'h1a', 100, 3, 300, 'moyenne', ['bv'], 'ets');
+
+    expect(calc_sse_j).toHaveBeenCalledWith(['bv'], 'ets', 'ca1', 'h1a', 'Janvier');
+    // apports internes calculés à partir de la surface et du nombre d'adultes équivalents
+    expect(calc_ai_j).toHaveBeenCalledWith(100, 3, 10);
+  });
+
+  test('un besoin nul sur tous les mois donne un besoin annuel nul', () => {
+    vi.mocked(calc_ai_j).mockReturnValue(0);
+    vi.mocked(calc_as_j).mockReturnValue(0);
+    vi.mocked(calc_sse_j).mockReturnValue(0);
+
+    const ret = calc_besoin_fr('ca1', 'h1a', 100, 3, 300, 'moyenne', [], null);
+
+    expect(ret.besoin_fr).toBe(0);
+    expect(ret.besoin_fr_depensier).toBe(0);
+  });
+});

package/10_clim.spec.js

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler `calc_clim` :
+ * - `tv` : accès à la table de valeurs `seer` (on contrôle la ligne retournée
+ *   et donc l'EER forfaitaire) ;
+ * - `requestInputID` : passe-plat vers les données d'entrée pour la période
+ *   d'installation.
+ */
+vi.mock('./utils.js', () => ({
+  tv: vi.fn(),
+  requestInputID: (de, du, field) => {
+    const enumName = `enum_${field}_id`;
+    du[enumName] = de[enumName];
+    return de[enumName];
+  }
+}));
+
+const { default: calc_clim } = await import('./10_clim.js');
+const { tv } = await import('./utils.js');
+
+/** Fabrique un objet climatisation minimal. */
+function clim(de) {
+  return { donnee_entree: de };
+}
+
+beforeEach(() => {
+  vi.mocked(tv).mockReset();
+});
+
+/**
+ * 10. Calcul de la consommation de climatisation (froid)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §10
+ */
+describe('calc_clim - consommation de climatisation', () => {
+  test('prorate le besoin de froid au ratio surface_clim / Sh', () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({ surface_clim: 50, enum_methode_saisie_carac_sys_id: '1' });
+
+    calc_clim(c, 1000, 1500, '1', 100);
+
+    // rs = 50 / 100 = 0.5
+    expect(c.donnee_intermediaire.besoin_fr).toBeCloseTo(500, 9);
+    expect(c.donnee_intermediaire.besoin_fr_depensier).toBeCloseTo(750, 9);
+  });
+
+  test('EER forfaitaire issu de la table : conso = 0.9 * besoin_fr / eer', () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({ surface_clim: 50, enum_methode_saisie_carac_sys_id: '1' });
+
+    calc_clim(c, 1000, 1500, '1', 100);
+
+    // valeur de référence de régression : 0.9 * 500 / 3
+    expect(c.donnee_intermediaire.conso_fr).toBeCloseTo(150, 9);
+    // 0.9 * 750 / 3
+    expect(c.donnee_intermediaire.conso_fr_depensier).toBeCloseTo(225, 9);
+    expect(c.donnee_entree.tv_seer_id).toBe(5);
+    expect(c.donnee_intermediaire.eer).toBe(3);
+  });
+
+  test("matcher de la table seer : zone climatique + période d'installation", () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({
+      surface_clim: 50,
+      enum_methode_saisie_carac_sys_id: '1',
+      enum_periode_installation_fr_id: '4'
+    });
+
+    calc_clim(c, 1000, 1500, '2', 100);
+
+    expect(tv).toHaveBeenCalledWith(
+      'seer',
+      {
+        enum_zone_climatique_id: '2',
+        enum_periode_installation_fr_id: '4'
+      },
+      c.donnee_entree
+    );
+  });
+
+  test.each([['6'], ['7'], ['8']])(
+    "méthode de saisie %s avec EER déjà connu : pas d'accès à la table forfaitaire",
+    (methode) => {
+      const c = {
+        donnee_entree: { surface_clim: 50, enum_methode_saisie_carac_sys_id: methode },
+        donnee_intermediaire: { eer: 4 }
+      };
+
+      calc_clim(c, 1000, 1500, '1', 100);
+
+      expect(tv).not.toHaveBeenCalled();
+      // conso calculée avec l'EER saisi : 0.9 * 500 / 4
+      expect(c.donnee_intermediaire.conso_fr).toBeCloseTo(112.5, 9);
+    }
+  );
+
+  test('méthode de saisie caractéristiques (6) mais EER absent : recours à la table', () => {
+    tv.mockReturnValue({ tv_seer_id: '5', eer: 3 });
+    const c = clim({ surface_clim: 50, enum_methode_saisie_carac_sys_id: '6' });
+
+    calc_clim(c, 1000, 1500, '1', 100);
+
+    expect(tv).toHaveBeenCalled();
+    expect(c.donnee_intermediaire.eer).toBe(3);
+  });
+
+  test('aucune ligne forfaitaire trouvée : EER indéfini, conso non finie', () => {
+    tv.mockReturnValue(null);
+    const c = clim({ surface_clim: 50, enum_methode_saisie_carac_sys_id: '1' });
+
+    calc_clim(c, 1000, 1500, '1', 100);
+
+    expect(c.donnee_intermediaire.eer).toBeUndefined();
+    expect(Number.isFinite(c.donnee_intermediaire.conso_fr)).toBe(false);
+  });
+});

package/11_besoin_ecs.spec.js

@@ -0,0 +1,69 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler le module :
+ * - `tvs.tefs` : température d'eau froide sanitaire mensuelle par classe d'altitude / zone ;
+ * - `Njj` : nombre de jours du mois ;
+ * - `mois_liste` : réduite à un seul mois pour rendre la somme annuelle vérifiable.
+ * Le calcul du besoin ECS ne dépend ainsi que de valeurs contrôlées.
+ */
+vi.mock('./tv.js', () => ({
+  tvs: {
+    tefs: { ca1: { Janvier: { h1a: 10 } } }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  mois_liste: ['Janvier'],
+  Njj: { Janvier: 30 }
+}));
+
+const { default: calc_besoin_ecs, calc_besoin_ecs_j } = await import('./11_besoin_ecs.js');
+
+/**
+ * 11. Calcul du besoin d'eau chaude sanitaire (Becs)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §11
+ */
+describe('calc_besoin_ecs_j - besoin ECS journalier', () => {
+  test('valeur de référence en mode conventionnel (56 L/j/personne)', () => {
+    // valeur de référence de régression : (1.163 * 2 * 56 * (40 - 10) * 30) / 1000
+    expect(calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 2, false)).toBeCloseTo(117.2304, 9);
+  });
+
+  test('valeur de référence en mode dépensier (79 L/j/personne)', () => {
+    // valeur de référence de régression : (1.163 * 2 * 79 * (40 - 10) * 30) / 1000
+    expect(calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 2, true)).toBeCloseTo(165.3786, 9);
+  });
+
+  test('le besoin dépensier est supérieur au besoin conventionnel (ratio 79/56)', () => {
+    const conventionnel = calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 2, false);
+    const depensier = calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 2, true);
+    expect(depensier / conventionnel).toBeCloseTo(79 / 56, 9);
+  });
+
+  test('un nombre équivalent d’adultes nul donne un besoin nul', () => {
+    expect(calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 0, false)).toBe(0);
+    expect(calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 0, true)).toBe(0);
+  });
+
+  test('le besoin est proportionnel au nombre équivalent d’adultes', () => {
+    const un = calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 1, false);
+    const trois = calc_besoin_ecs_j('ca1', 'Janvier', 'h1a', 3, false);
+    expect(trois).toBeCloseTo(3 * un, 9);
+  });
+});
+
+describe('calc_besoin_ecs - agrégation annuelle', () => {
+  test('agrège les besoins conventionnel et dépensier sur les mois', () => {
+    const ret = calc_besoin_ecs('ca1', 'h1a', 2);
+    // un seul mois mocké => identique au calcul journalier
+    expect(ret.besoin_ecs).toBeCloseTo(117.2304, 9);
+    expect(ret.besoin_ecs_depensier).toBeCloseTo(165.3786, 9);
+  });
+
+  test('un nombre équivalent d’adultes nul donne un besoin annuel nul', () => {
+    const ret = calc_besoin_ecs('ca1', 'h1a', 0);
+    expect(ret.besoin_ecs).toBe(0);
+    expect(ret.besoin_ecs_depensier).toBe(0);
+  });
+});

package/11_ecs.spec.js

@@ -0,0 +1,282 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler `calc_ecs` :
+ * - `enums.type_installation` : libellé du type d'installation (individuelle / collective) ;
+ * - `tv` : accès à la table rendement_distribution_ecs (ligne contrôlée) ;
+ * - `requestInput` : passe-plat vers les données d'entrée pour le réseau collectif ;
+ * - `calc_gen_ecs` : calcul par générateur, neutralisé (les consommations sont pré-remplies).
+ * Aucune vraie table de valeurs n'est sollicitée : les tests restent stables si les données changent.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    type_installation: {
+      1: 'installation individuelle',
+      2: 'installation collective',
+      3: 'installation collective multi-bâtiment'
+    }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  tv: vi.fn(),
+  requestInput: vi.fn()
+}));
+
+vi.mock('./14_generateur_ecs.js', () => ({
+  default: vi.fn()
+}));
+
+const { default: calc_ecs } = await import('./11_ecs.js');
+const { tv, requestInput } = await import('./utils.js');
+const { default: calc_gen_ecs } = await import('./14_generateur_ecs.js');
+
+/** Fabrique une installation ECS avec un générateur dont la consommation est pré-remplie. */
+function makeEcs(de, gens) {
+  return {
+    donnee_entree: de,
+    generateur_ecs_collection: {
+      generateur_ecs: gens ?? [
+        {
+          donnee_entree: { position_volume_chauffe: 1 },
+          donnee_intermediaire: { conso_ecs: 10, conso_ecs_depensier: 20 }
+        }
+      ]
+    }
+  };
+}
+
+beforeEach(() => {
+  vi.mocked(tv).mockReset();
+  vi.mocked(requestInput).mockReset();
+  vi.mocked(calc_gen_ecs).mockReset();
+  // ligne forfaitaire de rendement de distribution par défaut
+  vi.mocked(tv).mockReturnValue({ rd: '0.9', tv_rendement_distribution_ecs_id: '5' });
+});
+
+/**
+ * 11. Prise en compte de l'ECS (ratio de besoin + rendement de distribution)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §11 / §17.2.1
+ */
+describe('calc_ecs - ratio de besoin ECS', () => {
+  test('virtualisation : le ratio est la clé de répartition ECS', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5', cle_repartition_ecs: 0.5 };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', true, null, null, false);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.5);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBeCloseTo(50, 9);
+    expect(ecs.donnee_intermediaire.besoin_ecs_depensier).toBeCloseTo(100, 9);
+  });
+
+  test('immeuble à systèmes ECS individuels : ratio = 1 / nombre d’appartements', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, 4, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.25);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBeCloseTo(25, 9);
+  });
+
+  test('présence de rdim : ratio = 1 / rdim', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5', rdim: 2 };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(0.5);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBeCloseTo(50, 9);
+  });
+
+  test('virtualisation sans clé de répartition : ratio = 1 (valeur de repli)', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', true, null, null, false);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(1);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBe(100);
+  });
+
+  test('immeuble à systèmes ECS individuels sans nombre d’appartements : ratio calculé au prorata', () => {
+    const de = {
+      tv_rendement_distribution_ecs_id: '5',
+      surface_habitable: 50,
+      rdim: 1,
+      nombre_logement: 10
+    };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, 200, null, true);
+
+    // ratio = ((surface_habitable / surfaceImmeuble) * rdim) / (nombre_logement * nombreAppartements)
+    // nombreAppartements est nul -> division par 0 => ratio infini, on vérifie seulement la branche prise
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(Infinity);
+  });
+
+  test('immeuble à systèmes ECS individuels : surface immeuble et rdim absents utilisent le repli 1', () => {
+    const de = {
+      tv_rendement_distribution_ecs_id: '5',
+      surface_habitable: 50,
+      nombre_logement: 10
+    };
+    const ecs = makeEcs(de);
+    // surfaceImmeuble null et de.rdim absent -> les deux `|| 1` s'appliquent
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, null, true);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(Infinity);
+  });
+
+  test('rdim infini : la valeur de repli 1 s’applique (1 / Infinity vaut 0)', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5', rdim: Infinity };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    // 1 / Infinity = 0 -> `|| 1` prend le repli
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(1);
+  });
+
+  test('cas par défaut : ratio = 1 (aucune proratisation)', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(ecs.donnee_intermediaire.ratio_besoin_ecs).toBe(1);
+    expect(ecs.donnee_intermediaire.besoin_ecs).toBe(100);
+    expect(ecs.donnee_intermediaire.besoin_ecs_depensier).toBe(200);
+  });
+});
+
+describe('calc_ecs - rendement de distribution', () => {
+  test('la ligne forfaitaire alimente rendement_distribution et l’identifiant de table', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(ecs.donnee_intermediaire.rendement_distribution).toBe(0.9);
+    expect(de.tv_rendement_distribution_ecs_id).toBe(5);
+  });
+
+  test('installation individuelle, production dans le volume chauffé : matcher de configuration', () => {
+    const de = { enum_type_installation_id: '1' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {
+      configuration_logement: 'production volume habitable [+] pièces alimentées contiguës'
+    });
+  });
+
+  test('installation individuelle, production hors volume chauffé : configuration adaptée', () => {
+    const de = { enum_type_installation_id: '1' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 0 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {
+      configuration_logement: 'production hors volume habitable'
+    });
+  });
+
+  test('installation collective non isolée : matcher type de réseau + configuration', () => {
+    vi.mocked(requestInput).mockImplementation((de, du, field) =>
+      field === 'reseau_distribution_isole' ? 0 : undefined
+    );
+    const de = { enum_type_installation_id: '2' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, null, false);
+
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {
+      type_reseau_collectif: 'Réseau collectif non isolé',
+      configuration_logement: 'majorité des logements avec pièces alimentées contiguës'
+    });
+  });
+
+  test('installation collective multi-bâtiment isolée bouclée : configuration non contiguë', () => {
+    vi.mocked(requestInput).mockImplementation((de, du, field) => {
+      if (field === 'reseau_distribution_isole') return 1;
+      if (field === 'bouclage_reseau_ecs') return "réseau d'ecs bouclé";
+      return undefined;
+    });
+    const de = { enum_type_installation_id: '3' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, null, false);
+
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {
+      type_reseau_collectif: 'Réseau collectif isolé bouclé',
+      configuration_logement: 'majorité des logements avec pièces alimentées non contiguës'
+    });
+  });
+
+  test('installation collective isolée sans bouclage (traçage) : configuration ignorée', () => {
+    vi.mocked(requestInput).mockImplementation((de, du, field) => {
+      if (field === 'reseau_distribution_isole') return 1;
+      if (field === 'bouclage_reseau_ecs') return "réseau d'ecs non bouclé";
+      return undefined;
+    });
+    const de = { enum_type_installation_id: '2' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'immeuble', false, null, null, false);
+
+    // configuration_logement mise à null -> absente du matcher, seul le type de réseau subsiste
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {
+      type_reseau_collectif:
+        'Réseau collectif isolé avec traçage ou Réseau collectif isolé sans traçage ni bouclage'
+    });
+  });
+
+  test('aucune ligne forfaitaire trouvée : rendement de distribution non renseigné', () => {
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.mocked(tv).mockReturnValue(undefined);
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const ecs = makeEcs(de);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(ecs.donnee_intermediaire.rendement_distribution).toBeUndefined();
+    expect(errSpy).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+});
+
+describe('calc_ecs - agrégation des consommations', () => {
+  test('somme les consommations des générateurs et invoque calc_gen_ecs par générateur', () => {
+    const de = { tv_rendement_distribution_ecs_id: '5' };
+    const gens = [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 10, conso_ecs_depensier: 20 }
+      },
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 5, conso_ecs_depensier: 8 }
+      }
+    ];
+    const ecs = makeEcs(de, gens);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    expect(calc_gen_ecs).toHaveBeenCalledTimes(2);
+    expect(ecs.donnee_intermediaire.conso_ecs).toBe(15);
+    expect(ecs.donnee_intermediaire.conso_ecs_depensier).toBe(28);
+  });
+});

package/11_nadeq.spec.js

@@ -53,4 +53,41 @@ describe('Nadeq unit tests', () => {
       expect(nadeq.calculateNadeq(logement)).toBeCloseTo(expectedNadeq, 2);
     }
   );
+
+  /**
+   * Pour un appartement individuel, la méthode collective est appelée avec la surface habitable du
+   * logement et un unique appartement (Nappart = 1).
+   * enum_methode_application_dpe_log_id ∈ {2,3,4,5,31,32,35,36,37}
+   */
+  test.each([
+    // Shmoy < 10 => Nmax = 1
+    [2, 1, 8],
+    [3, 1, 8],
+    // 10 <= Shmoy < 50 => Nmax = 1.75 - 0.01875 * (50 - Shmoy) ; Shmoy = 45 => 1.65625
+    [4, 1.65625, 45],
+    // Shmoy >= 50 => Nmax = 0.035 * Shmoy = 2.625 (> 1.75) => 1.75 + 0.3 * (2.625 - 1.75) = 2.0125
+    [37, 2.0125, 75]
+  ])(
+    'should get appartement nadeq (méthode %s) = %s pour surface_habitable_logement %s',
+    (enum_methode_application_dpe_log_id, expectedNadeq, surface_habitable_logement) => {
+      const logement = {
+        caracteristique_generale: {
+          enum_methode_application_dpe_log_id,
+          surface_habitable_logement
+        }
+      };
+      expect(nadeq.calculateNadeq(logement)).toBeCloseTo(expectedNadeq, 4);
+    }
+  );
+
+  test('les identifiants de méthode sont comparés numériquement (chaîne "1" acceptée)', () => {
+    const logement = {
+      caracteristique_generale: {
+        enum_methode_application_dpe_log_id: '1',
+        surface_habitable_logement: 8
+      }
+    };
+    // méthode individuelle : surface < 30 => Nmax = 1
+    expect(nadeq.calculateNadeq(logement)).toBe(1);
+  });
 });