@open3cl/engine 1.0.0

package/conso.spec.js

@@ -0,0 +1,90 @@
+import calc_conso from './conso.js';
+
+describe('Recherche de bugs dans le calcul de la consommation', () => {
+  test('calcul de la consommation de chauffage pour 2475E2510509B', () => {
+    const Sh = 22.76; // Surface habitable
+    const zc_id = 1; // Zone climatique
+    const ca_id = 1; // Classe d'altitude
+    const vt = [];
+    const ch = [
+      {
+        donnee_entree: {
+          description:
+            'Convecteur électrique NFC, NF** et NF*** avec programmateur pièce par pièce (système individuel)',
+          reference: '2024_07_11_09_30_44_722898200737262',
+          surface_chauffee: 22.76,
+          rdim: 1,
+          nombre_niveau_installation_ch: 1,
+          enum_cfg_installation_ch_id: '1',
+          enum_type_installation_id: '1',
+          enum_methode_calcul_conso_id: '1'
+        },
+        emetteur_chauffage_collection: {
+          emetteur_chauffage: [
+            {
+              donnee_entree: {
+                description: '',
+                reference: 'Emetteur:2024_07_11_09_30_44_722898200737262#1',
+                surface_chauffee: 22.76,
+                tv_rendement_emission_id: 1,
+                tv_rendement_distribution_ch_id: 1,
+                tv_rendement_regulation_id: 1,
+                enum_type_emission_distribution_id: '1',
+                tv_intermittence_id: 138,
+                reseau_distribution_isole: 0,
+                enum_equipement_intermittence_id: '4',
+                enum_type_regulation_id: '2',
+                enum_periode_installation_emetteur_id: '1',
+                enum_type_chauffage_id: '1',
+                enum_temp_distribution_ch_id: '1',
+                enum_lien_generateur_emetteur_id: '1'
+              },
+              donnee_intermediaire: {
+                rendement_distribution: 1,
+                rendement_emission: 0.95,
+                rendement_regulation: 0.99,
+                i0: 0.86
+              }
+            }
+          ]
+        },
+        generateur_chauffage_collection: {
+          generateur_chauffage: [
+            {
+              donnee_entree: {
+                description: 'Electrique - Convecteur électrique NFC, NF** et NF***',
+                reference: 'Generateur:2024_07_11_09_30_44_722898200737262#1',
+                reference_generateur_mixte: '',
+                ref_produit_generateur_ch: 'Sans Objet',
+                enum_type_generateur_ch_id: '98',
+                enum_usage_generateur_id: '1',
+                enum_type_energie_id: '1',
+                position_volume_chauffe: 1,
+                tv_rendement_generation_id: 29,
+                identifiant_reseau_chaleur: '',
+                enum_methode_saisie_carac_sys_id: '1',
+                enum_lien_generateur_emetteur_id: '1'
+              },
+              donnee_intermediaire: {
+                rendement_generation: 1,
+                conso_ch: 6322.706407855126,
+                conso_ch_depensier: 7679.56883918009,
+                rg: 1,
+                rg_dep: 1,
+                conso_auxiliaire_generation_ch: 0,
+                conso_auxiliaire_generation_ch_depensier: 0
+              }
+            }
+          ]
+        }
+      }
+    ];
+    const ecs = [];
+    const fr = [];
+
+    const result = calc_conso(Sh, zc_id, ca_id, vt, ch, ecs, fr);
+
+    expect(result.ef_conso.conso_ch).toBe(6322.706407855126);
+    expect(result.ef_conso.conso_ch_depensier).toBe(7679.56883918009);
+  });
+});

package/core/assets/domain/add-additionnal-ue-values-tables.js

@@ -0,0 +1,57 @@
+import { UPB_ADDITIONAL_VALUES } from '../../tv/infrastructure/assets/additional-ue-values.js';
+
+/**
+ * Add additional values for ue
+ */
+export class AddAdditionnalUeValuesTables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   */
+  constructor(fileStore, appConfig) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+  }
+
+  /**
+   * Ajout de valeurs supplémentaires pour le calcul du facteur Ue pour les déperditions plancher_bas
+   * @param tableValues
+   * @returns {*}
+   */
+  execute(tableValues) {
+    UPB_ADDITIONAL_VALUES.forEach(
+      ({
+        type_adjacence_plancher,
+        enum_type_adjacence_id,
+        type_adjacence,
+        enum_periode_construction_id,
+        periode_construction,
+        values
+      }) => {
+        const baseData = {
+          type_adjacence_plancher,
+          enum_type_adjacence_id,
+          type_adjacence,
+          enum_periode_construction_id,
+          periode_construction
+        };
+
+        values.forEach(({ ue, '2s_p': key2SP, upb }) => {
+          tableValues['ue'].push({ ...baseData, '2s_p': key2SP, upb, ue });
+        });
+      }
+    );
+
+    return tableValues;
+  }
+}

