@ohos-ports/floss 5.0.1-beta.1 → 5.0.1-beta.3

package/lib/browser-runner.js

@@ -0,0 +1,486 @@
+"use strict";
+Object.defineProperty(exports, "____esModule", { value: true });
+exports.runInBrowser = void 0;
+
+const path = require("path");
+const fs = require("fs");
+const http = require("http");
+const glob = require("glob");
+
+// ─── Constants ─────────────────────────────────────────────────────────
+
+const BROWSER_PKG = "com.haitai.htbrowser";
+const BROWSER_ABILITY = "EntryAbility";
+const CDP_PORT = 9333;
+
+const BOOL_FLAGS = [
+    "disable-extensions", "disable-default-apps",
+    "disable-component-extensions-with-background-pages",
+    "no-first-run", "no-default-browser-check",
+    "disable-background-networking",
+    "disable-client-side-phishing-detection", "disable-popup-blocking",
+    "disable-prompt-on-repost", "disable-breakpad",
+    "disable-hang-monitor", "disable-ipc-flooding-protection",
+    "metrics-recording-only", "disable-sync",
+    "disable-search-engine-choice-screen",
+    "disable-background-timer-throttling",
+    "disable-renderer-backgrounding",
+    "disable-backgrounding-occluded-windows",
+    "disable-field-trial-config", "disable-component-update",
+    "disable-dev-shm-usage", "no-service-autorun",
+    "disable-infobars", "allow-file-access-from-files",
+    "enable-automation", "allow-pre-commit-input",
+];
+
+const DISABLED_FEATURES = [
+    "AvoidUnnecessaryBeforeUnloadCheckSync",
+    "DestroyProfileOnBrowserClose",
+    "DialMediaRouteProvider", "GlobalMediaControls",
+    "HttpsUpgrades", "LensOverlay", "MediaRouter",
+    "PaintHolding", "Translate",
+].join(",");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ─── HDC utilities ────────────────────────────────────────────────────
+
+function getHdcPath() {
+    if (process.platform === "openharmony") {
+        try {
+            fs.accessSync("/data/service/hnp/bin/hdc");
+            return "/data/service/hnp/bin/hdc";
+        } catch {}
+    }
+    return process.env.HDC_PATH || "hdc";
+}
+
+function execHdc(args, timeout) {
+    const { execFileSync } = require("child_process");
+    try {
+        return execFileSync(getHdcPath(), args, {
+            timeout: timeout || 30000,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    } catch (e) {
+        throw new Error("hdc " + args.join(" ") + " failed: " + e.message);
+    }
+}
+
+// ─── Browser launch / close ───────────────────────────────────────────
+
+function buildLaunchArgs() {
+    const args = [
+        "--remote-debugging-port=" + CDP_PORT,
+        "--remote-allow-origins=http://127.0.0.1:" + CDP_PORT,
+    ];
+    for (var i = 0; i < BOOL_FLAGS.length; i++) {
+        args.push("--" + BOOL_FLAGS[i]);
+    }
+    args.push("--password-store=basic", "--use-mock-keychain");
+    args.push("--force-color-profile=srgb");
+    args.push("--disable-features=" + DISABLED_FEATURES);
+    return args.join(" ");
+}
+
+async function launchBrowser() {
+    // 1. Check if browser is installed
+    var installedApps;
+    try {
+        installedApps = execHdc(["shell", "bm", "dump", "-a"], 10000);
+    } catch (e) {
+        throw new Error("Cannot query installed apps via hdc. Is hdc available? " + e.message);
+    }
+    if (!installedApps.includes(BROWSER_PKG)) {
+        throw new Error('Browser "' + BROWSER_PKG + '" is not installed on this device.');
+    }
+
+    // 2. Kill existing browser process
+    try { execHdc(["shell", "aa", "force-stop", BROWSER_PKG], 10000); } catch {}
+    await sleep(1000);
+
+    // 3. Start browser with CDP enabled
+    var cmdArgs = buildLaunchArgs();
+    execHdc([
+        "shell", "aa", "start",
+        "-b", BROWSER_PKG,
+        "-a", BROWSER_ABILITY,
+        "--ps", "cmdArgs", cmdArgs,
+    ], 15000);
+
+    // 4. Wait for CDP endpoint
+    var wsUrl = await waitForCdpEndpoint(CDP_PORT, 30000);
+    return wsUrl;
+}
+
+async function closeBrowser() {
+    try { execHdc(["shell", "aa", "force-stop", BROWSER_PKG], 10000); } catch {}
+}
+
+// ─── CDP endpoint discovery ──────────────────────────────────────────
+
+function httpGet(url, timeout) {
+    return new Promise(function (resolve, reject) {
+        var req = http.get(url, function (res) {
+            var data = "";
+            res.on("data", function (chunk) { data += chunk; });
+            res.on("end", function () {
+                if (res.statusCode !== 200) return reject(new Error("HTTP " + res.statusCode));
+                try { resolve(JSON.parse(data)); }
+                catch (e) { reject(new Error("JSON parse failed: " + e.message)); }
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(timeout || 2000, function () { req.destroy(); reject(new Error("Timeout")); });
+    });
+}
+
+async function waitForCdpEndpoint(port, timeoutMs) {
+    var start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            var data = await httpGet("http://127.0.0.1:" + port + "/json/version", 2000);
+            if (data.webSocketDebuggerUrl) return data.webSocketDebuggerUrl;
+        } catch (e) {
+            try {
+                var data6 = await httpGet("http://[::1]:" + port + "/json/version", 2000);
+                if (data6.webSocketDebuggerUrl) return data6.webSocketDebuggerUrl;
+            } catch (e2) {
+                await sleep(500);
+            }
+        }
+    }
+    throw new Error("CDP endpoint timeout on port " + port + " after " + timeoutMs + "ms. " +
+        "Ensure browser is running and CDP is enabled.");
+}
+
+// ─── CDP WebSocket client ────────────────────────────────────────────
+
+function createWebSocket(url) {
+    // Try 'ws' package first (most reliable)
+    var WSImpl = null;
+    try { WSImpl = require("ws"); }
+    catch (e) {
+        // Fall back to built-in WebSocket (Node.js 22+)
+        if (typeof globalThis.WebSocket !== "undefined") {
+            WSImpl = globalThis.WebSocket;
+        }
+    }
+    if (!WSImpl) {
+        throw new Error("No WebSocket available. Install 'ws' package or use Node.js 22+.");
+    }
+
+    var ws = new WSImpl(url);
+
+    // Detect ws package (EventEmitter style) vs built-in (addEventListener style)
+    var isWsPkg = typeof ws.on === "function";
+
+    return {
+        onOpen: function (cb) {
+            if (isWsPkg) ws.on("open", cb);
+            else ws.addEventListener("open", cb);
+        },
+        onMessage: function (cb) {
+            if (isWsPkg) {
+                ws.on("message", function (data) {
+                    cb(typeof data === "string" ? data : data.toString());
+                });
+            } else {
+                ws.addEventListener("message", function (e) { cb(e.data); });
+            }
+        },
+        onError: function (cb) {
+            if (isWsPkg) ws.on("error", cb);
+            else ws.addEventListener("error", function (e) { cb(e); });
+        },
+        send: function (data) { ws.send(data); },
+        close: function () { try { ws.close(); } catch (e) {} },
+    };
+}
+
+function CdpClient(wsUrl) {
+    this.wsUrl = wsUrl;
+    this.id = 0;
+    this.callbacks = {};
+    this.eventHandlers = {};
+    this.ws = null;
+}
+
+CdpClient.prototype.connect = function () {
+    var self = this;
+    return new Promise(function (resolve, reject) {
+        self.ws = createWebSocket(self.wsUrl);
+        self.ws.onOpen(function () { resolve(); });
+        self.ws.onError(function (err) {
+            reject(new Error("WebSocket connection error: " + (err && err.message || err)));
+        });
+        self.ws.onMessage(function (data) {
+            var msg;
+            try { msg = JSON.parse(data); }
+            catch (e) { return; }
+
+            if (msg.id !== undefined) {
+                // Response to a command
+                var cb = self.callbacks[msg.id];
+                if (cb) {
+                    delete self.callbacks[msg.id];
+                    if (msg.error) {
+                        cb.reject(new Error("CDP error: " + JSON.stringify(msg.error)));
+                    } else {
+                        cb.resolve(msg.result);
+                    }
+                }
+            } else if (msg.method) {
+                // Event
+                var handlers = self.eventHandlers[msg.method] || [];
+                for (var i = 0; i < handlers.length; i++) {
+                    handlers[i](msg.params || {}, msg.sessionId);
+                }
+            }
+        });
+    });
+};
+
+CdpClient.prototype.send = function (method, params, sessionId) {
+    var self = this;
+    var id = ++this.id;
+    var msg = { id: id, method: method, params: params || {} };
+    if (sessionId) msg.sessionId = sessionId;
+
+    return new Promise(function (resolve, reject) {
+        self.callbacks[id] = { resolve: resolve, reject: reject };
+        self.ws.send(JSON.stringify(msg));
+    });
+};
+
+CdpClient.prototype.on = function (method, handler) {
+    if (!this.eventHandlers[method]) this.eventHandlers[method] = [];
+    this.eventHandlers[method].push(handler);
+};
+
+CdpClient.prototype.close = function () {
+    if (this.ws) this.ws.close();
+};
+
+// ─── File resolution (same logic as renderer.js addFile) ─────────────
+
+function resolveFiles(files) {
+    return files
+        .map(function (file) {
+            var testPath = path.resolve(file);
+            if (!fs.existsSync(testPath)) {
+                return null;
+            }
+            if (fs.statSync(testPath).isDirectory()) {
+                var indexFile = path.join(testPath, "index.js");
+                var indexTs = path.join(testPath, "index.ts");
+                if (fs.existsSync(indexFile)) {
+                    return indexFile;
+                } else if (fs.existsSync(indexTs)) {
+                    return indexTs;
+                }
+                console.error("No index.js file found in directory: " + testPath);
+                return null;
+            }
+            return testPath;
+        })
+        .filter(function (file) { return file !== null; });
+}
+
+// ─── Main: run tests in browser via CDP ──────────────────────────────
+
+/**
+ * Run tests in a real Chromium browser (海泰浏览器) via CDP.
+ *
+ * This provides full browser capabilities: DOM, Canvas, WebGL, CSS layout.
+ * Browser is launched via hdc, controlled via Chrome DevTools Protocol.
+ *
+ * @param {Object} opts - Floss options (path, reporter, require, quiet, etc.)
+ * @returns {Promise<void>} Resolves on success, rejects on failure
+ */
+function runInBrowser(opts) {
+    return new Promise(async function (resolve, reject) {
+        var client = null;
+        var browserLaunched = false;
+        var sessionId = null;
+
+        try {
+            // ── 1. Launch browser via hdc ──
+            var wsUrl = await launchBrowser();
+            browserLaunched = true;
+
+            // ── 2. Connect to CDP browser endpoint ──
+            client = new CdpClient(wsUrl);
+            await client.connect();
+
+            // ── 3. Create a new page (tab) ──
+            var targetResult = await client.send("Target.createTarget", {
+                url: "about:blank",
+            });
+            var targetId = targetResult.targetId;
+
+            // ── 4. Attach to the target (flatten mode for session-based commands) ──
+            var attachResult = await client.send("Target.attachToTarget", {
+                targetId: targetId,
+                flatten: true,
+            });
+            sessionId = attachResult.sessionId;
+
+            // ── 5. Enable Runtime + Page domains ──
+            await client.send("Runtime.enable", {}, sessionId);
+            await client.send("Page.enable", {}, sessionId);
+
+            // ── 6. Wait for page to be ready ──
+            await new Promise(function (pageResolve) {
+                var done = false;
+                var timeout = setTimeout(function () {
+                    if (!done) { done = true; pageResolve(); }
+                }, 5000);
+                client.on("Page.loadEventFired", function (_params, sid) {
+                    if (sid === sessionId && !done) {
+                        done = true;
+                        clearTimeout(timeout);
+                        pageResolve();
+                    }
+                });
+            });
+
+            // ── 7. Set up test page HTML ──
+            await client.send("Runtime.evaluate", {
+                expression: 'document.body.innerHTML = ' +
+                    '"<div id=\\"mocha\\"></div>' +
+                    '<div id=\\"messages\\"></div>' +
+                    '<div id=\\"fixtures\\"></div>";',
+            }, sessionId);
+
+            // ── 8. Set up result capture via console ──
+            var resultPromise = new Promise(function (resResolve, resReject) {
+                var settled = false;
+                var testTimeout = setTimeout(function () {
+                    if (!settled) {
+                        settled = true;
+                        resReject(new Error("Test execution timeout (120s)"));
+                    }
+                }, 120000);
+
+                client.on("Runtime.consoleAPICalled", function (params, sid) {
+                    if (sid !== sessionId) return;
+                    if (!params.args || params.args.length === 0) return;
+
+                    var text = params.args.map(function (a) {
+                        return a.value !== undefined ? a.value : (a.description || "");
+                    }).join("");
+
+                    // Forward console output to Node.js stdout (unless quiet)
+                    if (!opts.quiet && !text.startsWith("__FLOSS_RESULT__:")) {
+                        process.stdout.write(text + "\n");
+                    }
+
+                    // Capture result marker
+                    if (text.startsWith("__FLOSS_RESULT__:")) {
+                        if (!settled) {
+                            settled = true;
+                            clearTimeout(testTimeout);
+                            try {
+                                var result = JSON.parse(
+                                    text.substring("__FLOSS_RESULT__:".length)
+                                );
+                                resResolve(result);
+                            } catch (e) {
+                                resReject(new Error("Failed to parse test results: " + e.message));
+                            }
+                        }
+                    }
+                });
+            });
+
+            // ── 9. Inject Mocha browser bundle ──
+            var mochaPkgDir = path.dirname(require.resolve("mocha/package.json"));
+            var mochaBrowserPath = path.join(mochaPkgDir, "mocha.js");
+            if (!fs.existsSync(mochaBrowserPath)) {
+                throw new Error("Mocha browser bundle not found at: " + mochaBrowserPath);
+            }
+            var mochaContent = fs.readFileSync(mochaBrowserPath, "utf-8");
+            await client.send("Runtime.evaluate", {
+                expression: mochaContent,
+            }, sessionId);
+
+            // ── 10. Setup Mocha BDD interface ──
+            await client.send("Runtime.evaluate", {
+                expression: 'mocha.setup({ ui: "bdd" });',
+            }, sessionId);
+
+            // ── 11. Load additional module if specified ──
+            // Note: opts.require (e.g. ts-node/register) is Node.js-specific
+            // and cannot run in browser context. Skipped for CDP path.
+            if (opts.require) {
+                process.stderr.write(
+                    "[floss] Warning: --require option is not supported in browser mode " +
+                    "(CDP path). Module loading is Node.js-specific.\n"
+                );
+            }
+
+            // ── 12. Inject test files ──
+            var files = glob.sync(opts.path);
+            var resolvedFiles = resolveFiles(files);
+
+            if (resolvedFiles.length === 0) {
+                throw new Error("No test files found for path: " + opts.path);
+            }
+
+            for (var i = 0; i < resolvedFiles.length; i++) {
+                var fileContent = fs.readFileSync(resolvedFiles[i], "utf-8");
+                // Inject test file content directly.
+                // describe/it/before/after are global (set up by mocha.setup).
+                // Files using require()/module.exports will not work in browser context.
+                await client.send("Runtime.evaluate", {
+                    expression: fileContent,
+                }, sessionId);
+            }
+
+            // ── 13. Run Mocha tests ──
+            await client.send("Runtime.evaluate", {
+                expression: [
+                    "mocha.run(function(failures) {",
+                    "    var result = {",
+                    "        failures: failures,",
+                    "        total: (typeof mocha !== 'undefined' && mocha.stats) ? mocha.stats.total : 0,",
+                    "        passes: (typeof mocha !== 'undefined' && mocha.stats) ? mocha.stats.passes : 0",
+                    "    };",
+                    "    console.log('__FLOSS_RESULT__:' + JSON.stringify(result));",
+                    "});",
+                ].join("\n"),
+            }, sessionId);
+
+            // ── 14. Wait for test results ──
+            var result = await resultPromise;
+
+            // ── 15. Cleanup ──
+            client.close();
+            await closeBrowser();
+
+            // ── 16. Return result ──
+            if (result.total === 0) {
+                reject(new Error(
+                    "No tests executed in browser. Test files likely use require() " +
+                    "which is not available in browser context."
+                ));
+            } else if (result.failures > 0) {
+                reject(new Error(
+                    "Mocha tests failed: " + result.failures +
+                    " failure(s) out of " + (result.total || "unknown") + " test(s)."
+                ));
+            } else {
+                resolve();
+            }
+
+        } catch (e) {
+            // Cleanup on error
+            if (client) { try { client.close(); } catch (e2) {} }
+            if (browserLaunched) { try { await closeBrowser(); } catch (e3) {} }
+            reject(e);
+        }
+    });
+}
+
+exports.runInBrowser = runInBrowser;

package/lib/index.js

@@ -48,15 +48,26 @@ function floss(options) {
         throw new Error('Path type is not a string');
     }
     if (!opts.electron) {
-        // Electron not available (e.g., HarmonyOS). Use Node.js + jsdom runner.
-        // This provides fully functional test execution using real Mocha and jsdom.
+        // Electron not available (e.g., HarmonyOS). Try three fallback levels:
+        //   Level 1: 海泰浏览器 (Chromium) via CDP — full browser capabilities
+        //   Level 2: jsdom — basic DOM simulation (pure JS, no rendering)
+        //   Level 3: Error — no runner available
+
+        // Level 1: Try browser-runner (海泰浏览器 + CDP)
+        // Level 2: Fall back to node-runner (jsdom) on any failure
         try {
+            const browserRunner = require('./browser-runner');
+            return browserRunner.runInBrowser(opts).catch((browserErr) => {
+                // Browser runner failed (launch error, 0 tests, or timeout)
+                const nodeRunner = require('./node-runner');
+                return nodeRunner.runInNode(opts);
+            });
+        }
+        catch (browserErr) {
+            // require('./browser-runner') failed synchronously
             const nodeRunner = require('./node-runner');
             return nodeRunner.runInNode(opts);
         }
-        catch (e) {
-            throw new Error('Unable to find Electron. Install \'electron\' alongside Floss. (Node.js runner failed: ' + e.message + ')');
-        }
     }
     const app = path.join(__dirname, 'main');
     const args = JSON.stringify(opts);

package/lib/node-runner.js

@@ -19,13 +19,6 @@ const querystring = require("querystring");
 function runInNode(opts) {
     return new Promise((resolve, reject) => {
         try {
-            // Set global options (same as renderer.js line 41)
-            // This allows test code to access custom options via global.options
-            global.options = opts;
-            // Inject args into process.argv (same as Electron spawn behavior)
-            if (opts.args && opts.args.length) {
-                process.argv.push(...opts.args);
-            }
             // Set up jsdom environment for DOM-dependent tests
             // jsdom provides a real DOM implementation (not a stub)
             const { JSDOM } = require('jsdom');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohos-ports/floss",
-  "version": "5.0.1-beta.1",
+  "version": "5.0.1-beta.3",
   "description": "Unit-testing for those hard to reach places",
   "bin": "./lib/floss.js",
   "main": "./lib/index.js",
@@ -64,10 +64,13 @@
     "chalk": "^4.1.0",
     "commander": "^7.0.0",
     "glob": "^7.1.6",
-    "jsdom": "^30.0.1",
     "mocha": "^8.0.0",
     "resolve": "^1.19.0"
   },
+  "optionalDependencies": {
+    "jsdom": "^30.0.1",
+    "ws": "^8.0.0"
+  },
   "peerDependencies": {
     "electron": ">=12 <14",
     "nyc": ">=13"