diff --git a/src/bds.ts b/src/bds.ts index 71a906e4f8..1b2ad1bcde 100644 --- a/src/bds.ts +++ b/src/bds.ts @@ -7,7 +7,7 @@ import { isBrowser, isWebWorker } from "wherearewe"; import { v4 as uuidv4 } from "uuid"; import { suivreBdDeFonction } from "@constl/utils-ipa"; -import type { InfoColAvecCatégorie } from "@/tableaux.js"; +import { attendreStabilité, type InfoColAvecCatégorie } from "@/tableaux.js"; import { schémaStatut, schémaStructureBdMétadonnées, @@ -25,6 +25,7 @@ import type { élémentBdListeDonnées, différenceTableaux, élémentDonnées, + donnéesTableauExportation, } from "@/tableaux.js"; import ClientConstellation from "@/client.js"; import { @@ -69,6 +70,11 @@ export interface infoScore { total: number; } +export type donnéesBdExportation = { + nomBd: string; + tableaux: donnéesTableauExportation[]; +}; + export interface donnéesBdExportées { doc: WorkBook; fichiersSFIP: Set; @@ -2153,22 +2159,11 @@ export default class BDs extends ComposanteClientListe { }: { idBd: string; langues?: string[]; - f: schémaFonctionSuivi<{ - nomBd: string; - données: { - nomTableau: string; - données: élémentBdListeDonnées[]; - fichiersSFIP: Set; - }[]; - }>; + f: schémaFonctionSuivi; }): Promise { const info: { nomsBd?: { [langue: string]: string }; - données?: { - nomTableau: string; - données: élémentBdListeDonnées[]; - fichiersSFIP: Set; - }[]; + données?: donnéesTableauExportation[]; } = {}; const fsOublier: schémaFonctionOublier[] = []; @@ -2181,7 +2176,7 @@ export default class BDs extends ComposanteClientListe { nomsBd && langues ? traduire(nomsBd, langues) || idCourt : idCourt; await f({ nomBd, - données, + tableaux: données, }); }; @@ -2192,33 +2187,24 @@ export default class BDs extends ComposanteClientListe { return await this.suivreTableauxBd({ idBd, f: fSuivreRacine }); }, f: async ( - données: { - nomTableau: string; - données: élémentBdListeDonnées[]; - fichiersSFIP: Set; - }[], + données: donnéesTableauExportation[], ) => { info.données = données; await fFinale(); }, fBranche: async ( id: string, - fSuivreBranche: schémaFonctionSuivi<{ - idTableau: string; - données: { - nomTableau: string; - données: élémentBdListeDonnées[]; - fichiersSFIP: Set; - }; - }>, + fSuivreBranche: schémaFonctionSuivi, ): Promise => { return await this.client.tableaux!.suivreDonnéesExportation({ idTableau: id, langues, - f: async (données) => - await fSuivreBranche({ idTableau: id, données }), + f: async (données) =>{ + return await fSuivreBranche(données)}, }); }, + fIdBdDeBranche: x => x.id, + fCode: (x) => x.id, }); fsOublier.push(fOublierDonnées); @@ -2248,34 +2234,33 @@ export default class BDs extends ComposanteClientListe { nomFichier?: string; }): Promise { const doc = utils.book_new(); - const fichiersSFIP: Set = new Set(); - - const infosTableaux = await uneFois( - (f: schémaFonctionSuivi) => - this.suivreTableauxBd({ idBd, f }), - ); - for (const tableau of infosTableaux) { - const { id: idTableau } = tableau; - const { fichiersSFIP: fichiersSFIPTableau } = - await this.client.tableaux!.exporterDonnées({ - idTableau, + const données = await uneFois( + async ( + fSuivi: schémaFonctionSuivi, + ): Promise => { + return await this.suivreDonnéesExportation({ + idBd, langues, - doc, + f: fSuivi, }); - fichiersSFIPTableau.forEach((f) => fichiersSFIP.add(f)); - } - - if (!nomFichier) { - const nomsBd = await uneFois( - (f: schémaFonctionSuivi<{ [key: string]: string }>) => - this.suivreNomsBd({ idBd, f }), - ); - const idCourt = idBd.split("/").pop()!; - - nomFichier = langues ? traduire(nomsBd, langues) || idCourt : idCourt; + }, + attendreStabilité(1000) + ); + + nomFichier = nomFichier || données.nomBd; + + const fichiersSFIP = new Set(); + + for (const tableau of données.tableaux) { + tableau.fichiersSFIP.forEach(x=>fichiersSFIP.add(x)) + + /* Créer le tableau */ + const tableauXLSX = utils.json_to_sheet(tableau.données); + + /* Ajouter la feuille au document. XLSX n'accepte pas les noms de colonne > 31 caractères */ + utils.book_append_sheet(doc, tableauXLSX, tableau.nomTableau.slice(0, 30)); } - return { doc, fichiersSFIP, nomFichier }; } diff --git a/src/projets.ts b/src/projets.ts index 71e9829ae6..906f2f6936 100644 --- a/src/projets.ts +++ b/src/projets.ts @@ -1,6 +1,6 @@ import type { ToFile } from "ipfs-core-types/src/utils"; -import { WorkBook, BookType, write as writeXLSX } from "xlsx"; +import { WorkBook, BookType, write as writeXLSX, utils } from "xlsx"; import toBuffer from "it-to-buffer"; import path from "path"; @@ -24,15 +24,20 @@ import { import { traduire, zipper, uneFois } from "@constl/utils-ipa"; import { ComposanteClientListe } from "./composanteClient.js"; import { JSONSchemaType } from "ajv"; -import { schémaCopiéDe } from "./bds.js"; +import { donnéesBdExportation, schémaCopiéDe } from "./bds.js"; import { TypedKeyValue, TypedSet } from "@constl/bohr-db"; import { estUnContrôleurConstellation } from "./accès/utils.js"; +import { attendreStabilité } from "./tableaux.js"; const schémaStructureBdMotsClefsdeProjet: JSONSchemaType = { type: "string", }; const schémaStuctureBdsDeProjet: JSONSchemaType = { type: "string" }; +export interface donnéesProjetExportation { + nomProjet: string; + bds: donnéesBdExportation[] +}; export interface donnéesProjetExportées { docs: { doc: WorkBook; nom: string }[]; fichiersSFIP: Set; @@ -847,57 +852,121 @@ export default class Projets extends ComposanteClientListe { }); } - async exporterDonnées({ + async suivreDonnéesExportation({ idProjet, langues, - nomFichier, + f, }: { idProjet: string; langues?: string[]; - nomFichier?: string; - }): Promise { - if (!nomFichier) { - const nomsBd = await uneFois( - (f: schémaFonctionSuivi<{ [key: string]: string }>) => - this.suivreNomsProjet({ idProjet, f }), - ); + f: schémaFonctionSuivi; + }): Promise { + const info: { + nomsProjet?: { [langue: string]: string }; + données?: donnéesBdExportation[]; + } = {}; + const fsOublier: schémaFonctionOublier[] = []; + + const fFinale = async () => { + const { nomsProjet, données } = info; + if (!données) return; + const idCourt = idProjet.split("/").pop()!; + const nomProjet = + nomsProjet && langues + ? traduire(nomsProjet, langues) || idCourt + : idCourt; + return await f({ + nomProjet, + bds: données, + }); + }; - nomFichier = langues ? traduire(nomsBd, langues) || idCourt : idCourt; + const fOublierDonnées = await this.client.suivreBdsDeFonctionListe({ + fListe: async (fSuivreRacine: (éléments: string[]) => Promise) => { + return await this.suivreBdsProjet({ idProjet, f: fSuivreRacine }); + }, + f: async ( + données: donnéesBdExportation[], + ) => { + info.données = données; + await fFinale(); + }, + fBranche: async ( + id: string, + fSuivreBranche: schémaFonctionSuivi, + ): Promise => { + return await this.client.bds!.suivreDonnéesExportation({ + idBd: id, + langues, + f: fSuivreBranche, + }); + }, + }); + fsOublier.push(fOublierDonnées); + + if (langues) { + const fOublierNomsProjet = await this.suivreNomsProjet({ + idProjet, + f: async (noms) => { + info.nomsProjet = noms; + await fFinale(); + }, + }); + fsOublier.push(fOublierNomsProjet); } - const données: donnéesProjetExportées = { - docs: [], - fichiersSFIP: new Set(), - nomFichier, + + return async () => { + await Promise.all(fsOublier.map((f) => f())); }; - const idsBds = await uneFois((f: schémaFonctionSuivi) => - this.suivreBdsProjet({ idProjet, f }), + } + + async exporterDonnées({ + idProjet, + langues, + nomFichier, + }: { + idProjet: string; + langues?: string[]; + nomFichier?: string; + }): Promise { + const données = await uneFois( + async ( + fSuivi: schémaFonctionSuivi, + ): Promise => { + return await this.suivreDonnéesExportation({ + idProjet, + langues, + f: fSuivi, + }); + }, + attendreStabilité(1000) ); - for (const idBd of idsBds) { - const { doc, fichiersSFIP } = await this.client.bds!.exporterDonnées({ - idBd, - langues, - }); - let nom: string; - const idCourtBd = idBd.split("/").pop()!; - if (langues) { - const noms = await uneFois( - (f: schémaFonctionSuivi<{ [key: string]: string }>) => - this.client.bds!.suivreNomsBd({ idBd, f }), - ); + nomFichier = nomFichier || données.nomProjet; - nom = traduire(noms, langues) || idCourtBd; - } else { - nom = idCourtBd; - } - données.docs.push({ doc, nom }); + const fichiersSFIP = new Set(); + données.bds.forEach(bd=>{ + bd.tableaux.forEach( + t => t.fichiersSFIP.forEach(x=>fichiersSFIP.add(x)) + ) + }); - for (const fichier of fichiersSFIP) { - données.fichiersSFIP.add(fichier); - } - } - return données; + return { + docs: données.bds.map(donnéesBd => { + const doc = utils.book_new(); + for (const tableau of donnéesBd.tableaux) { + /* Créer le tableau */ + const tableauXLSX = utils.json_to_sheet(tableau.données); + + /* Ajouter la feuille au document. XLSX n'accepte pas les noms de colonne > 31 caractères */ + utils.book_append_sheet(doc, tableauXLSX, tableau.nomTableau.slice(0, 30)); + } + return { doc, nom: donnéesBd.nomBd } + }), + fichiersSFIP, + nomFichier, + }; } async exporterDocumentDonnées({ diff --git a/src/tableaux.ts b/src/tableaux.ts index 9ad2f742b9..585969b3a3 100644 --- a/src/tableaux.ts +++ b/src/tableaux.ts @@ -59,6 +59,12 @@ export type élémentBdListeDonnées = { [key: string]: élémentsBd; }; +export type donnéesTableauExportation = { + nomTableau: string; + données: élémentBdListeDonnées[]; + fichiersSFIP: Set; +}; + export type InfoCol = { id: string; variable: string; @@ -93,6 +99,27 @@ export type conversionDonnéesChaîne = { langue: string; }; +export const attendreStabilité = (n: number): (v: T) => Promise => { + let déjàAppellé = false; + let val: string | undefined = undefined; + let annulerRebours: () => void = faisRien; + + return (v: T) => new Promise(résoudre => { + if (déjàAppellé && JSON.stringify(v) === val) return; + + déjàAppellé = true; + annulerRebours(); + val = JSON.stringify(v); + console.log(val, n); + + const crono = setTimeout(() => résoudre(true), n); + annulerRebours = () => { + clearTimeout(crono); + résoudre(false); + } + }) +} + const schémaBdInfoColAvecCatégorie: JSONSchemaType<{ [id: string]: InfoColAvecCatégorie; }> = { @@ -651,8 +678,7 @@ export default class Tableaux { ); } } - - if (val !== undefined) élémentFinal[langues ? variable : col] = val; + if (val !== undefined) élémentFinal[variable] = val; } return élémentFinal; @@ -665,11 +691,7 @@ export default class Tableaux { }: { idTableau: string; langues?: string[]; - f: schémaFonctionSuivi<{ - nomTableau: string; - données: élémentBdListeDonnées[]; - fichiersSFIP: Set; - }>; + f: schémaFonctionSuivi; }): Promise { const info: { nomsTableau?: { [clef: string]: string }; @@ -681,7 +703,8 @@ export default class Tableaux { const fFinale = async () => { const { colonnes, données, nomsTableau, nomsVariables } = info; - if (colonnes && données) { + + if (colonnes && données && (!langues || (nomsTableau && nomsVariables))) { const fichiersSFIP: Set = new Set(); let donnéesFormattées = await Promise.all( @@ -714,16 +737,17 @@ export default class Tableaux { return acc; }, {}), ); + const idCourtTableau = idTableau.split("/").pop()!; const nomTableau = langues && nomsTableau ? traduire(nomsTableau, langues) || idCourtTableau : idCourtTableau; - await f({ - nomTableau, - données: donnéesFormattées, - fichiersSFIP, + return await f({ + nomTableau, + données: donnéesFormattées, + fichiersSFIP, }); } }; @@ -801,90 +825,32 @@ export default class Tableaux { }): Promise { /* Créer le document si nécessaire */ doc = doc || utils.book_new(); - const fichiersSFIP: Set = new Set(); - - let nomTableau: string; - const idCourtTableau = idTableau.split("/").pop()!; - if (langues) { - const noms = await uneFois( - (f: schémaFonctionSuivi<{ [key: string]: string }>) => - this.suivreNomsTableau({ idTableau, f }), - ); - - nomTableau = traduire(noms, langues) || idCourtTableau; - } else { - nomTableau = idCourtTableau; - } const données = await uneFois( - (f: schémaFonctionSuivi<élémentDonnées<élémentBdListeDonnées>[]>) => - this.suivreDonnées({ idTableau, f }), - ); - - const colonnes = await uneFois( - (f: schémaFonctionSuivi) => - this.suivreColonnesTableau({ idTableau, f, catégories: true }), - (c) => - !!c && - c.length >= - [ - ...new Set( - données - .map((d) => Object.keys(d.données).filter((x) => x !== "id")) - .flat(), - ), - ].length, - ); - - let donnéesPourXLSX = await Promise.all( - données.map((d) => - this.formaterÉlément({ - é: d.données, - fichiersSFIP, - colonnes, + async ( + fSuivi: schémaFonctionSuivi<{ + nomTableau: string; + données: élémentBdListeDonnées[]; + fichiersSFIP: Set; + }>, + ): Promise => { + return await this.suivreDonnéesExportation({ + idTableau, langues, - }), - ), + f: fSuivi, + }); + }, + attendreStabilité(1000) ); - if (langues) { - const variables = await uneFois((f: schémaFonctionSuivi) => - this.suivreVariables({ idTableau, f }), - ); - const nomsVariables: { [key: string]: string } = {}; - for (const idVar of variables) { - const nomsDisponibles = await uneFois( - (f: schémaFonctionSuivi<{ [key: string]: string }>) => - this.client.variables!.suivreNomsVariable({ idVariable: idVar, f }), - ); - const idCol = colonnes.find((c) => c.variable === idVar)?.id; - if (!idCol) - throw new Error( - `Colonnne pour variable ${idVar} non trouvée parmis les colonnnes :\n${JSON.stringify( - colonnes, - undefined, - 2, - )}.`, - ); - nomsVariables[idVar] = traduire(nomsDisponibles, langues) || idCol; - } - donnéesPourXLSX = donnéesPourXLSX.map((d) => - Object.keys(d).reduce((acc: élémentBdListeDonnées, elem: string) => { - const nomVar = nomsVariables[elem]; - acc[nomVar] = d[elem]; - return acc; - }, {}), - ); - } - /* Créer le tableau */ - const tableau = utils.json_to_sheet(donnéesPourXLSX); + const tableau = utils.json_to_sheet(données.données); /* Ajouter la feuille au document. XLSX n'accepte pas les noms de colonne > 31 caractères */ - utils.book_append_sheet(doc, tableau, nomTableau.slice(0, 30)); + utils.book_append_sheet(doc, tableau, données.nomTableau.slice(0, 30)); - nomFichier = nomFichier || nomTableau; - return { doc, fichiersSFIP, nomFichier }; + nomFichier = nomFichier || données.nomTableau; + return { doc, fichiersSFIP: données.fichiersSFIP, nomFichier }; } async ajouterÉlément({ @@ -1734,7 +1700,7 @@ export default class Tableaux { catégories = false, }: { idTableau: string; - f: schémaFonctionSuivi<(InfoCol|InfoColAvecCatégorie)[]>; + f: schémaFonctionSuivi<(InfoCol | InfoColAvecCatégorie)[]>; catégories?: boolean; }): Promise { const fFinale = async (colonnes?: InfoColAvecCatégorie[]) => { diff --git a/src/version.ts b/src/version.ts index 64ca0acf64..9f55e5d9d8 100644 --- a/src/version.ts +++ b/src/version.ts @@ -1,2 +1,2 @@ // Generated by genversion. -export const version = '0.9.11'; +export const version = '0.9.12'; diff --git a/test/tableaux.spec.ts b/test/tableaux.spec.ts index fd24a0c05c..f6296c8f8c 100644 --- a/test/tableaux.spec.ts +++ b/test/tableaux.spec.ts @@ -735,123 +735,159 @@ typesClients.forEach((type) => { [idColonneTempMin]: min, })), }); + }); - after(async () => { - await Promise.all(fsOublier.map((f) => f())); - erreursValid.toutAnnuler(); - erreursRègles.toutAnnuler(); - }); + after(async () => { + await Promise.all(fsOublier.map((f) => f())); + erreursValid.toutAnnuler(); + erreursRègles.toutAnnuler(); + }); - it("Erreur règle si la colonne n'existe pas", async () => { - règle1 = { - typeRègle: "bornes", - détails: { - type: "dynamiqueColonne", - val: idColonneTempMax, - op: "≤", - }, - }; + it("Erreur règle si la colonne n'existe pas", async () => { + règle1 = { + typeRègle: "bornes", + détails: { + type: "dynamiqueColonne", + val: idColonneTempMax, + op: "≤", + }, + }; - idRègle1 = await client.tableaux!.ajouterRègleTableau({ - idTableau: idTableauRègles, - idColonne: idColonneTempMin, - règle: règle1, - }); + idRègle1 = await client.tableaux!.ajouterRègleTableau({ + idTableau: idTableauRègles, + idColonne: idColonneTempMin, + règle: règle1, + }); - const réf: erreurRègleBornesColonneInexistante[] = [ - { + const réf: erreurRègleBornesColonneInexistante[] = [ + { + règle: { + source: { type: "tableau", id: idTableauRègles }, + colonne: idColonneTempMin, règle: { - source: { type: "tableau", id: idTableauRègles }, - colonne: idColonneTempMin, - règle: { - id: idRègle1, - règle: règle1, - }, + id: idRègle1, + règle: règle1, }, - détails: "colonneBornesInexistante", }, - ]; + détails: "colonneBornesInexistante", + }, + ]; - const résValid = await erreursValid.attendreExiste(); - expect(résValid.length).to.equal(0); + const résValid = await erreursValid.attendreExiste(); + expect(résValid.length).to.equal(0); - const résRègles = await erreursRègles.attendreQue( - (x) => x.length > 0, - ); - expect(résRègles).to.deep.equal(réf); - }); + const résRègles = await erreursRègles.attendreQue( + (x) => x.length > 0, + ); + expect(résRègles).to.deep.equal(réf); + }); - it("Ajout colonne réf détectée", async () => { - await client.tableaux!.ajouterColonneTableau({ - idTableau: idTableauRègles, - idVariable: idVariableTempMax, - idColonne: idColonneTempMax, - }); - const val = await erreursRègles.attendreQue((x) => x.length === 0); - expect(val.length).to.equal(0); + it("Ajout colonne réf détectée", async () => { + await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauRègles, + idVariable: idVariableTempMax, + idColonne: idColonneTempMax, }); + const val = await erreursRègles.attendreQue((x) => x.length === 0); + expect(val.length).to.equal(0); + }); - it("Ajout éléments colonne réf détecté", async () => { - await client.tableaux!.modifierÉlément({ - idTableau: idTableauRègles, - vals: { [idColonneTempMax]: -1 }, - idÉlément: idsDonnées[0], - }); + it("Ajout éléments colonne réf détecté", async () => { + await client.tableaux!.modifierÉlément({ + idTableau: idTableauRègles, + vals: { [idColonneTempMax]: -1 }, + idÉlément: idsDonnées[0], + }); - const réf: erreurValidation = { - id: idsDonnées[0], - erreur: { + const réf: erreurValidation = { + id: idsDonnées[0], + erreur: { + règle: { + source: { type: "tableau", id: idTableauRègles }, + colonne: idColonneTempMin, règle: { - source: { type: "tableau", id: idTableauRègles }, - colonne: idColonneTempMin, - règle: { - id: idRègle1, - règle: règle1, - }, + id: idRègle1, + règle: règle1, }, }, - }; + }, + }; - const valErreursValid = await erreursValid.attendreQue( - (x) => x.length > 0, - ); - expect(valErreursValid).to.deep.equal([réf]); + const valErreursValid = await erreursValid.attendreQue( + (x) => x.length > 0, + ); + expect(valErreursValid).to.deep.equal([réf]); - await client.tableaux!.modifierÉlément({ - idTableau: idTableauRègles, - vals: { [idColonneTempMax]: 6 }, - idÉlément: idsDonnées[0], - }); - const résValid = await erreursValid.attendreQue( - (x) => x.length < 1, - ); - expect(résValid.length).to.equal(0); + await client.tableaux!.modifierÉlément({ + idTableau: idTableauRègles, + vals: { [idColonneTempMax]: 6 }, + idÉlément: idsDonnées[0], }); + const résValid = await erreursValid.attendreQue( + (x) => x.length < 1, + ); + expect(résValid.length).to.equal(0); + }); - it("Ajout éléments valides", async () => { + it("Ajout éléments valides", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableauRègles, + vals: { + [idColonneTempMin]: -15, + [idColonneTempMax]: -5, + }, + }); + const résValid = await erreursValid.attendreExiste(); + expect(résValid.length).to.equal(0); + }); + + it("Ajout éléments invalides", async () => { + id2 = ( await client.tableaux!.ajouterÉlément({ idTableau: idTableauRègles, vals: { [idColonneTempMin]: -15, - [idColonneTempMax]: -5, + [idColonneTempMax]: -25, }, - }); - const résValid = await erreursValid.attendreExiste(); - expect(résValid.length).to.equal(0); - }); + }) + )[0]; - it("Ajout éléments invalides", async () => { - id2 = ( - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauRègles, - vals: { - [idColonneTempMin]: -15, - [idColonneTempMax]: -25, + const réf: erreurValidation = { + id: id2, + erreur: { + règle: { + source: { type: "tableau", id: idTableauRègles }, + colonne: idColonneTempMin, + règle: { + id: idRègle1, + règle: règle1, }, - }) - )[0]; + }, + }, + }; + + const valErreursValid = await erreursValid.attendreQue( + (x) => x.length > 0, + ); + expect(valErreursValid).to.deep.equal([réf]); + }); + + it("Règle bornes relatives variable", async () => { + règle2 = { + typeRègle: "bornes", + détails: { + type: "dynamiqueVariable", + val: idVariableTempMin, + op: ">=", + }, + }; + idRègle2 = await client.variables!.ajouterRègleVariable({ + idVariable: idVariableTempMax, + règle: règle2, + }); - const réf: erreurValidation = { + const réf: erreurValidation[] = [ + { id: id2, erreur: { règle: { @@ -863,1093 +899,1058 @@ typesClients.forEach((type) => { }, }, }, - }; - - const valErreursValid = await erreursValid.attendreQue( - (x) => x.length > 0, - ); - expect(valErreursValid).to.deep.equal([réf]); - }); - - it("Règle bornes relatives variable", async () => { - règle2 = { - typeRègle: "bornes", - détails: { - type: "dynamiqueVariable", - val: idVariableTempMin, - op: ">=", - }, - }; - idRègle2 = await client.variables!.ajouterRègleVariable({ - idVariable: idVariableTempMax, - règle: règle2, - }); - - const réf: erreurValidation[] = [ - { - id: id2, - erreur: { - règle: { - source: { type: "tableau", id: idTableauRègles }, - colonne: idColonneTempMin, - règle: { - id: idRègle1, - règle: règle1, - }, - }, - }, - }, - { - id: id2, - erreur: { + }, + { + id: id2, + erreur: { + règle: { + source: { type: "variable", id: idVariableTempMax }, + colonne: idColonneTempMax, règle: { - source: { type: "variable", id: idVariableTempMax }, - colonne: idColonneTempMax, - règle: { - id: idRègle2, - règle: règle2, - }, + id: idRègle2, + règle: règle2, }, }, }, - ]; + }, + ]; - const valErreursValid = await erreursValid.attendreQue( - (x) => x.length > 1, - ); - expect(valErreursValid).to.deep.equal(réf); - }); + const valErreursValid = await erreursValid.attendreQue( + (x) => x.length > 1, + ); + expect(valErreursValid).to.deep.equal(réf); + }); - it("Erreur règle variable introuvable", async () => { - const règle: règleBornes = { - typeRègle: "bornes", - détails: { - type: "dynamiqueVariable", - val: idVariableTempMoyenne, - op: "<=", - }, - }; + it("Erreur règle variable introuvable", async () => { + const règle: règleBornes = { + typeRègle: "bornes", + détails: { + type: "dynamiqueVariable", + val: idVariableTempMoyenne, + op: "<=", + }, + }; - idRègle3 = await client.tableaux!.ajouterRègleTableau({ - idTableau: idTableauRègles, - idColonne: idColonneTempMin, - règle, - }); + idRègle3 = await client.tableaux!.ajouterRègleTableau({ + idTableau: idTableauRègles, + idColonne: idColonneTempMin, + règle, + }); - const réf: [erreurRègleBornesVariableNonPrésente] = [ - { - détails: "variableBornesNonPrésente", + const réf: [erreurRègleBornesVariableNonPrésente] = [ + { + détails: "variableBornesNonPrésente", + règle: { + source: { type: "tableau", id: idTableauRègles }, + colonne: idColonneTempMin, règle: { - source: { type: "tableau", id: idTableauRègles }, - colonne: idColonneTempMin, - règle: { - id: idRègle3, - règle, - }, + id: idRègle3, + règle, }, }, - ]; + }, + ]; - const val1 = await erreursRègles.attendreQue( - (x) => !!x && x.length > 0, - ); - expect(val1).to.deep.equal(réf); + const val1 = await erreursRègles.attendreQue( + (x) => !!x && x.length > 0, + ); + expect(val1).to.deep.equal(réf); - await client.tableaux!.ajouterColonneTableau({ - idTableau: idTableauRègles, - idVariable: idVariableTempMoyenne, - }); - const val2 = await erreursRègles.attendreQue( - (x) => !!x && x.length === 0, - ); - expect(val2.length).to.equal(0); + await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauRègles, + idVariable: idVariableTempMoyenne, }); + const val2 = await erreursRègles.attendreQue( + (x) => !!x && x.length === 0, + ); + expect(val2.length).to.equal(0); }); + }); - describe("Règle valeur catégorique", function () { - describe("Catégories fixes", function () { - let idTableauRègles: string; - let idColonne: string; - let idVariable: string; - - const erreurs = new utilsTestAttente.AttendreRésultat< - erreurValidation[] - >(); + describe("Règle valeur catégorique", function () { + describe("Catégories fixes", function () { + let idTableauRègles: string; + let idColonne: string; + let idVariable: string; - const fsOublier: schémaFonctionOublier[] = []; + const erreurs = new utilsTestAttente.AttendreRésultat< + erreurValidation[] + >(); - before(async () => { - idTableauRègles = await client.tableaux!.créerTableau({ idBd }); + const fsOublier: schémaFonctionOublier[] = []; - fsOublier.push( - await client.tableaux!.suivreValidDonnées({ - idTableau: idTableauRègles, - f: (e) => erreurs.mettreÀJour(e), - }), - ); + before(async () => { + idTableauRègles = await client.tableaux!.créerTableau({ idBd }); - idVariable = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", - }); - idColonne = await client.tableaux!.ajouterColonneTableau({ + fsOublier.push( + await client.tableaux!.suivreValidDonnées({ idTableau: idTableauRègles, - idVariable, - }); - - const règleCatégorique: règleValeurCatégorique = { - typeRègle: "valeurCatégorique", - détails: { type: "fixe", options: ["வணக்கம்", "សួស្តើ"] }, - }; + f: (e) => erreurs.mettreÀJour(e), + }), + ); - await client.tableaux!.ajouterRègleTableau({ - idTableau: idTableauRègles, - idColonne, - règle: règleCatégorique, - }); + idVariable = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", }); - - after(async () => { - await Promise.all(fsOublier.map((f) => f())); - erreurs.toutAnnuler(); + idColonne = await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauRègles, + idVariable, }); - it("Ajout éléments valides", async () => { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauRègles, - vals: { - [idColonne]: "வணக்கம்", - }, - }); - const rés = await erreurs.attendreExiste(); - expect(rés.length).to.equal(0); - }); - it("Ajout éléments invalides", async () => { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauRègles, - vals: { - [idColonne]: "សូស្ដី", - }, - }); - const val = await erreurs.attendreQue((x) => !!x && x.length > 0); - expect(val.length).to.equal(1); + const règleCatégorique: règleValeurCatégorique = { + typeRègle: "valeurCatégorique", + détails: { type: "fixe", options: ["வணக்கம்", "សួស្តើ"] }, + }; + + await client.tableaux!.ajouterRègleTableau({ + idTableau: idTableauRègles, + idColonne, + règle: règleCatégorique, }); }); - describe("Catégories d'une colonne d'un tableau", function () { - let idTableauÀTester: string; - let idColonneÀTester: string; - let idTableauCatégories: string; + after(async () => { + await Promise.all(fsOublier.map((f) => f())); + erreurs.toutAnnuler(); + }); - let idVariable: string; - let idVariableRéf: string; - let idRègle: string; - let règleCatégorique: règleValeurCatégorique; + it("Ajout éléments valides", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableauRègles, + vals: { + [idColonne]: "வணக்கம்", + }, + }); + const rés = await erreurs.attendreExiste(); + expect(rés.length).to.equal(0); + }); + it("Ajout éléments invalides", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableauRègles, + vals: { + [idColonne]: "សូស្ដី", + }, + }); + const val = await erreurs.attendreQue((x) => !!x && x.length > 0); + expect(val.length).to.equal(1); + }); + }); - const idColonneCatégories = "id colonne catégories"; + describe("Catégories d'une colonne d'un tableau", function () { + let idTableauÀTester: string; + let idColonneÀTester: string; + let idTableauCatégories: string; - const erreursValid = new utilsTestAttente.AttendreRésultat< - erreurValidation[] - >(); - const erreursRègles = new utilsTestAttente.AttendreRésultat< - erreurRègle[] - >(); + let idVariable: string; + let idVariableRéf: string; + let idRègle: string; + let règleCatégorique: règleValeurCatégorique; - const fsOublier: schémaFonctionOublier[] = []; + const idColonneCatégories = "id colonne catégories"; - before(async () => { - idTableauÀTester = await client.tableaux!.créerTableau({ idBd }); + const erreursValid = new utilsTestAttente.AttendreRésultat< + erreurValidation[] + >(); + const erreursRègles = new utilsTestAttente.AttendreRésultat< + erreurRègle[] + >(); - fsOublier.push( - await client.tableaux!.suivreValidDonnées({ - idTableau: idTableauÀTester, - f: (e) => erreursValid.mettreÀJour(e), - }), - ); + const fsOublier: schémaFonctionOublier[] = []; - fsOublier.push( - await client.tableaux!.suivreValidRègles({ - idTableau: idTableauÀTester, - f: (e) => erreursRègles.mettreÀJour(e), - }), - ); + before(async () => { + idTableauÀTester = await client.tableaux!.créerTableau({ idBd }); - idVariable = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", - }); - idVariableRéf = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", - }); - idColonneÀTester = await client.tableaux!.ajouterColonneTableau({ + fsOublier.push( + await client.tableaux!.suivreValidDonnées({ idTableau: idTableauÀTester, - idVariable, - }); - - idTableauCatégories = await client.tableaux!.créerTableau({ - idBd, - }); - - règleCatégorique = { - typeRègle: "valeurCatégorique", - détails: { - type: "dynamique", - tableau: idTableauCatégories, - colonne: idColonneCatégories, - }, - }; + f: (e) => erreursValid.mettreÀJour(e), + }), + ); - idRègle = await client.tableaux!.ajouterRègleTableau({ + fsOublier.push( + await client.tableaux!.suivreValidRègles({ idTableau: idTableauÀTester, - idColonne: idColonneÀTester, - règle: règleCatégorique, - }); + f: (e) => erreursRègles.mettreÀJour(e), + }), + ); + + idVariable = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", + }); + idVariableRéf = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", + }); + idColonneÀTester = await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauÀTester, + idVariable, }); - after(async () => { - await Promise.all(fsOublier.map((f) => f())); - erreursValid.toutAnnuler(); - erreursRègles.toutAnnuler(); + idTableauCatégories = await client.tableaux!.créerTableau({ + idBd, }); - it("Pas d'erreur (ici, au moins) si la colonne n'existe pas", async () => { - const rés = await erreursValid.attendreExiste(); - expect(rés.length).to.equal(0); + règleCatégorique = { + typeRègle: "valeurCatégorique", + détails: { + type: "dynamique", + tableau: idTableauCatégories, + colonne: idColonneCatégories, + }, + }; + + idRègle = await client.tableaux!.ajouterRègleTableau({ + idTableau: idTableauÀTester, + idColonne: idColonneÀTester, + règle: règleCatégorique, }); + }); + + after(async () => { + await Promise.all(fsOublier.map((f) => f())); + erreursValid.toutAnnuler(); + erreursRègles.toutAnnuler(); + }); + + it("Pas d'erreur (ici, au moins) si la colonne n'existe pas", async () => { + const rés = await erreursValid.attendreExiste(); + expect(rés.length).to.equal(0); + }); - it("Mais on a une erreur au niveau de la règle", async () => { - const réf: erreurRègleCatégoriqueColonneInexistante = { + it("Mais on a une erreur au niveau de la règle", async () => { + const réf: erreurRègleCatégoriqueColonneInexistante = { + règle: { règle: { - règle: { - id: idRègle, - règle: règleCatégorique, - }, - source: { type: "tableau", id: idTableauÀTester }, - colonne: idColonneÀTester, + id: idRègle, + règle: règleCatégorique, }, - détails: "colonneCatégInexistante", - }; - const val = await erreursRègles.attendreQue((x) => !!x?.length); - expect(val).to.deep.equal([réf]); + source: { type: "tableau", id: idTableauÀTester }, + colonne: idColonneÀTester, + }, + détails: "colonneCatégInexistante", + }; + const val = await erreursRègles.attendreQue((x) => !!x?.length); + expect(val).to.deep.equal([réf]); + }); + + it("Ajout colonne réf", async () => { + await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauCatégories, + idVariable: idVariableRéf, + idColonne: idColonneCatégories, }); + const val = await erreursRègles.attendreQue( + (x) => x?.length === 0, + ); + expect(val.length).to.equal(0); + }); - it("Ajout colonne réf", async () => { - await client.tableaux!.ajouterColonneTableau({ - idTableau: idTableauCatégories, - idVariable: idVariableRéf, - idColonne: idColonneCatégories, - }); - const val = await erreursRègles.attendreQue( - (x) => x?.length === 0, - ); - expect(val.length).to.equal(0); + it("Ajout éléments colonne réf détecté", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableauÀTester, + vals: { + [idColonneÀTester]: "வணக்கம்", + }, }); + let rés = await erreursValid.attendreQue((x) => x.length > 0); + expect(rés.length).to.equal(1); - it("Ajout éléments colonne réf détecté", async () => { + for (const mot of ["வணக்கம்", "Ütz iwäch"]) { await client.tableaux!.ajouterÉlément({ - idTableau: idTableauÀTester, + idTableau: idTableauCatégories, vals: { - [idColonneÀTester]: "வணக்கம்", + [idColonneCatégories]: mot, }, }); - let rés = await erreursValid.attendreQue((x) => x.length > 0); - expect(rés.length).to.equal(1); - - for (const mot of ["வணக்கம்", "Ütz iwäch"]) { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauCatégories, - vals: { - [idColonneCatégories]: mot, - }, - }); - } + } - rés = await erreursValid.attendreQue((x) => x.length < 1); - expect(rés.length).to.equal(0); - }); - it("Ajout éléments valides", async () => { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauÀTester, - vals: { - [idColonneÀTester]: "Ütz iwäch", - }, - }); - const rés = await erreursValid.attendreExiste(); - expect(rés.length).to.equal(0); - }); - it("Ajout éléments invalides", async () => { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauÀTester, - vals: { - [idColonneÀTester]: "வணக்கம", - }, - }); - const rés = await erreursValid.attendreQue((x) => x.length > 0); - expect(rés.length).to.equal(1); - }); + rés = await erreursValid.attendreQue((x) => x.length < 1); + expect(rés.length).to.equal(0); }); - }); - - describe("Tableau avec variables non locales", function () { - let idTableau: string; - let idColonne: string; - - const variables = new attente.AttendreRésultat(); - const colonnes = new attente.AttendreRésultat< - InfoColAvecCatégorie[] - >(); - const colonnesSansCatégorie = new attente.AttendreRésultat< - InfoCol[] - >(); - const données = new attente.AttendreRésultat<élémentDonnées[]>(); - - const idVarChaîne = - "/orbitdb/zdpuAximNmZyUWXGCaLmwSEGDeWmuqfgaoogA7KNSa1B2DAAF"; - const fsOublier: schémaFonctionOublier[] = []; - - before(async () => { - idTableau = await client.tableaux!.créerTableau({ idBd }); - idColonne = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVarChaîne, + it("Ajout éléments valides", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableauÀTester, + vals: { + [idColonneÀTester]: "Ütz iwäch", + }, }); - fsOublier.push( - await client.tableaux!.suivreVariables({ - idTableau, - f: (v) => variables.mettreÀJour(v), - }), - ); - fsOublier.push( - await client.tableaux!.suivreColonnesTableau({ - idTableau, - f: (c) => colonnes.mettreÀJour(c), - catégories: true, - }), - ); - fsOublier.push( - await client.tableaux!.suivreColonnesTableau({ - idTableau, - f: (c) => colonnesSansCatégorie.mettreÀJour(c), - catégories: false, - }), - ); - fsOublier.push( - await client.tableaux!.suivreDonnées({ - idTableau, - f: (d) => données.mettreÀJour(d), - }), - ); + const rés = await erreursValid.attendreExiste(); + expect(rés.length).to.equal(0); }); - - after(async () => { - await Promise.all(fsOublier.map((f) => f())); - }); - - it("Tableau créé", () => { - expect(isValidAddress(idTableau)).to.be.true(); - }); - it("Suivre variables", async () => { - const valVariables = await variables.attendreQue( - (x) => x.length > 0, - ); - expect(valVariables).to.deep.equal([idVarChaîne]); - }); - it("Suivre colonnes", async () => { - expect(colonnes.val).to.be.undefined; - }); - it("Suivre colonnes sans catégorie", async () => { - const val = await colonnesSansCatégorie.attendreQue( - (x) => x.length > 0, - ); - expect(val).to.deep.equal([ - { id: idColonne, variable: idVarChaîne }, - ]); - }); - it("Ajouter données", async () => { + it("Ajout éléments invalides", async () => { await client.tableaux!.ajouterÉlément({ - idTableau, + idTableau: idTableauÀTester, vals: { - [idColonne]: "Bonjour !", + [idColonneÀTester]: "வணக்கம", }, }); - - const valDonnées = await données.attendreQue((x) => x.length > 0); - expect(valDonnées[0].données[idColonne]).to.equal("Bonjour !"); + const rés = await erreursValid.attendreQue((x) => x.length > 0); + expect(rés.length).to.equal(1); }); }); + }); - describe("Copier tableau", function () { - let idTableau: string; - let idVariable: string; - let idColonne: string; - let idRègle: string; - - const variables = new attente.AttendreRésultat(); - const noms = new attente.AttendreRésultat<{ - [key: string]: string; - }>(); - const données = new attente.AttendreRésultat< - élémentDonnées<élémentBdListeDonnées>[] - >(); - const colonnes = new attente.AttendreRésultat< - InfoColAvecCatégorie[] - >(); - const colsIndexe = new attente.AttendreRésultat(); - const règles = new attente.AttendreRésultat(); - - let idTableauCopie: string; - - const réfNoms = { - த: "மழை", - हिं: "बारिश", - }; - const règle: règleBornes = { - typeRègle: "bornes", - détails: { - type: "fixe", - val: 0, - op: ">", - }, - }; + describe("Tableau avec variables non locales", function () { + let idTableau: string; + let idColonne: string; - const fsOublier: schémaFonctionOublier[] = []; + const variables = new attente.AttendreRésultat(); + const colonnes = new attente.AttendreRésultat< + InfoColAvecCatégorie[] + >(); + const colonnesSansCatégorie = new attente.AttendreRésultat< + InfoCol[] + >(); + const données = new attente.AttendreRésultat<élémentDonnées[]>(); - before(async () => { - idTableau = await client.tableaux!.créerTableau({ idBd }); - await client.tableaux!.sauvegarderNomsTableau({ - idTableau, - noms: réfNoms, - }); + const idVarChaîne = + "/orbitdb/zdpuAximNmZyUWXGCaLmwSEGDeWmuqfgaoogA7KNSa1B2DAAF"; + const fsOublier: schémaFonctionOublier[] = []; - idVariable = await client.variables!.créerVariable({ - catégorie: "numérique", - }); - idColonne = await client.tableaux!.ajouterColonneTableau({ + before(async () => { + idTableau = await client.tableaux!.créerTableau({ idBd }); + idColonne = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable: idVarChaîne, + }); + fsOublier.push( + await client.tableaux!.suivreVariables({ idTableau, - idVariable, - }); - await client.tableaux!.changerColIndex({ + f: (v) => variables.mettreÀJour(v), + }), + ); + fsOublier.push( + await client.tableaux!.suivreColonnesTableau({ idTableau, - idColonne, - val: true, - }); - - await client.tableaux!.ajouterÉlément({ + f: (c) => colonnes.mettreÀJour(c), + catégories: true, + }), + ); + fsOublier.push( + await client.tableaux!.suivreColonnesTableau({ idTableau, - vals: { - [idColonne]: 123, - }, - }); - - idRègle = await client.tableaux!.ajouterRègleTableau({ + f: (c) => colonnesSansCatégorie.mettreÀJour(c), + catégories: false, + }), + ); + fsOublier.push( + await client.tableaux!.suivreDonnées({ idTableau, - idColonne, - règle, - }); + f: (d) => données.mettreÀJour(d), + }), + ); + }); - idTableauCopie = await client.tableaux!.copierTableau({ - id: idTableau, - idBd, - }); + after(async () => { + await Promise.all(fsOublier.map((f) => f())); + }); - fsOublier.push( - await client.tableaux!.suivreVariables({ - idTableau: idTableauCopie, - f: (x) => variables.mettreÀJour(x), - }), - ); - fsOublier.push( - await client.tableaux!.suivreNomsTableau({ - idTableau: idTableauCopie, - f: (x) => noms.mettreÀJour(x), - }), - ); - fsOublier.push( - await client.tableaux!.suivreDonnées({ - idTableau: idTableauCopie, - f: (x) => données.mettreÀJour(x), - }), - ); - fsOublier.push( - await client.tableaux!.suivreColonnesTableau({ - idTableau: idTableauCopie, - f: (x) => colonnes.mettreÀJour(x), - catégories: true, - }), - ); - fsOublier.push( - await client.tableaux!.suivreIndex({ - idTableau: idTableauCopie, - f: (x) => colsIndexe.mettreÀJour(x), - }), - ); - fsOublier.push( - await client.tableaux!.suivreRègles({ - idTableau: idTableauCopie, - f: (x) => règles.mettreÀJour(x), - }), - ); + it("Tableau créé", () => { + expect(isValidAddress(idTableau)).to.be.true(); + }); + it("Suivre variables", async () => { + const valVariables = await variables.attendreQue( + (x) => x.length > 0, + ); + expect(valVariables).to.deep.equal([idVarChaîne]); + }); + it("Suivre colonnes", async () => { + expect(colonnes.val).to.be.undefined; + }); + it("Suivre colonnes sans catégorie", async () => { + const val = await colonnesSansCatégorie.attendreQue( + (x) => x.length > 0, + ); + expect(val).to.deep.equal([ + { id: idColonne, variable: idVarChaîne }, + ]); + }); + it("Ajouter données", async () => { + await client.tableaux!.ajouterÉlément({ + idTableau, + vals: { + [idColonne]: "Bonjour !", + }, }); - after(async () => { - await Promise.all(fsOublier.map((f) => f())); - colonnes.toutAnnuler(); + const valDonnées = await données.attendreQue((x) => x.length > 0); + expect(valDonnées[0].données[idColonne]).to.equal("Bonjour !"); + }); + }); + + describe("Copier tableau", function () { + let idTableau: string; + let idVariable: string; + let idColonne: string; + let idRègle: string; + + const variables = new attente.AttendreRésultat(); + const noms = new attente.AttendreRésultat<{ + [key: string]: string; + }>(); + const données = new attente.AttendreRésultat< + élémentDonnées<élémentBdListeDonnées>[] + >(); + const colonnes = new attente.AttendreRésultat< + InfoColAvecCatégorie[] + >(); + const colsIndexe = new attente.AttendreRésultat(); + const règles = new attente.AttendreRésultat(); + + let idTableauCopie: string; + + const réfNoms = { + த: "மழை", + हिं: "बारिश", + }; + const règle: règleBornes = { + typeRègle: "bornes", + détails: { + type: "fixe", + val: 0, + op: ">", + }, + }; + + const fsOublier: schémaFonctionOublier[] = []; + + before(async () => { + idTableau = await client.tableaux!.créerTableau({ idBd }); + await client.tableaux!.sauvegarderNomsTableau({ + idTableau, + noms: réfNoms, }); - it("Le tableau est copié", async () => { - expect(isValidAddress(idTableauCopie)).to.be.true(); + idVariable = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + idColonne = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable, + }); + await client.tableaux!.changerColIndex({ + idTableau, + idColonne, + val: true, }); - it("Les noms sont copiés", async () => { - const val = await noms.attendreExiste(); - expect(val).to.deep.equal(réfNoms); + await client.tableaux!.ajouterÉlément({ + idTableau, + vals: { + [idColonne]: 123, + }, }); - it("Les colonnes sont copiées", async () => { - const val = await colonnes.attendreQue((x) => x.length > 0); - expect(Array.isArray(val)).to.be.true(); - expect(val.length).to.equal(1); - expect(val[0].variable).to.equal(idVariable); + idRègle = await client.tableaux!.ajouterRègleTableau({ + idTableau, + idColonne, + règle, }); - it("Les indexes sont copiés", async () => { - const val = await colsIndexe.attendreQue((x) => x.length > 0); - expect(Array.isArray(val)).to.be.true(); - expect(val.length).to.equal(1); - expect(val[0]).to.equal(idColonne); + idTableauCopie = await client.tableaux!.copierTableau({ + id: idTableau, + idBd, }); - it("Les règles sont copiés", async () => { - const vals = await règles.attendreQue((x) => - x.some((r) => r.règle.id === idRègle), - ); + fsOublier.push( + await client.tableaux!.suivreVariables({ + idTableau: idTableauCopie, + f: (x) => variables.mettreÀJour(x), + }), + ); + fsOublier.push( + await client.tableaux!.suivreNomsTableau({ + idTableau: idTableauCopie, + f: (x) => noms.mettreÀJour(x), + }), + ); + fsOublier.push( + await client.tableaux!.suivreDonnées({ + idTableau: idTableauCopie, + f: (x) => données.mettreÀJour(x), + }), + ); + fsOublier.push( + await client.tableaux!.suivreColonnesTableau({ + idTableau: idTableauCopie, + f: (x) => colonnes.mettreÀJour(x), + catégories: true, + }), + ); + fsOublier.push( + await client.tableaux!.suivreIndex({ + idTableau: idTableauCopie, + f: (x) => colsIndexe.mettreÀJour(x), + }), + ); + fsOublier.push( + await client.tableaux!.suivreRègles({ + idTableau: idTableauCopie, + f: (x) => règles.mettreÀJour(x), + }), + ); + }); - const règleRecherchée = vals.find((r) => r.règle.id === idRègle); - expect(règleRecherchée).to.not.be.undefined(); - expect(règleRecherchée?.colonne).to.equal(colonnes.val?.[0].id); - expect(règleRecherchée?.règle.règle).to.deep.equal(règle); - }); + after(async () => { + await Promise.all(fsOublier.map((f) => f())); + colonnes.toutAnnuler(); + }); - it("Les variables sont copiés", async () => { - const val = await variables.attendreQue((v) => v.length > 0); + it("Le tableau est copié", async () => { + expect(isValidAddress(idTableauCopie)).to.be.true(); + }); - expect(Array.isArray(val)).to.be.true(); - expect(val.length).to.equal(1); - expect(val[0]).to.equal(idVariable); - }); + it("Les noms sont copiés", async () => { + const val = await noms.attendreExiste(); + expect(val).to.deep.equal(réfNoms); + }); - it("Les données sont copiés", async () => { - const valColonnes = await colonnes.attendreExiste(); - const valDonnées = await données.attendreQue((x) => x.length > 0); + it("Les colonnes sont copiées", async () => { + const val = await colonnes.attendreQue((x) => x.length > 0); + expect(Array.isArray(val)).to.be.true(); + expect(val.length).to.equal(1); + expect(val[0].variable).to.equal(idVariable); + }); - expect(Array.isArray(valDonnées)).to.be.true(); - expect(valDonnées.length).to.equal(1); - expect(valDonnées[0].données[valColonnes[0].id]).to.equal(123); - }); + it("Les indexes sont copiés", async () => { + const val = await colsIndexe.attendreQue((x) => x.length > 0); + expect(Array.isArray(val)).to.be.true(); + expect(val.length).to.equal(1); + expect(val[0]).to.equal(idColonne); }); - describe("Combiner données tableaux", function () { - let idTableauBase: string; - let idTableau2: string; + it("Les règles sont copiés", async () => { + const vals = await règles.attendreQue((x) => + x.some((r) => r.règle.id === idRègle), + ); - let idVarDate: string; - let idVarEndroit: string; - let idVarTempMin: string; - let idVarTempMax: string; + const règleRecherchée = vals.find((r) => r.règle.id === idRègle); + expect(règleRecherchée).to.not.be.undefined(); + expect(règleRecherchée?.colonne).to.equal(colonnes.val?.[0].id); + expect(règleRecherchée?.règle.règle).to.deep.equal(règle); + }); - const données = new attente.AttendreRésultat< - élémentDonnées<élémentBdListeDonnées>[] - >(); - let fOublier: schémaFonctionOublier; + it("Les variables sont copiés", async () => { + const val = await variables.attendreQue((v) => v.length > 0); - const idsCols: { [key: string]: string } = {}; + expect(Array.isArray(val)).to.be.true(); + expect(val.length).to.equal(1); + expect(val[0]).to.equal(idVariable); + }); - before(async () => { - idTableauBase = await client.tableaux!.créerTableau({ idBd }); - idTableau2 = await client.tableaux!.créerTableau({ idBd }); + it("Les données sont copiés", async () => { + const valColonnes = await colonnes.attendreExiste(); + const valDonnées = await données.attendreQue((x) => x.length > 0); - idVarDate = await client.variables!.créerVariable({ - catégorie: "horoDatage", + expect(Array.isArray(valDonnées)).to.be.true(); + expect(valDonnées.length).to.equal(1); + expect(valDonnées[0].données[valColonnes[0].id]).to.equal(123); + }); + }); + + describe("Combiner données tableaux", function () { + let idTableauBase: string; + let idTableau2: string; + + let idVarDate: string; + let idVarEndroit: string; + let idVarTempMin: string; + let idVarTempMax: string; + + const données = new attente.AttendreRésultat< + élémentDonnées<élémentBdListeDonnées>[] + >(); + let fOublier: schémaFonctionOublier; + + const idsCols: { [key: string]: string } = {}; + + before(async () => { + idTableauBase = await client.tableaux!.créerTableau({ idBd }); + idTableau2 = await client.tableaux!.créerTableau({ idBd }); + + idVarDate = await client.variables!.créerVariable({ + catégorie: "horoDatage", + }); + idVarEndroit = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", + }); + idVarTempMin = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + idVarTempMax = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + + for (const idVar of [ + idVarDate, + idVarEndroit, + idVarTempMin, + idVarTempMax, + ]) { + const idCol = await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableauBase, + idVariable: idVar, }); - idVarEndroit = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", + + idsCols[idVar] = idCol; + await client.tableaux!.ajouterColonneTableau({ + idTableau: idTableau2, + idVariable: idVar, + idColonne: idCol, }); - idVarTempMin = await client.variables!.créerVariable({ - catégorie: "numérique", + } + for (const idVar of [idVarDate, idVarEndroit]) { + await client.tableaux!.changerColIndex({ + idTableau: idTableauBase, + idColonne: idsCols[idVar], + val: true, }); - idVarTempMax = await client.variables!.créerVariable({ - catégorie: "numérique", + await client.tableaux!.changerColIndex({ + idTableau: idTableau2, + idColonne: idsCols[idVar], + val: true, }); + } - for (const idVar of [ - idVarDate, - idVarEndroit, - idVarTempMin, - idVarTempMax, - ]) { - const idCol = await client.tableaux!.ajouterColonneTableau({ - idTableau: idTableauBase, - idVariable: idVar, - }); - - idsCols[idVar] = idCol; - await client.tableaux!.ajouterColonneTableau({ - idTableau: idTableau2, - idVariable: idVar, - idColonne: idCol, - }); - } - for (const idVar of [idVarDate, idVarEndroit]) { - await client.tableaux!.changerColIndex({ - idTableau: idTableauBase, - idColonne: idsCols[idVar], - val: true, - }); - await client.tableaux!.changerColIndex({ - idTableau: idTableau2, - idColonne: idsCols[idVar], - val: true, - }); - } + fOublier = await client.tableaux!.suivreDonnées({ + idTableau: idTableauBase, + f: (d) => données.mettreÀJour(d), + }); - fOublier = await client.tableaux!.suivreDonnées({ + const élémentsBase = [ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-01", + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-02", + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "là-bas", + [idsCols[idVarDate]]: "2021-01-01", + [idsCols[idVarTempMin]]: 25, + }, + ]; + for (const élément of élémentsBase) { + await client.tableaux!.ajouterÉlément({ idTableau: idTableauBase, - f: (d) => données.mettreÀJour(d), + vals: élément, }); + } - const élémentsBase = [ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-01", - [idsCols[idVarTempMin]]: 25, - }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-02", - [idsCols[idVarTempMin]]: 25, - }, - { - [idsCols[idVarEndroit]]: "là-bas", - [idsCols[idVarDate]]: "2021-01-01", - [idsCols[idVarTempMin]]: 25, - }, - ]; - for (const élément of élémentsBase) { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableauBase, - vals: élément, - }); - } - - const éléments2 = [ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-01", - [idsCols[idVarTempMin]]: 27, - [idsCols[idVarTempMax]]: 30, - }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-02", - [idsCols[idVarTempMin]]: 27, - }, - { - [idsCols[idVarEndroit]]: "là-bas", - [idsCols[idVarDate]]: "2021-01-02", - [idsCols[idVarTempMin]]: 27, - }, - ]; - for (const élément of éléments2) { - await client.tableaux!.ajouterÉlément({ - idTableau: idTableau2, - vals: élément, - }); - } - - await client.tableaux!.combinerDonnées({ - idTableauBase, - idTableau2, + const éléments2 = [ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-01", + [idsCols[idVarTempMin]]: 27, + [idsCols[idVarTempMax]]: 30, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-02", + [idsCols[idVarTempMin]]: 27, + }, + { + [idsCols[idVarEndroit]]: "là-bas", + [idsCols[idVarDate]]: "2021-01-02", + [idsCols[idVarTempMin]]: 27, + }, + ]; + for (const élément of éléments2) { + await client.tableaux!.ajouterÉlément({ + idTableau: idTableau2, + vals: élément, }); - }); + } - after(async () => { - if (fOublier) await fOublier(); + await client.tableaux!.combinerDonnées({ + idTableauBase, + idTableau2, }); + }); - it("Données manquantes ajoutées", async () => { - const réf = [ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-01", - [idsCols[idVarTempMin]]: 25, - [idsCols[idVarTempMax]]: 30, - }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: "2021-01-02", - [idsCols[idVarTempMin]]: 25, - }, - { - [idsCols[idVarEndroit]]: "là-bas", - [idsCols[idVarDate]]: "2021-01-01", - [idsCols[idVarTempMin]]: 25, - }, - { - [idsCols[idVarEndroit]]: "là-bas", - [idsCols[idVarDate]]: "2021-01-02", - [idsCols[idVarTempMin]]: 27, - }, - ]; - const val = await données.attendreQue( - (x) => x.length === réf.length, - ); - - expect(Array.isArray(val)).to.be.true(); - expect(val.length).to.equal(4); - expect( - val - .map((d) => d.données) - .map((d) => { - delete d.id; - return d; - }), - ).to.deep.include.members(réf); - }); + after(async () => { + if (fOublier) await fOublier(); }); - describe("Importer données", function () { - let fOublier: schémaFonctionOublier; - let idTableau: string; + it("Données manquantes ajoutées", async () => { + const réf = [ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-01", + [idsCols[idVarTempMin]]: 25, + [idsCols[idVarTempMax]]: 30, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: "2021-01-02", + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "là-bas", + [idsCols[idVarDate]]: "2021-01-01", + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "là-bas", + [idsCols[idVarDate]]: "2021-01-02", + [idsCols[idVarTempMin]]: 27, + }, + ]; + const val = await données.attendreQue( + (x) => x.length === réf.length, + ); - let idVarDate: string; - let idVarEndroit: string; - let idVarTempMin: string; - let idVarTempMax: string; + expect(Array.isArray(val)).to.be.true(); + expect(val.length).to.equal(4); + expect( + val + .map((d) => d.données) + .map((d) => { + delete d.id; + return d; + }), + ).to.deep.include.members(réf); + }); + }); - const données = new attente.AttendreRésultat< - élémentDonnées<élémentBdListeDonnées>[] - >(); + describe("Importer données", function () { + let fOublier: schémaFonctionOublier; + let idTableau: string; - const idsCols: { [key: string]: string } = {}; + let idVarDate: string; + let idVarEndroit: string; + let idVarTempMin: string; + let idVarTempMax: string; - before(async () => { - idTableau = await client.tableaux!.créerTableau({ idBd }); + const données = new attente.AttendreRésultat< + élémentDonnées<élémentBdListeDonnées>[] + >(); - idVarDate = await client.variables!.créerVariable({ - catégorie: "horoDatage", - }); - idVarEndroit = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", - }); - idVarTempMin = await client.variables!.créerVariable({ - catégorie: "numérique", - }); - idVarTempMax = await client.variables!.créerVariable({ - catégorie: "numérique", - }); + const idsCols: { [key: string]: string } = {}; - for (const idVar of [ - idVarDate, - idVarEndroit, - idVarTempMin, - idVarTempMax, - ]) { - const idCol = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVar, - }); - idsCols[idVar] = idCol; - } + before(async () => { + idTableau = await client.tableaux!.créerTableau({ idBd }); - fOublier = await client.tableaux!.suivreDonnées({ + idVarDate = await client.variables!.créerVariable({ + catégorie: "horoDatage", + }); + idVarEndroit = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", + }); + idVarTempMin = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + idVarTempMax = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + + for (const idVar of [ + idVarDate, + idVarEndroit, + idVarTempMin, + idVarTempMax, + ]) { + const idCol = await client.tableaux!.ajouterColonneTableau({ idTableau, - f: (d) => données.mettreÀJour(d), + idVariable: idVar, }); + idsCols[idVar] = idCol; + } - const élémentsBase = [ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-01").valueOf(), - }, - [idsCols[idVarTempMin]]: 25, + fOublier = await client.tableaux!.suivreDonnées({ + idTableau, + f: (d) => données.mettreÀJour(d), + }); + + const élémentsBase = [ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-01").valueOf(), }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-02").valueOf(), - }, - [idsCols[idVarTempMin]]: 25, + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-02").valueOf(), }, - { - [idsCols[idVarEndroit]]: "là-bas", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-01").valueOf(), - }, - [idsCols[idVarTempMin]]: 25, + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "là-bas", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-01").valueOf(), }, - ]; + [idsCols[idVarTempMin]]: 25, + }, + ]; - await client.tableaux!.ajouterÉlément({ - idTableau, - vals: élémentsBase, - }); + await client.tableaux!.ajouterÉlément({ + idTableau, + vals: élémentsBase, + }); - // Il faut attendre que les données soient bien ajoutées avant de progresser avec l'importation. - await données.attendreQue((x) => x.length === 3); + // Il faut attendre que les données soient bien ajoutées avant de progresser avec l'importation. + await données.attendreQue((x) => x.length === 3); - const nouvellesDonnées = [ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-01").valueOf(), - }, - [idsCols[idVarTempMin]]: 25, + const nouvellesDonnées = [ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-01").valueOf(), }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-02").valueOf(), - }, - [idsCols[idVarTempMin]]: 27, + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-02").valueOf(), }, - ]; - await client.tableaux!.importerDonnées({ - idTableau, - données: nouvellesDonnées, - }); + [idsCols[idVarTempMin]]: 27, + }, + ]; + await client.tableaux!.importerDonnées({ + idTableau, + données: nouvellesDonnées, }); + }); - after(async () => { - if (fOublier) await fOublier(); - }); + after(async () => { + if (fOublier) await fOublier(); + }); - it("Données importées correctement", async () => { - const val = await données.attendreQue( - (x) => - x.length === 2 && - !x.some((d) => d.données[idsCols[idVarEndroit]] === "là-bas"), - ); + it("Données importées correctement", async () => { + const val = await données.attendreQue( + (x) => + x.length === 2 && + !x.some((d) => d.données[idsCols[idVarEndroit]] === "là-bas"), + ); - expect(Array.isArray(val)).to.be.true(); - expect(val.length).to.equal(2); - expect( - val - .map((d) => d.données) - .map((d) => { - delete d.id; - return d; - }), - ).to.have.deep.members([ - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-01").valueOf(), - }, - [idsCols[idVarTempMin]]: 25, + expect(Array.isArray(val)).to.be.true(); + expect(val.length).to.equal(2); + expect( + val + .map((d) => d.données) + .map((d) => { + delete d.id; + return d; + }), + ).to.have.deep.members([ + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-01").valueOf(), }, - { - [idsCols[idVarEndroit]]: "ici", - [idsCols[idVarDate]]: { - système: "dateJS", - val: new Date("2021-01-02").valueOf(), - }, - [idsCols[idVarTempMin]]: 27, + [idsCols[idVarTempMin]]: 25, + }, + { + [idsCols[idVarEndroit]]: "ici", + [idsCols[idVarDate]]: { + système: "dateJS", + val: new Date("2021-01-02").valueOf(), }, - ]); - }); + [idsCols[idVarTempMin]]: 27, + }, + ]); }); + }); - describe("Exporter données", function () { - let idTableau: string; - let idVarNumérique: string; - let idVarChaîne: string; - let idVarFichier: string; - let idVarBooléenne: string; + describe("Exporter données", function () { + let idTableau: string; + let idVarNumérique: string; + let idVarChaîne: string; + let idVarFichier: string; + let idVarBooléenne: string; - let idColNumérique: string; - let idColChaîne: string; - let idColFichier: string; - let idColBooléenne: string; + let idColNumérique: string; + let idColChaîne: string; + let idColFichier: string; + let idColBooléenne: string; - let doc: XLSX.WorkBook; - let fichiersSFIP: Set; + let doc: XLSX.WorkBook; + let fichiersSFIP: Set; - let fOublier: schémaFonctionOublier; + let fOublier: schémaFonctionOublier; - const nomTableauFr = "Tableau test"; + const nomTableauFr = "Tableau test"; - before(async () => { - idTableau = await client.tableaux!.créerTableau({ idBd }); - idVarNumérique = await client.variables!.créerVariable({ - catégorie: "numérique", - }); - idVarChaîne = await client.variables!.créerVariable({ - catégorie: "chaîneNonTraductible", - }); - idVarFichier = await client.variables!.créerVariable({ - catégorie: "fichier", - }); - idVarBooléenne = await client.variables!.créerVariable({ - catégorie: "booléen", - }); + before(async () => { + idTableau = await client.tableaux!.créerTableau({ idBd }); + idVarNumérique = await client.variables!.créerVariable({ + catégorie: "numérique", + }); + idVarChaîne = await client.variables!.créerVariable({ + catégorie: "chaîneNonTraductible", + }); + idVarFichier = await client.variables!.créerVariable({ + catégorie: "fichier", + }); + idVarBooléenne = await client.variables!.créerVariable({ + catégorie: "booléen", + }); - idColNumérique = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVarNumérique, - }); - idColChaîne = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVarChaîne, - }); - idColBooléenne = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVarBooléenne, - }); - idColFichier = await client.tableaux!.ajouterColonneTableau({ - idTableau, - idVariable: idVarFichier, - }); + idColNumérique = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable: idVarNumérique, + }); + idColChaîne = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable: idVarChaîne, + }); + idColBooléenne = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable: idVarBooléenne, + }); + idColFichier = await client.tableaux!.ajouterColonneTableau({ + idTableau, + idVariable: idVarFichier, + }); - await client.tableaux!.sauvegarderNomsTableau({ - idTableau, - noms: { - fr: nomTableauFr, - }, - }); + await client.tableaux!.sauvegarderNomsTableau({ + idTableau, + noms: { + fr: nomTableauFr, + }, + }); - await client.variables!.sauvegarderNomsVariable({ - idVariable: idVarNumérique, - noms: { - fr: "Numérique", - हिं: "यह है संख्या", - }, - }); + await client.variables!.sauvegarderNomsVariable({ + idVariable: idVarNumérique, + noms: { + fr: "Numérique", + हिं: "यह है संख्या", + }, + }); - await client.variables!.sauvegarderNomsVariable({ - idVariable: idVarChaîne, - noms: { - fr: "Chaîne", - த: "இது உரை ஆகும்", - }, - }); + await client.variables!.sauvegarderNomsVariable({ + idVariable: idVarChaîne, + noms: { + fr: "Chaîne", + த: "இது உரை ஆகும்", + }, + }); - const éléments: { [key: string]: élémentsBd }[] = [ - { - [idColNumérique]: 123, - [idColChaîne]: "வணக்கம்", - [idColBooléenne]: true, - [idColFichier]: - "QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4", - }, - { - [idColNumérique]: 456, - }, - ]; - for (const élément of éléments) { - await client.tableaux!.ajouterÉlément({ - idTableau, - vals: élément, - }); - } - ({ doc, fichiersSFIP } = await client.tableaux!.exporterDonnées({ + const éléments: { [key: string]: élémentsBd }[] = [ + { + [idColNumérique]: 123, + [idColChaîne]: "வணக்கம்", + [idColBooléenne]: true, + [idColFichier]: + "QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4", + }, + { + [idColNumérique]: 456, + }, + ]; + for (const élément of éléments) { + await client.tableaux!.ajouterÉlément({ idTableau, - langues: ["த", "fr"], - })); - }); + vals: élément, + }); + } + ({ doc, fichiersSFIP } = await client.tableaux!.exporterDonnées({ + idTableau, + langues: ["த", "fr"], + })); + }); - after(async () => { - if (fOublier) await fOublier(); - }); - - it("Langue appropriée pour le nom du tableau", () => { - expect(doc.SheetNames[0]).to.equal(nomTableauFr); - }); - - it("Langue appropriée pour les noms des colonnes", () => { - for (const { cellule } of [ - { cellule: "A1" }, - { cellule: "B1" }, - { cellule: "C1" }, - { cellule: "D1" }, - ]) { - expect([ - "Numérique", - "இது உரை ஆகும்", - idColBooléenne, - idColFichier, - ]).to.contain( - (doc.Sheets[nomTableauFr][cellule] as XLSX.CellObject).v, - ); - } - }); + after(async () => { + if (fOublier) await fOublier(); + }); + + it("Langue appropriée pour le nom du tableau", () => { + expect(doc.SheetNames[0]).to.equal(nomTableauFr); + }); - it("Données numériques exportées", async () => { - const iColNumérique = ["A", "B", "C", "D"].find( - (i) => doc.Sheets[nomTableauFr][`${i}1`].v === "Numérique", + it("Langue appropriée pour les noms des colonnes", () => { + for (const { cellule } of [ + { cellule: "A1" }, + { cellule: "B1" }, + { cellule: "C1" }, + { cellule: "D1" }, + ]) { + expect([ + "Numérique", + "இது உரை ஆகும்", + idColBooléenne, + idColFichier, + ]).to.contain( + (doc.Sheets[nomTableauFr][cellule] as XLSX.CellObject).v, ); - const val = doc.Sheets[nomTableauFr][`${iColNumérique}2`].v; - expect(val).to.equal(123); + } + }); - const val2 = doc.Sheets[nomTableauFr][`${iColNumérique}3`].v; - expect(val2).to.equal(456); - }); + it("Données numériques exportées", async () => { + const iColNumérique = ["A", "B", "C", "D"].find( + (i) => doc.Sheets[nomTableauFr][`${i}1`].v === "Numérique", + ); + const val = doc.Sheets[nomTableauFr][`${iColNumérique}2`].v; + expect(val).to.equal(123); - it("Données chaîne exportées", async () => { - const iColChaîne = ["A", "B", "C", "D"].find( - (i) => doc.Sheets[nomTableauFr][`${i}1`].v === "இது உரை ஆகும்", - ); - const val = doc.Sheets[nomTableauFr][`${iColChaîne}2`].v; - expect(val).to.equal("வணக்கம்"); - }); + const val2 = doc.Sheets[nomTableauFr][`${iColNumérique}3`].v; + expect(val2).to.equal(456); + }); - it("Données booléennes exportées", async () => { - const iColBooléenne = ["A", "B", "C", "D"].find( - (i) => doc.Sheets[nomTableauFr][`${i}1`].v === idColBooléenne, - ); - const val = doc.Sheets[nomTableauFr][`${iColBooléenne}2`].v; - expect(val).to.equal("true"); - }); + it("Données chaîne exportées", async () => { + const iColChaîne = ["A", "B", "C", "D"].find( + (i) => doc.Sheets[nomTableauFr][`${i}1`].v === "இது உரை ஆகும்", + ); + const val = doc.Sheets[nomTableauFr][`${iColChaîne}2`].v; + expect(val).to.equal("வணக்கம்"); + }); - it("Données fichier exportées", async () => { - const iColFichier = ["A", "B", "C", "D"].find( - (i) => doc.Sheets[nomTableauFr][`${i}1`].v === idColFichier, - ); - const val = doc.Sheets[nomTableauFr][`${iColFichier}2`].v; - expect(val).to.equal( - "QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4", - ); - }); + it("Données booléennes exportées", async () => { + const iColBooléenne = ["A", "B", "C", "D"].find( + (i) => doc.Sheets[nomTableauFr][`${i}1`].v === idColBooléenne, + ); + const val = doc.Sheets[nomTableauFr][`${iColBooléenne}2`].v; + expect(val).to.equal("true"); + }); - it("Les fichiers SFIP sont détectés", async () => { - expect(fichiersSFIP.size).to.equal(1); - expect(fichiersSFIP).to.deep.equal( - new Set(["QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4"]), - ); - }); + it("Données fichier exportées", async () => { + const iColFichier = ["A", "B", "C", "D"].find( + (i) => doc.Sheets[nomTableauFr][`${i}1`].v === idColFichier, + ); + const val = doc.Sheets[nomTableauFr][`${iColFichier}2`].v; + expect(val).to.equal( + "QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4", + ); + }); - it("Exporter avec ids des colonnes et du tableau", async () => { - ({ doc } = await client.tableaux!.exporterDonnées({ idTableau })); - const idTableauCourt = idTableau.split("/").pop()!.slice(0, 30); - expect(doc.SheetNames[0]).to.equal(idTableauCourt); - for (const { cellule } of [ - { cellule: "A1" }, - { cellule: "B1" }, - { cellule: "C1" }, - { cellule: "D1" }, - ]) { - expect([ - idColNumérique, - idColChaîne, - idColBooléenne, - idColFichier, - ]).to.contain(doc.Sheets[idTableauCourt][cellule].v); - } - }); + it("Les fichiers SFIP sont détectés", async () => { + expect(fichiersSFIP.size).to.equal(1); + expect(fichiersSFIP).to.deep.equal( + new Set(["QmNR2n4zywCV61MeMLB6JwPueAPqheqpfiA4fLPMxouEmQ.mp4"]), + ); + }); + + it("Exporter avec ids des colonnes et du tableau", async () => { + ({ doc } = await client.tableaux!.exporterDonnées({ idTableau })); + + const idTableauCourt = idTableau.split("/").pop()!.slice(0, 30); + expect(doc.SheetNames[0]).to.equal(idTableauCourt); + for (const { cellule } of [ + { cellule: "A1" }, + { cellule: "B1" }, + { cellule: "C1" }, + { cellule: "D1" }, + ]) { + expect([ + idColNumérique, + idColChaîne, + idColBooléenne, + idColFichier, + ]).to.contain(doc.Sheets[idTableauCourt][cellule].v); + } }); }); });