@open3cl/engine 1.6.0 → 1.6.2

package/15_conso_aux.spec.js

@@ -0,0 +1,225 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées uniquement pour `conso_aux_distribution_ch` :
+ * - `enums` : libellés de classe d'altitude / zone climatique ;
+ * - `tvs.nref19` : nombre d'heures de fonctionnement mensuel ;
+ * - `mois_liste` / `Tbase` : réduits à des valeurs contrôlées.
+ * `conso_aux_gen` n'utilise aucune de ces dépendances (calcul autonome).
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    classe_altitude: { 1: 'ca1' },
+    zone_climatique: { 1: 'h1a' }
+  }
+}));
+
+vi.mock('./tv.js', () => ({
+  default: {
+    nref19: { 0: { ca1: { Janvier: { h1a: 100 } } } }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  mois_liste: ['Janvier'],
+  Tbase: { ca1: { h1: -9 } }
+}));
+
+const { conso_aux_gen, conso_aux_distribution_ch } = await import('./15_conso_aux.js');
+
+/**
+ * 15.1 Consommation des auxiliaires de génération
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.1
+ */
+describe('conso_aux_gen - auxiliaires de génération', () => {
+  let di;
+
+  beforeEach(() => {
+    di = { pn: 20000 };
+  });
+
+  test('chaudière gaz (chauffage) : facteurs G=20, H=1.6 appliqués', () => {
+    const de = { enum_type_generateur_ch_id: '90' };
+    conso_aux_gen(di, de, 'ch', 1000, 1200, 100);
+    expect(di.conso_auxiliaire_generation_ch).toBeCloseTo(2.6, 10);
+    expect(di.conso_auxiliaire_generation_ch_depensier).toBeCloseTo(3.12, 10);
+  });
+
+  test('générateur hors des plages connues : consommation nulle (G=H=0)', () => {
+    const de = { enum_type_generateur_ch_id: '1' };
+    conso_aux_gen(di, de, 'ch', 1000, 1200, 100);
+    expect(di.conso_auxiliaire_generation_ch).toBe(0);
+    expect(di.conso_auxiliaire_generation_ch_depensier).toBe(0);
+  });
+
+  test("chaudière bois : facteurs appliqués seulement en présence d'un ventilateur", () => {
+    const avecVentilateur = { pn: 20000 };
+    conso_aux_gen(
+      avecVentilateur,
+      { enum_type_generateur_ch_id: '60', presenceVentilateur: 1 },
+      'ch',
+      1000,
+      1200,
+      100
+    );
+    expect(avecVentilateur.conso_auxiliaire_generation_ch).toBeCloseTo(14.165, 10);
+
+    const sansVentilateur = { pn: 20000 };
+    conso_aux_gen(
+      sansVentilateur,
+      { enum_type_generateur_ch_id: '60', presenceVentilateur: 0 },
+      'ch',
+      1000,
+      1200,
+      100
+    );
+    expect(sansVentilateur.conso_auxiliaire_generation_ch).toBe(0);
+  });
+
+  test('chaudière gaz avec Pn > 400 kW : puissance plafonnée à 400 kW', () => {
+    const diCap = { pn: 500000 };
+    conso_aux_gen(diCap, { enum_type_generateur_ch_id: '90' }, 'ch', 1000, 1200, 100);
+    expect(diCap.conso_auxiliaire_generation_ch).toBeCloseTo(1.65, 10);
+    expect(diCap.conso_auxiliaire_generation_ch_depensier).toBeCloseTo(1.584, 10);
+  });
+
+  test('type ECS : aucun prorata de surface chauffée appliqué', () => {
+    const de = { enum_type_generateur_ecs_id: '50' };
+    conso_aux_gen(di, de, 'ecs', 800, 1000, 100);
+    expect(di.conso_auxiliaire_generation_ecs).toBeCloseTo(2.08, 10);
+    expect(di.conso_auxiliaire_generation_ecs_depensier).toBeCloseTo(2.6, 10);
+  });
+
+  test('générateur à air chaud avec Pn > 300 kW : puissance plafonnée à 300 kW', () => {
+    // enum_type_generateur_ch_id = 50 => générateur à air chaud (H=4), G=0
+    const diAir = { pn: 500000 };
+    conso_aux_gen(diAir, { enum_type_generateur_ch_id: '50' }, 'ch', 1000, 1200, 100);
+    // g=0, h=4, pe plafonné à 300000 => Paux = 0 + 4*300 = 1200
+    // conso = (1 * (1200 * 1000 * 1)) / 300000 = 4
+    expect(diAir.conso_auxiliaire_generation_ch).toBeCloseTo(4, 10);
+    // depensier utilise di.pn (500000, non plafonné) : (1200 * 1200) / 500000 = 2.88
+    expect(diAir.conso_auxiliaire_generation_ch_depensier).toBeCloseTo(2.88, 10);
+  });
+
+  test('chaudière bois avec ventilateur et Pn > 70 kW : puissance plafonnée à 70 kW', () => {
+    // enum_type_generateur_ch_id = 60 => chaudière bois (G=73.3, H=10.5)
+    const diBois = { pn: 100000 };
+    conso_aux_gen(
+      diBois,
+      { enum_type_generateur_ch_id: '60', presenceVentilateur: 1 },
+      'ch',
+      1000,
+      1200,
+      100
+    );
+    // pe plafonné à 70000 => Paux = 73.3 + 10.5*70 = 808.3
+    // conso = (1 * (808.3 * 1000 * 1)) / 70000
+    expect(diBois.conso_auxiliaire_generation_ch).toBeCloseTo((808.3 * 1000) / 70000, 10);
+  });
+
+  test('type de générateur inconnu (ni ch ni ecs) : facteurs nuls, consommation nulle', () => {
+    // Couvre la branche de repli `values[type] || []` de getFacteur
+    const diInconnu = { pn: 20000 };
+    conso_aux_gen(diInconnu, {}, 'autre', 1000, 1200, 100);
+    expect(diInconnu.conso_auxiliaire_generation_autre).toBe(0);
+    expect(diInconnu.conso_auxiliaire_generation_autre_depensier).toBe(0);
+  });
+});
+
+/**
+ * 15.2 Consommation des auxiliaires de distribution de chauffage
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.2
+ */
+describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
+  const emCh = [
+    {
+      donnee_entree: {
+        enum_type_emission_distribution_id: '10',
+        enum_temp_distribution_ch_id: '3'
+      }
+    }
+  ];
+
+  test('puissance de circulateur plafonnée à 30 W pour une faible déperdition', () => {
+    const di = {};
+    // GV très faible => la puissance calculée reste sous le plancher de 30 W
+    conso_aux_distribution_ch(emCh, {}, di, {}, 100, 1, 1, '0', 1);
+    // Pcircem19 = 30 (plancher), nref19 = 100 => 30 * 100 / 1000 = 3
+    expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(3, 10);
+  });
+
+  test('une déperdition élevée augmente la consommation au-dessus du plancher', () => {
+    const di = {};
+    conso_aux_distribution_ch(emCh, {}, di, {}, 100, 1, 1, '0', 100000);
+    expect(di.conso_auxiliaire_distribution_ch).toBeGreaterThan(3);
+  });
+
+  test('émetteur plancher/plafond chauffant (deltaPem=15, Fcot=0,156)', () => {
+    // Type 6 => première liste : deltaPem=15, Fcot=0,156, deltaDim=7,5 (temp id 3)
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '6',
+          enum_temp_distribution_ch_id: '3'
+        }
+      }
+    ];
+    const di = {};
+    conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+    // valeur de référence de régression
+    expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(215.1781621610199, 9);
+  });
+
+  test('émetteur radiateur monotube (deltaPem=30)', () => {
+    // Type 24 => deuxième liste : deltaPem=30
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '24',
+          enum_temp_distribution_ch_id: '3'
+        }
+      }
+    ];
+    const di = {};
+    conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+    // valeur de référence de régression
+    expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(372.082418731648, 9);
+  });
+
+  test('plusieurs émetteurs : Fcot forcé à 0,802 (cas le plus défavorable)', () => {
+    // Deux émetteurs de type plancher chauffant : sans le forçage, Fcot=0,156.
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '6',
+          enum_temp_distribution_ch_id: '3'
+        }
+      },
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '6',
+          enum_temp_distribution_ch_id: '3'
+        }
+      }
+    ];
+    const di = {};
+    conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+    // valeur de référence de régression (Fcot=0,802 malgré des planchers chauffants)
+    expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(260.5604692803713, 9);
+  });
+
+  test('température de distribution haute (id 4) : deltaDim = 15', () => {
+    const em = [
+      {
+        donnee_entree: {
+          enum_type_emission_distribution_id: '10',
+          enum_temp_distribution_ch_id: '4'
+        }
+      }
+    ];
+    const di = {};
+    conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+    // valeur de référence de régression
+    expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(136.51553416032854, 9);
+  });
+});