package/core/assets/domain/synchronize-assets.js

@@ -0,0 +1,29 @@
+export class SynchronizeAssets {
+  /**
+   * @type {SynchronizeEnumTables}
+   */
+  #synchronizeEnumTables;
+
+  /**
+   * @type {SynchronizeValeurTables}
+   */
+  #synchronizeValeurTables;
+
+  /**
+   * @param synchronizeEnumTables {SynchronizeEnumTables}
+   * @param synchronizeValeurTables {SynchronizeValeurTables}
+   */
+  constructor(synchronizeEnumTables, synchronizeValeurTables) {
+    this.#synchronizeEnumTables = synchronizeEnumTables;
+    this.#synchronizeValeurTables = synchronizeValeurTables;
+  }
+
+  execute() {
+    return Promise.all([
+      this.#synchronizeEnumTables.execute(),
+      this.#synchronizeValeurTables.execute()
+    ])
+      .then(() => console.log('enum and valeur tables are synchronized successfully'))
+      .catch((error) => console.error('Could not synchronize files', error));
+  }
+}

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

@@ -0,0 +1,37 @@
+import { SynchronizeAssets } from './synchronize-assets.js';
+import { SynchronizeEnumTables } from './synchronize-enum-tables.js';
+import { SynchronizeValeurTables } from './synchronize-valeur-tables.js';
+import { jest } from '@jest/globals';
+
+describe('SynchronizeAssets unit tests', () => {
+  it('should synchronize xlsx and ods files', () => {
+    const synchronizeEnumTables = new SynchronizeEnumTables(null, null);
+    const synchronizeValeurTables = new SynchronizeValeurTables(null, null, null);
+    const synchronizeAssets = new SynchronizeAssets(synchronizeEnumTables, synchronizeValeurTables);
+
+    jest.spyOn(console, 'log').mockReturnValue(null);
+    jest.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
+    jest.spyOn(synchronizeValeurTables, 'execute').mockResolvedValue({});
+
+    return synchronizeAssets.execute().then(() => {
+      expect(synchronizeEnumTables.execute).toHaveBeenCalled();
+      expect(synchronizeValeurTables.execute).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalled();
+    });
+  });
+
+  it('should log errors if synchronization has failed', () => {
+    const synchronizeEnumTables = new SynchronizeEnumTables(null, null);
+    const synchronizeValeurTables = new SynchronizeValeurTables(null, null, null);
+    const synchronizeAssets = new SynchronizeAssets(synchronizeEnumTables, synchronizeValeurTables);
+
+    jest.spyOn(console, 'error').mockReturnValue(null);
+    jest.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
+    jest.spyOn(synchronizeValeurTables, 'execute').mockRejectedValue(null);
+
+    return synchronizeAssets.execute().catch((error) => {
+      expect(error).toBeDefined();
+      expect(console.error).toHaveBeenCalled();
+    });
+  });
+});

package/core/assets/domain/synchronize-c1-tables.js

@@ -0,0 +1,61 @@
+import { set } from 'lodash-es';
+
+const ZONE_CLIMATIQUE_PROPERTY = 'zc';
+const MOIS_PROPERTY = 'mois';
+const EXCLUDED_PROPERTIES = [ZONE_CLIMATIQUE_PROPERTY, MOIS_PROPERTY];
+
+/**
+ * Read the `18.5_c1.ods` local file
+ * - Convert the file into a json object
+ * - Extract, format data and return data
+ *
+ *  The file content is merged in the `tv.js` file generated in the {@link SynchronizeValeurTables} use case.
+ */
+export class SynchronizeC1Tables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   */
+  constructor(fileStore, appConfig) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+  }
+
+  /**
+   *
+   * @return {Promise<any>}
+   */
+  execute() {
+    return this.#fileStore.readLocalOdsFileAndConvertToJson(this.#appConfig.c1FilePath).then(
+      /** @param excelSheets {{[key: string]: {zc: string, mois: string}[]}} **/ (excelSheets) => {
+        const output = {};
+
+        // For each tab in Excel file
+        for (const sheetName in excelSheets) {
+          output[sheetName] = {};
+
+          excelSheets[sheetName].forEach((sheetValue) => {
+            for (const sheetValueKey in sheetValue) {
+              if (!EXCLUDED_PROPERTIES.includes(sheetValueKey)) {
+                const path = `${sheetName}.${sheetValue.zc}.${sheetValue.mois}.${sheetValueKey}`;
+                set(output, path, parseFloat(sheetValue[sheetValueKey]));
+              }
+            }
+          });
+        }
+
+        return output;
+      }
+    );
+  }
+}

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

