🛠️ [fix] Improve macOS smoke test reliability

Improves the reliability of the macOS smoke test by enhancing output directory resolution and ensuring test API availability.

- 🔍 Updates the smoke test to search for the application in both `release` and `dist` directories, and also allows specifying a custom directory via environment variable.
 - Previously, the test only checked the `release` directory, causing failures when the application was built to a different location.
 - 🧪 Adds checks to ensure that Vitest's test API (e.g., `expect`, `describe`, `it`) is available in the global scope during tests.
 - This mitigates issues where the test API might not be properly initialized, leading to test failures.
 - 💾 Mocks `localStorage` and `sessionStorage` to prevent errors during tests and restores them after each test.
 - ➕ Adds `.last-run.json` to `.gitignore` to prevent it from being committed. [skip-ci] [ci-skip]

Signed-off-by: Nick2bad4u <[email protected]>

Author: Nick2bad4u

.gitignore

@@ -358,3 +358,4 @@ electron-app/.stylelintignore
 electron-app/.env.development
 electron-app/.env.production
 html/
+electron-app/test-results/.last-run.json

electron-app/scripts/run-mac-smoke-test.cjs

@@ -9,7 +9,18 @@ const path = require("node:path");
 
 const PROJECT_ROOT = path.resolve(__dirname, "..");
 const REPO_ROOT = path.resolve(PROJECT_ROOT, "..");
-const RELEASE_DIR = path.resolve(PROJECT_ROOT, "release");
+const CUSTOM_OUTPUT_DIR = process.env.FFV_SMOKE_BUILD_DIR?.trim();
+/** @type {string[]} */
+const OUTPUT_DIR_CANDIDATES = [];
+
+if (CUSTOM_OUTPUT_DIR) {
+    OUTPUT_DIR_CANDIDATES.push(path.resolve(PROJECT_ROOT, CUSTOM_OUTPUT_DIR));
+}
+
+OUTPUT_DIR_CANDIDATES.push(
+    path.resolve(PROJECT_ROOT, "release"),
+    path.resolve(PROJECT_ROOT, "dist"),
+);
 const SAMPLE_FIT = process.env.FFV_SMOKE_SAMPLE ?? path.join(REPO_ROOT, "fit-test-files", "17326739450_ACTIVITY.fit");
 const SMOKE_TIMEOUT_MS = Number(process.env.FFV_SMOKE_TEST_TIMEOUT_MS || 120_000);
 
@@ -47,13 +58,16 @@ async function main() {
         throw new Error(`[mac-smoke-test] Sample FIT file not found at ${SAMPLE_FIT}`);
     }
 
-    if (!fs.existsSync(RELEASE_DIR) || !fs.statSync(RELEASE_DIR).isDirectory()) {
-        throw new Error(`[mac-smoke-test] Release directory missing at ${RELEASE_DIR}`);
+    const outputDir = resolveOutputDirectory();
+    if (!outputDir) {
+        throw new Error(`[mac-smoke-test] Packaged output directory missing. Checked: ${OUTPUT_DIR_CANDIDATES.join(", ")}`);
     }
 
-    const executablePath = findExecutable(RELEASE_DIR);
+    console.info(`[mac-smoke-test] Inspecting packaged artifacts in ${outputDir}`);
+
+    const executablePath = findExecutable(outputDir);
     if (!executablePath) {
-        throw new Error(`[mac-smoke-test] Unable to locate packaged macOS binary under ${RELEASE_DIR}`);
+        throw new Error(`[mac-smoke-test] Unable to locate packaged macOS binary under ${outputDir}`);
     }
 
     console.info(`[mac-smoke-test] Launching ${executablePath}`);
@@ -108,6 +122,23 @@ async function main() {
     console.info("[mac-smoke-test] Smoke test completed successfully.");
 }
 
+/**
+ * Determine which packaged output directory is available for the smoke test.
+ * @returns {string|null}
+ */
+function resolveOutputDirectory() {
+    for (const candidate of OUTPUT_DIR_CANDIDATES) {
+        try {
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+                return candidate;
+            }
+        } catch {
+            // Ignore filesystem errors so we can continue scanning.
+        }
+    }
+    return null;
+}
+
 main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;

electron-app/tests/setupVitest.js

@@ -1,7 +1,17 @@
 // @ts-nocheck
 // Mock Leaflet global L for all Vitest tests
 import { JSDOM } from "jsdom";
-import { vi, afterEach as vitestAfterEach, beforeEach as vitestBeforeEach, afterAll as vitestAfterAll } from "vitest";
+import {
+    vi,
+    afterEach as vitestAfterEach,
+    beforeEach as vitestBeforeEach,
+    afterAll as vitestAfterAll,
+    beforeAll as vitestBeforeAll,
+    describe as vitestDescribe,
+    it as vitestIt,
+    test as vitestTest,
+    expect as vitestExpect,
+} from "vitest";
 // Soft import of state manager test-only resets; guarded to avoid module init cost when not present
 /** @type {undefined | (() => void)} */
 let __resetStateMgr;
@@ -144,13 +154,143 @@ function ensureConsoleAlive() {
     }
 }
 