package/16.2_production_enr.spec.js

@@ -249,4 +249,192 @@ describe('production ENR unit tests', () => {
       }
     });
   });
+
+  test('should reuse an existing donnee_intermediaire when computing conso elec ac', () => {
+    // Le noeud donnee_intermediaire préexiste : il doit être conservé (et non recréé)
+    const productionElecEnr = {
+      donnee_intermediaire: { valeur_existante: 42 },
+      panneaux_pv_collection: {
+        panneaux_pv: [{ nombre_module: 8, enum_orientation_pv_id: 1, enum_inclinaison_pv_id: 2 }]
+      }
+    };
+
+    const productionElectricite = {};
+    const conso = {
+      ef_conso: {},
+      sortie_par_energie_collection: {
+        sortie_par_energie: [
+          { enum_type_energie_id: '1', conso_5_usages: 1500, conso_ch: 1000, conso_ecs: 1500 }
+        ]
+      }
+    };
+
+    productionENR.calculateConsoElecAc(
+      productionElectricite,
+      productionElecEnr,
+      conso,
+      1,
+      'maison',
+      10
+    );
+
+    // la clé préexistante est préservée, les champs calculés sont ajoutés
+    expect(productionElecEnr.donnee_intermediaire.valeur_existante).toBe(42);
+    expect(productionElecEnr.donnee_intermediaire.production_pv).toBe(2826.8015616000007);
+    expect(productionElecEnr.donnee_intermediaire.conso_elec_ac).toBeGreaterThan(0);
+  });
+
+  test('should get ppv when panneaux_pv is a single object (not an array)', () => {
+    const productionElecEnr = {
+      panneaux_pv_collection: {
+        panneaux_pv: {
+          nombre_module: 8,
+          enum_orientation_pv_id: 1,
+          enum_inclinaison_pv_id: 2
+        }
+      }
+    };
+    // même résultat qu'avec un tableau à un élément
+    expect(productionENR.getPpv(productionElecEnr, 1)).toBe(2826.8015616000007);
+  });
+
+  test('should update ep conso with a coeff ep override', () => {
+    const productionElectricite = {
+      conso_elec_ac_ecs: 200,
+      conso_elec_ac_ch: 150,
+      conso_elec_ac_fr: 100,
+      conso_elec_ac_eclairage: 250,
+      conso_elec_ac_auxiliaire: 300
+    };
+    const conso = {
+      ep_conso: {
+        ep_conso_ecs: 1000,
+        ep_conso_ch: 500,
+        ep_conso_fr: 800,
+        ep_conso_eclairage: 900,
+        ep_conso_totale_auxiliaire: 1250,
+        ep_conso_5_usages: 5000,
+        ep_conso_5_usages_m2: 100
+      }
+    };
+
+    // coeff_ep_override = 2 : chaque poste est minoré de 2 * autoconso
+    productionENR.updateEPConso(productionElectricite, conso, 10, 2);
+
+    expect(conso.ep_conso).toStrictEqual({
+      ep_conso_ecs: 600, // 1000 - 2*200
+      ep_conso_ch: 200, // 500 - 2*150
+      ep_conso_fr: 600, // 800 - 2*100
+      ep_conso_eclairage: 400, // 900 - 2*250
+      ep_conso_totale_auxiliaire: 650, // 1250 - 2*300
+      ep_conso_5_usages: 3000, // 5000 - 2*1000
+      ep_conso_5_usages_m2: 300 // floor(3000 / 10)
+    });
+  });
+
+  test('should update ep conso with the default coeff ep (1.9) when no override', () => {
+    const productionElectricite = {
+      conso_elec_ac_ecs: 200,
+      conso_elec_ac_ch: 150,
+      conso_elec_ac_fr: 100,
+      conso_elec_ac_eclairage: 250,
+      conso_elec_ac_auxiliaire: 300
+    };
+    const conso = {
+      ep_conso: {
+        ep_conso_ecs: 1000,
+        ep_conso_ch: 500,
+        ep_conso_fr: 800,
+        ep_conso_eclairage: 900,
+        ep_conso_totale_auxiliaire: 1250,
+        ep_conso_5_usages: 5000,
+        ep_conso_5_usages_m2: 100
+      }
+    };
+
+    // pas d'override => coefficient par défaut 1.9
+    productionENR.updateEPConso(productionElectricite, conso, 10);
+
+    expect(conso.ep_conso).toStrictEqual({
+      ep_conso_ecs: 620, // 1000 - 1.9*200
+      ep_conso_ch: 215, // 500 - 1.9*150
+      ep_conso_fr: 610, // 800 - 1.9*100
+      ep_conso_eclairage: 425, // 900 - 1.9*250
+      ep_conso_totale_auxiliaire: 680, // 1250 - 1.9*300
+      ep_conso_5_usages: 3100, // 5000 - 1.9*1000
+      ep_conso_5_usages_m2: 310 // floor(3100 / 10)
+    });
+  });
+
+  test.each([
+    ['une installation absente', null],
+    ["l'absence de production photovoltaïque", { donnee_entree: { presence_production_pv: 0 } }]
+  ])('calculateEnr retourne des autoconsommations nulles pour %s', (_label, productionElecEnr) => {
+    const conso = { ef_conso: {}, ep_conso: {} };
+
+    const ret = productionENR.calculateEnr(productionElecEnr, conso, 10, 'maison', 1, 100);
+
+    expect(ret).toStrictEqual({
+      production_pv: 0,
+      conso_elec_ac: 0,
+      conso_elec_ac_ch: 0,
+      conso_elec_ac_ecs: 0,
+      conso_elec_ac_fr: 0,
+      conso_elec_ac_eclairage: 0,
+      conso_elec_ac_auxiliaire: 0,
+      conso_elec_ac_autre_usage: 0
+    });
+  });
+
+  test('calculateEnr calcule et applique les autoconsommations en présence de PV', () => {
+    const productionElecEnr = {
+      donnee_entree: { presence_production_pv: 1 },
+      panneaux_pv_collection: {
+        panneaux_pv: [{ nombre_module: 8, enum_orientation_pv_id: 1, enum_inclinaison_pv_id: 2 }]
+      }
+    };
+    const conso = {
+      ef_conso: {
+        conso_ecs: 1000,
+        conso_ch: 500,
+        conso_fr: 800,
+        conso_eclairage: 900,
+        conso_totale_auxiliaire: 1250,
+        conso_5_usages: 1500,
+        conso_5_usages_m2: 100
+      },
+      ep_conso: {
+        ep_conso_ecs: 3000,
+        ep_conso_ch: 1500,
+        ep_conso_fr: 2000,
+        ep_conso_eclairage: 1800,
+        ep_conso_totale_auxiliaire: 2500,
+        ep_conso_5_usages: 10000,
+        ep_conso_5_usages_m2: 100
+      },
+      sortie_par_energie_collection: {
+        sortie_par_energie: [
+          { enum_type_energie_id: '1', conso_5_usages: 1500, conso_ch: 1000, conso_ecs: 1500 }
+        ]
+      }
+    };
+
+    const ret = productionENR.calculateEnr(productionElecEnr, conso, 10, 'maison', 1, 100);
+
+    // valeurs de référence de régression
+    expect(ret).toStrictEqual({
+      production_pv: 2826.8015616000007,
+      conso_elec_ac: 403.3632077277818,
+      conso_elec_ac_ch: 17.146151231786686,
+      conso_elec_ac_ecs: 64.29806711920007,
+      conso_elec_ac_fr: 171.46151231786683,
+      conso_elec_ac_eclairage: 38.57884027152004,
+      conso_elec_ac_auxiliaire: 0,
+      conso_elec_ac_autre_usage: 21.14245810055866
+    });
+
+    // les consommations d'énergie finale sont bien minorées par l'autoconsommation
+    expect(conso.ef_conso.conso_ecs).toBeLessThan(1000);
+    expect(conso.ef_conso.conso_5_usages).toBeLessThan(1500);
+  });
 });

