@constl/utils-tests 1.6.15 → 2.0.0

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,25 @@
-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é } 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";

package/src/libp2p/config.ts

@@ -0,0 +1,115 @@
+/*
+Certaines parties de ce fichier proviennent de @orbitdb/quickstart
+
+MIT License
+
+Copyright (c) 2024 OrbitDB Community
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import {
+  gossipsub,
+  GossipSubComponents,
+  GossipSub,
+} from "@chainsafe/libp2p-gossipsub";
+import { noise } from "@chainsafe/libp2p-noise";
+import { yamux } from "@chainsafe/libp2p-yamux";
+import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
+import { Identify, identify } from "@libp2p/identify";
+import { webRTC } from "@libp2p/webrtc";
+import { webSockets } from "@libp2p/websockets";
+
+import { Libp2pOptions } from "libp2p";
+
+import { PrivateKey } from "@libp2p/interface";
+
+export type ServicesLibp2pTest = {
+  identify: Identify;
+  pubsub: GossipSub;
+  obtClefPrivée: ServiceClefPrivée;
+};
+
+export interface ComposantesServiceClefPrivée {
+  privateKey: PrivateKey;
+}
+
+export class ServiceClefPrivée {
+  privateKey: PrivateKey;
+
+  constructor(components: ComposantesServiceClefPrivée) {
+    this.privateKey = components.privateKey;
+  }
+
+  obtenirClef(): PrivateKey {
+    return this.privateKey;
+  }
+}
+
+/**
+ * Configuration Libp2p pour Node.js.
+ */
+export const OptionsDéfautLibp2pNode: () => Libp2pOptions<ServicesLibp2pTest> =
+  () => {
+    return {
+      addresses: {
+        listen: ["/ip4/0.0.0.0/tcp/0/ws", "/p2p-circuit"],
+      },
+      transports: [webSockets(), webRTC(), circuitRelayTransport()],
+      connectionEncrypters: [noise()],
+      streamMuxers: [yamux()],
+      connectionGater: {
+        denyDialMultiaddr: () => false,
+      },
+      services: {
+        identify: identify(),
+        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
+          components: GossipSubComponents,
+        ) => GossipSub, // Erreur de type dans @chainsafe/pubsub
+        obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
+          new ServiceClefPrivée(components),
+      },
+    };
+  };
+
+/**
+ * Configuration Libp2p pour les navigateurs.
+ */
+export const OptionsDéfautLibp2pNavigateur: () => Libp2pOptions<ServicesLibp2pTest> =
+  () => {
+    return {
+      addresses: {
+        listen: ["/webrtc", "/p2p-circuit"],
+      },
+      transports: [webSockets(), webRTC(), circuitRelayTransport()],
+      connectionEncrypters: [noise()],
+      streamMuxers: [yamux()],
+      connectionGater: {
+        denyDialMultiaddr: () => false,
+      },
+      services: {
+        identify: identify(),
+        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
+          components: GossipSubComponents,
+        ) => GossipSub, // Erreur de type dans @chainsafe/pubsub,
+        obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
+          new ServiceClefPrivée(components),
+      },
+    };
+  };

package/src/libp2p/index.ts

@@ -0,0 +1,9 @@
+export {
+  ServicesLibp2pTest,
+  ComposantesServiceClefPrivée,
+  ServiceClefPrivée,
+  OptionsDéfautLibp2pNode,
+  OptionsDéfautLibp2pNavigateur,
+} from "./config.js";
+export { créerLibp2psTest } from "./libp2p.js";
+export { connecterPairs, toutesConnectées } from "./utils.js";

package/src/libp2p/libp2p.ts