+function ensureGlobalTestApi() {
+    try {
+        if (typeof globalThis.expect !== "function") {
+            globalThis.expect = vitestExpect;
+        }
+        if (typeof globalThis.describe !== "function") {
+            globalThis.describe = vitestDescribe;
+        }
+        if (typeof globalThis.it !== "function") {
+            globalThis.it = vitestIt;
+        }
+        if (typeof globalThis.test !== "function") {
+            globalThis.test = vitestTest;
+        }
+        if (typeof globalThis.beforeEach !== "function") {
+            globalThis.beforeEach = vitestBeforeEach;
+        }
+        if (typeof globalThis.afterEach !== "function") {
+            globalThis.afterEach = vitestAfterEach;
+        }
+        if (typeof globalThis.beforeAll !== "function") {
+            globalThis.beforeAll = vitestBeforeAll;
+        }
+        if (typeof globalThis.afterAll !== "function") {
+            globalThis.afterAll = vitestAfterAll;
+        }
+    } catch {
+        /* ignore */
+    }
+}
+
+ensureGlobalTestApi();
+
+class MemoryStorage {
+    constructor() {
+        this._store = new Map();
+    }
+
+    getItem(key) {
+        const normalized = String(key);
+        return this._store.has(normalized) ? this._store.get(normalized) : null;
+    }
+
+    setItem(key, value) {
+        this._store.set(String(key), String(value));
+    }
+
+    removeItem(key) {
+        this._store.delete(String(key));
+    }
+
+    clear() {
+        this._store.clear();
+    }
+
+    key(index) {
+        return Array.from(this._store.keys())[Number(index)] ?? null;
+    }
+
+    get length() {
+        return this._store.size;
+    }
+}
+
+function isStorageValid(candidate) {
+    return (
+        !!candidate &&
+        typeof candidate.getItem === "function" &&
+        typeof candidate.setItem === "function" &&
+        typeof candidate.removeItem === "function" &&
+        typeof candidate.clear === "function"
+    );
+}
+
+function captureStorage(key) {
+    try {
+        const fromGlobal = /** @type {any} */ (globalThis)[key];
+        if (isStorageValid(fromGlobal)) {
+            return fromGlobal;
+        }
+    } catch {
+        /* ignore */
+    }
+    try {
+        if (typeof window !== "undefined") {
+            const fromWindow = /** @type {any} */ (window)[key];
+            if (isStorageValid(fromWindow)) {
+                return fromWindow;
+            }
+        }
+    } catch {
+        /* ignore */
+    }
+    return undefined;
+}
+
+function assignStorage(target, key, storage) {
+    if (!target) return;
+    try {
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: storage,
+        });
+    } catch {
+        try {
+            target[key] = storage;
+        } catch {
+            /* ignore */
+        }
+    }
+}
+
+function restoreStorage(key, initial) {
+    const replacement = isStorageValid(initial) ? initial : new MemoryStorage();
+    assignStorage(globalThis, key, replacement);
+    if (typeof window !== "undefined") {
+        assignStorage(window, key, replacement);
+    }
+    return replacement;
+}
+
+const __initialLocalStorage = captureStorage("localStorage");
+const __initialSessionStorage = captureStorage("sessionStorage");
+
+restoreStorage("localStorage", __initialLocalStorage);
+restoreStorage("sessionStorage", __initialSessionStorage);
+
 // Register hooks defensively: in some execution modes (e.g., forks pool or
 // early setup evaluation), the Vitest runner might not yet be ready, causing
 // "Vitest failed to find the runner". Swallow those cases and proceed; tests
 // will still run, and other suites can register hooks when the runner is ready.
 try {
     vitestBeforeEach(() => {
         ensureConsoleAlive();
+        ensureGlobalTestApi();
         try {
             const g = /** @type {any} */ (globalThis);
             if (!g.process || typeof g.process !== "object") g.process = {};
@@ -167,13 +307,16 @@ try {
         } catch {
             /* ignore */
         }
+        restoreStorage("localStorage", __initialLocalStorage);
+        restoreStorage("sessionStorage", __initialSessionStorage);
     });
 } catch {
     /* ignore: runner not yet available */
 }
 try {
     vitestAfterEach(() => {
         ensureConsoleAlive();
+        ensureGlobalTestApi();
         try {
             const g = /** @type {any} */ (globalThis);
             if (!g.process || typeof g.process !== "object") g.process = {};
@@ -190,12 +333,19 @@ try {
         } catch {
             /* ignore */
         }
+        restoreStorage("localStorage", __initialLocalStorage);
+        restoreStorage("sessionStorage", __initialSessionStorage);
     });
 } catch {
     /* ignore: runner not yet available */
 }
 try {
-    vitestAfterAll(() => ensureConsoleAlive());
+    vitestAfterAll(() => {
+        ensureConsoleAlive();
+        ensureGlobalTestApi();
+        restoreStorage("localStorage", __initialLocalStorage);
+        restoreStorage("sessionStorage", __initialSessionStorage);
+    });
 } catch {
     /* ignore: runner not yet available */
 }