obsidian-testing-framework 0.4.9 → 0.5.0

package/lib/fixtures.d.ts

@@ -1,10 +1,13 @@
-import { ElectronApplication, JSHandle, Page } from "playwright";
+import { Browser, JSHandle, Page } from "playwright";
 import { ObsidianTestingConfig } from "./index.js";
 import { App } from "obsidian";
 export interface ObsidianTestFixtures {
-    electronApp: ElectronApplication;
+    electronApp: Browser;
     page: Page;
     obsidian: ObsidianTestingConfig;
-    ___vaultId: string;
+    ___internal: {
+        vaultId: string;
+        release: () => Promise<void>;
+    };
     appHandle: JSHandle<App>;
 }

package/lib/index.d.ts

@@ -1,4 +1,3 @@
-import { ObsidianTestFixtures } from "./fixtures.js";
 import { Concurrency } from "./internal-util.js";
 export interface ObsidianTestingConfig {
     vaultPoolDir?: string;
@@ -6,8 +5,28 @@ export interface ObsidianTestingConfig {
     obsidianPath?: string;
     concurrent?: Concurrency;
 }
-export declare const test: import("vitest").TestAPI<Omit<object, "$__worker"> & Record<ObsidianTestFixtures, K extends never ? object[K] : unknown> & {
-    readonly $__worker?: Record<ObsidianTestFixtures, K extends never ? object[K] : unknown>;
-    readonly $__file?: unknown;
+export declare const test: import("vitest").TestAPI<Omit<Omit<Omit<object, "$__file"> & Record<"___internal", {
+    vaultId: string;
+    release: () => Promise<void>;
+}> & {
+    readonly $__worker?: unknown;
+    readonly $__file?: Record<"___internal", {
+        vaultId: string;
+        release: () => Promise<void>;
+    }>;
     readonly $__test?: unknown;
+}, "$__file"> & Record<"electronApp", import("playwright-core").Browser> & {
+    readonly $__worker?: unknown;
+    readonly $__file?: Record<"___internal", {
+        vaultId: string;
+        release: () => Promise<void>;
+    }> & Record<"electronApp", import("playwright-core").Browser>;
+    readonly $__test?: unknown;
+}, "$__test"> & Record<"page", import("playwright-core").Page> & {
+    readonly $__worker?: unknown;
+    readonly $__file?: Record<"___internal", {
+        vaultId: string;
+        release: () => Promise<void>;
+    }> & Record<"electronApp", import("playwright-core").Browser>;
+    readonly $__test?: Record<"page", import("playwright-core").Page>;
 }>;

package/lib/index.js

@@ -1,76 +1,101 @@
 import { test as base, inject } from "vitest";
-import { _electron as electron } from "playwright";
+import { chromium } from "playwright";
 import path from "path";
-import { readFileSync, } from "fs";
-import { findConfig, generateVaultConfig } from "./internal-util.js";
+import { readFileSync } from "fs";
+import { findConfig, generateVaultConfig, addConsoleListener, getAsar, } from "./internal-util.js";
 import { pageUtils, waitForIndexingComplete } from "./util.js";
 import { randomBytes } from "crypto";
-import { addConsoleListener, getExe } from "./internal-util.js";
-// @ts-ignore some error about a string type now having `undefined` as part of it's union
-export const test = base.extend({
-    ___vaultId: [
-        async ({}, run) => {
-            process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "true";
-            const obsidianPath = inject("obsidianPath") ?? undefined;
-            const vaultHash = randomBytes(8).toString("hex").toLocaleLowerCase();
-            const concurrent = inject("concurrent") ?? "copy";
-            const vault = inject("vault");
-            const vaultPoolDir = inject("vaultPoolDir");
-            console.log("asar located at:", getExe(obsidianPath));
-            await generateVaultConfig(vault, vaultHash, concurrent, vaultPoolDir);
-            await run(vaultHash);
-        },
-        { auto: true, scope: "file" },
-    ],
-    electronApp: [
-        async ({ ___vaultId: vaultId }, run) => {
-            const obsidianPath = inject("obsidianPath") ?? undefined;
-            const tmp = JSON.parse(readFileSync(path.join(findConfig(), "obsidian.json")).toString());
-            console.log("vaultid", vaultId, vaultId in tmp.vaults);
-            let uriArg = "";
-            if (vaultId) {
-                if (!!vaultId) {
-                    uriArg = `obsidian://open?vault=${encodeURIComponent(vaultId)}`;
-                }
-            }
-            const electronApp = await electron.launch({
-                timeout: 60000,
-                args: [getExe(obsidianPath), uriArg].filter((a) => !!a),
-            });
-            addConsoleListener(electronApp);
-            await electronApp.firstWindow();
-            await run(electronApp);
-            await electronApp.close();
-        },
-        { auto: true },
-    ],
-    page: [
-        async ({ electronApp, ___vaultId: vaultId }, run) => {
-            const windows = electronApp.windows();
-            // console.log("windows", windows);
-            let page = windows[windows.length - 1];
-            await page.evaluate((vaultId) => {
-                window.localStorage.setItem(`enable-plugin-${vaultId}`, "true");
-            }, vaultId);
-            await page.waitForLoadState("domcontentloaded");
-            try {
-                await waitForIndexingComplete(page);
-            }
-            catch (e) {
-                console.warn("timed out waiting for metadata cache. continuing...");
-            }
-            for (let fn of Object.entries(pageUtils)) {
-                await page.exposeFunction(fn[0], fn[1]);
-            }
-            page.on("pageerror", (exc) => {
-                console.error("EXCEPTION");
-                console.error(exc);
-            });
-            page.on("console", async (msg) => {
-                console.log(...(await Promise.all(msg.args().map((a) => a.jsonValue()))));
-            });
-            await run(page);
-        },
-        { auto: true },
-    ],
+import { retryUntilTruthy, ipcRendererSend } from "electron-playwright-helpers";
+export const test = base
+    .extend("___internal", { auto: true, scope: "file" }, async ({}, {}) => {
+    const concurrent = inject("concurrent") ?? "copy";
+    const vault = inject("vault");
+    const vaultPoolDir = inject("vaultPoolDir");
+    const vaultId = randomBytes(8).toString("hex").toLocaleLowerCase();
+    console.debug("about to lock");
+    const release = async () => { };
+    console.debug("lock acquired !");
+    await generateVaultConfig(vault, vaultId, concurrent, vaultPoolDir);
+    return { vaultId, release };
+})
+    .extend("electronApp", { auto: true, scope: "file" }, async ({ ___internal: { vaultId } }, { onCleanup }) => {
+    const obsidianPath = inject("obsidianPath") ?? undefined;
+    const vaultPoolDir = inject("vaultPoolDir");
+    console.log("asar located at:", getAsar(obsidianPath));
+    const tmp = JSON.parse(readFileSync(path.join(findConfig(), "obsidian.json")).toString());
+    console.log("vaultid", vaultId, vaultId in tmp.vaults);
+    const dbgInfo = await fetch("http://localhost:9222/json/version").then((res) => res.json());
+    console.log("dbgInfo", dbgInfo);
+    const browser = await chromium.connectOverCDP(dbgInfo.webSocketDebuggerUrl, {
+        isLocal: true,
+        slowMo: 100,
+    });
+    console.log("app launched");
+    addConsoleListener(browser);
+    console.log("ctx", browser.contexts().length);
+    const ctx = browser.contexts()[0];
+    const titles = await Promise.all(ctx.pages().map((p) => p.title()));
+    const page = ctx.pages().find((_, i) => titles[i] === "Obsidian");
+    await ipcRendererSend(page, "vault-open", path.join(vaultPoolDir, `vault-${vaultId}`), false);
+    console.log("dialogs restored");
+    {
+        const page = await retryUntilTruthy(async () => {
+            const pages = ctx.pages();
+            console.log("finding", vaultId);
+            console.log("num windows", pages.length);
+            console.log("page titles", await Promise.all(pages.map((w) => w.title())));
+            const titles = await Promise.all(pages.map((w) => w.title()));
+            const idx = titles.findIndex((t) => t.includes(`vault-${vaultId}`));
+            console.log("idx", idx);
+            return pages[idx];
+        });
+        await page.waitForLoadState("domcontentloaded");
+        await page.waitForSelector(".modal-button-container", {
+            state: "attached",
+        });
+        const mbc = page.locator(".modal-button-container");
+        await mbc.locator("button").first().click();
+        const focusedElementHandle = await page.evaluateHandle(() => document.activeElement);
+        await focusedElementHandle.press("Escape");
+        console.log("esc pressed");
+        try {
+            await waitForIndexingComplete(page);
+        }
+        catch (e) {
+            console.warn("timed out waiting for metadata cache. continuing...");
+        }
+        for (let fn of Object.entries(pageUtils)) {
+            await page.exposeFunction(fn[0], fn[1]);
+        }
+        page.on("pageerror", (exc) => {
+            console.error("EXCEPTION");
+            console.error(exc);
+        });
+        page.on("console", async (msg) => {
+            console.log(...(await Promise.all(msg.args().map((a) => a.jsonValue()))));
+        });
+    }
+    console.debug("[electronApp] running tests");
+    onCleanup(async () => {
+        const titles = await Promise.all(ctx.pages().map((p) => p.title()));
+        const idx = titles.findIndex((t) => t.includes(`vault-${vaultId}`));
+        const page = ctx.pages()[idx];
+        await page.close();
+    });
+    return browser;
+})
+    .extend("page", { auto: true }, async ({ electronApp, ___internal: { vaultId } }, {}) => {
+    let page = await retryUntilTruthy(async () => {
+        const ctx = electronApp.contexts()[0];
+        const pages = ctx.pages();
+        console.log("finding", vaultId);
+        console.log("num windows", pages.length);
+        console.log("page titles", await Promise.all(pages.map((w) => w.title())));
+        const titles = await Promise.all(pages.map((w) => w.title()));
+        const idx = titles.findIndex((t) => t.includes(`vault-${vaultId}`));
+        console.log("idx", idx);
+        return pages[idx];
+    });
+    console.debug("[page] running tests @", vaultId);
+    return page;
 });

package/lib/internal-util.d.ts

@@ -1,4 +1,4 @@
-import { ElectronApplication } from "playwright";
+import { Browser } from "playwright";
 export type ConfigJson = {
     vaults: {
         [key: string]: {
@@ -10,7 +10,10 @@ export type ConfigJson = {
 };
 export type Concurrency = false | "copy" | "symlink";
 export declare function checkToy(): void;
+export declare function getAsar(obsidianPath?: string): string;
 export declare function getExe(obsidianPath?: string): string;
-export declare function addConsoleListener(app: ElectronApplication): void;
+export declare function addConsoleListener(app: Browser): void;
 export declare function findConfig(): any;
 export declare function generateVaultConfig(vault: string, vaultHash: string, concurrent: Concurrency, vaultPoolDir: string): Promise<string>;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function timeout<T, A extends any[]>(fn: (...args: A) => Promise<T>, ms: number, ...args: A): Promise<T>;

package/lib/internal-util.js

@@ -1,24 +1,24 @@
 import path from "path";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { cp, readFile, writeFile } from "fs/promises";
-import { lock } from "proper-lockfile";
+import { cp, readFile, rm } from "fs/promises";
 import symlinkDir from "symlink-dir";
 export function checkToy() {
     if (process.platform == "darwin") {
         throw new Error("use a non-toy operating system, dumbass");
     }
 }
-export function getExe(obsidianPath) {
+export function getAsar(obsidianPath) {
     checkToy();
+    const asarName = "app.asar";
     if (obsidianPath) {
         return path.join(obsidianPath, "Resources", "app.asar");
     }
     if (process.platform == "win32") {
-        let p = path.join(process.env.LOCALAPPDATA, "Obsidian", "Resources", "app.asar");
+        let p = path.join(process.env.LOCALAPPDATA, "Obsidian", "Resources", asarName);
         if (existsSync(p)) {
             return p;
         }
-        p = path.join(process.env.PROGRAMFILES, "Obsidian", "Resources", "app.asar");
+        p = path.join(process.env.PROGRAMFILES, "Obsidian", "Resources", asarName);
         if (existsSync(p)) {
             return p;
         }
@@ -34,14 +34,21 @@ export function getExe(obsidianPath) {
     for (let i = 0; i < possibleDirs.length; i++) {
         if (existsSync(possibleDirs[i])) {
             // console.log(execSync(`ls -l ${possibleDirs[i]}`).toString());
-            return path.join(possibleDirs[i], "resources", "app.asar");
+            return path.join(possibleDirs[i], "resources", asarName);
         }
     }
     return "";
 }
+export function getExe(obsidianPath) {
+    const dirname = path.dirname(getAsar(obsidianPath));
+    let filename = process.platform == "win32" ? "Obsidian.exe" : "obsidian";
+    return path.normalize(path.join(dirname, "..", filename));
+}
 export function addConsoleListener(app) {
-    app.on("console", async (msg) => {
-        console.log(...(await Promise.all(msg.args().map((a) => a.jsonValue()))));
+    app.contexts().forEach(context => {
+        context.on("console", async (msg) => {
+            console.log(...(await Promise.all(msg.args().map((a) => a.jsonValue()))));
+        });
     });
 }
 export function findConfig() {
@@ -66,35 +73,32 @@ export async function generateVaultConfig(vault, vaultHash, concurrent, vaultPoo
     if (!existsSync(obsidianConfigFile)) {
         writeFileSync(obsidianConfigFile, JSON.stringify({ vaults: {} }));
     }
-    let releaser;
-    releaser = await lock(obsidianConfigFile, {
-        retries: 5,
-    });
     try {
         const json = JSON.parse((await readFile(obsidianConfigFile)).toString());
         const hasVault = Object.values(json.vaults).some((a) => a.path === vault) && !concurrent;
+        console.log("vpd", vaultPoolDir);
         if (concurrent === "symlink") {
             await symlinkDir(vault, path.join(vaultPoolDir, `vault-${vaultHash}`));
         }
         else if (concurrent === "copy") {
             await cp(vault, path.join(vaultPoolDir, `vault-${vaultHash}`), { recursive: true });
         }
+        if (concurrent) {
+            await rm(path.join(vaultPoolDir, `vault-${vaultHash}`, ".obsidian/workspace.json"));
+        }
         if (!hasVault) {
             json.vaults[vaultHash] = {
                 path: concurrent ? path.join(vaultPoolDir, `vault-${vaultHash}`) : vault,
                 ts: Date.now(),
             };
-            await writeFile(obsidianConfigFile, JSON.stringify(json, null, "\t"));
-            await writeFile(path.join(configLocation, `${vaultHash}.json`), "{}");
+            // await writeFile(obsidianConfigFile, JSON.stringify(json, null, "\t"));
+            // await writeFile(path.join(configLocation, `${vaultHash}.json`), "{}");
         }
     }
     catch (err) {
         console.error("error generating vault config", err);
         throw err;
     }
-    finally {
-        await releaser();
-    }
     const json = JSON.parse((await readFile(obsidianConfigFile)).toString());
     const hasVault = Object.values(json.vaults).some((a) => a.path === vault);
     if (hasVault) {
@@ -102,3 +106,20 @@ export async function generateVaultConfig(vault, vaultHash, concurrent, vaultPoo
     }
     return vaultHash;
 }
+export async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function timeout(fn, ms, ...args) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`timeout after ${ms}ms`));
+        }, ms);
+        fn(...args).then((result) => {
+            clearTimeout(timeout);
+            resolve(result);
+        }).catch((err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}

package/lib/setup.d.ts

@@ -1,2 +1,2 @@
 import type { TestProject } from "vitest/node";
-export default function setup(project: TestProject): () => Promise<void>;
+export default function setup(project: TestProject): Promise<() => Promise<void>>;

package/lib/setup.js

@@ -1,22 +1,54 @@
+import { _electron as electron } from "playwright";
 import path from "path";
 import os from "os";
-import { mkdtempSync, rmdirSync, readFileSync, writeFileSync } from "fs";
-import { findConfig } from "./internal-util.js";
-export default function setup(project) {
+import { mkdtempSync, rmdirSync, readFileSync, writeFileSync, unlinkSync, } from "fs";
+import { findConfig, getAsar } from "./internal-util.js";
+export default async function setup(project) {
     const concurrent = project.config.provide.concurrent ?? "copy";
     if (!concurrent) {
         return async () => { };
     }
-    const prefix = path.join(os.tmpdir(), "obsidian-testing-framework-vault-pool-");
-    const vaultPoolDir = mkdtempSync(prefix);
+    const prefix = "obsidian-testing-framework-vault-pool-";
+    const fullPrefix = path.join(os.tmpdir(), prefix);
+    const vaultPoolDir = mkdtempSync(fullPrefix);
     project.provide("vaultPoolDir", vaultPoolDir);
+    project.globTestFiles;
     console.log("BEFORE", vaultPoolDir);
+    const launch = async () => {
+        return await electron.launch({
+            timeout: 60000,
+            args: [
+                getAsar(project.config.provide.obsidianPath),
+                "--remote-debugging-address=0.0.0.0",
+                "--remote-debugging-port=9222",
+                "--",
+                "obsidian://choose-vault",
+            ].filter((a) => !!a),
+        });
+    };
+    let app = await launch();
+    project.onTestsRerun(async () => {
+        await app.close();
+        app = await launch();
+    });
     return async () => {
         console.log("AFTER");
+        await app.close();
         rmdirSync(vaultPoolDir, { recursive: true });
         const configFile = path.join(findConfig(), "obsidian.json");
         const json = JSON.parse(readFileSync(configFile).toString());
-        const filtered = Object.fromEntries(Object.entries(json.vaults).filter(([, v]) => !v.path.includes(prefix)));
+        const filtered = Object.fromEntries(Object.entries(json.vaults).filter(([, v]) => !v.path.includes(fullPrefix)));
+        const toRemove = Object.entries(json.vaults)
+            .filter(([, v]) => v.path.includes(prefix))
+            .map(([k]) => k);
         writeFileSync(configFile, JSON.stringify({ vaults: filtered }));
+        for (const vault of toRemove) {
+            try {
+                unlinkSync(path.join(findConfig(), `${vault}.json`));
+            }
+            catch (e) {
+                continue;
+            }
+        }
     };
 }

package/package.json

@@ -10,6 +10,7 @@
     "asar": "^3.2.0",
     "async-mutex": "^0.5.0",
     "electron": "^33.0.2",
+    "electron-playwright-helpers": "^2.1.0",
     "obsidian": "latest",
     "playwright": "^1.58.2",
     "proper-lockfile": "^4.1.2",
@@ -29,7 +30,7 @@
     ".": "./lib/index.js"
   },
   "readme": "",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
   "repository": {
@@ -45,6 +46,7 @@
   "devDependencies": {
     "@types/proper-lockfile": "^4",
     "@types/tmp": "^0",
+    "playwright-core": "^1.58.2",
     "rimraf": "^6.0.1",
     "vitest": "^4.1.0"
   }