@open3cl/engine 1.6.0 → 1.6.2

package/2021_04_13_qualite_isolation.spec.js

@@ -0,0 +1,286 @@
+import { describe, expect, test } from 'vitest';
+
+/**
+ * Module purement calculatoire (aucune dépendance externe) : on teste
+ * directement les seuils de qualité et l'agrégation des déperditions.
+ */
+const { default: calc_qualite_isolation, qualite_isol } = await import(
+  './2021_04_13_qualite_isolation.js'
+);
+
+/**
+ * Qualité de l'isolation
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - annexe qualité d'isolation
+ */
+describe('qualite_isol - classement selon les seuils U', () => {
+  const seuils = [0.3, 0.45, 0.65];
+
+  test('déperdition ou surface nulle : U = 0 => très bonne (1)', () => {
+    expect(qualite_isol(0, 100, ...seuils)).toBe(1);
+    expect(qualite_isol(50, 0, ...seuils)).toBe(1);
+  });
+
+  test('U strictement inférieur au seuil 1 : très bonne (1)', () => {
+    // U = 20 / 100 = 0.2 < 0.3
+    expect(qualite_isol(20, 100, ...seuils)).toBe(1);
+  });
+
+  test('U dans [seuil1, seuil2[ : bonne (2)', () => {
+    // U = 0.4
+    expect(qualite_isol(40, 100, ...seuils)).toBe(2);
+  });
+
+  test('U dans [seuil2, seuil3[ : moyenne (3)', () => {
+    // U = 0.5
+    expect(qualite_isol(50, 100, ...seuils)).toBe(3);
+  });
+
+  test('U supérieur ou égal au seuil 3 : insuffisante (4)', () => {
+    // U = 0.9 >= 0.65
+    expect(qualite_isol(90, 100, ...seuils)).toBe(4);
+  });
+
+  test('les bornes sont exclusives par le bas (U === seuil => classe suivante)', () => {
+    // U === seuil1 (0.3) => n'est pas < seuil1 => classe 2
+    expect(qualite_isol(30, 100, ...seuils)).toBe(2);
+  });
+});
+
+/** Paroi générique surface/U. */
+function mur({ adjacence = '1', surface, umur, b = 1 }) {
+  return {
+    donnee_entree: { enum_type_adjacence_id: adjacence, surface_paroi_opaque: surface },
+    donnee_intermediaire: { b, umur }
+  };
+}
+function plancherBas({ adjacence = '1', surface, upb }) {
+  return {
+    donnee_entree: { enum_type_adjacence_id: adjacence, surface_paroi_opaque: surface },
+    donnee_intermediaire: { upb }
+  };
+}
+function plancherHaut({ adjacence = '1', typePh = '12', description, surface, uph }) {
+  return {
+    donnee_entree: {
+      enum_type_adjacence_id: adjacence,
+      enum_type_plancher_haut_id: typePh,
+      description,
+      surface_paroi_opaque: surface
+    },
+    donnee_intermediaire: { uph }
+  };
+}
+function baie({ surface, u, b = 1 }) {
+  return {
+    donnee_entree: { surface_totale_baie: surface, u_menuiserie: u },
+    donnee_intermediaire: { b, u_menuiserie: u }
+  };
+}
+function porte({ surface, u, b = 1 }) {
+  return {
+    donnee_entree: { surface_porte: surface, uporte: u },
+    donnee_intermediaire: { b, uporte: u }
+  };
+}
+function enveloppe({ murs = [], pb = [], ph = [], bv = [], portes = [] }) {
+  return {
+    mur_collection: { mur: murs },
+    plancher_haut_collection: { plancher_haut: ph },
+    plancher_bas_collection: { plancher_bas: pb },
+    baie_vitree_collection: { baie_vitree: bv },
+    porte_collection: { porte: portes }
+  };
+}
+
+describe('calc_qualite_isolation - agrégation et classement', () => {
+  test('cas de référence : ubat et classes de qualité', () => {
+    const env = enveloppe({
+      murs: [mur({ surface: 100, umur: 0.5 })],
+      pb: [plancherBas({ surface: 50, upb: 0.4 })],
+      ph: [plancherHaut({ surface: 30, uph: 0.2 })],
+      bv: [baie({ surface: 20, u: 2 })],
+      portes: [porte({ surface: 5, u: 2 })]
+    });
+    const dp = {
+      deperdition_mur: 50,
+      deperdition_plancher_bas: 20,
+      deperdition_plancher_haut: 6,
+      deperdition_baie_vitree: 40,
+      deperdition_porte: 10,
+      deperdition_pont_thermique: 10
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // valeur de référence de régression : 136 / 205
+    expect(ret.ubat).toBeCloseTo(0.6634146341463415, 9);
+    expect(ret.qualite_isol_enveloppe).toBe(3);
+    expect(ret.qualite_isol_mur).toBe(3); // U = 0.5
+    expect(ret.qualite_isol_plancher_bas).toBe(2); // U = 0.4
+    expect(ret.qualite_isol_menuiserie).toBe(2); // U = 50/25 = 2
+    expect(ret.qualite_isol_plancher_haut_comble_amenage).toBe(2); // U = 0.2
+  });
+
+  test('les locaux non déperditifs (adjacence 22) sont exclus des murs et planchers bas', () => {
+    const env = enveloppe({
+      murs: [mur({ surface: 100, umur: 0.5 }), mur({ adjacence: '22', surface: 999, umur: 9 })],
+      pb: [
+        plancherBas({ surface: 50, upb: 0.4 }),
+        plancherBas({ adjacence: '22', surface: 999, upb: 9 })
+      ]
+    });
+    const dp = {
+      deperdition_mur: 50,
+      deperdition_plancher_bas: 20,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // surface déperditive = 100 + 50 = 150 ; ubat = 70 / 150
+    expect(ret.ubat).toBeCloseTo(70 / 150, 9);
+    expect(ret.qualite_isol_mur).toBe(3); // 0.5 seule paroi retenue
+  });
+
+  test('un mur avec coefficient b nul est exclu du calcul', () => {
+    const env = enveloppe({
+      murs: [mur({ surface: 100, umur: 0.5 }), mur({ surface: 200, umur: 9, b: 0 })]
+    });
+    const dp = {
+      deperdition_mur: 50,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // seul le mur b>0 (surface 100) est compté
+    expect(ret.ubat).toBeCloseTo(0.5, 9);
+    expect(ret.qualite_isol_mur).toBe(3);
+  });
+
+  test("plancher haut non adjacent à l'extérieur (adjacence !== 1) : classé comble perdu", () => {
+    const env = enveloppe({
+      ph: [plancherHaut({ adjacence: '5', surface: 40, uph: 0.1 })]
+    });
+    const dp = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 4,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // U = 4 / 40 = 0.1 < 0.15 => très bonne (1)
+    expect(ret.qualite_isol_plancher_haut_comble_perdu).toBe(1);
+    expect(ret.qualite_isol_plancher_haut_comble_amenage).toBeUndefined();
+    expect(ret.qualite_isol_plancher_haut_toit_terrasse).toBeUndefined();
+  });
+
+  test('plancher haut extérieur sans marqueur combles aménagés : classé toit terrasse', () => {
+    const env = enveloppe({
+      ph: [
+        plancherHaut({
+          adjacence: '1',
+          typePh: '5',
+          description: 'dalle béton',
+          surface: 40,
+          uph: 0.28
+        })
+      ]
+    });
+    const dp = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 11.2,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // U = 0.28 : seuils toit terrasse 0.25 / 0.3 / 0.35 => classe 2 (dans [0.25, 0.3[)
+    expect(ret.qualite_isol_plancher_haut_toit_terrasse).toBe(2);
+  });
+
+  test('description contenant « combles aménagés » : classé combles aménagés', () => {
+    const env = enveloppe({
+      ph: [
+        plancherHaut({
+          adjacence: '1',
+          typePh: '5',
+          description: 'Combles aménagés sous rampant',
+          surface: 30,
+          uph: 0.2
+        })
+      ]
+    });
+    const dp = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 6,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    expect(ret.qualite_isol_plancher_haut_comble_amenage).toBe(2);
+  });
+
+  test('collections sans tableau interne (undefined) : repli sur des listes vides', () => {
+    // Aucune des collections n'expose son tableau => branches `|| []` empruntées.
+    const env = {
+      mur_collection: {},
+      plancher_haut_collection: {},
+      plancher_bas_collection: {},
+      baie_vitree_collection: {},
+      porte_collection: {}
+    };
+    const dp = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    expect(Number.isFinite(ret.ubat)).toBe(false);
+    expect(ret.qualite_isol_mur).toBe(1);
+    expect(ret.qualite_isol_plancher_haut_comble_amenage).toBeUndefined();
+  });
+
+  test('collections vides : ubat non fini, seules les quatre qualités de base présentes', () => {
+    const env = enveloppe({});
+    const dp = {
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_porte: 0,
+      deperdition_pont_thermique: 0
+    };
+
+    const ret = calc_qualite_isolation(env, dp);
+
+    // 0 / 0 => NaN
+    expect(Number.isFinite(ret.ubat)).toBe(false);
+    expect(ret.qualite_isol_plancher_haut_comble_amenage).toBeUndefined();
+    expect(ret.qualite_isol_plancher_haut_toit_terrasse).toBeUndefined();
+    expect(ret.qualite_isol_plancher_haut_comble_perdu).toBeUndefined();
+  });
+});

package/3.1_b.js

@@ -1,7 +1,7 @@
 import enums from './enums.js';
 import { tv, requestInput, requestInputID, bug_for_bug_compat } from './utils.js';
 
-function findRanges(inputNumber) {
+export function findRanges(inputNumber) {
   const ranges = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
   const result = [];
 

package/3.1_b.spec.js

@@ -0,0 +1,367 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Dépendances mockées pour isoler la logique de `3.1_b.js` :
+ * - `tv` : accès à la table de valeurs coef_reduction_deperdition (on contrôle la ligne retournée) ;
+ * - `requestInput` / `requestInputID` : simples passe-plats vers les données d'entrée ;
+ * - `bug_for_bug_compat` : désactivé pour isoler le comportement nominal ;
+ * - `enums` : mapping minimal nécessaire au calcul.
+ */
+/**
+ * `bug_for_bug_compat` est exposé via un accesseur adossé à un état hoisté afin de pouvoir
+ * l'activer sur les tests reproduisant les comportements bugués des DPE réels.
+ */
+const state = vi.hoisted(() => ({ bug: false }));
+
+vi.mock('./utils.js', () => ({
+  tv: vi.fn(),
+  requestInputID: (de, du, field) => {
+    const enumName = `enum_${field}_id`;
+    du[enumName] = de[enumName];
+    return de[enumName];
+  },
+  requestInput: (de, du, field) => de[field],
+  get bug_for_bug_compat() {
+    return state.bug;
+  }
+}));
+
+vi.mock('./enums.js', () => ({
+  default: {
+    zone_climatique: { 1: 'h1a', 2: 'h1b', 8: 'h3' },
+    type_adjacence: { 8: 'garage', 9: 'cellier', 10: 'espace tampon', 12: 'comble', 21: 'autres' },
+    cfg_isolation_lnc: { 1: 'local chauffé non accessible', 2: 'lc non isolé + lnc non isolé' }
+  }
+}));
+
+const { default: b, findRanges } = await import('./3.1_b.js');
+const { tv } = await import('./utils.js');
+
+const TABLE = 'coef_reduction_deperdition';
+
+let errorSpy;
+
+beforeEach(() => {
+  tv.mockReset();
+  state.bug = false;
+  errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  errorSpy.mockRestore();
+});
+
+/**
+ * 3.1 Coefficient de réduction des déperditions (b)
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §3.1
+ */
+describe('findRanges - encadrement du rapport surface_aiu / surface_aue', () => {
+  const ranges = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+
+  test('valeur inférieure à la plus petite borne : borne inférieure nulle', () => {
+    expect(findRanges(0.1)).toEqual([null, 0.25]);
+  });
+
+  test('valeur supérieure à la plus grande borne : borne supérieure nulle', () => {
+    expect(findRanges(60)).toEqual([50, null]);
+  });
+
+  test('valeur strictement comprise entre deux bornes : encadrement [inf, sup]', () => {
+    expect(findRanges(0.3)).toEqual([0.25, 0.5]);
+    expect(findRanges(1.1)).toEqual([1, 1.25]);
+    expect(findRanges(9)).toEqual([8, 10]);
+  });
+
+  test('valeur égale à une borne intermédiaire : encadrement [borne précédente, borne]', () => {
+    expect(findRanges(0.5)).toEqual([0.25, 0.5]);
+    expect(findRanges(1)).toEqual([0.75, 1]);
+    expect(findRanges(50)).toEqual([25, 50]);
+  });
+
+  test('valeur égale à la première borne : un seul élément (pas de borne précédente)', () => {
+    // i === 0 : la boucle ne pousse pas de borne inférieure
+    expect(findRanges(0.25)).toEqual([0.25]);
+  });
+
+  test('toutes les bornes exactes retournent un encadrement cohérent', () => {
+    ranges.forEach((value, index) => {
+      const result = findRanges(value);
+      if (index === 0) {
+        expect(result).toEqual([0.25]);
+      } else {
+        expect(result).toEqual([ranges[index - 1], value]);
+      }
+    });
+  });
+});
+
+describe('b - calcul du coefficient de réduction des déperditions', () => {
+  /**
+   * Local chauffé non accessible / non déperditif avec surface_aue nulle (cf. page 10) :
+   * b = 0 et aucun accès à la table de valeurs.
+   */
+  test.each([
+    ['8', 'garage'],
+    ['9', 'cellier'],
+    ['12', 'comble faiblement ventilé'],
+    ['21', 'autres dépendances']
+  ])(
+    'surface_aue nulle pour une adjacence de type %s (%s) : b = 0 sans accès table',
+    (adjacence) => {
+      const di = {};
+      const de = { enum_type_adjacence_id: adjacence, surface_aue: 0 };
+      b(di, de, {}, 1);
+      expect(di.b).toBe(0);
+      expect(tv).not.toHaveBeenCalled();
+    }
+  );
+
+  /**
+   * Espace tampon solarisé (adjacence 10) : le matcher inclut la zone climatique (2 premiers
+   * caractères) et la configuration d'isolation du local non chauffé.
+   */
+  test('espace tampon solarisé (adjacence 10) : matcher zone climatique + cfg isolation', () => {
+    tv.mockReturnValue({ b: '0.58', tv_coef_reduction_deperdition_id: '269' });
+    const di = {};
+    const de = { enum_type_adjacence_id: '10', enum_cfg_isolation_lnc_id: '7' };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, {
+      enum_type_adjacence_id: '10',
+      zone_climatique: 'h1',
+      enum_cfg_isolation_lnc_id: '7'
+    });
+    expect(di.b).toBe(0.58);
+    expect(de.tv_coef_reduction_deperdition_id).toBe(269);
+  });
+
+  /**
+   * Adjacence de type garage avec surface_aiu === surface_aue :
+   * bornes par défaut 0,75 < aiu/aue ≤ 1,00.
+   */
+  test('garage (adjacence 8), surface_aiu === surface_aue : bornes par défaut', () => {
+    tv.mockReturnValue({ b: '0.7', tv_coef_reduction_deperdition_id: '100' });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 20,
+      surface_aue: 20
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,75 <',
+      aiu_aue_max: '≤ 1,00'
+    });
+    expect(di.b).toBe(0.7);
+  });
+
+  /**
+   * Adjacence de type garage avec rapport surface_aiu / surface_aue = 0.5 :
+   * findRanges([0.25, 0.5]) => bornes '0,25 <' et '≤ 0,50'.
+   */
+  test('garage (adjacence 8), rapport surface_aiu / surface_aue = 0.5 : bornes encadrantes', () => {
+    tv.mockReturnValue({ b: '0.8', tv_coef_reduction_deperdition_id: '101' });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 10,
+      surface_aue: 20
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,25 <',
+      aiu_aue_max: '≤ 0,50'
+    });
+    expect(di.b).toBe(0.8);
+  });
+
+  test('aucune valeur forfaitaire trouvée : di.b reste indéfini', () => {
+    tv.mockReturnValue(null);
+    const di = {};
+    const de = { enum_type_adjacence_id: '10', enum_cfg_isolation_lnc_id: '7' };
+
+    b(di, de, {}, 1);
+
+    expect(di.b).toBeUndefined();
+  });
+
+  /**
+   * Configuration "local chauffé non accessible" (cfg_isolation_lnc = 1) : le rapport aiu/aue
+   * n'est pas connu, l'adjacence est retirée du matcher.
+   */
+  test('local chauffé non accessible (cfg 1) : adjacence retirée du matcher', () => {
+    tv.mockReturnValue({ b: '0.95', tv_coef_reduction_deperdition_id: '300' });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '1',
+      surface_aue: 20
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, { enum_cfg_isolation_lnc_id: '1' });
+    expect(di.b).toBe(0.95);
+  });
+
+  /**
+   * Rapport surface_aiu / surface_aue égal exactement à la plus petite borne (0,25) :
+   * seule la borne supérieure aiu_aue_max est renseignée.
+   */
+  test('rapport égal à la borne minimale (0,25) : seule aiu_aue_max est renseignée', () => {
+    tv.mockReturnValue({ b: '0.85', tv_coef_reduction_deperdition_id: '150' });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 5,
+      surface_aue: 20 // rapport = 0,25
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_max: '≤ 0,25'
+    });
+    expect(di.b).toBe(0.85);
+  });
+
+  /**
+   * Compatibilité bug : surface_aiu === surface_aue mais le DPE a renseigné des bornes aiu/aue
+   * via tv_coef_reduction_deperdition_id différentes des bornes par défaut. Ces bornes sont
+   * conservées (avec émission d'une erreur explicative).
+   */
+  test('compat bug : bornes aiu/aue issues du DPE conservées malgré aiu === aue', () => {
+    state.bug = true;
+    tv.mockImplementation((table, matcher) => {
+      // 1er appel : lecture de la ligne référencée par tv_coef_reduction_deperdition_id
+      if (matcher.tv_coef_reduction_deperdition_id) {
+        return { aiu_aue_min: '0,50 <', aiu_aue_max: '≤ 0,75' };
+      }
+      // 2e appel : lecture de la valeur de b avec le matcher final
+      return { b: '0.8', tv_coef_reduction_deperdition_id: '200' };
+    });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 20,
+      surface_aue: 20,
+      tv_coef_reduction_deperdition_id: 5,
+      description: 'paroi test'
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenLastCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,50 <',
+      aiu_aue_max: '≤ 0,75'
+    });
+    expect(errorSpy).toHaveBeenCalled();
+    expect(di.b).toBe(0.8);
+  });
+
+  /**
+   * Compat bug : la ligne référencée ne fournit pas de bornes (valeurs absentes) : les bornes
+   * par défaut '0,75 <' et '≤ 1,00' sont conservées et aucune erreur n'est émise.
+   */
+  test('compat bug : bornes absentes dans le DPE, bornes par défaut conservées', () => {
+    state.bug = true;
+    tv.mockImplementation((table, matcher) => {
+      if (matcher.tv_coef_reduction_deperdition_id) {
+        return { aiu_aue_min: undefined, aiu_aue_max: undefined };
+      }
+      return { b: '0.7', tv_coef_reduction_deperdition_id: '201' };
+    });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 20,
+      surface_aue: 20,
+      tv_coef_reduction_deperdition_id: 5
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenLastCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,75 <',
+      aiu_aue_max: '≤ 1,00'
+    });
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(di.b).toBe(0.7);
+  });
+
+  /**
+   * Compat bug : aucune ligne référencée retournée (tv_coef_reduction_deperdition_id présent
+   * mais table vide) : les bornes par défaut sont conservées.
+   */
+  test('compat bug : aucune ligne référencée, bornes par défaut conservées', () => {
+    state.bug = true;
+    tv.mockImplementation((table, matcher) => {
+      if (matcher.tv_coef_reduction_deperdition_id) return null;
+      return { b: '0.72', tv_coef_reduction_deperdition_id: '202' };
+    });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 20,
+      surface_aue: 20,
+      tv_coef_reduction_deperdition_id: 5
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenLastCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,75 <',
+      aiu_aue_max: '≤ 1,00'
+    });
+    expect(di.b).toBe(0.72);
+  });
+
+  /**
+   * Compat bug activée mais tv_coef_reduction_deperdition_id absent : le bloc de reprise n'est
+   * pas exécuté, les bornes par défaut sont utilisées directement.
+   */
+  test('compat bug sans tv_coef_reduction_deperdition_id : bornes par défaut', () => {
+    state.bug = true;
+    tv.mockReturnValue({ b: '0.7', tv_coef_reduction_deperdition_id: '203' });
+    const di = {};
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 20,
+      surface_aue: 20
+    };
+
+    b(di, de, {}, 1);
+
+    expect(tv).toHaveBeenCalledWith(TABLE, {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      aiu_aue_min: '0,75 <',
+      aiu_aue_max: '≤ 1,00'
+    });
+    expect(di.b).toBe(0.7);
+  });
+});