wdio-obsidian-service 3.0.4 → 3.1.1

package/dist/index.d.ts

@@ -471,6 +471,16 @@ interface ObsidianCapabilityOptions {
      * Path to the app asar to load into obsidian. If omitted it will be downloaded automatically.
      */
     appPath?: string;
+    /**
+     * Where to store test vaults when test on Android.
+     *
+     * Options:
+     * - "app-storage": Store the vault as Obsidian app data. Default.
+     * - "device-storage": Store the vault on the SD card (`/storage/emulated/0`). Currently not recommended due to
+     *                     intermittent write failures in Capacitor that cause flaky tests. See https://forum.obsidian.md/t/102935
+     * - custom path: Store vaults under a custom device storage path. Same caveats as "device-storage" apply.
+     */
+    androidVaultStorage?: string;
 }
 /**
  * Options passed to wdio-obsidian-service service in wdio.conf.mts. E.g.
@@ -563,14 +573,27 @@ declare class ObsidianWorkerService implements Services.ServiceInstance {
      */
     private electronSetupConfigDir;
     /**
-     * Sets up the Obsidian app. Installs and launches it if needed, and sets permissions and contexts.
+     * Transfers src to dest. src may be a file or a directory.
+     * Handles making sure the permissions under Obsidian app storage are correct.
+     */
+    private appiumUpload;
+    /**
+     * Sets up the Obsidian app. Installs and launches it if needed, and sets permissions and contexts. Opens the vault
+     * switcher page.
      *
      * You can configure Appium to install and launch the app for you. However, if you do that it reboots the app after
      * every session/spec which is really slow. So we are handling the app setup manually here.
      */
     private appiumSetupApp;