@@ -0,0 +1,35 @@
+import { SynchronizeC1Tables } from './synchronize-c1-tables.js';
+import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
+import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
+import { C1TablesFixture } from '../../../../test/fixtures/core/assets/c1-tables.fixture.js';
+import { jest } from '@jest/globals';
+
+describe('SynchronizeC1Tables unit tests', () => {
+  it('should read and parse 18.5_c1.ods file', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
+
+    const c1Data = C1TablesFixture.aC1Example();
+    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(c1Data);
+    jest.spyOn(ApplicationConfig.prototype, 'c1FilePath', 'get').mockReturnValue('src/file.ods');
+
+    return synchronizeC1Tables.execute().then((output) => {
+      expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();
+      expect(output).toMatchObject({
+        c1: {
+          h1a: {
+            Janvier: {
+              'sud sup75°': 1.0,
+              'sud 25°-75°': 1.67
+            },
+            Février: {
+              'sud sup75°': 1.0,
+              'sud 25°-75°': 1.78
+            }
+          }
+        }
+      });
+    });
+  });
+});

package/core/assets/domain/synchronize-dpe-ges-limit-values-tables.js

@@ -0,0 +1,73 @@
+import { set } from 'lodash-es';
+
+const CLASSE_ALTITUDE_PROPERTY = 'classe_altitude';
+const SURFACE_PROPERTY = 'surface';
+const EXCLUDED_PROPERTIES = [CLASSE_ALTITUDE_PROPERTY, SURFACE_PROPERTY];
+
+/**
+ * Read the `dpe_ges_limit_values.ods` local file
+ * - Convert the file into a json object
+ * - Extract, format data and return data
+ *
+ *  The file content is merged in the `tv.js` file generated in the {@link SynchronizeValeurTables} use case.
+ */
+export class SynchronizeDpeGesLimitValuesTables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   */
+  constructor(fileStore, appConfig) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+  }
+
+  /**
+   * @return {Promise<any>}
+   */
+  execute() {
+    return this.#fileStore
+      .readLocalOdsFileAndConvertToJson(this.#appConfig.dpeGesLimitValuesFilePath)
+      .then(
+        /** @param excelSheets {{[key: string]: {classe_altitude: string, surface: string}[]}} **/ (
+          excelSheets
+        ) => {
+          const output = {};
+
+          // For each tab in Excel file
+          for (const sheetName in excelSheets) {
+            output[sheetName] = {};
+
+            excelSheets[sheetName].forEach((sheetValue) => {
+              // Group by "classe_altitude" an "surface"
+              let groupKey = sheetValue.classe_altitude;
+
+              if (!output[sheetName][groupKey]) {
+                output[sheetName][groupKey] = {};
+              }
+
+              output[sheetName][groupKey][parseFloat(sheetValue.surface)] = {};
+
+              for (const sheetValueKey in sheetValue) {
+                if (!EXCLUDED_PROPERTIES.includes(sheetValueKey)) {
+                  const path = `${sheetName}.${groupKey}.${sheetValue.surface}.${sheetValueKey}`;
+                  set(output, path, parseFloat(sheetValue[sheetValueKey]));
+                }
+              }
+            });
+          }
+
+          return output;
+        }
+      );
+  }
+}

package/core/assets/domain/synchronize-dpe-ges-limit-values-tables.spec.js