package/16_conso_eclairage.spec.js

@@ -0,0 +1,62 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Le module ne dépend que du mapping enum_zone_climatique_id -> libellé de zone.
+ * On le mocke afin d'isoler le test du contenu réel de `enums`.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    zone_climatique: {
+      1: 'h1a',
+      2: 'h1b',
+      3: 'h1c',
+      4: 'h2a',
+      5: 'h2b',
+      6: 'h2c',
+      7: 'h2d',
+      8: 'h3'
+    }
+  }
+}));
+
+const { default: calc_conso_eclairage } = await import('./16_conso_eclairage.js');
+
+/**
+ * 16.1 Consommation d'éclairage (Cecl)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §16.1
+ *
+ * Cecl = (C * Pecl * Nh) / 1000 avec C = 0.9 (interrupteur) et Pecl = 1.4 W/m²
+ * Nh = nombre d'heures de fonctionnement de l'éclairage, fonction de la zone climatique.
+ */
+describe("Calcul de la consommation d'éclairage (Cecl)", () => {
+  // [enum_zone_climatique_id, libellé, Nh, Cecl attendu]
+  test.each([
+    ['1', 'h1a', 1500, (0.9 * 1.4 * 1500) / 1000],
+    ['2', 'h1b', 1445, (0.9 * 1.4 * 1445) / 1000],
+    ['3', 'h1c', 1476, (0.9 * 1.4 * 1476) / 1000],
+    ['4', 'h2a', 1500, (0.9 * 1.4 * 1500) / 1000],
+    ['5', 'h2b', 1531, (0.9 * 1.4 * 1531) / 1000],
+    ['6', 'h2c', 1566, (0.9 * 1.4 * 1566) / 1000],
+    ['7', 'h2d', 1566, (0.9 * 1.4 * 1566) / 1000],
+    ['8', 'h3', 1506, (0.9 * 1.4 * 1506) / 1000]
+  ])(
+    'zone climatique %s (%s) : Nh=%d heures => Cecl attendu',
+    (zc_id, _libelle, _nh, cecl_attendu) => {
+      expect(calc_conso_eclairage(zc_id)).toBeCloseTo(cecl_attendu, 10);
+    }
+  );
+
+  test('la consommation est identique pour deux zones ayant le même Nh (h1a et h2a)', () => {
+    expect(calc_conso_eclairage('1')).toBeCloseTo(calc_conso_eclairage('4'), 10);
+  });
+
+  test("la consommation croît avec le nombre d'heures (h1b < h3 < h2c)", () => {
+    expect(calc_conso_eclairage('2')).toBeLessThan(calc_conso_eclairage('8'));
+    expect(calc_conso_eclairage('8')).toBeLessThan(calc_conso_eclairage('6'));
+  });
+
+  test('retourne NaN pour un identifiant de zone climatique inconnu', () => {
+    // enums.zone_climatique[zc_id] est undefined => Nh[undefined] est undefined => NaN
+    expect(calc_conso_eclairage('99')).toBeNaN();
+  });
+});