@@ -0,0 +1,41 @@
+import { Libp2p } from "@libp2p/interface";
+import { createLibp2p } from "libp2p";
+import {
+  OptionsDéfautLibp2pNavigateur,
+  OptionsDéfautLibp2pNode,
+  ServicesLibp2pTest,
+} from "./config.js";
+import { isBrowser } from "wherearewe";
+import { connecterPairs } from "./utils.js";
+import { obtenirAdresseRelai } from "../relai/index.js";
+
+export const créerLibp2psTest = async ({
+  n,
+  adresseRelai,
+}: {
+  n: number;
+  adresseRelai?: string;
+}): Promise<{
+  libp2ps: Libp2p<ServicesLibp2pTest>[];
+  fermer: () => Promise<void>;
+}> => {
+  adresseRelai = adresseRelai ?? obtenirAdresseRelai();
+
+  const libp2ps: Libp2p<ServicesLibp2pTest>[] = [];
+  for (const _ of Array(n).keys()) {
+    const libp2p = await createLibp2p(
+      isBrowser ? OptionsDéfautLibp2pNavigateur() : OptionsDéfautLibp2pNode(),
+    );
+
+    for (const l of libp2ps) {
+      await connecterPairs(libp2p, l, { adresseRelai });
+    }
+    libp2ps.push(libp2p);
+  }
+
+  const fermer = async () => {
+    await Promise.all(libp2ps.map((l) => l.stop()));
+  };
+
+  return { libp2ps, fermer };
+};

package/src/libp2p/utils.ts

@@ -0,0 +1,59 @@
+import { Libp2p } from "@libp2p/interface";
+import { WebRTC } from "@multiformats/multiaddr-matcher";
+import { multiaddr, Multiaddr } from "@multiformats/multiaddr";
+import { isBrowser, isElectronRenderer } from "wherearewe";
+import { ServicesLibp2pTest } from "./config.js";
+
+const filtreParDéfaut = () => true;
+
+type OptionsConnectionPairs = {
+  adresseRelai: string;
+  filtre?: (ma: Multiaddr) => boolean;
+};
+export const connecterPairs = async <
+  T extends Libp2p = Libp2p<ServicesLibp2pTest>,
+>(
+  libp2p1: T,
+  libp2p2: T,
+  options: OptionsConnectionPairs,
+) => {
+  const filtre = options.filtre ?? filtreParDéfaut;
+
+  if (isBrowser || isElectronRenderer) {
+    await libp2p1.dial(multiaddr(options.adresseRelai));
+
+    const adresse1 = await new Promise<Multiaddr>((resolve) => {
+      const testConnecté = () => {
+        const adresse = libp2p1
+          .getMultiaddrs()
+          .filter((ma) => WebRTC.matches(ma) && filtre(ma))
+          .pop();
+        if (adresse != null) {
+          clearInterval(interval);
+          resolve(adresse);
+        }
+      };
+      const interval = setInterval(testConnecté, 100);
+      testConnecté();
+    });
+    await libp2p2.dial(adresse1);
+  } else {
+    await libp2p2.peerStore.save(libp2p1.peerId, {
+      multiaddrs: libp2p1.getMultiaddrs().filter(filtre),
+    });
+    await libp2p2.dial(libp2p1.peerId);
+  }
+};
+
+export const toutesConnectées = async (
+  libp2ps: Libp2p<ServicesLibp2pTest>[],
+  options: OptionsConnectionPairs,
+) => {
+  const connectées: Libp2p<ServicesLibp2pTest>[] = [];
+  for (const lib of libp2ps) {
+    for (const autre of connectées) {
+      await connecterPairs(lib, autre, options);
+    }
+    connectées.push(lib);
+  }
+};

package/src/orbite.ts

