@constl/utils-tests 0.1.0

package/src/client.ts

@@ -0,0 +1,127 @@
+import OrbitDB from "orbit-db";
+import { initierSFIP, arrêterSFIP } from "@/sfip.js";
+import type { IPFS } from "ipfs-core";
+import { client, générerClient } from "@constl/ipa";
+import { isBrowser } from "wherearewe";
+
+import { connectPeers } from "@/orbitDbTestUtils.js";
+import { dossierTempoTests } from "@/dossiers.js";
+
+const { ClientConstellation } = client;
+
+export const générerOrbites = async (
+  n = 1
+): Promise<{ orbites: OrbitDB[]; fOublier: () => Promise<void> }> => {
+  const sfips: IPFS[] = [];
+  const orbites: OrbitDB[] = [];
+
+  const {
+    dossier: racineDossierOrbite,
+    fEffacer: fEffacerRacineDossierOrbite,
+  } = await dossierTempoTests();
+
+  fEffacerRacineDossierOrbite();
+
+  const _générer = async (i: number): Promise<void> => {
+    const racineDossier = `${racineDossierOrbite}/${i}`;
+    const sfip = await initierSFIP(`${racineDossier}/sfip`);
+    const orbite = await OrbitDB.createInstance(sfip, {
+      directory: `${racineDossier}/orbite`,
+    });
+
+    for (const ip of sfips) {
+      await connectPeers(sfip, ip);
+    }
+
+    sfips.push(sfip);
+    orbites.push(orbite);
+  };
+
+  await Promise.all([...Array(n).keys()].map((i) => _générer(i)));
+
+  const fOublier = async () => {
+    await Promise.all(
+      orbites.map(async (orbite) => {
+        await orbite.stop();
+      })
+    );
+
+    await Promise.all(
+      sfips.map(async (d) => {
+        await arrêterSFIP(d);
+      })
+    );
+
+    fEffacerRacineDossierOrbite();
+  };
+  return { orbites, fOublier };
+};
+
+export type typeClient = "directe" | "proc" | "travailleur";
+
+export const générerClients = async (
+  n = 1,
+  type: typeClient = "directe"
+): Promise<{
+  clients: client.ClientConstellation[];
+  fOublier: () => Promise<void>;
+}> => {
+  const clients: client.ClientConstellation[] = [];
+  const fsOublier: (() => Promise<void>)[] = [];
+  // Nécessaire pour Playwright
+  if (isBrowser) window.localStorage.clear();
+
+  if (type === "directe" || type == "proc") {
+    const { orbites, fOublier: fOublierOrbites } = await générerOrbites(n);
+    fsOublier.push(fOublierOrbites);
+
+    for (const i in [...Array(n).keys()]) {
+      let client: client.ClientConstellation;
+      switch (type) {
+        case "directe": {
+          client = await ClientConstellation.créer({
+            orbite: orbites[i],
+          });
+          break;
+        }
+
+        case "proc": {
+          client = générerClient({
+            opts: { orbite: orbites[i] },
+            mandataire: "proc"
+          });
+          break;
+        }
+
+        default:
+          throw new Error(type);
+      }
+      clients.push(client);
+    }
+  } else if (type === "travailleur") {
+    let client: client.ClientConstellation;
+    for (const i in [...Array(n).keys()]) {
+      client = générerClient({
+        opts: { orbite: { dossier: String(i) } },
+        mandataire: "travailleur"
+      });
+      clients.push(client);
+    }
+  } else {
+    throw new Error(type);
+  }
+
+  const fOublier = async () => {
+    if (isBrowser) return;  // Mystère et boule de gomme !!
+    await Promise.all(clients.map((client) => client.fermer()));
+    await Promise.all(fsOublier.map((f) => f()));
+  };
+  return { fOublier, clients };
+};
+
+export const typesClients: typeClient[] =
+  process.env.MANDATAIRE === "TOUS"
+    ? ["directe", "proc"]
+    : process.env.MANDATAIRE === "PROC"
+    ? ["proc"]
+    : ["directe"];

package/src/dossiers.ts

@@ -0,0 +1,46 @@
+import { isNode, isElectronMain } from "wherearewe";
+import { v4 as uuidv4 } from "uuid";
+
+export const dossierTempoTests = async (): Promise<{
+  dossier: string;
+  fEffacer: () => void;
+}> => {
+  if (isNode || isElectronMain) {
+    const fs = await import("fs");
+    const path = await import("path");
+    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 };
+  } else {
+    const dossier = uuidv4() + "/constl-ipa";
+    return {
+      dossier,
+      fEffacer: () => {
+        // Rien à faire, je crois
+      },
+    };
+  }
+};
+
+export const obtDirTempoPourTest = async ({
+  base,
+  nom,
+}: {
+  base: string;
+  nom?: string;
+}): Promise<string> => {
+  if (isNode || isElectronMain) {
+    const fs = await import("fs");
+    const path = await import("path");
+
+    const dossier = path.resolve(base, (nom || "") + uuidv4());
+    fs.mkdirSync(dossier, { recursive: true });
+    return dossier;
+  } else {
+    const dossier = base + "/" + (nom || "") + uuidv4();
+    return dossier;
+  }
+};

package/src/index.ts

