@open3cl/engine 1.6.1 → 1.6.2

package/core/assets/domain/synchronize-valeur-tables.spec.js

@@ -51,4 +51,52 @@ describe('SynchronizeValeurTables unit tests', () => {
       );
     });
   });
+
+  test('ajoute les valeurs Ue supplémentaires quand la table `ue` est présente', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
+    const synchronizeSolicitationTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+    const addAdditionnalUeValuesTables = new AddAdditionnalUeValuesTables(fileStore, appConfig);
+    const synchronizeValeurTables = new SynchronizeValeurTables(
+      fileStore,
+      appConfig,
+      synchronizeSolicitationTables,
+      synchronizeDpeGesLimitValuesTables,
+      addAdditionnalUeValuesTables,
+      synchronizeC1Tables
+    );
+
+    vi.spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get').mockReturnValue(
+      'http://localhost/file.xlsx'
+    );
+    vi.spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get').mockReturnValue(
+      'src/assets'
+    );
+
+    // Le classeur téléchargé contient une table `ue` : la branche d'ajout des
+    // valeurs Ue supplémentaires doit être empruntée.
+    vi.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue({
+      ue: [{ type_adjacence: 'ext', ue: '1.5' }]
+    });
+    vi.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    vi.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
+    const addUeSpy = vi
+      .spyOn(addAdditionnalUeValuesTables, 'execute')
+      .mockReturnValue({ ue: 'valeurs-ue-completees' });
+
+    return synchronizeValeurTables.execute().then(() => {
+      // La fonction d'ajout reçoit les valeurs fusionnées contenant la table ue.
+      expect(addUeSpy).toHaveBeenCalledWith(expect.objectContaining({ ue: expect.any(Array) }));
+      // Le fichier écrit contient le résultat renvoyé par l'ajout Ue.
+      const contenu = vi.mocked(fileStore.writeFileToLocalSystem).mock.calls[0][1];
+      expect(contenu).toContain('valeurs-ue-completees');
+    });
+  });
 });

package/core/conf/infrastructure/application.config.spec.js

@@ -0,0 +1,35 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { ApplicationConfig } from './application.config.js';
+
+/** @type {ApplicationConfig} */
+let config;
+
+describe('ApplicationConfig', () => {
+  beforeEach(() => {
+    config = new ApplicationConfig();
+  });
+
+  test('expose la version et l’URL du dépôt ADEME', () => {
+    expect(config.ademeRepositoryVersion).toBe('fix-pont-thermique-et-warning-audit-copro');
+    expect(config.ademeRepositoryUrl).toBe('https://gitlab.com/observatoire-dpe/observatoire-dpe');
+  });
+
+  test('construit l’URL du fichier des tables d’enums à partir de l’URL et de la version', () => {
+    expect(config.ademeEnumTablesFileUrl).toBe(
+      `${config.ademeRepositoryUrl}/-/raw/${config.ademeRepositoryVersion}/modele_donnee/enum_tables.xlsx?ref_type=tags&inline=false`
+    );
+  });
+
+  test('construit l’URL du fichier des tables de valeurs', () => {
+    expect(config.ademeValeurTablesFileUrl).toBe(
+      `${config.ademeRepositoryUrl}/-/raw/${config.ademeRepositoryVersion}/modele_donnee/valeur_tables.xlsx?ref_type=tags&inline=false`
+    );
+  });
+
+  test('expose les chemins des fichiers locaux de tables de valeurs', () => {
+    expect(config.solicitationsExtFilePath).toBe('src/tv/18.2_sollicitations_ext.ods');
+    expect(config.c1FilePath).toBe('src/tv/18.5_c1.ods');
+    expect(config.dpeGesLimitValuesFilePath).toBe('src/tv/dpe_ges_limit_values.ods');
+    expect(config.assetsOutputFolder).toBe('src');
+  });
+});

package/core/file/infrastructure/adapter/csv-parser.store.spec.js