@@ -1,236 +1,56 @@
-/*
-Certaines parties de ce fichier proviennent d'OrbitDB et de @orbitdb/quickstart
-
-MIT License
-
-Copyright (c) 2019 Haja Networks Oy
-Copyright (c) 2024 OrbitDB Community
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-import type { HeliaLibp2p } from "helia";
-import type {
-  Identity,
-  OrbitDB,
-  Database,
-  IdentitiesType,
-} from "@orbitdb/core";
-import type { TypedKeyValue, TypedFeed, TypedSet } from "@constl/bohr-db";
-import { once } from "events";
-
-import { dossierTempo } from "@/dossiers.js";
-import { connecterPairs } from "@/sfip.js";
-import { isNode, isElectronMain } from "wherearewe";
-
-import { createHelia } from "helia";
-import { Libp2p, createLibp2p } from "libp2p";
-import { createOrbitDB } from "@orbitdb/core";
-import { LevelBlockstore } from "blockstore-level";
-import { bitswap } from "@helia/block-brokers";
-import {
-  DefaultLibp2pOptions,
-  DefaultLibp2pBrowserOptions,
-  type ServicesLibp2pConstlTest,
-} from "./libp2p.js";
-import type { ServiceMap } from "@libp2p/interface";
-
-const isBrowser = () => typeof window !== "undefined";
-
-const startOrbitDB = async ({
-  id,
-  identity,
-  identities,
-  directory,
-}: {
-  id?: string;
-  identity?: Identity;
-  identities?: IdentitiesType;
-  directory?: string;
-} = {}) => {
-  const options = isBrowser()
-    ? DefaultLibp2pBrowserOptions
-    : DefaultLibp2pOptions;
-  const libp2p = await createLibp2p({ ...options });
-  directory = directory || ".";
-  const blockstore = new LevelBlockstore(`${directory}/ipfs/blocs`);
-  const ipfs = await createHelia({
-    libp2p,
-    blockstore,
-    blockBrokers: [bitswap()],
-  });
-  const orbitdb = await createOrbitDB({
-    ipfs,
-    id,
-    identity,
-    identities,
-    directory,
-  });
-  return orbitdb;
-};
-
-const stopOrbitDB = async (orbitdb: OrbitDB<ServicesLibp2pConstlTest>) => {
-  await orbitdb.stop();
-  await orbitdb.ipfs.stop();
-  // @ts-expect-error Je ne sais pas pourquoi
-  await orbitdb.ipfs.blockstore.unwrap().unwrap().child.db.close();
-};
-
-export const créerOrbiteTest = async ({
-  n = 1,
+import { OrbitDB, createOrbitDB } from "@orbitdb/core";
+import { dossierTempo } from "./dossiers.js";
+import { ServicesLibp2pTest } from "./libp2p/index.js";
+import { créerHéliasTest } from "./hélia.js";
+import { join } from "path";
+import { sousDossier } from "./utils.js";
+import { obtenirAdresseRelai } from "./relai/utils.js";
+
+export const créerOrbitesTest = async ({
+  n,
+  dossier,
+  adresseRelai,
 }: {
   n: number;
+  dossier?: string;
+  adresseRelai?: string;
 }): Promise<{
-  orbites: OrbitDB<ServicesLibp2pConstlTest>[];
-  fOublier: () => Promise<void>;
+  orbites: OrbitDB<ServicesLibp2pTest>[];
+  fermer: () => Promise<void>;
 }> => {
-  const sfips: HeliaLibp2p<Libp2p<ServicesLibp2pConstlTest>>[] = [];
-  const orbites: OrbitDB<ServicesLibp2pConstlTest>[] = [];
-
-  const {
-    dossier: racineDossierOrbite,
-    fEffacer: fEffacerRacineDossierOrbite,
-  } = await dossierTempo();
+  adresseRelai = adresseRelai ?? obtenirAdresseRelai();
 
-  const _générer = async (i: number): Promise<void> => {
-    const racineDossier = `${racineDossierOrbite}/${i}`;
-    const orbite = await startOrbitDB({
-      directory: `${racineDossier}/orbite`,
-    });
-    for (const ip of sfips) {
-      await connecterPairs(orbite.ipfs, ip);
-    }
-    sfips.push(orbite.ipfs);
-
-    orbites.push(orbite);
-  };
-
-  await Promise.all([...Array(n).keys()].map((i) => _générer(i)));
-
-  const fOublier = async () => {
-    for (const o of orbites) await stopOrbitDB(o);
-
-    try {
-      fEffacerRacineDossierOrbite();
-    } catch (e) {
-      // Sur Windows, parfois les fichiers de Hélia sont encore en utilisation
-      if ((isNode || isElectronMain) && process.platform === "win32") {
-        console.log("On ignore ça sur Windows\n", e);
-        return;
-      } else {
-        throw e;
-      }
-    }
-  };
-  return { orbites, fOublier };
-};
-
-export const attendreSync = async (
-  bd: Awaited<ReturnType<typeof Database>>,
-): Promise<void> => {
-  await once(bd.events, "update");
-};
-
-export type ContrôleurConstellation = {
-  type: string;
-  address: string;
-  adresseBdAccès: string;
-  write: string;
-  estAutorisé: (id: string) => Promise<boolean>;
-  grant: (rôle: "MODÉRATEUR" | "MEMBRE", id: string) => Promise<void>;
-  revoke: (_rôle: "MODÉRATEUR" | "MEMBRE", _id: string) => Promise<void>;
-  bd: Awaited<ReturnType<typeof Database>>;
-};
+  let effacerDossier: () => void = () => {};
+  if (!dossier) {
+    ({ dossier, effacer: effacerDossier } = await dossierTempo());
+  }
 
-const attendreInvité = (
-  accès: ContrôleurConstellation,
-  idInvité: string,
-): Promise<void> =>
-  new Promise<void>((résoudre) => {
-    const testAutorisé = async () => {
-      const autorisé = await accès.estAutorisé(idInvité);
-      if (autorisé) {
-        résoudre();
-      } else {
-        setTimeout(testAutorisé, 100);
-      }
-    };
-    testAutorisé();
+  const orbites: OrbitDB<ServicesLibp2pTest>[] = [];
+  const { hélias, fermer: fermerHélias } = await créerHéliasTest({
+    n,
+    dossier,
+    adresseRelai,
   });
 
-export const peutÉcrire = async <T extends ServiceMap = ServiceMap>(
-  bd:
-    | TypedKeyValue<{ [clef: string]: number }>
-    | TypedFeed<string>
-    | TypedSet<string>,
-  attendre?: OrbitDB<T>,
-): Promise<boolean> => {
-  if (attendre) {
-    await attendreInvité(
-      bd.access as unknown as ContrôleurConstellation,
-      attendre.identity.id,
+  let i = 0;
+  for (const hélia of hélias) {
+    orbites.push(
+      await createOrbitDB({
+        ipfs: hélia,
+        directory: join(sousDossier({ dossier, i }), "orbite"),
+      }),
     );
+    i++;
   }
 
-  try {
-    if (bd.type === "keyvalue") {
-      const bdKV = bd as TypedKeyValue<{ [clef: string]: number }>;
-
-      // Important d'avoir une clef unique pour éviter l'interférence entre les tests
-      const CLEF = "test" + Math.random().toString();
-      const VAL = 123;
-
-      await bdKV.set(CLEF, VAL);
-      const val = await bdKV.get(CLEF);
-
-      await bdKV.del(CLEF);
-      return val === VAL;
-    } else if (bd.type === "feed") {
-      const VAL = "test";
-
-      await (bd as TypedFeed<string>).add(VAL);
-      const éléments = await (bd as TypedFeed<string>).all();
-
-      const autorisé = éléments.length === 1 && éléments[0].value === VAL;
-      if (éléments.length === 1) {
-        await (bd as TypedFeed<string>).remove(éléments[0].hash);
-      }
-      return autorisé;
-    } else if (bd.type === "set") {
-      const VAL = "test";
-
-      await bd.add(VAL);
-      const éléments = await bd.all();
+  const fermer = async () => {
+    await Promise.all(orbites.map((o) => o.stop()));
+    await fermerHélias();
+    effacerDossier();
+  };
 
-      const autorisé = éléments.length === 1 && éléments[0].value === VAL;
-      if (éléments.length === 1) {
-        await bd.del(éléments[0].hash);
-      }
-      return autorisé;
-    } else {
-      // @ts-expect-error bd.type n'a plus d'options
-      throw new Error(`Type de BD ${bd.type} non supporté par ce test.`);
-    }
-  } catch (e) {
-    if (e.toString().includes("is not allowed to write to the log")) {
-      return false;
-    }
-    throw e;
-  }
+  return {
+    orbites,
+    fermer,
+  };
 };