obsidian-testing-framework 0.3.13 → 0.4.0

package/lib/fixtures.d.ts

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

package/lib/index.d.ts

@@ -1,13 +1,13 @@
+import { ObsidianTestFixtures } from "./fixtures.js";
+import { Concurrency } from "./internal-util.js";
 export interface ObsidianTestingConfig {
+    vaultPoolDir?: string;
     vault?: string;
     obsidianPath?: string;
-    concurrent?: false | "copy" | "symlink";
+    concurrent?: Concurrency;
 }
-export declare const test: import("vitest").TestAPI<{
-    page: import("playwright-core").Page;
-    obsidian: ObsidianTestingConfig;
-    electronApp: import("playwright-core").ElectronApplication;
-    ___vaultId: string;
-    appHandle: import("playwright-core").JSHandle<import("obsidian").App>;
-    vaultPoolDir: string;
+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;
+    readonly $__test?: unknown;
 }>;

package/lib/index.js

@@ -1,89 +1,27 @@
 import { test as base, inject } from "vitest";
 import { _electron as electron } from "playwright";
 import path from "path";
-import os from "os";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmdirSync, writeFileSync, } from "fs";
+import { readFileSync, } from "fs";
+import { findConfig, generateVaultConfig } from "./internal-util.js";
 import { pageUtils, waitForIndexingComplete } from "./util.js";
 import { randomBytes } from "crypto";
-import { addConsoleListener, checkToy, getExe } from "./internal-util.js";
-import symlinkDir from "symlink-dir";
-function findConfig() {
-    let configLocation;
-    checkToy();
-    if (process.platform == "win32") {
-        configLocation = path.join(`${process.env.APPDATA}`, "Obsidian");
-    }
-    else {
-        configLocation = path.join(`${process.env.XDG_CONFIG_HOME}`, "obsidian");
-        try {
-            mkdirSync(configLocation, { recursive: true });
-        }
-        catch (e) { }
-    }
-    return configLocation;
-}
-function generateVaultConfig(vault, vaultHash, concurrent, vaultPoolDir) {
-    let configLocation = findConfig();
-    console.log("vault is", vault, existsSync(vault));
-    const obsidianConfigFile = path.join(configLocation, "obsidian.json");
-    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: concurrent ? path.join(vaultPoolDir, vaultHash) : vault,
-            ts: Date.now(),
-        };
-        writeFileSync(obsidianConfigFile, JSON.stringify(json, null, "\t"));
-        writeFileSync(path.join(configLocation, `${vaultHash}.json`), "{}");
-        return vaultHash;
-    }
-    else {
-        return Object.entries(json.vaults).find((a) => a[1].path === vault)[0];
-    }
-}
+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({
-    vaultPoolDir: [
-        async ({}, run) => {
-            const concurrent = inject("concurrent") ?? "copy";
-            if (!concurrent) {
-                await run("");
-                return;
-            }
-            const prefix = path.join(os.tmpdir(), "obsidian-testing-framework-vault-pool-");
-            const vaultPoolDir = mkdtempSync(prefix);
-            console.log("BEFORE", vaultPoolDir);
-            await run(vaultPoolDir);
-            console.log("AFTER");
-            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)));
-            writeFileSync(configFile, JSON.stringify({ vaults: filtered }));
-        },
-        { scope: "file", auto: true },
-    ],
     ___vaultId: [
         async ({}, run) => {
             process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "true";
             const vaultHash = randomBytes(8).toString("hex").toLocaleLowerCase();
             await run(vaultHash);
         },
-        { auto: true },
+        { auto: true, scope: "test" },
     ],
     electronApp: [
-        async ({ ___vaultId: vaultId, vaultPoolDir }, run) => {
+        async ({ ___vaultId: vaultId }, run) => {
             const obsidianPath = inject("obsidianPath") ?? undefined;
             const concurrent = inject("concurrent") ?? "copy";
             const vault = inject("vault");
+            const vaultPoolDir = inject("vaultPoolDir");
             console.log("asar located at:", getExe(obsidianPath));
             generateVaultConfig(vault, vaultId, concurrent, vaultPoolDir);
             const tmp = JSON.parse(readFileSync(path.join(findConfig(), "obsidian.json")).toString());

package/lib/internal-util.d.ts

@@ -1,4 +1,16 @@
 import { ElectronApplication } from "playwright";
+export type ConfigJson = {
+    vaults: {
+        [key: string]: {
+            path: string;
+            ts: number;
+            open?: boolean;
+        };
+    };
+};
+export type Concurrency = false | "copy" | "symlink";
 export declare function checkToy(): void;
 export declare function getExe(obsidianPath?: string): string;
 export declare function addConsoleListener(app: ElectronApplication): void;
+export declare function findConfig(): any;
+export declare function generateVaultConfig(vault: string, vaultHash: string, concurrent: Concurrency, vaultPoolDir: string): string;

package/lib/internal-util.js

@@ -1,5 +1,6 @@
 import path from "path";
-import { existsSync } from "fs";
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import symlinkDir from "symlink-dir";
 export function checkToy() {
     if (process.platform == "darwin") {
         throw new Error("use a non-toy operating system, dumbass");
@@ -41,3 +42,45 @@ export function addConsoleListener(app) {
         console.log(...(await Promise.all(msg.args().map((a) => a.jsonValue()))));
     });
 }
+export function findConfig() {
+    let configLocation;
+    checkToy();
+    if (process.platform == "win32") {
+        configLocation = path.join(`${process.env.APPDATA}`, "Obsidian");
+    }
+    else {
+        configLocation = path.join(`${process.env.XDG_CONFIG_HOME}`, "obsidian");
+        try {
+            mkdirSync(configLocation, { recursive: true });
+        }
+        catch (e) { }
+    }
+    return configLocation;
+}
+export function generateVaultConfig(vault, vaultHash, concurrent, vaultPoolDir) {
+    let configLocation = findConfig();
+    console.log("vault is", vault, existsSync(vault));
+    const obsidianConfigFile = path.join(configLocation, "obsidian.json");
+    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: concurrent ? path.join(vaultPoolDir, vaultHash) : vault,
+            ts: Date.now(),
+        };
+        writeFileSync(obsidianConfigFile, JSON.stringify(json, null, "\t"));
+        writeFileSync(path.join(configLocation, `${vaultHash}.json`), "{}");
+        return vaultHash;
+    }
+    else {
+        return Object.entries(json.vaults).find((a) => a[1].path === vault)[0];
+    }
+}

package/lib/setup.d.ts

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

package/lib/setup.js

@@ -0,0 +1,22 @@
+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) {
+    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);
+    project.provide("vaultPoolDir", vaultPoolDir);
+    console.log("BEFORE", vaultPoolDir);
+    return async () => {
+        console.log("AFTER");
+        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)));
+        writeFileSync(configFile, JSON.stringify({ vaults: filtered }));
+    };
+}

package/package.json

@@ -24,10 +24,11 @@
   "exports": {
     "./fixture": "./lib/fixtures.js",
     "./util": "./lib/util.js",
+    "./setup": "./lib/setup.js",
     ".": "./lib/index.js"
   },
   "readme": "",
-  "version": "0.3.13",
+  "version": "0.4.0",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
   "repository": {
@@ -43,6 +44,6 @@
   "devDependencies": {
     "@types/tmp": "^0",
     "rimraf": "^6.0.1",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.0"
   }
 }