@@ -0,0 +1,72 @@
+import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
+import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
+import { DpeGesLimitValuesTablesFixture } from '../../../../test/fixtures/core/assets/dpe-ges-limit-values-tables.fixture.js';
+import { SynchronizeDpeGesLimitValuesTables } from './synchronize-dpe-ges-limit-values-tables.js';
+import { jest } from '@jest/globals';
+
+describe('SynchronizeDpeGesLimitValuesTables unit tests', () => {
+  it('should read and parse dpe_ges_limit_values file', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+
+    const dpeGesLimitData = DpeGesLimitValuesTablesFixture.aDpeGesLimitExample();
+    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(dpeGesLimitData);
+    jest
+      .spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get')
+      .mockReturnValue('src/file.ods');
+
+    return synchronizeDpeGesLimitValuesTables.execute().then((output) => {
+      expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();
+      expect(output).toStrictEqual({
+        dpe_class_limit: {
+          'inférieur à 400m': {
+            3: {
+              A: 146,
+              B: 186,
+              C: 386,
+              D: 505,
+              E: 622,
+              F: 739
+            }
+          },
+          '400-800m': {
+            10: {
+              A: 124,
+              B: 164,
+              C: 329,
+              D: 428,
+              E: 533,
+              F: 640
+            }
+          }
+        },
+        ges_class_limit: {
+          '400-800m': {
+            10: {
+              A: 10,
+              B: 15,
+              C: 40,
+              D: 62,
+              E: 84,
+              F: 115
+            }
+          },
+          'inférieur à 400m': {
+            3: {
+              A: 11,
+              B: 16,
+              C: 44,
+              D: 68,
+              E: 90,
+              F: 122
+            }
+          }
+        }
+      });
+    });
+  });
+});

package/core/assets/domain/synchronize-enum-tables.js

@@ -0,0 +1,77 @@
+/**
+ * Download the `enum_tables.xlsx` file from the official ademe repository and generates a new `enums.js` file
+ * Please see @link https://gitlab.com/observatoire-dpe/observatoire-dpe/-/tree/master
+ * - Convert the file into a json object
+ * - Extract, format data and then generate a new enums.js file
+ */
+export class SynchronizeEnumTables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   */
+  constructor(fileStore, appConfig) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  execute() {
+    return this.#fileStore
+      .downloadXlsxFileAndConvertToJson(this.#appConfig.ademeEnumTablesFileUrl)
+      .then(
+        /** @param excelSheets {{[tabName: string]: {id: string, lib: string}[]}} xlsx content file grouped by tab */
+        (excelSheets) => {
+          const enumsOutput = {};
+
+          // for each tab in xlsx file
+          Object.keys(excelSheets)
+            .filter((sheetName) => sheetName !== 'index') // Exclude first tab called "index"
+            .forEach((sheetName) => {
+              /**
+               * Each Excel sheet has a list of columns
+               * Keep only the two first columns for now for compatibility with the legacy `enums.js` file
+               * @type {{id: string, lib: string}[]}
+               */
+              const excelSheetValues = excelSheets[sheetName];
+
+              const outputTabValues = {};
+
+              /**
+               * Convert object in the form of [{id: 1, lib: "test"}, {id: 2, lib: "test 2"}]
+               * to {1: "test", 2: "test 2"}
+               */
+              excelSheetValues.forEach((excelSheetValue) => {
+                outputTabValues[excelSheetValue.id] = excelSheetValue.lib.replace(/ :/g, ' :');
+
+                // For compatibility with the legacy `enums.js` file, force the lowercase for
+                // each value except the `classe_etiquette`
+                if (sheetName !== 'classe_etiquette') {
+                  outputTabValues[excelSheetValue.id] =
+                    outputTabValues[excelSheetValue.id].toLowerCase();
+                }
+              });
+
+              enumsOutput[sheetName] = outputTabValues;
+            });
+
+          // Overwrite the enums.js file in filesystem
+          return this.#fileStore.writeFileToLocalSystem(
+            `${this.#appConfig.assetsOutputFolder}/enums.js`,
+            `/** @type {TableEnum} **/\nconst enums = ${JSON.stringify(enumsOutput, null, 2)};\n export default enums;`
+          );
+        }
+      );
+  }
+}

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

@@ -0,0 +1,31 @@
+import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
+import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
+import { EnumTablesFixture } from '../../../../test/fixtures/core/assets/enum-tables.fixture.js';
+import { SynchronizeEnumTables } from './synchronize-enum-tables.js';
+import { jest } from '@jest/globals';
+
+describe('SynchronizeEnumTables', () => {
+  it('should download, parse and convert enum_tables.xlsx file', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeEnumTables = new SynchronizeEnumTables(fileStore, appConfig);
+
+    const enumTablesData = EnumTablesFixture.anEnumTableExample();
+    jest
+      .spyOn(ApplicationConfig.prototype, 'ademeEnumTablesFileUrl', 'get')
+      .mockReturnValue('http://localhost/file.xlsx');
+    jest
+      .spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get')
+      .mockReturnValue('src/assets');
+    jest.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(enumTablesData);
+    jest.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+
+    return synchronizeEnumTables.execute().then(() => {
+      expect(fileStore.downloadXlsxFileAndConvertToJson).toHaveBeenCalled();
+      expect(fileStore.writeFileToLocalSystem).toHaveBeenCalledWith(
+        'src/assets/enums.js',
+        expect.any(String)
+      );
+    });
+  });
+});

