@constl/utils-tests 1.7.0 → 2.0.1

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const sousDossier: ({ dossier, i }: {
+    dossier: string;
+    i: number;
+}) => string;

package/dist/utils.js

@@ -0,0 +1,5 @@
+import { join } from "path";
+export const sousDossier = ({ dossier, i }) => {
+    return join(dossier, i.toString());
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,EAAkC,EAAE,EAAE;IAC5E,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;AACrC,CAAC,CAAC"}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.0";
+export declare const version = "2.0.1";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = "1.7.0";
+export const version = "2.0.1";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.7.0",
+  "version": "2.0.1",
   "license": "AGPL-3.0-or-later",
   "name": "@constl/utils-tests",
   "author": "Julien Jean Malard-Adam",

package/src/attente.ts

@@ -1,165 +1,138 @@
-import { EventEmitter } from "events";
-import { v4 as uuidv4 } from "uuid";
-import { isBrowser, isWebWorker } from "wherearewe";
-import type { Download } from "playwright";
-
-export class AttendreRésultat<T> {
-  val?: T;
-  fsOublier: { [clef: string]: () => void };
-  événements: EventEmitter;
-
-  constructor() {
-    this.événements = new EventEmitter();
-    this.val = undefined;
-    this.fsOublier = {};
-  }
-
-  mettreÀJour(x?: T) {
-    this.val = x;
-    this.événements.emit("changé");
-  }
-
-  async attendreQue(f: (x: T) => boolean | Promise<boolean>): Promise<T> {
-    if (this.val !== undefined && (await f(this.val))) return this.val;
-    const id = uuidv4();
-
-    return new Promise((résoudre) => {
-      const fLorsqueChangé = async () => {
-        if (this.val !== undefined && (await f(this.val))) {
-          this.oublier(id);
-          résoudre(this.val);
-        }
-      };
-      this.événements.on("changé", fLorsqueChangé);
-      this.fsOublier[id] = () => this.événements.off("changé", fLorsqueChangé);
-    });
-  }
-
-  async attendreExiste(): Promise<T> {
-    const val = (await this.attendreQue((x) => !!x)) as T;
-    return val;
-  }
-
-  async attendreNexistePas(): Promise<void> {
-    if (this.val === undefined) return;
-
-    const id = uuidv4();
-
-    return new Promise((résoudre) => {
-      const fLorsqueChangé = async () => {
-        if (this.val === undefined) {
-          this.oublier(id);
-          résoudre();
-        }
-      };
-      this.événements.on("changé", fLorsqueChangé);
-      this.fsOublier[id] = () => this.événements.off("changé", fLorsqueChangé);
-    });
-  }
-
-  oublier(id: string) {
-    this.fsOublier[id]();
-    delete this.fsOublier[id];
-  }
-
-  toutAnnuler() {
-    Object.keys(this.fsOublier).forEach((id) => this.oublier(id));
+import { isBrowser, isElectronRenderer } from "wherearewe";
+
+export const que = async <T>(
+  f: () => T | Promise<T | undefined>,
+  t = 100,
+): Promise<void> => {
+  return new Promise((résoudre) => {
+    const testF = async () => {
+      const résultat = await f();
+      if (résultat) {
+        résoudre();
+      } else {
+        setTimeout(testF, t);
+      }
+    };
+    testF();
+  });
+};
+
+export const attendreFichierExiste = async ({
+  fichier,
+  signal,
+}: {
+  fichier: string;
+  signal?: AbortSignal;
+}): Promise<boolean> => {
+  if (isBrowser || isElectronRenderer) {
+    throw new Error("Test non disponible dans le navigateur.");
   }
-}
-
-export class AttendreFichierExiste extends EventEmitter {
-  fOublier?: () => void;
+  const chokidar = await import("chokidar");
+  const fs = await import("fs");
+  const path = await import("path");
+
+  return new Promise<boolean>((résoudre) => {
+    // Arrêter tout de suite si le fichier existe déjà
+    if (fs.existsSync(fichier)) résoudre(true);
+
+    // Actions signal
+    const lorsqueAvorté = () => {
+      fermerEtRésoudre(false);
+    };
+
+    // Actions écouteur de fichiers
+    const dossier = path.dirname(fichier);
+    const écouteur = chokidar.watch(dossier);
+    const fermerÉcouteur = async () => await écouteur.close();
+
+    const lorsquFichierAjouté = () => {
+      if (fs.existsSync(fichier)) {
+        fermerEtRésoudre(true);
+      }
+    };
+
+    // Fermeture des écouteurs
+    const fermerEtRésoudre = async (statut: boolean) => {
+      signal?.removeEventListener("abort", lorsqueAvorté);
+      écouteur.off("add", lorsquFichierAjouté);
+      await fermerÉcouteur();
+
+      résoudre(statut);
+    };
+
+    signal?.addEventListener("abort", lorsqueAvorté);
+
+    écouteur.on("add", lorsquFichierAjouté);
+    if (signal?.aborted) fermerEtRésoudre(false);
+
+    if (fs.existsSync(fichier)) fermerEtRésoudre(true);
+  });
+};
+
+export const attendreFichierModifié = async ({
+  fichier,
+  condition,
+  signal,
+}: {
   fichier: string;
-  attenteTéléchargement?: Promise<Download>;
-
-  constructor(fichier: string) {
-    super();
-    this.fichier = fichier;
+  condition?: () => Promise<boolean>;
+  signal?: AbortSignal;
+}) => {
+  if (isBrowser || isElectronRenderer) {
+    throw new Error("Test non disponible dans le navigateur.");
   }
 
-  async attendre(): Promise<void> {
-    if (isBrowser || isWebWorker) {
-      throw new Error("Test non disponible dans le navigateur.");
-    } else {
-      const chokidar = await import("chokidar");
-      const fs = await import("fs");
-      const path = await import("path");
-
-      await new Promise<void>((résoudre) => {
-        if (fs.existsSync(this.fichier)) résoudre();
-        const dossier = path.dirname(this.fichier);
-        const écouteur = chokidar.watch(dossier);
-        this.fOublier = () => écouteur.close();
-        écouteur.on("add", async () => {
-          if (fs.existsSync(this.fichier)) {
-            await écouteur.close();
-            résoudre();
-          }
-        });
-        if (fs.existsSync(this.fichier)) {
-          écouteur.close();
-          résoudre();
+  await attendreFichierExiste({ fichier, signal });
+  const tempsAvant = Date.now();
+
+  const chokidar = await import("chokidar");
+  const fs = await import("fs");
+
+  return new Promise((résoudre) => {
+    // Actions signal
+    const lorsqueAvorté = () => {
+      fermerEtRésoudre(false);
+    };
+
+    // Actions écouteur de fichiers
+    const écouteur = chokidar.watch(fichier);
+    const fermerÉcouteur = async () => await écouteur.close();
+    const lorsqueModifié = async (adresse: string) => {
+      if (adresse !== fichier) return;
+      await vérifierModifié();
+    };
+
+    const fermerEtRésoudre = async (statut: boolean) => {
+      clearInterval(intervale);
+      signal?.removeEventListener("abort", lorsqueAvorté);
+      écouteur.off("change", lorsqueModifié);
+      await fermerÉcouteur();
+
+      résoudre(statut);
+    };
+
+    const vérifierModifié = async () => {
+      try {
+        const { mtime } = fs.statSync(fichier);
+        const prêt = mtime.getTime() > tempsAvant;
+
+        if (prêt && (!condition || (await condition()))) {
+          fermerEtRésoudre(true);
         }
-      });
-    }
-  }
+      } catch {
+        // Le fichier a été effacé
+        await fermerEtRésoudre(false);
+      }
+    };
 
-  annuler() {
-    this.fOublier?.();
-  }
-}
+    signal?.addEventListener("abort", lorsqueAvorté);
 
-export class AttendreFichierModifié extends EventEmitter {
-  fsOublier: (() => void)[];
-  fichier: string;
-  attendreExiste: AttendreFichierExiste;
-
-  constructor(fichier: string) {
-    super();
-    this.fichier = fichier;
-    this.attendreExiste = new AttendreFichierExiste(fichier);
-    this.fsOublier = [];
-    this.fsOublier.push(() => this.attendreExiste.annuler());
-  }
+    écouteur.on("change", lorsqueModifié);
+    écouteur.on("unlink", lorsqueModifié);
 
-  async attendre(
-    tempsAvant: number,
-    condition?: () => Promise<boolean>,
-  ): Promise<void> {
-    await this.attendreExiste.attendre();
-    const chokidar = await import("chokidar");
-    const fs = await import("fs");
-    return new Promise((résoudre, rejeter) => {
-      const écouteur = chokidar.watch(this.fichier);
-      this.fsOublier.push(() => écouteur.close());
-
-      const vérifierModifié = async () => {
-        try {
-          const { mtime } = fs.statSync(this.fichier);
-          const prêt = mtime.getTime() > tempsAvant;
-
-          if (prêt && (!condition || (await condition()))) {
-            await écouteur.close();
-            clearInterval(intervale);
-            résoudre();
-          }
-        } catch (e) {
-          // Le fichier a été effacé
-          écouteur.close();
-          rejeter(e);
-        }
-      };
-
-      écouteur.on("change", async (adresse) => {
-        if (adresse !== this.fichier) return;
-        await vérifierModifié();
-      });
-      // Parfois, on dirait que chokidar ne détecte pas l'événement...
-      const intervale = setInterval(vérifierModifié, 1000);
-    });
-  }
+    if (signal?.aborted) fermerEtRésoudre(false);
 
-  annuler() {
-    this.fsOublier.forEach((f) => f());
-  }
-}
+    // Parfois, on dirait que chokidar ne détecte pas l'événement...
+    const intervale = setInterval(vérifierModifié, 1000);
+  });
+};

package/src/config.ts

@@ -1,7 +1,7 @@
 import type { PartialOptions } from "aegir";
 import type { BuildOptions } from "esbuild";
 
-import { lancerRelai } from "./sfip.js";
+import { lancerRelai } from "./relai/index.js";
 
 export const obtConfigEsbuild = async (): Promise<BuildOptions> => {
   const { createRequire } = (await import("module")).default;
@@ -11,7 +11,7 @@ export const obtConfigEsbuild = async (): Promise<BuildOptions> => {
   const __dirname = path.dirname(fileURLToPath(import.meta.url));
   const require = createRequire(import.meta.url);
   const configEsbuild: BuildOptions = {
-    // this will inject all the named exports from 'node-globals.js' as globals
+    // ceci injecte les exportations nomées de 'node-globals.js' en tant que variables globales
     inject: [path.join(__dirname, "./scripts/node-globals.js")],
     plugins: [
       {
@@ -64,7 +64,13 @@ type RetourAvant = {
   relai?: () => void;
 };
 
-export const générerConfigÆgir = async (): Promise<PartialOptions> => {
+export const générerConfigÆgir = async ({
+  portDéfautRelai,
+  clefPrivéeRelai,
+}: {
+  portDéfautRelai?: string;
+  clefPrivéeRelai?: string;
+} = {}): Promise<PartialOptions> => {
   const esbuild = await obtConfigEsbuild();
   return {
     test: {
@@ -72,7 +78,7 @@ export const générerConfigÆgir = async (): Promise<PartialOptions> => {
       before: async (opts): Promise<RetourAvant> => {
         let relai = undefined;
         if (opts.target.includes("browser")) {
-          relai = await lancerRelai();
+          relai = await lancerRelai({ portDéfautRelai, clefPrivéeRelai });
         }
 
         return { relai };

package/src/constellation.ts

@@ -1,79 +1,58 @@
-import type { réseau, client, Constellation } from "@constl/ipa";
-import type { OrbitDB } from "@orbitdb/core";
 import { isBrowser } from "wherearewe";
-import { créerConstellation as _créerConstellation } from "@constl/ipa";
+import { créerOrbitesTest } from "./orbite.js";
+import { dossierTempo } from "./dossiers.js";
+import { OrbitDB } from "@orbitdb/core";
 
-import { créerOrbiteTest } from "@/orbite.js";
-import { AttendreRésultat } from "@/attente.js";
-import type { ServicesLibp2pConstlTest } from "./libp2p";
+interface InterfaceConstellation {
+  fermer: () => Promise<void>;
+}
+
+interface OptionsConstellation {
+  dossier?: string;
+  orbite?: OrbitDB;
+}
 
 export const créerConstellationsTest = async <
-  T = Constellation,
-  U = client.optsConstellation,
+  T extends InterfaceConstellation,
 >({
   n = 1,
-  créerConstellation = _créerConstellation as unknown as (opts: U) => T,
+  créerConstellation,
+  dossier,
 }: {
   n: number;
-  créerConstellation: (opts: U) => T;
+  créerConstellation: (opts: OptionsConstellation) => T;
+  dossier?: string;
 }): Promise<{
-  clients: ReturnType<typeof créerConstellation>[];
-  orbites: OrbitDB<ServicesLibp2pConstlTest>[];
-  fOublier: () => Promise<void>;
+  constls: T[];
+  fermer: () => Promise<void>;
 }> => {
-  const clients: ReturnType<typeof créerConstellation>[] = [];
-  const fsOublier: (() => Promise<void>)[] = [];
-
-  // Nécessaire pour Playwright
-  if (isBrowser) window.localStorage.clear();
+  let effacerDossier: () => void = () => {};
+  if (!dossier) {
+    ({ dossier, effacer: effacerDossier } = await dossierTempo());
+  }
 
-  const { orbites, fOublier: fOublierOrbites } = await créerOrbiteTest({ n });
-  fsOublier.push(fOublierOrbites);
+  const { orbites, fermer: fermerOrbites } = await créerOrbitesTest({
+    n,
+    dossier,
+  });
 
+  const constls: T[] = [];
   for (const i in [...Array(n).keys()]) {
-    const client = créerConstellation({
+    const constl = créerConstellation({
       orbite: orbites[i],
-      dossier: orbites[i].directory.split("/").slice(0, -1).join("/"),
-    } as U);
-    clients.push(client);
+      dossier,
+    });
+    constls.push(constl);
   }
 
-  const fOublier = async () => {
-    for (const client of clients) await (client as Constellation).fermer();
-    await Promise.all(fsOublier.map((f) => f()));
-  };
-  return { fOublier, clients, orbites };
-};
-
-export const constellationConnectéeÀ = async (
-  constellation: client.Constellation,
-  connectéeÀ: client.Constellation,
-): Promise<void> => {
-  const dispositifsConnectés = new AttendreRésultat<
-    réseau.statutDispositif[]
-  >();
-  const idCompte2 = await connectéeÀ.obtIdCompte();
+  const fermer = async () => {
+    for (const constl of constls) await constl.fermer();
 
-  const fOublier = await constellation.réseau.suivreConnexionsDispositifs({
-    f: (dispositifs) => dispositifsConnectés.mettreÀJour(dispositifs),
-  });
-  await dispositifsConnectés.attendreQue((dispositifs) => {
-    return !!dispositifs.find((d) => d.infoDispositif.idCompte === idCompte2);
-  });
-  await fOublier();
-  return;
-};
+    await fermerOrbites();
+    effacerDossier();
 
-export const constellationsConnectées = async (
-  ...clients: client.Constellation[]
-): Promise<void> => {
-  if (clients.length < 2) return;
-  const promesses: Promise<void>[] = [];
-  for (let i = 1; i < clients.length; i++) {
-    for (let j = 0; j < i; j++) {
-      promesses.push(constellationConnectéeÀ(clients[i], clients[j]));
-      promesses.push(constellationConnectéeÀ(clients[j], clients[i]));
-    }
-  }
-  await Promise.all(promesses);
+    // Nécessaire pour Playwright
+    if (isBrowser) window.localStorage.clear();
+  };
+  return { constls, fermer };
 };

package/src/dossiers.ts

@@ -3,7 +3,7 @@ import { v4 as uuidv4 } from "uuid";
 
 export const dossierTempo = async (): Promise<{
   dossier: string;
-  fEffacer: () => void;
+  effacer: () => void;
 }> => {
   if (isNode || isElectronMain) {
     const fs = await import("fs");
@@ -11,14 +11,26 @@ export const dossierTempo = async (): Promise<{
     const os = await import("os");
     const sync = (await import("rimraf")).sync;
 
-    const dossier = fs.mkdtempSync(path.join(os.tmpdir(), "constl-ipa-"));
-    const fEffacer = () => sync(dossier);
-    return { dossier, fEffacer };
+    const dossier = fs.mkdtempSync(path.join(os.tmpdir(), "constl-"));
+    const effacer = () => {
+      try {
+        sync(dossier);
+      } catch (e) {
+        // Sur Windows, parfois les fichiers de Hélia sont encore en utilisation
+        if (process.platform === "win32") {
+          console.log("On ignore ça sur Windows\n", e);
+          return;
+        } else {
+          throw e;
+        }
+      }
+    };
+    return { dossier, effacer };
   } else {
-    const dossier = uuidv4() + "/constl-ipa";
+    const dossier = uuidv4() + "/constl-";
     return {
       dossier,
-      fEffacer: () => {
+      effacer: () => {
         // Rien à faire, je crois
       },
     };

package/src/h/303/251lia.ts

@@ -0,0 +1,61 @@
+import { Helia, createHelia } from "helia";
+import { ServicesLibp2pTest, créerLibp2psTest } from "./libp2p/index.js";
+import { Libp2p } from "@libp2p/interface";
+import { bitswap } from "@helia/block-brokers";
+import { MemoryBlockstore } from "blockstore-core";
+import { join } from "path";
+import { sousDossier } from "./utils.js";
+import { LevelBlockstore } from "blockstore-level";
+import { obtenirAdresseRelai } from "./relai/index.js";
+
+export const créerHéliasTest = async ({
+  n,
+  dossier,
+  adresseRelai,
+}: {
+  n: number;
+  dossier?: string;
+  adresseRelai?: string;
+}): Promise<{
+  hélias: Helia<Libp2p<ServicesLibp2pTest>>[];
+  fermer: () => Promise<void>;
+}> => {
+  adresseRelai = adresseRelai ?? obtenirAdresseRelai();
+
+  const { libp2ps, fermer: fermerLibsp2p } = await créerLibp2psTest({
+    n,
+    adresseRelai,
+  });
+
+  let i = 0;
+  const hélias = await Promise.all(
+    libp2ps.map(async (libp2p) => {
+      const blockstore = dossier
+        ? new LevelBlockstore(
+            join(sousDossier({ dossier, i }), "hélia", "blocks"),
+          )
+        : new MemoryBlockstore();
+      i++;
+
+      const optionsHélia = {
+        blockstore,
+        libp2p,
+        blockBrokers: [bitswap()],
+      };
+      return await createHelia(optionsHélia);
+    }),
+  );
+
+  const fermer = async () => {
+    await Promise.all(
+      hélias.map(async (h) => {
+        await h.stop();
+        // @ts-expect-error Je ne sais pas pourquoi
+        await h.blockstore.unwrap()?.unwrap()?.child?.db?.close();
+      }),
+    );
+    await fermerLibsp2p();
+  };
+
+  return { hélias, fermer };
+};

package/src/index.ts

@@ -1,9 +1,29 @@
-export * as attente from "@/attente.js";
-export * as constellation from "@/constellation.js";
-export * as dossiers from "@/dossiers.js";
-export * as orbite from "@/orbite.js";
-export * as sfip from "@/sfip.js";
-export * as config from "@/config.js";
-export * as libp2p from "@/libp2p.js";
+export {
+  ServicesLibp2pTest,
+  ComposantesServiceClefPrivée,
+  ServiceClefPrivée,
+  OptionsDéfautLibp2pNode,
+  OptionsDéfautLibp2pNavigateur,
+  créerLibp2psTest,
+  toutesConnectées,
+  connecterPairs,
+} from "./libp2p/index.js";
 
-export { version } from "@/version.js";
+export {
+  ID_DÉFAUT_RELAI,
+  PORT_DÉFAUT_RELAI,
+  obtenirAdresseRelai,
+  lancerRelai,
+  obtenirFichierRelai,
+} from "./relai/index.js";
+
+export {
+  attendreFichierExiste,
+  attendreFichierModifié,
+  que,
+} from "./attente.js";
+export { obtConfigEsbuild, générerConfigÆgir } from "./config.js";
+export { créerConstellationsTest } from "./constellation.js";
+export { dossierTempo } from "./dossiers.js";
+export { créerHéliasTest } from "./hélia.js";
+export { créerOrbitesTest } from "./orbite.js";