obsidian-integration-testing 8.4.0 → 9.1.0

package/dist/lib/esm/transport-options.d.mts

@@ -100,6 +100,34 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * @default `90000`
      */
     readonly layoutReadyTimeoutInMilliseconds?: number;
+    /**
+     * Number of extra attempts to enable the plugin and verify it loaded, on top
+     * of the first attempt.
+     *
+     * On a freshly cold-booted emulator the plugin subsystem can still be settling
+     * when the harness enables the plugin, so the enable lands in the enabled set
+     * but the load races and fails (`"<id>" is in the enabled set but not loaded`).
+     * Device-idle and `layoutReady` are already awaited, so this is the narrow
+     * residual race: the harness retries the enable + load-verification this many
+     * times with exponential backoff (see
+     * {@link pluginEnableRetryDelayInMilliseconds}), forcing a genuine reload each
+     * attempt. A captured plugin load error is treated as a deterministic bug and
+     * is **not** retried. Set `0` to disable retry (a single attempt).
+     *
+     * @default `3`
+     */
+    readonly pluginEnableRetryCount?: number;
+    /**
+     * Base delay in milliseconds between plugin-enable attempts (see
+     * {@link pluginEnableRetryCount}).
+     *
+     * The delay grows exponentially per retry: the first retry waits this long,
+     * the second twice as long, the third four times, and so on — giving a
+     * still-settling cold guest progressively more time to become ready.
+     *
+     * @default `2000`
+     */
+    readonly pluginEnableRetryDelayInMilliseconds?: number;
     /**
      * Timeout in milliseconds for establishing the Appium session (WebDriverIO
      * `remote()` — UiAutomator2 server install + app launch).

package/dist/lib/esm/transport.d.mts

@@ -3,6 +3,18 @@
  *
  * Defines the transport interface for communicating with a running Obsidian instance.
  */
