obsidian-testing-framework 0.2.4 → 0.3.0

package/lib/electron-singleton.js

@@ -1,17 +1,21 @@
 import { _electron as electron } from "playwright";
 import { addConsoleListener } from "./internal-util.js";
+import { Mutex } from "async-mutex";
 const singleton = {
     app: null,
 };
+const mutex = new Mutex();
 export async function getOrCreateApp(obsidianPath, uriArg) {
     if (singleton.app) {
         return singleton.app;
     }
+    const release = await mutex.acquire();
     const app = await electron.launch({
         timeout: 60000,
         args: [obsidianPath, uriArg].filter((a) => !!a),
     });
     addConsoleListener(app);
     singleton.app = app;
+    await release();
     return app;
 }

package/lib/fixtures.d.ts

@@ -6,4 +6,5 @@ export interface ObsidianTestFixtures {
     page: Page;
     obsidian: ObsidianTestingConfig;
     appHandle: JSHandle<App>;
+    vaultPoolDir: string;
 }

package/lib/index.d.ts

@@ -1,11 +1,12 @@
 export interface ObsidianTestingConfig {
     vault?: string;
     obsidianPath?: string;
-    experimentalUseSingleton?: boolean;
+    concurrent?: false | "copy" | "symlink";
 }
 export declare const test: import("vitest").TestAPI<{
     page: import("playwright-core").Page;
     obsidian: ObsidianTestingConfig;
     electronApp: import("playwright-core").ElectronApplication;
     appHandle: import("playwright-core").JSHandle<import("obsidian").App>;
+    vaultPoolDir: string;
 }>;

package/lib/index.js

@@ -1,15 +1,13 @@
 import { test as base, inject } from "vitest";
 import { _electron as electron } from "playwright";
 import path from "path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmdirSync, writeFileSync, } from "fs";
 import { pageUtils, waitForIndexingComplete } from "./util.js";
 import { randomBytes } from "crypto";
 import { addConsoleListener, checkToy, getExe } from "./internal-util.js";
-import { getOrCreateApp } from "./electron-singleton.js";
-function generateVaultConfig(vault) {
-    const vaultHash = randomBytes(8).toString("hex").toLocaleLowerCase();
+import symlinkDir from "symlink-dir";
+function findConfig() {
     let configLocation;
-    console.log("vault is", vault, existsSync(vault));
     checkToy();
     if (process.platform == "win32") {
         configLocation = path.join(`${process.env.APPDATA}`, "Obsidian");
@@ -22,13 +20,26 @@ function generateVaultConfig(vault) {
         catch (e) { }
     }
     const obsidianConfigFile = path.join(configLocation, "obsidian.json");
+    return obsidianConfigFile;
+}
+function generateVaultConfig(vault, concurrent, vaultPoolDir) {
+    const vaultHash = randomBytes(8).toString("hex").toLocaleLowerCase();
+    let configLocation;
+    console.log("vault is", vault, existsSync(vault));
+    const obsidianConfigFile = findConfig();
     if (!existsSync(obsidianConfigFile)) {
         writeFileSync(obsidianConfigFile, JSON.stringify({ vaults: {} }));
     }
     const json = JSON.parse(readFileSync(obsidianConfigFile).toString());
+    if (concurrent === "symlink") {
+        symlinkDir.sync(vault, path.join(vaultPoolDir, vaultHash));
+    }
+    else if (concurrent === "copy") {
+        cpSync(vault, path.join(vaultPoolDir, vaultHash), { recursive: true });
+    }
     if (!Object.values(json.vaults).some((a) => a.path === vault)) {
         json.vaults[vaultHash] = {
-            path: vault,
+            path: concurrent ? path.join(vaultPoolDir, vaultHash) : vault,
             ts: Date.now(),
         };
         writeFileSync(obsidianConfigFile, JSON.stringify(json));
@@ -41,34 +52,46 @@ function generateVaultConfig(vault) {
 }
 // @ts-ignore some error about a string type now having `undefined` as part of it's union
 export const test = base.extend({
-    electronApp: [
+    vaultPoolDir: [
         async ({}, run) => {
+            const concurrent = inject("concurrent") ?? "copy";
+            if (!concurrent) {
+                await run("");
+                return;
+            }
+            const prefix = "obsidian-testing-framework-vault-pool-";
+            const vaultPoolDir = mkdtempSync(prefix);
+            await run(vaultPoolDir);
+            rmdirSync(vaultPoolDir, { recursive: true });
+            const configFile = findConfig();
+            const json = JSON.parse(readFileSync(configFile).toString());
+            const filtered = Object.fromEntries(Object.entries(json.vaults).filter(([, v]) => !v.path.includes(prefix)));
+            writeFileSync(configFile, JSON.stringify({ vaults: filtered }));
+        },
+        { scope: "worker", auto: true },
+    ],
+    electronApp: [
+        async ({ vaultPoolDir }, run) => {
             const obsidianPath = inject("obsidianPath") ?? undefined;
-            const experimentalUseSingleton = inject("experimentalUseSingleton") ?? false;
             const vault = inject("vault");
+            const concurrent = inject("concurrent") ?? "copy";
             process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "true";
             console.log("asar located at:", getExe(obsidianPath));
             let uriArg = "";
             if (vault) {
-                let id = generateVaultConfig(vault);
+                let id = generateVaultConfig(vault, concurrent, vaultPoolDir);
                 if (!!id) {
                     uriArg = `obsidian://open?vault=${encodeURIComponent(id)}`;
                 }
             }
-            const electronApp = experimentalUseSingleton
-                ? await getOrCreateApp(getExe(obsidianPath), !!uriArg ? uriArg : undefined)
-                : await electron.launch({
-                    timeout: 60000,
-                    args: [getExe(obsidianPath), uriArg].filter((a) => !!a),
-                });
-            if (!experimentalUseSingleton) {
-                addConsoleListener(electronApp);
-            }
+            const electronApp = await electron.launch({
+                timeout: 60000,
+                args: [getExe(obsidianPath), uriArg].filter((a) => !!a),
+            });
+            addConsoleListener(electronApp);
             await electronApp.firstWindow();
             await run(electronApp);
-            if (!experimentalUseSingleton) {
-                await electronApp.close();
-            }
+            await electronApp.close();
         },
         { auto: true },
     ],

package/package.json

@@ -8,9 +8,11 @@
     "@codemirror/view": "^6.0.1",
     "@playwright/test": "^1.58.2",
     "asar": "^3.2.0",
+    "async-mutex": "^0.5.0",
     "electron": "^33.0.2",
     "obsidian": "latest",
     "playwright": "^1.58.2",
+    "symlink-dir": "^9.0.0",
     "tmp": "^0.2.3",
     "typescript": "^5.6.3",
     "xvfb-maybe": "^0.2.1"
@@ -25,7 +27,7 @@
     ".": "./lib/index.js"
   },
   "readme": "",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
   "repository": {