@@ -0,0 +1,111 @@
+import { once } from "events";
+
+import OrbitDB from "orbit-db";
+import type Store from "orbit-db-store";
+import type KeyValueStore from "orbit-db-kvstore";
+import type FeedStore from "orbit-db-feedstore";
+
+import type {client, réseau} from "@constl/ipa";
+
+import { AttendreRésultat } from "@/attente.js";
+import type ContrôleurConstellation from "@constl/ipa/dist/src/accès/cntrlConstellation.js";
+
+export * as sfip from "@/sfip.js";
+export * as attente from "@/attente.js";
+export * as client from "@/client.js";
+export * as dossiers from "@/dossiers.js";
+
+
+const attendreInvité = (bd: Store, idInvité: string): Promise<void> =>
+  new Promise<void>((resolve) => {
+    const testAutorisé = async () => {
+      const autorisé = await (
+        bd.access as unknown as ContrôleurConstellation
+      ).estAutorisé(idInvité);
+      if (autorisé) {
+        clearInterval(interval);
+        resolve();
+      }
+    };
+    const interval = setInterval(testAutorisé, 100);
+    testAutorisé();
+  });
+
+export const clientConnectéÀ = async (
+  client1: client.ClientConstellation,
+  client2: client.ClientConstellation
+): Promise<void> => {
+  const dispositifsConnectés = new AttendreRésultat<réseau.statutDispositif[]>();
+  const idCompte2 = await client2.obtIdCompte();
+
+  const fOublier = await client1.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;
+};
+
+export const clientsConnectés = async (
+  ...clients: client.ClientConstellation[]
+): 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(clientConnectéÀ(clients[i], clients[j]));
+      promesses.push(clientConnectéÀ(clients[j], clients[i]));
+    };
+  }
+  await Promise.all(promesses);
+  return;
+};
+
+export const attendreSync = async (bd: Store): Promise<void> => {
+  const accès = bd.access as unknown as ContrôleurConstellation;
+  await once(accès.bd!.events, "peer.exchanged");
+};
+
+export const peutÉcrire = async (
+  bd: KeyValueStore<{ test: number }> | FeedStore<string>,
+  attendre?: OrbitDB
+): Promise<boolean> => {
+  if (attendre) {
+    await attendreInvité(bd, attendre.identity.id);
+  }
+
+  try {
+    if (bd.type === "keyvalue") {
+      const CLEF = "test";
+      const VAL = 123;
+
+      await (bd as KeyValueStore<{ test: number }>).set(CLEF, VAL);
+      const val = bd.get(CLEF);
+
+      await (bd as KeyValueStore<{ test: number }>).del(CLEF);
+      return val === VAL;
+    } else if (bd.type === "feed") {
+      const VAL = "test";
+
+      await (bd as FeedStore<string>).add(VAL);
+      const éléments = (bd as FeedStore<string>)
+        .iterator({ limit: -1 })
+        .collect();
+
+      const autorisé =
+        éléments.length === 1 && éléments[0].payload.value === VAL;
+      if (éléments.length === 1) {
+        await (bd as FeedStore<string>).remove(éléments[0].hash);
+      }
+      return autorisé;
+    } else {
+      throw new Error(`Type de BD ${bd.type} non supporté par ce test.`);
+    }
+  } catch {
+    return false;
+  }
+};

package/src/orbitDbTestUtils.ts

@@ -0,0 +1,55 @@
+/*
+MIT License
+
+Copyright (c) 2019 Haja Networks Oy
+
+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 { IPFS } from "ipfs-core";
+
+const defaultFilter = () => true;
+
+export const connectPeers = async (
+  ipfs1: IPFS,
+  ipfs2: IPFS,
+  options = {
+    filter: defaultFilter,
+  }
+) => {
+  const id1 = await ipfs1.id();
+  const id2 = await ipfs2.id();
+
+  const addresses1 = id1.addresses.filter(options.filter);
+  const addresses2 = id2.addresses.filter(options.filter);
+  if (addresses1.length && addresses2.length) {
+    await ipfs1.swarm.connect(addresses2[0]);
+    await ipfs2.swarm.connect(addresses1[0]);
+  }
+};
+
+export const tousConnecter = async (sfips: IPFS[]) => {
+  const connectés: IPFS[] = [];
+  for (const sfip of sfips) {
+    for (const autre of connectés) {
+      await connectPeers(sfip, autre);
+    }
+    connectés.push(sfip);
+  }
+};

package/src/sfip.ts

@@ -0,0 +1,20 @@
+import { create } from "ipfs-core";
+import type { IPFS } from "ipfs-core";
+
+export const config = {
+  patience: 10 * 1000,
+  patienceInit: 60 * 1000,
+};
+
+export const initierSFIP = async (dossier = ""): Promise<IPFS> => {
+  return create({
+    repo: dossier,
+    init: {
+      profiles: ["test"],
+    },
+  });
+};
+
+export const arrêterSFIP = async (sfip: IPFS) => {
+  await sfip.stop();
+};

package/src/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '0.1.0';

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  // "extends": "aegir/src/config/tsconfig.aegir.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "declaration": true,
+    "esModuleInterop": true,
+    "incremental": true,
+    "importHelpers": true,
+    "jsx": "react",
+    "lib": ["dom", "esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "outDir": "./dist",
+    "sourceMap": true,
+    "strict": true,
+    "strictPropertyInitialization": true,
+    "strictNullChecks": true,
+    "target": "esnext",
+    "useUnknownInCatchVariables": false,
+
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "importsNotUsedAsValues": "remove",
+
+    "plugins": [
+      { "transform": "typescript-transform-paths" },
+      { "transform": "typescript-transform-paths", "afterDeclarations": true }
+    ]
+  },
+  "include": ["src", "@types", "test"]
+}