+/**
+ * An opaque handle identifying a console-capture window opened by
+ * {@link ObsidianTransport.beginConsoleCapture} and consumed by
+ * {@link ObsidianTransport.readConsoleCaptureSince}.
+ */
+export interface ConsoleCaptureHandle {
+    /**
+     * A unique marker written into the target's log stream at capture start,
+     * used to slice out everything logged after this point.
+     */
+    readonly marker: string;
+}
 /**
  * A pluggable transport that evaluates JavaScript expressions inside a running
  * Obsidian instance and manages vault lifecycle.
@@ -13,6 +25,21 @@
  * - {@link AppiumTransport} — Mobile Obsidian via Appium WebView JS injection
  */
 export interface ObsidianTransport {
+    /**
+     * Begins capturing the target's native console/error stream so a later
+     * {@link ObsidianTransport.readConsoleCaptureSince} can return everything
+     * logged since this call.
+     *
+     * Used to surface the *real* plugin-load error when Obsidian swallows it
+     * before the harness's `loadPlugin` monkey-patch sees it (the error then
+     * only exists in the renderer/WebView console). Optional and platform-specific:
+     * implemented by {@link AppiumTransport} (tails `adb logcat`); absent on
+     * {@link DesktopCdpTransport} (desktop errors are surfaced in-renderer, and a
+     * developer can open DevTools directly).
+     *
+     * @returns An opaque handle to pass to {@link ObsidianTransport.readConsoleCaptureSince}, or `undefined` when unsupported.
+     */
+    beginConsoleCapture?(): Promise<ConsoleCaptureHandle | undefined>;
     /**
      * Disposes of transport resources (e.g. WebSocket connections, Appium sessions).
      */
@@ -64,6 +91,16 @@ export interface ObsidianTransport {
      * @param files - Map of relative file paths to content buffers.
      */
     pushFiles?(vaultPath: string, files: Record<string, Uint8Array>): Promise<void>;
+    /**
+     * Reads the native console/error output captured since the matching
+     * {@link ObsidianTransport.beginConsoleCapture} call.
+     *
+     * A bounded, post-hoc, failure-path-only dump — not a live monitor.
+     *
+     * @param handle - The handle returned by {@link ObsidianTransport.beginConsoleCapture} (or `undefined` when capture was unsupported).
+     * @returns The captured console/error text, or `undefined` when unsupported or nothing relevant was logged.
+     */
+    readConsoleCaptureSince?(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined>;
     /**
      * Registers a vault path so Obsidian can target it.
      *

package/dist/lib/esm/vault-path-match.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * Pure matching of a probed vault base path against a requested vault path.
+ *
+ * The desktop CDP transport routes an `evalInObsidian` call to the correct
+ * Obsidian window by probing each target's `app.vault.adapter.getBasePath()` and
+ * comparing it to the requested vault path. That comparison must tolerate benign
+ * formatting differences between the renderer-reported base path and the
+ * Node-side path (path-separator flavor, and case on case-insensitive
+ * filesystems), so it lives here as a pure, unit-tested helper rather than as a
+ * raw `===` inside the integration-only transport module (which is excluded from
+ * unit tests).
+ */
+/**
+ * Normalizes a vault path for comparison: unifies path separators to `/`, strips
+ * any trailing separators, and (on a case-insensitive filesystem) lowercases it.
+ *
+ * @param path - The path to normalize.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns The normalized path.
+ */
+export declare function normalizeVaultPathForComparison(path: string, isCaseInsensitive?: boolean): string;
+/**
+ * Whether a probed base path and a requested vault path refer to the same vault,
+ * comparing via {@link normalizeVaultPathForComparison} so separator-flavor and
+ * (on case-insensitive filesystems) case differences do not cause a false miss.
+ *
+ * @param basePath - The base path probed from an Obsidian target.
+ * @param vaultPath - The requested vault path.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns `true` when the two paths refer to the same vault.
+ */
+export declare function vaultPathsMatch(basePath: string, vaultPath: string, isCaseInsensitive?: boolean): boolean;

package/dist/lib/esm/vault-path-match.mjs

@@ -0,0 +1,14 @@
+import process from "node:process";
+const IS_CASE_INSENSITIVE_FILESYSTEM = process.platform === "win32";
+function normalizeVaultPathForComparison(path, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  const unifiedSeparators = path.replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return isCaseInsensitive ? unifiedSeparators.toLowerCase() : unifiedSeparators;
+}
+function vaultPathsMatch(basePath, vaultPath, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  return normalizeVaultPathForComparison(basePath, isCaseInsensitive) === normalizeVaultPathForComparison(vaultPath, isCaseInsensitive);
+}
+export {
+  normalizeVaultPathForComparison,
+  vaultPathsMatch
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vitest/global-setup-no-plugin.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @file
+ *
+ * Vitest **plugin-less** global setup/teardown adapter.
+ *
+ * The counterpart to `./global-setup.ts` (which installs and enables the built
+ * plugin). This one runs {@link createSetup} with `installPlugin: false`, so it
+ * launches the owned Obsidian instance, registers an **empty** temp vault, and
+ * publishes the owned-instance endpoint to workers — but copies/enables no
+ * plugin. Point a non-plugin consumer's `globalSetup` straight at
+ * `obsidian-integration-testing/vitest-global-setup-no-plugin`; no wrapper needed.
+ */
+/**
+ * Vitest global setup function (plugin-less; no pre-population).
+ *
+ * Registers an empty temp vault and provides `tempVaultPath` to tests, without
+ * copying or enabling any plugin.
+ */
+export declare const setup: (this: void, project: import("vitest/node").TestProject) => Promise<void>;
+/**
+ * Vitest global teardown function.
+ *
+ * Removes the temporary vault created during setup.
+ */
+export declare const teardown: (this: void) => Promise<void>;
+export { getTempVault } from './global-setup.mjs';

package/dist/lib/esm/vitest/global-setup-no-plugin.mjs

@@ -0,0 +1,11 @@
+import { createSetup } from "./global-setup.mjs";
+const noPluginGlobalSetup = createSetup({ installPlugin: false });
+const setup = noPluginGlobalSetup.setup;
+const teardown = noPluginGlobalSetup.teardown;
+import { getTempVault } from "./global-setup.mjs";
+export {
+  getTempVault,
+  setup,
+  teardown
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vitest/global-setup.d.mts

@@ -13,6 +13,22 @@ import { TempVault } from '../temp-vault.mjs';
  * Options for {@link createSetup}.
  */
 export interface CreateSetupOptions {
+    /**
+     * Community-plugin ids to enable in the vault in addition to the plugin-under-test,
+     * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each
+     * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)
+     * so the enable finds them on disk.
+     */
+    readonly enableCommunityPlugins?: readonly string[];
+    /**
+     * Whether to install and enable the built plugin in the temp vault. Defaults
+     * to `true`. Set to `false` for a **non-plugin** consumer that only needs a
+     * registered, empty vault to `evalInObsidian` against — the owned instance is
+     * still launched and its endpoint published to workers, so re-exporting
+     * `createSetup({ installPlugin: false })` reuses the same attach wiring with no
+     * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.
+     */
+    readonly installPlugin?: boolean;
     /**
      * Returns files/folders to write into the vault before Obsidian opens it (see
      * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,
@@ -31,7 +47,8 @@ export interface VitestGlobalSetup {
  * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault
  * before Obsidian opens it — use this for a dedicated large-vault/performance
  * project. The plain {@link setup} / {@link teardown} exports are the no-populate
- * case (`createSetup()`).
+ * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer
+ * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).
  *
  * @param options - Setup options.
  * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.
@@ -46,8 +63,8 @@ export declare function getTempVault(): TempVault;
 /**
  * Vitest global setup function (no pre-population).
  *
- * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,
- * and provides `tempVaultPath` to tests.
+ * Copies the built plugin into a temporary vault, enables it via a renderer eval
+ * over the transport, and provides `tempVaultPath` to tests.
  *
  * @param project - The Vitest project.
  * @returns A promise that resolves when setup completes.

package/dist/lib/esm/vitest/global-setup.mjs

@@ -20,7 +20,12 @@ function createSetup(options) {
     const transportOptions = environmentOptions?.["obsidianTransport"];
     const label = transportOptions?.type ?? "obsidian-cdp";
     try {
-      setupResult = await coreSetup({ populate: options?.populate?.(), transportOptions });
+      setupResult = await coreSetup({
+        enableCommunityPlugins: options?.enableCommunityPlugins,
+        installPlugin: options?.installPlugin,
+        populate: options?.populate?.(),
+        transportOptions
+      });
     } catch (error) {
       log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);
       project.provide("setupError", errorToString(error));
@@ -50,4 +55,4 @@ export {
   setup,
   teardown
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport { errorToString } from '../error-to-string.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { log } from '../log.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('tempVaultPath'));\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Community-plugin ids to enable in the vault in addition to the plugin-under-test,\n   * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each\n   * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)\n   * so the enable finds them on disk.\n   */\n  readonly enableCommunityPlugins?: readonly string[];\n\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({\n        enableCommunityPlugins: options?.enableCommunityPlugins,\n        installPlugin: options?.installPlugin,\n        populate: options?.populate?.(),\n        transportOptions\n      });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run.\n      // Individual tests in this project will fail with the stored error\n      // When they try to inject the temp vault path.\n      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);\n      project.provide('setupError', errorToString(error));\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('tempVaultPath', setupResult.tempVault.path);\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = inject('tempVaultPath');\n  const setupErrorMessage = inject('setupError');\n  if (setupErrorMessage) {\n    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);\n  }\n  return new TempVault(tempVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via a renderer eval\n * over the transport, and provides `tempVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n"],
  "mappings": "AAaA,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,iBAAiB;AAE1B,4BAA4B,MAAM,OAAO,mBAAmB,CAAC;AAC7D,qBAAqB,MAAM,OAAO,eAAe,CAAC;AAkD3C,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,MAAM,UAAU;AAAA,QAC5B,wBAAwB,SAAS;AAAA,QACjC,eAAe,SAAS;AAAA,QACxB,UAAU,SAAS,WAAW;AAAA,QAC9B;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAgB;AAIvB,UAAI,sBAAsB,KAAK,4DAA4D,cAAc,KAAK,CAAC,EAAE;AACjH,cAAQ,QAAQ,cAAc,cAAc,KAAK,CAAC;AAClD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,iBAAiB,YAAY,UAAU,IAAI;AAAA,EAC7D;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,OAAO,eAAe;AAC5C,QAAM,oBAAoB,OAAO,YAAY;AAC7C,MAAI,mBAAmB;AACrB,UAAM,IAAI,MAAM,0DAAqD,iBAAiB,EAAE;AAAA,EAC1F;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "8.4.0",
+  "version": "9.1.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -30,7 +30,17 @@
         "default": "./dist/lib/cjs/index.cjs"
       }
     },
-    "./jest-global-setup": {
+    "./jest-global-setup-no-plugin": {
+      "import": {
+        "types": "./dist/lib/esm/jest/global-setup-no-plugin.d.mts",
+        "default": "./dist/lib/esm/jest/global-setup-no-plugin.mjs"
+      },
+      "require": {
+        "types": "./dist/lib/cjs/jest/global-setup-no-plugin.d.cts",
+        "default": "./dist/lib/cjs/jest/global-setup-no-plugin.cjs"
+      }
+    },
+    "./jest-global-setup-plugin": {
       "import": {
         "types": "./dist/lib/esm/jest/global-setup.d.mts",
         "default": "./dist/lib/esm/jest/global-setup.mjs"
@@ -40,7 +50,17 @@
         "default": "./dist/lib/cjs/jest/global-setup.cjs"
       }
     },
-    "./jest-global-teardown": {
+    "./jest-global-teardown-no-plugin": {
+      "import": {
+        "types": "./dist/lib/esm/jest/global-teardown-no-plugin.d.mts",
+        "default": "./dist/lib/esm/jest/global-teardown-no-plugin.mjs"
+      },
+      "require": {
+        "types": "./dist/lib/cjs/jest/global-teardown-no-plugin.d.cts",
+        "default": "./dist/lib/cjs/jest/global-teardown-no-plugin.cjs"
+      }
+    },
+    "./jest-global-teardown-plugin": {
       "import": {
         "types": "./dist/lib/esm/jest/global-teardown.d.mts",
         "default": "./dist/lib/esm/jest/global-teardown.mjs"
@@ -60,7 +80,17 @@
         "default": "./dist/lib/cjs/jest/setup.cjs"
       }
     },
-    "./vitest-global-setup": {
+    "./vitest-global-setup-no-plugin": {
+      "import": {
+        "types": "./dist/lib/esm/vitest/global-setup-no-plugin.d.mts",
+        "default": "./dist/lib/esm/vitest/global-setup-no-plugin.mjs"
+      },
+      "require": {
+        "types": "./dist/lib/cjs/vitest/global-setup-no-plugin.d.cts",
+        "default": "./dist/lib/cjs/vitest/global-setup-no-plugin.cjs"
+      }
+    },
+    "./vitest-global-setup-plugin": {
       "import": {
         "types": "./dist/lib/esm/vitest/global-setup.d.mts",
         "default": "./dist/lib/esm/vitest/global-setup.mjs"
@@ -162,8 +192,8 @@
     "@types/markdown-it": "^14.1.2",
     "@types/semver": "^7.7.1",
     "@types/turndown": "^5.0.6",
-    "@typescript-eslint/rule-tester": "^8.64.0",
-    "@typescript-eslint/utils": "^8.64.0",
+    "@typescript-eslint/rule-tester": "^8.65.0",
+    "@typescript-eslint/utils": "^8.65.0",
     "@vitest/coverage-v8": "^4.1.10",
     "@vitest/runner": "4.1.0",
     "@wdio/protocols": "9.27.0",
@@ -176,7 +206,7 @@
     "eslint": "^10.7.0",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsdoc": "^63.0.13",
+    "eslint-plugin-jsdoc": "^63.2.0",
     "eslint-plugin-perfectionist": "^5.10.0",
     "eslint-plugin-tsdoc": "^0.5.2",
     "globals": "^17.7.0",
@@ -195,7 +225,7 @@
     "ts-jest": "^29.4.11",
     "type-fest": "^5.8.0",
     "typescript": "6.0.3",
-    "typescript-eslint": "^8.64.0",
+    "typescript-eslint": "^8.65.0",
     "vite": "^8.1.5",
     "vitest": "^4.1.10"
   },