package/2021_04_13_confort_ete.spec.js

@@ -0,0 +1,159 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler `calc_confort_ete` :
+ * - `enums.classe_inertie` : détermine le caractère « lourd » de l'inertie ;
+ * - `getKeyByValue` : réduit à un passe-plat renvoyant directement le libellé
+ *   de confort (on assertera donc `enum_indicateur_confort_ete_id` = libellé) ;
+ * - `requestInput` : passe-plat lisant le champ demandé dans les données d'entrée.
+ */
+vi.mock('./enums.js', () => ({
+  default: {
+    classe_inertie: { 1: 'légère', 2: 'moyenne', 3: 'lourde', 4: 'très lourde' },
+    indicateur_confort_ete: { 1: 'insuffisant', 2: 'moyen', 3: 'bon' }
+  }
+}));
+
+vi.mock('./utils.js', () => ({
+  getKeyByValue: (object, value) => value,
+  requestInput: (de, du, field) => de[field]
+}));
+
+const { default: calc_confort_ete } = await import('./2021_04_13_confort_ete.js');
+
+/** Fabrique une baie vitrée : `enum_orientation_id` sert au caractère traversant,
+ * `orientation` et `type_fermeture` à la protection solaire. */
+function baie({ orientationId, orientation = 'sud', typeFermeture = 'volet' }) {
+  return {
+    donnee_entree: {
+      enum_orientation_id: orientationId,
+      orientation,
+      type_fermeture: typeFermeture
+    },
+    donnee_utilisateur: {}
+  };
+}
+
+/** Fabrique un plancher haut avec son type d'adjacence et d'isolation. */
+function plancherHaut({ typeAdjacence = 'extérieur', typeIsolation = 'isolé' }) {
+  return {
+    donnee_entree: { type_adjacence: typeAdjacence, type_isolation: typeIsolation },
+    donnee_utilisateur: {}
+  };
+}
+
+/**
+ * Indicateur de confort d'été
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - annexe confort d'été
+ */
+describe("calc_confort_ete - indicateur de confort d'été", () => {
+  test('inertie lourde + aspect traversant : niveau « bon »', () => {
+    // deux orientations distinctes => aspect_traversant = 1 ; inertie lourde = 1 => nv_bon = 2
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeIsolation: 'isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(1);
+    expect(ret.aspect_traversant).toBe(1);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('bon');
+  });
+
+  test('inertie « très lourde » également considérée comme lourde', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('4', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(1);
+  });
+
+  test('une seule orientation : aspect non traversant', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '1' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('2', bv, ph);
+
+    expect(ret.aspect_traversant).toBe(0);
+  });
+
+  test('inertie légère sans aspect traversant : niveau « moyen »', () => {
+    // nv_bon = 0 (< 2) mais protections OK => moyen
+    const bv = [baie({ orientationId: '1' })];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('1', bv, ph);
+
+    expect(ret.inertie_lourde).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('moyen');
+  });
+
+  test("toiture non isolée donnant sur l'extérieur : niveau « insuffisant »", () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeAdjacence: 'extérieur', typeIsolation: 'non isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('insuffisant');
+  });
+
+  test("toiture d'isolation inconnue donnant sur l'extérieur : isolation nulle", () => {
+    const bv = [baie({ orientationId: '1' })];
+    const ph = [plancherHaut({ typeAdjacence: 'extérieur', typeIsolation: 'inconnu' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(0);
+  });
+
+  test('toiture non isolée mais non extérieure : isolation préservée', () => {
+    const bv = [baie({ orientationId: '1' }), baie({ orientationId: '2' })];
+    const ph = [plancherHaut({ typeAdjacence: 'local non chauffé', typeIsolation: 'non isolé' })];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.isolation_toiture).toBe(1);
+  });
+
+  test('baie non nord sans fermeture : protection solaire nulle => « insuffisant »', () => {
+    const bv = [
+      baie({
+        orientationId: '1',
+        orientation: 'sud',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      })
+    ];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.protection_solaire_exterieure).toBe(0);
+    expect(ret.enum_indicateur_confort_ete_id).toBe('insuffisant');
+  });
+
+  test('baie nord sans fermeture : ignorée, protection solaire préservée', () => {
+    const bv = [
+      baie({
+        orientationId: '1',
+        orientation: 'nord',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      }),
+      baie({
+        orientationId: '2',
+        orientation: 'nord',
+        typeFermeture: 'abscence de fermeture pour la baie vitrée'
+      })
+    ];
+    const ph = [plancherHaut({})];
+
+    const ret = calc_confort_ete('3', bv, ph);
+
+    expect(ret.protection_solaire_exterieure).toBe(1);
+  });
+
+  test("le brasseur d'air est toujours absent (0) dans ce calcul", () => {
+    const ret = calc_confort_ete('3', [baie({ orientationId: '1' })], [plancherHaut({})]);
+    expect(ret.brasseur_air).toBe(0);
+  });
+});

package/2021_04_13_qualite_isolation.js

@@ -1,7 +1,7 @@
 /**
  * @returns {number}
  */
-function qualite_isol(dep, surface, seuil1, seuil2, seuil3) {
+export function qualite_isol(dep, surface, seuil1, seuil2, seuil3) {
   /**
    * 1 - Très bonne
    * 2 - Bonne