@open3cl/engine 1.8.8 → 1.8.9

package/conso.js

@@ -122,6 +122,129 @@ function cout_electricite(cef) {
   else return 56 + 0.15989 * cef;
 }
 
+/**
+ * Date d'entrée en vigueur du barème des prix des énergies mis à jour.
+ * Constatée sur les DPE publiés par l'ADEME (dataset dpe03existant) : barème 2021 jusqu'au
+ * 30/06/2024, barème mis à jour pour les DPE établis à partir du 01/07/2024 (et toujours en 2026).
+ */
+export const DATE_BAREME_COUT_2024 = '2024-07-01';
+
+function cout_gaz_naturel_2024(cef) {
+  if (cef < 5009) return 0.1312 * cef;
+  else if (cef < 50055) return 182 + 0.09488 * cef;
+  else return 288 + 0.09274 * cef;
+}
+
+function cout_electricite_2024(cef) {
+  if (cef < 1000) return 0.34721 * cef;
+  else if (cef < 2500) return 158 + 0.18954 * cef;
+  else if (cef < 5000) return 158 + 0.18949 * cef;
+  else if (cef < 15000) return 119 + 0.19726 * cef;
+  else return 78 + 0.20001 * cef;
+}
+
+/**
+ * Barème des prix des énergies applicable aux DPE établis à partir du 01/07/2024.
+ * Mêmes tranches qu'en 2021 ; valeurs calées sur les sorties Tribu (moteur CSTB) et les DPE ADEME.
+ */
+const coef_cout_2024 = {
+  'fioul domestique': 0.14821,
+  'réseau de chauffage urbain': 0.08921,
+  propane: 0.15672,
+  gpl: 0.15672,
+  butane: 0.23429,
+  charbon: 0.02787,
+  'bois – granulés (pellets) ou briquettes': 0.09897,
+  'bois – bûches': 0.042,
+  'bois – plaquettes forestières': 0.042,
+  'bois – plaquettes d’industrie': 0.042,
+  'gaz naturel': cout_gaz_naturel_2024,
+  "électricité d'origine renouvelable utilisée dans le bâtiment": cout_electricite_2024,
+  'électricité ch': cout_electricite_2024,
+  'électricité ecs': cout_electricite_2024,
+  'électricité fr': cout_electricite_2024,
+  'électricité éclairage': cout_electricite_2024,
+  'électricité auxiliaire': cout_electricite_2024
+};
+
+/**
+ * Sélection du barème des prix des énergies selon la date d'établissement du DPE.
+ * @param dateDpe {string} date d'établissement du DPE (AAAA-MM-JJ)
+ * @returns {object} barème 2021 (Annexe 7) avant le 01/07/2024, barème mis à jour ensuite
+ */
+export function getCoefCout(dateDpe) {
+  return new Date(dateDpe) >= new Date(DATE_BAREME_COUT_2024) ? coef_cout_2024 : coef_cout;
+}
+
+/** Clé (symbole) portant le barème des générateurs d'installations collectives d'un immeuble. */
+const COUT_COLLECTIF = Symbol('cout_collectif');
+
+/** Énergies dont le coût suit un barème par tranches, regroupées par énergie facturée. */
+const ENERGIES_A_TRANCHES = {
+  'électricité ch': 'électricité',
+  'électricité ecs': 'électricité',
+  'électricité fr': 'électricité',
+  'électricité éclairage': 'électricité',
+  'électricité auxiliaire': 'électricité',
+  "électricité d'origine renouvelable utilisée dans le bâtiment": 'électricité renouvelable',
+  'gaz naturel': 'gaz naturel'
+};
+
+/**
+ * Table « masque » : consommation conservée pour les clés du groupe, annulée pour les autres.
+ * Permet de totaliser la consommation d'une énergie avec les fonctions d'agrégation existantes.
+ * @param groupe {string} énergie facturée (valeur de ENERGIES_A_TRANCHES)
+ * @returns {object}
+ */
+export function masqueEnergie(groupe) {
+  const cles = Object.values(enums.type_energie)
+    .filter((label) => label !== 'électricité')
+    .concat(Object.keys(ENERGIES_A_TRANCHES));
+  return Object.fromEntries(
+    cles.map((cle) => [cle, ENERGIES_A_TRANCHES[cle] === groupe ? (c) => c : () => 0])
+  );
+}
+
+/**
+ * Barème « prix moyen » pour les DPE établis à partir du 01/07/2024 (constaté sur Tribu et sur
+ * les DPE publiés par l'ADEME) : pour l'électricité et le gaz naturel, la tranche est déterminée
+ * sur la consommation annuelle TOTALE de l'énergie (tous usages) et le coût est réparti entre les
+ * postes au prorata de leur consommation.
+ * Immeuble : consommation des usages individuels rapportée au logement (N × f(C / N)) ;
+ * chauffage / ECS des installations collectives tarifés sur leur total (f(C)).
+ *
+ * @param base {object} barème (prix unitaires et fonctions par tranches)
+ * @param consoGroupe {function(masque): {total: number, collectif: number}} consommations EF
+ * @param nbLogements {number} nombre de logements (1 hors immeuble)
+ * @param genCollectifs {Set} générateurs de chauffage / ECS d'installations collectives
+ * @returns {object}
+ */
+export function coefCoutProrata(base, consoGroupe, nbLogements, genCollectifs) {
+  const coef = { ...base };
+  const coefCollectif = { ...base };
+  new Set(Object.values(ENERGIES_A_TRANCHES)).forEach((groupe) => {
+    const { total, collectif } = consoGroupe(masqueEnergie(groupe));
+    const individuel = total - collectif;
+    Object.keys(ENERGIES_A_TRANCHES)
+      .filter((cle) => ENERGIES_A_TRANCHES[cle] === groupe)
+      .forEach((cle) => {
+        const f = base[cle];
+        const prix = individuel > 0 ? (nbLogements * f(individuel / nbLogements)) / individuel : 0;
+        const prixCollectif = collectif > 0 ? f(collectif) / collectif : 0;
+        coef[cle] = (c) => prix * c;
+        coefCollectif[cle] = (c) => prixCollectif * c;
+      });
+  });
+  coef[COUT_COLLECTIF] = { generateurs: genCollectifs, coef: coefCollectif };
+  return coef;
+}
+
+/** Barème d'un générateur : barème collectif s'il appartient à une installation collective. */
+function coefPourGenerateur(coef, gen) {
+  const collectif = coef?.[COUT_COLLECTIF];
+  return collectif?.generateurs.has(gen) ? collectif.coef : coef;
+}
+
 function getConso(coef, type_energie, conso) {
   // is coef is a function, execute it
   if (!coef) return conso;
@@ -197,7 +320,8 @@ export default function calc_conso(
   prorataECS,
   prorataChauffage,
   dateDpe,
-  coeffEp
+  coeffEp,
+  nbLogements = 1
 ) {
   const gen_ch = ch.reduce((acc, ch) => {
     const generateur_chauffage = ch.generateur_chauffage_collection.generateur_chauffage;
@@ -237,6 +361,56 @@ export default function calc_conso(
     return acc.concat(generateur_ecs);
   }, []);
 
+  /**
+   * Barème des coûts : barème 2021 (par poste) avant le 01/07/2024 ; ensuite barème mis à jour
+   * avec tranche déterminée sur la consommation totale de l'énergie (voir coefCoutProrata).
+   */
+  const coefCout = () => {
+    const base = getCoefCout(dateDpe);
+    if (base === coef_cout) return coef_cout;
+    const genCollectifs = new Set();
+    if (nbLogements > 1) {
+      gen_ch
+        .filter((g) => g.donnee_entree.enum_type_installation_id !== '1')
+        .forEach((g) => genCollectifs.add(g));
+      ecs
+        .filter((inst) => (inst.donnee_entree.enum_type_installation_id ?? '1') !== '1')
+        .forEach((inst) =>
+          inst.generateur_ecs_collection.generateur_ecs.forEach((g) => genCollectifs.add(g))
+        );
+    }
+    const consoGroupe = (masque) => {
+      const tot = calc_conso_pond(
+        Sh,
+        zc_id,
+        vt,
+        gen_ch,
+        gen_ecs,
+        fr,
+        'c',
+        masque,
+        prorataECS,
+        prorataChauffage,
+        ecs
+      );
+      const coll = calc_conso_pond(
+        0,
+        zc_id,
+        [],
+        gen_ch.filter((g) => genCollectifs.has(g)),
+        gen_ecs.filter((g) => genCollectifs.has(g)),
+        [],
+        'c',
+        masque,
+        prorataECS,
+        prorataChauffage,
+        []
+      );
+      return { total: tot.c_5_usages, collectif: coll.c_ch + coll.c_ecs };
+    };
+    return coefCoutProrata(base, consoGroupe, nbLogements, genCollectifs);
+  };
+
   const ret = {
     ef_conso: calc_conso_pond(
       Sh,
@@ -288,7 +462,7 @@ export default function calc_conso(
       gen_ecs,
       fr,
       'cout',
-      coef_cout,
+      coefCout(),
       prorataECS,
       prorataChauffage,
       ecs,
@@ -424,7 +598,7 @@ function getEcsConso(gen_ecs, field, coef, prorataECS, prefix) {
     const conso = gen_ecs.donnee_intermediaire[field];
     const typeEnergie = getTypeEnergie(gen_ecs.donnee_entree, 'ecs');
 
-    let coeffConsoEcs = { ...coef };
+    let coeffConsoEcs = { ...coefPourGenerateur(coef, gen_ecs) };
 
     if (prefix === 'emission_ges') {
       coeffConsoEcs[typeEnergie] = gen_ecs.donnee_utilisateur.coeffEmissionGes;
@@ -458,7 +632,7 @@ function getChauffageConso(gen_ch, field, coef, prorataChauffage, prefix) {
         ? gen_ch.donnee_entree.cle_repartition_ch || prorataChauffage
         : prorataChauffage;
 
-    let coeffConsoChauffage = { ...coef };
+    let coeffConsoChauffage = { ...coefPourGenerateur(coef, gen_ch) };
 
     if (prefix === 'emission_ges') {
       coeffConsoChauffage[typeEnergie] = gen_ch.donnee_utilisateur.coeffEmissionGes;

package/conso.spec.js

@@ -51,7 +51,11 @@ const {
   classe_bilan_dpe,
   classe_emission_ges,
   getCoefKey,
-  coef_ep
+  coef_ep,
+  getCoefCout,
+  coefCoutProrata,
+  masqueEnergie,
+  DATE_BAREME_COUT_2024
 } = await import('./conso.js');
 
 /**
@@ -499,3 +503,185 @@ describe('calc_conso - agrégation des consommations', () => {
     expect(ids).toContain('1');
   });
 });
+
+/**
+ * Barème des prix des énergies selon la date d'établissement du DPE.
+ * Barème 2021 : Annexe 7 de l'arrêté du 31/03/2021.
+ * Barème mis à jour (DPE à partir du 01/07/2024) : valeurs calées sur les sorties Tribu (CSTB)
+ * des autotests et sur les DPE publiés par l'ADEME (dataset dpe03existant), reproduites à ±1 €.
+ */
+describe('getCoefCout - sélection du barème par date de DPE', () => {
+  test('date de bascule : 01/07/2024', () => {
+    expect(DATE_BAREME_COUT_2024).toBe('2024-07-01');
+  });
+
+  test('DPE établi avant le 01/07/2024 : barème 2021 inchangé', () => {
+    const coef = getCoefCout('2024-06-30');
+    // Annexe 7 : électricité 1000 kWh => 149 + 0,14066 × 1000
+    expect(coef['électricité ch'](1000)).toBeCloseTo(149 + 0.14066 * 1000, 9);
+    expect(coef['gaz naturel'](3000)).toBeCloseTo(0.11121 * 3000, 9);
+    expect(coef['fioul domestique']).toBe(0.09142);
+    expect(coef.propane).toBe(0.14305);
+  });
+
+  test.each(['2024-07-01', '2025-12-31', '2026-01-15'])(
+    'DPE établi le %s : barème mis à jour',
+    (date) => {
+      const coef = getCoefCout(date);
+      // Tribu / ADEME : électricité 1000 kWh => 158 + 0,18954 × 1000
+      expect(coef['électricité ch'](1000)).toBeCloseTo(158 + 0.18954 * 1000, 9);
+    }
+  );
+
+  test('barème mis à jour : prix unitaires constants (fioul, propane, bois, réseau...)', () => {
+    const coef = getCoefCout('2026-01-15');
+    // Tribu : fioul 0,1482 €/kWh ; propane 0,1567 €/kWh (constants quelle que soit la conso)
+    expect(coef['fioul domestique']).toBe(0.14821);
+    expect(coef.propane).toBe(0.15672);
+    expect(coef.gpl).toBe(0.15672);
+    expect(coef.butane).toBe(0.23429);
+    expect(coef.charbon).toBe(0.02787);
+    expect(coef['réseau de chauffage urbain']).toBe(0.08921);
+    expect(coef['bois – granulés (pellets) ou briquettes']).toBe(0.09897);
+    expect(coef['bois – bûches']).toBe(0.042);
+    expect(coef['bois – plaquettes forestières']).toBe(0.042);
+    expect(coef['bois – plaquettes d’industrie']).toBe(0.042);
+  });
+
+  test.each([
+    // [conso, coût attendu] électricité, une valeur par tranche + limites
+    [500, 0.34721 * 500],
+    [999.99, 0.34721 * 999.99],
+    [1000, 158 + 0.18954 * 1000],
+    [2499.99, 158 + 0.18954 * 2499.99],
+    [2500, 158 + 0.18949 * 2500],
+    [4999.99, 158 + 0.18949 * 4999.99],
+    [5000, 119 + 0.19726 * 5000],
+    [14999.99, 119 + 0.19726 * 14999.99],
+    [15000, 78 + 0.20001 * 15000],
+    [20000, 78 + 0.20001 * 20000]
+  ])('barème mis à jour - électricité %s kWh => %s €', (conso, attendu) => {
+    const coef = getCoefCout('2026-01-15');
+    [
+      'électricité ch',
+      'électricité ecs',
+      'électricité fr',
+      'électricité éclairage',
+      'électricité auxiliaire',
+      "électricité d'origine renouvelable utilisée dans le bâtiment"
+    ].forEach((cle) => expect(coef[cle](conso)).toBeCloseTo(attendu, 9));
+  });
+
+  test.each([
+    // [conso, coût attendu] gaz naturel, une valeur par tranche + limites
+    [3000, 0.1312 * 3000],
+    [5008.99, 0.1312 * 5008.99],
+    [5009, 182 + 0.09488 * 5009],
+    [50054.99, 182 + 0.09488 * 50054.99],
+    [50055, 288 + 0.09274 * 50055],
+    [100000, 288 + 0.09274 * 100000]
+  ])('barème mis à jour - gaz naturel %s kWh => %s €', (conso, attendu) => {
+    expect(getCoefCout('2026-01-15')['gaz naturel'](conso)).toBeCloseTo(attendu, 9);
+  });
+});
+
+describe("masqueEnergie / coefCoutProrata - tranche sur la conso totale de l'énergie", () => {
+  test('masque électricité : clés électriques conservées, autres énergies annulées', () => {
+    const masque = masqueEnergie('électricité');
+    expect(masque['électricité ch'](10)).toBe(10);
+    expect(masque['électricité auxiliaire'](10)).toBe(10);
+    expect(masque['gaz naturel'](10)).toBe(0);
+    expect(masque['réseau de chauffage urbain'](10)).toBe(0);
+    expect(masque["électricité d'origine renouvelable utilisée dans le bâtiment"](10)).toBe(0);
+    expect(masque['électricité']).toBeUndefined();
+  });
+
+  test('aucune consommation : prix moyen nul', () => {
+    const coef = coefCoutProrata(
+      getCoefCout('2026-01-15'),
+      () => ({ total: 0, collectif: 0 }),
+      1,
+      new Set()
+    );
+    expect(coef['électricité ch'](100)).toBe(0);
+    expect(coef['gaz naturel'](100)).toBe(0);
+    // Prix constants conservés
+    expect(coef['fioul domestique']).toBe(0.14821);
+  });
+});
+
+describe('calc_conso - coût avec le barème mis à jour (DPE 2026)', () => {
+  const DATE_DPE_2026 = '2026-01-15';
+  let errorSpy;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  test('DPE antérieur au 01/07/2024 : coût par poste au barème 2021 (inchangé)', () => {
+    const ch = [installCh({}, [genCh('1', { conso_ch: 3000, conso_ch_depensier: 3000 })])];
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, '2024-06-30', coef_ep);
+    // Chauffage tarifé seul : 122 + 0,15176 × 3000 ; éclairage seul : 0,29007 × 100
+    expect(res.cout.cout_ch).toBeCloseTo(122 + 0.15176 * 3000, 9);
+    expect(res.cout.cout_eclairage).toBeCloseTo(0.29007 * 100, 9);
+  });
+
+  test('maison tout électrique : tranche sur la conso électrique totale, coût réparti au prorata', () => {
+    const ch = [installCh({}, [genCh('1', { conso_ch: 3000, conso_ch_depensier: 3000 })])];
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE_2026, coef_ep);
+    // Conso élec totale = 3000 (ch) + 100 (éclairage = 1 × Sh) = 3100 kWh
+    const total = 158 + 0.18949 * 3100;
+    expect(res.cout.cout_5_usages).toBeCloseTo(total, 9);
+    expect(res.cout.cout_ch).toBeCloseTo((total * 3000) / 3100, 9);
+    expect(res.cout.cout_eclairage).toBeCloseTo((total * 100) / 3100, 9);
+  });
+
+  test('maison gaz + électricité : chaque énergie tarifée sur sa propre conso totale', () => {
+    const ch = [installCh({}, [genCh('2', { conso_ch: 8000, conso_ch_depensier: 8000 })])];
+    const ecs = [installEcs({}, [genEcs('2', { conso_ecs: 2000, conso_ecs_depensier: 2000 })])];
+    const res = calc_conso(100, 1, 1, [], ch, ecs, [], 1, 1, DATE_DPE_2026, coef_ep);
+    // Gaz total 10000 kWh => 182 + 0,09488 × 10000 ; élec (éclairage) 100 kWh => 0,34721 × 100
+    const gaz = 182 + 0.09488 * 10000;
+    expect(res.cout.cout_ch).toBeCloseTo((gaz * 8000) / 10000, 9);
+    expect(res.cout.cout_ecs).toBeCloseTo((gaz * 2000) / 10000, 9);
+    expect(res.cout.cout_eclairage).toBeCloseTo(0.34721 * 100, 9);
+  });
+
+  test('immeuble à chauffage individuel : barème appliqué par logement (N × f(C / N))', () => {
+    const ch = [installCh({}, [genCh('1', { conso_ch: 8000, conso_ch_depensier: 8000 })])];
+    const res = calc_conso(100, 1, 1, [], ch, [], [], 1, 1, DATE_DPE_2026, coef_ep, 4);
+    // Élec totale 8100 kWh pour 4 logements : 4 × f(2025) = 4 × (158 + 0,18954 × 2025)
+    expect(res.cout.cout_5_usages).toBeCloseTo(4 * (158 + 0.18954 * 2025), 9);
+  });
+
+  test('immeuble à installations collectives : chauffage / ECS collectifs tarifés sur leur total', () => {
+    const ch = [
+      installCh({ enum_type_installation_id: '2' }, [
+        genCh('2', { conso_ch: 60000, conso_ch_depensier: 60000 })
+      ])
+    ];
+    const ecs = [
+      installEcs({ enum_type_installation_id: '2' }, [
+        genEcs('1', { conso_ecs: 4000, conso_ecs_depensier: 4000 })
+      ])
+    ];
+    const res = calc_conso(100, 1, 1, [], ch, ecs, [], 1, 1, DATE_DPE_2026, coef_ep, 4);
+    // Gaz collectif 60000 kWh => 288 + 0,09274 × 60000 (pas de division par logement)
+    expect(res.cout.cout_ch).toBeCloseTo(288 + 0.09274 * 60000, 9);
+    // ECS élec collective 4000 kWh => 158 + 0,18949 × 4000
+    expect(res.cout.cout_ecs).toBeCloseTo(158 + 0.18949 * 4000, 9);
+    // Éclairage (usage individuel) 100 kWh / 4 logements => 4 × 0,34721 × 25
+    expect(res.cout.cout_eclairage).toBeCloseTo(4 * 0.34721 * 25, 9);
+  });
+
+  test("immeuble, ECS sans type d'installation : considérée individuelle", () => {
+    const ecs = [installEcs({}, [genEcs('1', { conso_ecs: 4000, conso_ecs_depensier: 4000 })])];
+    const res = calc_conso(100, 1, 1, [], [], ecs, [], 1, 1, DATE_DPE_2026, coef_ep, 4);
+    // Élec totale 4100 kWh / 4 logements => 4 × (158 + 0,18954 × 1025)
+    expect(res.cout.cout_5_usages).toBeCloseTo(4 * (158 + 0.18954 * 1025), 9);
+  });
+});

package/engine.js

@@ -33,7 +33,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.8.8';
+const LIB_VERSION = '1.8.9';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -573,7 +573,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep
+    coef_ep,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   const production_electricite = productionENR.calculateEnr(
@@ -595,7 +596,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_1_7
+    coef_ep_1_7,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(
@@ -618,7 +620,8 @@ export function calcul_3cl(inputDpe, options) {
     prorataECS,
     prorataChauffage,
     dateDpe,
-    coef_ep_2_3
+    coef_ep_2_3,
+    th === 'immeuble' ? Nb_lgt : 1
   );
 
   productionENR.calculateEnr(

package/package.json

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

package/utils.js

@@ -277,10 +277,15 @@ export function requestInput(de, du, field, type) {
     return enums[field][de[enum_name]];
   } else {
     // not enums
+    // `!type` couvre aussi NaN, 0 et '' (valeurs falsy)
     if (!type) {
       console.error(`requestInput: type is not defined for ${field}`);
       return null;
     }
+    if (!['string', 'number', 'boolean'].includes(typeof type)) {
+      console.error(`requestInput: type has an unexpected type (${typeof type}) for ${field}`);
+      return null;
+    }
     du[field] = type;
     return de[field];
   }

package/utils.spec.js

@@ -287,6 +287,59 @@ describe('Utils unit tests', () => {
       spy.mockRestore();
     });
 
+    test.each([
+      ['NaN', Number.NaN],
+      ['0', 0],
+      ['une chaîne vide', '']
+    ])(
+      'requestInput : champ non enum avec %s comme type est traité comme un type absent',
+      (_libelle, type) => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const de = { epaisseur: 5 };
+        const du = {};
+        expect(requestInput(de, du, 'epaisseur', type)).toBeNull();
+        expect(spy).toHaveBeenCalledWith('requestInput: type is not defined for epaisseur');
+        // Le type invalide n'est pas publié dans donnee_utilisateur
+        expect(du).toStrictEqual({});
+        spy.mockRestore();
+      }
+    );
+
+    test.each([
+      ['un objet', { a: 1 }, 'object'],
+      ['un tableau', ['number'], 'object'],
+      ['une fonction', () => 'number', 'function'],
+      ['un symbole', Symbol('number'), 'symbol'],
+      ['un bigint', 10n, 'bigint']
+    ])(
+      'requestInput : champ non enum avec %s comme type journalise une erreur et retourne null',
+      (_libelle, type, typeAttendu) => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const de = { epaisseur: 5 };
+        const du = {};
+        expect(requestInput(de, du, 'epaisseur', type)).toBeNull();
+        expect(spy).toHaveBeenCalledWith(
+          `requestInput: type has an unexpected type (${typeAttendu}) for epaisseur`
+        );
+        expect(du).toStrictEqual({});
+        spy.mockRestore();
+      }
+    );
+
+    test.each([
+      ['une chaîne', 'string'],
+      ['un nombre', 1],
+      ['un booléen', true]
+    ])('requestInput : champ non enum avec %s comme type est accepté', (_libelle, type) => {
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const de = { epaisseur: 5 };
+      const du = {};
+      expect(requestInput(de, du, 'epaisseur', type)).toBe(5);
+      expect(du.epaisseur).toBe(type);
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
     test('requestInputID : sans type publie les clés et retourne l identifiant', () => {
       const de = { enum_materiaux_id: '1' };
       const du = {};