@@ -1,28 +1,46 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import CsvParserStore from './csv-parser.store.js';
-import { createReadStream } from 'node:fs';
-import { resolve } from 'node:path';
+import { Readable } from 'node:stream';
 
 describe('CsvParserStore', () => {
   /** @type {CsvParserStore} **/
   let store;
 
-  /** @type {ReadStream} **/
-  let stream;
-
   beforeEach(() => {
     store = new CsvParserStore();
   });
 
   describe('parseFromStream', () => {
-    it('should parse a csv file from a stream', () => {
-      stream = createReadStream(resolve('test/corpus/corpus_dpe.csv'));
-
-      return store
-        .parseFromStream(stream, {}, (data) => data)
-        .then((data) => {
-          expect(data).toBeDefined();
-        });
+    // Flux CSV construit en mémoire pour garder le test isolé (aucune dépendance à un fichier réel).
+    it('convertit chaque ligne du flux en objet à partir des en-têtes', async () => {
+      const stream = Readable.from(['numero_dpe,etiquette\nDPE-1,A\nDPE-2,F\n']);
+
+      const data = await store.parseFromStream(stream, { headers: true }, (row) => row);
+
+      expect(data).toStrictEqual([
+        { numero_dpe: 'DPE-1', etiquette: 'A' },
+        { numero_dpe: 'DPE-2', etiquette: 'F' }
+      ]);
+    });
+
+    it('applique la fonction de transformation à chaque ligne', async () => {
+      const stream = Readable.from(['numero_dpe,etiquette\nDPE-1,A\n']);
+
+      const data = await store.parseFromStream(stream, { headers: true }, (row) => ({
+        id: row.numero_dpe
+      }));
+
+      expect(data).toStrictEqual([{ id: 'DPE-1' }]);
+    });
+
+    it('rejette la promesse lorsque la transformation lève une erreur', async () => {
+      const stream = Readable.from(['numero_dpe,etiquette\nDPE-1,A\n']);
+
+      await expect(
+        store.parseFromStream(stream, { headers: true }, () => {
+          throw new Error('ligne invalide');
+        })
+      ).rejects.toThrow('ligne invalide');
     });
   });
 });

package/core/file/infrastructure/adapter/file.store.spec.js

@@ -1,5 +1,29 @@
-import { FileStore } from './file.store.js';
-import { describe, expect, test, vi } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+// Isolation : on mocke le module `fs` pour ne pas dépendre du système de fichiers
+// (lecture d'un vrai `.ods`) ni écrire réellement sur le disque.
+vi.mock('fs', () => ({
+  readFile: vi.fn((path, cb) => cb(null, Buffer.from(new ArrayBuffer(1)))),
+  writeFile: vi.fn((path, content, opts, cb) => cb(null))
+}));
+
+// Isolation : on mocke `xlsx` pour piloter le contenu du classeur retourné et
+// tester la logique propre au fichier (fusion de cellules `!merges`) sans
+// dépendre du parsing réel d'un binaire.
+vi.mock('xlsx', () => ({
+  read: vi.fn(() => ({ SheetNames: ['Sheet1'], Sheets: { Sheet1: {} } })),
+  utils: {
+    // Colonnes : 0 -> A, 1 -> B, ...
+    encode_col: vi.fn((c) => String.fromCharCode(65 + c)),
+    // Lignes : 0 -> 1, 1 -> 2, ... (numérotation 1-based du tableur)
+    encode_row: vi.fn((r) => String(r + 1)),
+    sheet_to_json: vi.fn(() => [])
+  }
+}));
+
+const { readFile, writeFile } = await import('fs');
+const XLSX = await import('xlsx');
+const { FileStore } = await import('./file.store.js');
 
 global.fetch = vi.fn(() =>
   Promise.resolve({
@@ -7,25 +31,137 @@ global.fetch = vi.fn(() =>
   })
 );
 
-describe('FileStore unit tests', () => {
-  test('should be able to download and parse an xlsx file', () => {
-    const fileStore = new FileStore();
+describe('FileStore', () => {
+  beforeEach(() => {
+    vi.mocked(readFile).mockReset();
+    vi.mocked(writeFile).mockReset();
+    vi.mocked(XLSX.read).mockReset();
+    vi.mocked(XLSX.utils.sheet_to_json).mockReset();
+    vi.mocked(XLSX.utils.encode_col).mockClear();
+    vi.mocked(XLSX.utils.encode_row).mockClear();
+
+    // Comportements par défaut « nominaux ».
+    vi.mocked(readFile).mockImplementation((path, cb) => cb(null, Buffer.from(new ArrayBuffer(1))));
+    vi.mocked(writeFile).mockImplementation((path, content, opts, cb) => cb(null));
+    vi.mocked(XLSX.read).mockReturnValue({
+      SheetNames: ['Sheet1'],
+      Sheets: { Sheet1: {} }
+    });
+    vi.mocked(XLSX.utils.sheet_to_json).mockReturnValue([]);
+  });
+
+  describe('downloadXlsxFileAndConvertToJson', () => {
+    test('télécharge le fichier puis le convertit en JSON par feuille', async () => {
+      const fileStore = new FileStore();
+
+      const output = await fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080');
 
-    return fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080').then((output) => {
       expect(output).toEqual({ Sheet1: [] });
+      // Le buffer téléchargé est lu par XLSX avec les bonnes options.
+      expect(fetch).toHaveBeenCalledWith('http://localhost:8080');
+      expect(XLSX.read).toHaveBeenCalledWith(expect.anything(), {
+        type: 'string',
+        raw: false
+      });
     });
   });
 
-  test('should be able to read and parse local ods file', () => {
-    const fileStore = new FileStore();
+  describe('readLocalOdsFileAndConvertToJson', () => {
+    test('lit le fichier local et le convertit en JSON par feuille', async () => {
+      const fileStore = new FileStore();
+
+      const output = await fileStore.readLocalOdsFileAndConvertToJson('file.ods');
 
-    return fileStore.readLocalOdsFileAndConvertToJson('file.ods').then((output) => {
       expect(output).toEqual({ Sheet1: [] });
+      expect(readFile).toHaveBeenCalledWith('file.ods', expect.any(Function));
+      // La lecture locale utilise l'option `type: 'buffer'`.
+      expect(XLSX.read).toHaveBeenCalledWith(expect.anything(), {
+        type: 'buffer',
+        raw: false
+      });
+    });
+
+    test("journalise et avale l'erreur si la lecture échoue (branche rejet + catch)", async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.mocked(readFile).mockImplementation((path, cb) => cb(new Error('lecture impossible')));
+
+      const fileStore = new FileStore();
+      const output = await fileStore.readLocalOdsFileAndConvertToJson('absent.ods');
+
+      // Le catch avale l'erreur : la promesse se résout sur `undefined`.
+      expect(output).toBeUndefined();
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Could not parse file: absent.ods, reason: lecture impossible'
+      );
+      // XLSX ne doit pas être appelé en cas d'erreur de lecture.
+      expect(XLSX.read).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('writeFileToLocalSystem', () => {
+    test('écrit le contenu en UTF-8 et résout la promesse', async () => {
+      const fileStore = new FileStore();
+
+      await expect(
+        fileStore.writeFileToLocalSystem('sortie.json', 'contenu')
+      ).resolves.toBeUndefined();
+
+      expect(writeFile).toHaveBeenCalledWith(
+        'sortie.json',
+        'contenu',
+        { encoding: 'utf-8' },
+        expect.any(Function)
+      );
+    });
+
+    test("rejette la promesse si l'écriture échoue (branche rejet)", async () => {
+      const erreur = new Error('disque plein');
+      vi.mocked(writeFile).mockImplementation((path, content, opts, cb) => cb(erreur));
+
+      const fileStore = new FileStore();
+
+      await expect(fileStore.writeFileToLocalSystem('sortie.json', 'contenu')).rejects.toBe(erreur);
     });
   });
 
-  test('should write file to local system', () => {
-    const fileStore = new FileStore();
-    return fileStore.writeFileToLocalSystem('src/output.js', 'filecontent');
+  describe('conversion des feuilles avec cellules fusionnées', () => {
+    test('propage la valeur de la première cellule sur les lignes fusionnées', async () => {
+      const firstCell = { v: 'valeur fusionnée' };
+      const feuille = {
+        // Fusion de A1 à A3 (3 lignes, colonne 0).
+        '!merges': [{ s: { c: 0, r: 0 }, e: { c: 0, r: 2 } }],
+        A1: firstCell
+      };
+      const classeur = { SheetNames: ['Sheet1'], Sheets: { Sheet1: feuille } };
+      vi.mocked(XLSX.read).mockReturnValue(classeur);
+
+      const fileStore = new FileStore();
+      await fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080');
+
+      // nbMergedRows = 2 : les cellules A2 et A3 reçoivent la valeur de A1.
+      expect(feuille.A2).toBe(firstCell);
+      expect(feuille.A3).toBe(firstCell);
+      // La feuille (mutée) est ensuite transformée en JSON.
+      expect(XLSX.utils.sheet_to_json).toHaveBeenCalledWith(feuille, {
+        raw: false
+      });
+    });
+
+    test("ne modifie pas la feuille en l'absence de fusion", async () => {
+      const feuille = { A1: { v: 'x' } };
+      vi.mocked(XLSX.read).mockReturnValue({
+        SheetNames: ['Sheet1'],
+        Sheets: { Sheet1: feuille }
+      });
+
+      const fileStore = new FileStore();
+      await fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080');
+
+      // Aucune cellule supplémentaire n'est créée.
+      expect(Object.keys(feuille)).toEqual(['A1']);
+      expect(XLSX.utils.encode_col).not.toHaveBeenCalled();
+    });
   });
 });

package/core/tv/infrastructure/assets/additional-ue-values.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vitest';
+import { UPB_ADDITIONAL_VALUES } from './additional-ue-values.js';
+
+/**
+ * `UPB_ADDITIONAL_VALUES` complète la table de valeurs Ue pour les
+ * déperditions des planchers bas. On vérifie la cohérence structurelle des
+ * entrées sans figer l'intégralité des valeurs numériques.
+ */
+describe('Valeurs Ue additionnelles (UPB_ADDITIONAL_VALUES)', () => {
+  test('est un tableau non vide', () => {
+    expect(Array.isArray(UPB_ADDITIONAL_VALUES)).toBe(true);
+    expect(UPB_ADDITIONAL_VALUES.length).toBeGreaterThan(0);
+  });
+
+  test('chaque entrée possède les métadonnées d’adjacence attendues', () => {
+    UPB_ADDITIONAL_VALUES.forEach((entree) => {
+      expect(entree).toHaveProperty('type_adjacence_plancher');
+      expect(entree).toHaveProperty('enum_type_adjacence_id');
+      expect(entree).toHaveProperty('type_adjacence');
+      expect(entree).toHaveProperty('enum_periode_construction_id');
+      expect(entree).toHaveProperty('periode_construction');
+      expect(Array.isArray(entree.values)).toBe(true);
+      expect(entree.values.length).toBeGreaterThan(0);
+    });
+  });
+
+  test('chaque valeur contient les clés 2s_p, upb et ue exploitables numériquement', () => {
+    UPB_ADDITIONAL_VALUES.forEach((entree) => {
+      entree.values.forEach((valeur) => {
+        expect(valeur).toHaveProperty('2s_p');
+        expect(Number.isNaN(parseFloat(valeur.upb))).toBe(false);
+        expect(Number.isNaN(parseFloat(valeur.ue))).toBe(false);
+      });
+    });
+  });
+});

package/core/util/infrastructure/object-util.spec.js

@@ -1,7 +1,27 @@
 import { ObjectUtil } from './object-util.js';
 import { describe, expect, test } from 'vitest';
 
+const identite = (x) => x;
+
 describe('ObjectUtil unit tests', () => {
+  test("retourne la primitive telle quelle quand la racine n'est ni objet ni tableau", () => {
+    // Branche terminale `: obj` : une primitive n'est pas transformée.
+    expect(ObjectUtil.deepObjectTransform('brut', identite, identite)).toBe('brut');
+    expect(ObjectUtil.deepObjectTransform(42, identite, identite)).toBe(42);
+  });
+
+  test('conserve une valeur nulle sans tenter de la parcourir récursivement', () => {
+    // Branche `val !== null` : `null` est de type "object" mais ne doit pas
+    // être exploré récursivement.
+    const resultat = ObjectUtil.deepObjectTransform(
+      { a: null },
+      (key) => key.toUpperCase(),
+      identite
+    );
+
+    expect(resultat).toEqual({ A: null });
+  });
+
   test('should be able to deeply transform an object keys and values', () => {
     expect(
       ObjectUtil.deepObjectTransform(

package/core/util/logger/log-service.js

@@ -2,6 +2,21 @@ import { createLogger, format, transports } from 'winston';
 
 const { combine, timestamp, prettyPrint, colorize, errors, printf } = format;
 
+/**
+ * Formate une ligne de log. Si une pile (`stack`) est présente, elle est
+ * ajoutée à la suite du message. Fonction pure exportée pour être testée
+ * unitairement.
+ * @param {{level: string, message: string, timestamp: string, stack?: string}} info
+ * @return {string}
+ */
+export const formatLogLine = ({ level, message, timestamp, stack }) => {
+  if (stack) {
+    // print log trace
+    return `${timestamp} ${level}: ${message} - ${stack}`;
+  }
+  return `${timestamp} ${level}: ${message}`;
+};
+
 // Disable traditional console logs
 const copyLog = console.log;
 const copyWarn = console.warn;
@@ -15,13 +30,7 @@ export const logger = createLogger({
     colorize(),
     timestamp(),
     prettyPrint(),
-    printf(({ level, message, timestamp, stack }) => {
-      if (stack) {
-        // print log trace
-        return `${timestamp} ${level}: ${message} - ${stack}`;
-      }
-      return `${timestamp} ${level}: ${message}`;
-    })
+    printf(formatLogLine)
   ),
   transports: [new transports.Console()]
 });

package/core/util/logger/log-service.spec.js

@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, test } from 'vitest';
+import { formatLogLine, logger, setLoggerOff, setLoggerOn } from './log-service.js';
+
+/**
+ * Sauvegarde des méthodes console d'origine : `setLoggerOff`/`setLoggerOn`
+ * réaffectent les globales `console.*`, on restaure après chaque test pour
+ * garantir l'isolation.
+ */
+const consoleOrigine = {
+  log: console.log,
+  warn: console.warn,
+  debug: console.debug,
+  error: console.error
+};
+
+describe('Service de logs (log-service)', () => {
+  afterEach(() => {
+    console.log = consoleOrigine.log;
+    console.warn = consoleOrigine.warn;
+    console.debug = consoleOrigine.debug;
+    console.error = consoleOrigine.error;
+    logger.silent = false;
+  });
+
+  test('expose un logger winston avec les méthodes de niveau usuelles', () => {
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.warn).toBe('function');
+    expect(typeof logger.error).toBe('function');
+    expect(logger.level).toBe('info');
+  });
+
+  test('setLoggerOff rend le logger silencieux et neutralise log/warn/debug', () => {
+    setLoggerOff();
+
+    expect(logger.silent).toBe(true);
+    expect(console.log).not.toBe(consoleOrigine.log);
+    expect(console.warn).not.toBe(consoleOrigine.warn);
+    expect(console.debug).not.toBe(consoleOrigine.debug);
+    // Par défaut, console.error n'est pas neutralisé
+    expect(console.error).toBe(consoleOrigine.error);
+  });
+
+  test('setLoggerOff(true) neutralise aussi console.error', () => {
+    setLoggerOff(true);
+
+    expect(console.error).not.toBe(consoleOrigine.error);
+  });
+
+  test('setLoggerOn réactive le logger et restaure les méthodes console', () => {
+    setLoggerOff(true);
+    setLoggerOn(true);
+
+    expect(logger.silent).toBe(false);
+    expect(console.log).toBe(consoleOrigine.log);
+    expect(console.warn).toBe(consoleOrigine.warn);
+    expect(console.debug).toBe(consoleOrigine.debug);
+    expect(console.error).toBe(consoleOrigine.error);
+  });
+
+  test('les méthodes console neutralisées sont des fonctions no-op', () => {
+    setLoggerOff();
+
+    expect(() => console.log('ignoré')).not.toThrow();
+    expect(console.log('ignoré')).toBeUndefined();
+  });
+
+  test('toutes les méthodes console neutralisées (log/warn/debug/error) sont des no-op', () => {
+    setLoggerOff(true);
+
+    // On invoque chaque no-op pour vérifier l'absence d'effet/erreur.
+    expect(console.log('x')).toBeUndefined();
+    expect(console.warn('x')).toBeUndefined();
+    expect(console.debug('x')).toBeUndefined();
+    expect(console.error('x')).toBeUndefined();
+  });
+
+  test('formatLogLine formate un message simple sans pile (branche sans stack)', () => {
+    const ligne = formatLogLine({
+      level: 'info',
+      message: 'message simple',
+      timestamp: '2026-09-04T00:00:00'
+    });
+
+    // Sans pile, aucun séparateur de trace n'est ajouté.
+    expect(ligne).toBe('2026-09-04T00:00:00 info: message simple');
+    expect(ligne).not.toContain(' - ');
+  });
+
+  test('formatLogLine ajoute la pile quand elle est présente (branche stack)', () => {
+    const ligne = formatLogLine({
+      level: 'error',
+      message: 'boom',
+      timestamp: '2026-09-04T00:00:00',
+      stack: 'Error: boom\n    at fichier.js:1:1'
+    });
+
+    // La présence d'une pile insère le séparateur " - " suivi de la trace.
+    expect(ligne).toBe('2026-09-04T00:00:00 error: boom - Error: boom\n    at fichier.js:1:1');
+  });
+});

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);
+  });
+});