package/core/assets/domain/synchronize-solicitations-tables.js

@@ -0,0 +1,72 @@
+import { set } from 'lodash-es';
+
+const ILPA_PROPERTY = 'ilpa';
+const CLASSE_ALTITUDE_PROPERTY = 'classe_altitude';
+const MOIS_PROPERTY = 'mois';
+const EXCLUDED_PROPERTIES = [ILPA_PROPERTY, CLASSE_ALTITUDE_PROPERTY, MOIS_PROPERTY];
+
+/**
+ * Read the `18.2_sollicitations_ext.ods` local file
+ * - Convert the file into a json object
+ * - Extract, format data and return data
+ *
+ *  The file content is merged in the `tv.js` file generated in the {@link SynchronizeValeurTables} use case.
+ */
+export class SynchronizeSolicitationsTables {
+  /**
+   * @type {FileStore}
+   */
+  #fileStore;
+
+  /**
+   * @type {ApplicationConfig}
+   */
+  #appConfig;
+
+  /**
+   * @param fileStore {FileStore}
+   * @param appConfig {ApplicationConfig}
+   */
+  constructor(fileStore, appConfig) {
+    this.#fileStore = fileStore;
+    this.#appConfig = appConfig;
+  }
+
+  /**
+   * @return {Promise<any>}
+   */
+  execute() {
+    return this.#fileStore
+      .readLocalOdsFileAndConvertToJson(this.#appConfig.solicitationsExtFilePath)
+      .then(
+        /** @param excelSheets {{[key: string]: {ilpa?: number, classe_altitude: string, mois: string}[]}} **/ (
+          excelSheets
+        ) => {
+          const output = {};
+
+          // For each tab in Excel file
+          for (const sheetName in excelSheets) {
+            output[sheetName] = {};
+
+            excelSheets[sheetName].forEach((sheetValue) => {
+              // Group by "ilpa" property if it exists or "classe_altitude" otherwise
+              let groupKey = sheetValue.hasOwnProperty(ILPA_PROPERTY)
+                ? '.' + sheetValue.ilpa
+                : sheetValue.hasOwnProperty(CLASSE_ALTITUDE_PROPERTY)
+                  ? '.' + sheetValue.classe_altitude
+                  : '';
+
+              for (const sheetValueKey in sheetValue) {
+                if (!EXCLUDED_PROPERTIES.includes(sheetValueKey)) {
+                  const path = `${sheetName}${groupKey}${sheetValue.hasOwnProperty(ILPA_PROPERTY) ? '.' + sheetValue.classe_altitude : ''}.${sheetValue.mois}.${sheetValueKey}`;
+                  set(output, path, parseFloat(sheetValue[sheetValueKey]));
+                }
+              }
+            });
+          }
+
+          return output;
+        }
+      );
+  }
+}

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

@@ -0,0 +1,47 @@
+import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
+import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
+import { SynchronizeSolicitationsTables } from './synchronize-solicitations-tables.js';
+import { SolicitationsTablesFixture } from '../../../../test/fixtures/core/assets/solicitations-tables.fixture.js';
+import { jest } from '@jest/globals';
+
+describe('SynchronizeSolicitationsTables unit tests', () => {
+  it('should read and parse 18.2_sollicitations_ext.ods file', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeSolicitationsTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
+
+    const solicitationsData = SolicitationsTablesFixture.aSolicitationExample();
+    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(solicitationsData);
+    jest
+      .spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get')
+      .mockReturnValue('src/file.ods');
+
+    return synchronizeSolicitationsTables.execute().then((output) => {
+      expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();
+      expect(output).toMatchObject({
+        e: {
+          0: {
+            'inférieur à 400m': {
+              Janvier: {
+                h1a: 38.36
+              },
+              Février: {
+                h1a: 37.47
+              }
+            }
+          }
+        },
+        e_fr_26: {
+          'inférieur à 400m': {
+            Janvier: {
+              h1a: 0
+            },
+            Février: {
+              h1a: 0
+            }
+          }
+        }
+      });
+    });
+  });
+});