+    /**
+     * Uploads the vault to appium
+     */
+    private appiumUploadVault;
     /**
      * Opens the vault in appium.
+     *
+     * clearAppState determines whether we wipe localStorage or not. (In desktop mode we create a entirely new
+     * electron dir every time we open a new vault, in Android we need to use clearAppState to replicate that.)
      */
     private appiumOpenVault;
     /**

package/dist/index.js

@@ -1987,7 +1987,7 @@ var ERROR_LOG_VALIDATOR = [
 ];
 
 // src/service.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import ObsidianLauncher from "obsidian-launcher";
 
 // src/browserCommands.ts
@@ -2196,12 +2196,38 @@ function normalizePath(p) {
   p = p.normalize("NFC");
   return p;
 }
+function pathIsUnder(parent2, child) {
+  const rel = path2.relative(path2.resolve(parent2), path2.resolve(child));
+  return rel != "" && rel.split(path2.sep)[0] != ".." && !path2.isAbsolute(rel);
+}
 function isHidden(file) {
   return file.split("/").some((p) => p.startsWith("."));
 }
 function isText(file) {
   return [".md", ".json", ".txt", ".js"].includes(path2.extname(file).toLocaleLowerCase());
 }
+async function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function retry(func, opts = {}) {
+  const { retries = 4, backoff = 1e3, retryIf = () => true } = opts;
+  let attempt = 0;
+  let error;
+  while (attempt <= retries) {
+    try {
+      return await func(attempt);
+    } catch (e) {
+      error = e;
+    }
+    const delay = backoff * Math.random() + backoff * Math.pow(2, attempt);
+    if (!retryIf(error) || attempt >= retries) {
+      throw error;
+    }
+    await sleep(delay);
+    attempt += 1;
+  }
+  throw error;
+}
 
 // src/pageobjects/obsidianPage.ts
 var ObsidianPage = class extends BasePage {
@@ -2426,34 +2452,25 @@ var ObsidianPage = class extends BasePage {
     await this.browser.executeObsidian(async ({ app, obsidian }, file2, isVaultFile, strContent2, binContent2) => {
       file2 = obsidian.normalizePath(file2);
       const parent2 = file2.split("/").slice(0, -1).join("/");
-      let success = false;
-      let retries = 0;
-      while (!success && retries < 8) {
-        if (isVaultFile) {
-          if (parent2 && !app.vault.getAbstractFileByPath(parent2)) {
-            await app.vault.createFolder(parent2);
-          }
-          const fileObj = app.vault.getAbstractFileByPath(file2);
-          strContent2 = strContent2 ?? atob(binContent2);
-          if (fileObj) {
-            await app.vault.modify(fileObj, strContent2);
-          } else {
-            await app.vault.create(file2, strContent2);
-          }
+      if (isVaultFile) {
+        if (parent2 && !app.vault.getAbstractFileByPath(parent2)) {
+          await app.vault.createFolder(parent2);
+        }
+        const fileObj = app.vault.getAbstractFileByPath(file2);
+        strContent2 = strContent2 ?? atob(binContent2);
+        if (fileObj) {
+          await app.vault.modify(fileObj, strContent2);
         } else {
-          await app.vault.adapter.mkdir(parent2);
-          if (strContent2) {
-            await app.vault.adapter.write(file2, strContent2);
-          } else {
-            const buffer = Uint8Array.from(atob(binContent2), (c) => c.charCodeAt(0)).buffer;
-            await app.vault.adapter.writeBinary(file2, buffer);
-          }
+          await app.vault.create(file2, strContent2);
+        }
+      } else {
+        await app.vault.adapter.mkdir(parent2);
+        if (strContent2) {
+          await app.vault.adapter.write(file2, strContent2);
+        } else {
+          const buffer = Uint8Array.from(atob(binContent2), (c) => c.charCodeAt(0)).buffer;
+          await app.vault.adapter.writeBinary(file2, buffer);
         }
-        success = !obsidian.Platform.isAndroidApp || (strContent2?.length ?? binContent2.length) === 0 || (await app.vault.adapter.stat(file2)).size > 0;
-        retries++;
-      }
-      if (!success) {
-        throw new Error(`Failed to write file ${file2}`);
       }
     }, file, !isHidden(file) && isText(file), strContent, binContent);
   }
@@ -2746,7 +2763,9 @@ function getNormalizedObsidianOptions(cap) {
   return cap[OBSIDIAN_CAPABILITY_KEY];
 }
 var minSupportedObsidianVersion = "1.0.3";
-var androidVaultsDir = "/storage/emulated/0/Documents/wdio-obsidian-service-vaults";
+var ANDROID_APP_STORAGE_DIR = "/storage/emulated/0/Android/data/md.obsidian/files";
+var ANDROID_DEFAULT_DEVICE_STORAGE_DIR = "/storage/emulated/0/Documents/wdio-obsidian-service-vaults";
+var OBSIDIAN_HANG_ERROR = /* @__PURE__ */ Symbol("hang");
 var ObsidianLauncherService = class {
   constructor(options, capabilities, config) {
     this.options = options;
@@ -2805,6 +2824,15 @@ var ObsidianLauncherService = class {
           if (!chromedriverDir) {
             chromedriverDir = path4.join(this.obsidianLauncher.cacheDir, "appium-chromedriver");
           }
+          let androidVaultStorage = obsidianOptions.androidVaultStorage;
+          if (!androidVaultStorage) {
+            androidVaultStorage = semver2.lt(appVersion, "1.8.10") ? "device-storage" : "app-storage";
+          }
+          if (androidVaultStorage == "device-storage") {
+            androidVaultStorage = ANDROID_DEFAULT_DEVICE_STORAGE_DIR;
+          } else if (androidVaultStorage != "app-storage" && !androidVaultStorage.startsWith("/")) {
+            throw Error(`androidVaultStorage must be "app-storage", "device-storage", or an absolute path on the Android device.`);
+          }
           const normalizedObsidianOptions = {
             ...obsidianOptions,
             plugins,
@@ -2814,7 +2842,8 @@ var ObsidianLauncherService = class {
             appVersion,
             installerVersion: appVersion,
             emulateMobile: false,
-            testRunId: runId
+            testRunId: runId,
+            androidVaultStorage
           };
           cap[OBSIDIAN_CAPABILITY_KEY] = normalizedObsidianOptions;
           cap["appium:app"] = apk;
@@ -2958,7 +2987,36 @@ var ObsidianWorkerService = class {
     };
   }
   /**
-   * Sets up the Obsidian app. Installs and launches it if needed, and sets permissions and contexts.
+   * Transfers src to dest. src may be a file or a directory.
+   * Handles making sure the permissions under Obsidian app storage are correct.
+   */
+  async appiumUpload(src, dest) {
+    const browser2 = this.browser;
+    const isDirectory = (await fsAsync3.stat(src)).isDirectory();
+    const isAppStorage = pathIsUnder(ANDROID_APP_STORAGE_DIR, dest);
+    if (isAppStorage) {
+      const tmp = `/storage/emulated/0/Documents/tmp-${crypto3.randomBytes(10).toString("base64url").replace(/[-_]/g, "0")}`;
+      if (isDirectory) {
+        await appiumUploadFiles(browser2, { src, dest: tmp });
+      } else {
+        await browser2.pushFile(tmp, (await fsAsync3.readFile(src)).toString("base64"));
+      }
+      await browser2.execute(async (from, to) => {
+        const Filesystem = window.Capacitor.Plugins.Filesystem;
+        await Filesystem.copy({ from, to });
+      }, pathToFileURL(tmp).toString(), pathToFileURL(dest).toString());
+      await browser2.execute("mobile: shell", { command: "rm", args: ["-rf", tmp] });
+    } else {
+      if (isDirectory) {
+        await appiumUploadFiles(browser2, { src, dest });
+      } else {
+        await browser2.pushFile(dest, (await fsAsync3.readFile(src)).toString("base64"));
+      }
+    }
+  }
+  /**
+   * Sets up the Obsidian app. Installs and launches it if needed, and sets permissions and contexts. Opens the vault
+   * switcher page.
    * 
    * You can configure Appium to install and launch the app for you. However, if you do that it reboots the app after
    * every session/spec which is really slow. So we are handling the app setup manually here.
@@ -3014,30 +3072,50 @@ var ObsidianWorkerService = class {
         window.location.replace("http://localhost/");
       }
     });
-    if (!obsidianOptions.vault) {
-      await this.appiumCloseVault();
-    }
+    await this.appiumCloseVault();
   }
   /**
-   * Opens the vault in appium.
+   * Uploads the vault to appium
    */
-  async appiumOpenVault() {
+  async appiumUploadVault() {
     const browser2 = this.browser;
     const obsidianOptions = getNormalizedObsidianOptions(browser2.requestedCapabilities);
+    const isAppStorage = obsidianOptions.androidVaultStorage == "app-storage";
     const runId = obsidianOptions.testRunId;
-    const pathHash = crypto3.createHash("SHA256").update(obsidianOptions.openVault).digest("base64url").replace(/[-_]/g, "0").slice(0, 10);
+    const pathHash = crypto3.createHash("SHA256").update(obsidianOptions.openVault).digest("base64url").replace(/[-_]/g, "0").slice(0, 8);
     const basename = path4.basename(obsidianOptions.vault);
-    const androidVault = `${androidVaultsDir}/${basename}-${pathHash}-${runId}-${obsidianOptions.copy ? "" : "no"}copy`;
-    obsidianOptions.androidVault = androidVault;
-    if (!await appiumExists(browser2, androidVault)) {
-      await appiumUploadFiles(browser2, { src: obsidianOptions.openVault, dest: androidVault });
-    }
-    await browser2.execute(async (androidVault2) => {
-      localStorage.clear();
-      localStorage.setItem("mobile-external-vaults", JSON.stringify([androidVault2]));
-      localStorage.setItem("mobile-selected-vault", androidVault2);
-      localStorage.setItem(`enable-plugin-${androidVault2}`, "true");
-    }, androidVault);
+    const androidVaultName = `${basename}-${pathHash}-${runId}-wdio-${obsidianOptions.copy ? "copy" : "nocopy"}`;
+    const androidVaultPath = `${isAppStorage ? ANDROID_APP_STORAGE_DIR : obsidianOptions.androidVaultStorage}/${androidVaultName}`;
+    obsidianOptions.androidVault = androidVaultPath;
+    if (!await appiumExists(browser2, obsidianOptions.androidVault)) {
+      await this.appiumUpload(obsidianOptions.openVault, obsidianOptions.androidVault);
+    }
+  }
+  /**
+   * Opens the vault in appium.
+   * 
+   * clearAppState determines whether we wipe localStorage or not. (In desktop mode we create a entirely new
+   * electron dir every time we open a new vault, in Android we need to use clearAppState to replicate that.)
+   */
+  async appiumOpenVault(opts) {
+    const browser2 = this.browser;
+    const obsidianOptions = getNormalizedObsidianOptions(browser2.requestedCapabilities);
+    const isAppStorage = obsidianOptions.androidVaultStorage == "app-storage";
+    await browser2.execute(async (androidVaultPath, isAppStorage2, clearAppState) => {
+      if (clearAppState) {
+        localStorage.clear();
+      }
+      if (isAppStorage2) {
+        const androidVaultName = androidVaultPath.split("/").at(-1);
+        localStorage.setItem("mobile-external-vaults", JSON.stringify([]));
+        localStorage.setItem("mobile-selected-vault", androidVaultName);
+        localStorage.setItem(`enable-plugin-${androidVaultName}`, "true");
+      } else {
+        localStorage.setItem("mobile-external-vaults", JSON.stringify([androidVaultPath]));
+        localStorage.setItem("mobile-selected-vault", androidVaultPath);
+        localStorage.setItem(`enable-plugin-${androidVaultPath}`, "true");
+      }
+    }, obsidianOptions.androidVault, isAppStorage, opts.clearAppState);
     await navigateAndWait(browser2, () => location.reload());
   }
   /**
@@ -3045,8 +3123,12 @@ var ObsidianWorkerService = class {
    */
   async appiumCloseVault() {
     const browser2 = this.browser;
-    if (await browser2.execute(() => localStorage.length > 0)) {
-      await browser2.execute(() => localStorage.clear());
+    const isVaultOpen = await browser2.execute(() => !!localStorage.getItem("mobile-selected-vault"));
+    if (isVaultOpen) {
+      await browser2.execute(() => {
+        localStorage.removeItem("mobile-external-vaults");
+        localStorage.removeItem("mobile-selected-vault");
+      });
       await navigateAndWait(browser2, () => location.reload());
     }
   }
@@ -3067,10 +3149,37 @@ var ObsidianWorkerService = class {
       }, width, height);
     }
     if (obsidianOptions.vault) {
+      if (isAppium(browser2.requestedCapabilities) && semver2.gte(obsidianOptions.appVersion, "1.12.0")) {
+        await retry(async (attempt) => {
+          if (attempt > 0) {
+            console.warn("Obsidian Android app stuck, relaunching...");
+            await navigateAndWait(browser2, () => location.reload());
+          }
+          await browser2.waitUntil(
+            () => browser2.execute(() => !!window.ready),
+            // wait for enhance.js to be loaded
+            { timeout: 6e4, interval: 100 }
+          );
+          await browser2.waitUntil(
+            // if this fails to load soon after, we are in the hang state
+            () => browser2.execute(() => document.body?.classList.contains("is-mobile")),
+            { timeout: 2e3, interval: 100 }
+          ).catch(() => {
+            throw OBSIDIAN_HANG_ERROR;
+          });
+        }, {
+          retries: 2,
+          backoff: 2e3,
+          retryIf: (error) => error === OBSIDIAN_HANG_ERROR
+        });
+      }
       await browser2.waitUntil(
         // wait until the helper plugin is loaded
         () => browser2.execute(() => !!window.wdioObsidianService),
-        { timeout: 6e4, interval: 100 }
+        {
+          timeout: isAppium(browser2.requestedCapabilities) ? 12e4 : 6e4,
+          interval: 100
+        }
       );
       await browser2.executeObsidian(async ({ app }) => {
         await new Promise((resolve2) => app.workspace.onLayoutReady(resolve2));
@@ -3104,9 +3213,10 @@ var ObsidianWorkerService = class {
         this.requestedCapabilities[OBSIDIAN_CAPABILITY_KEY] = newObsidianOptions;
         if (vault) {
           await service.setupVault(this.requestedCapabilities);
-          await service.appiumOpenVault();
+          await service.appiumUploadVault();
+          await service.appiumOpenVault({ clearAppState: true });
         } else {
-          await navigateAndWait(this, () => location.replace("http://localhost/_capacitor_file_/not-a-file"));
+          await service.appiumCloseVault();
           const local = path4.join(oldObsidianOptions.openVault, ".obsidian");
           const localCommunityPlugins = path4.join(local, "community-plugins.json");
           const localAppearance = path4.join(local, "appearance.json");
@@ -3123,10 +3233,12 @@ var ObsidianWorkerService = class {
             plugins: selectedPlugins,
             themes: selectedThemes
           });
-          let files = [localCommunityPlugins, localAppearance];
-          files = (await Promise.all(files.map(async (f) => await fileExists(f) ? f : ""))).filter((f) => f);
-          await appiumUploadFiles(this, { src: local, dest: remote2, files });
-          await navigateAndWait(this, () => location.replace("http://localhost/"));
+          for (const [src, dest] of [[localCommunityPlugins, remoteCommunityPlugins], [localAppearance, remoteAppearance]]) {
+            if (await fileExists(src)) {
+              await service.appiumUpload(src, dest);
+            }
+          }
+          await service.appiumOpenVault({ clearAppState: false });
         }
       } else {
         const newCap = _3.cloneDeep(
@@ -3157,6 +3269,15 @@ var ObsidianWorkerService = class {
    * Runs before the session and browser have started.
    */
   async beforeSession(config, cap) {
+    if (!config.transformRequest) {
+      config.transformRequest = (requestOptions) => {
+        if (requestOptions.headers instanceof Headers) {
+          requestOptions.headers.delete("Connection");
+          requestOptions.headers.delete("Content-Length");
+        }
+        return requestOptions;
+      };
+    }
     try {
       if (!cap[OBSIDIAN_CAPABILITY_KEY]) return;
       if (cap[OBSIDIAN_CAPABILITY_KEY].vault != void 0) {
@@ -3186,7 +3307,8 @@ var ObsidianWorkerService = class {
       if (isAppium(browser2.requestedCapabilities)) {
         await this.appiumSetupApp();
         if (cap[OBSIDIAN_CAPABILITY_KEY].vault) {
-          await this.appiumOpenVault();
+          await this.appiumUploadVault();
+          await this.appiumOpenVault({ clearAppState: true });
         }
       }
       await this.prepareApp();
@@ -3201,8 +3323,13 @@ var ObsidianWorkerService = class {
     const obsidianOptions = getNormalizedObsidianOptions(browser2.requestedCapabilities);
     if (isAppium(cap)) {
       await this.appiumCloseVault();
+      const androidVaultsDir = obsidianOptions.androidVaultStorage == "app-storage" ? ANDROID_APP_STORAGE_DIR : obsidianOptions.androidVaultStorage;
       for (const file of await appiumReaddir(browser2, androidVaultsDir)) {
-        if (!file.includes(obsidianOptions.testRunId) || file.endsWith("-copy")) {
+        const name = path4.posix.basename(file);
+        const isServiceManaged = name.match(/-wdio-(no)?copy$/);
+        const isFromThisRun = name.includes(obsidianOptions.testRunId);
+        const isCopy = name.match(/-copy$/);
+        if (isServiceManaged && (!isFromThisRun || isCopy)) {
           await browser2.execute("mobile: shell", { command: "rm", args: ["-rf", file] });
         }
       }
@@ -3224,17 +3351,14 @@ import { remote } from "webdriverio";
 async function startWdioSession(params, serviceOptions) {
   serviceOptions = serviceOptions ?? {};
   const capabilities = params.capabilities;
-  const testRunnerOptions = {
-    cacheDir: params.cacheDir
-  };
   const launcherService = new ObsidianLauncherService(
     serviceOptions,
     [capabilities],
-    testRunnerOptions
+    params
   );
-  const workerService = new ObsidianWorkerService(serviceOptions, capabilities, testRunnerOptions);
-  await launcherService.onPrepare(testRunnerOptions, [capabilities]);
-  await workerService.beforeSession(testRunnerOptions, capabilities);
+  const workerService = new ObsidianWorkerService(serviceOptions, capabilities, params);
+  await launcherService.onPrepare(params, [capabilities]);
+  await workerService.beforeSession(params, capabilities);
   const browser2 = await remote(params);
   await workerService.before(capabilities, [], browser2);
   return browser2;