@ohos-ports/floss 5.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jibo, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,188 @@
+# Floss
+
+Unit-testing for those hard to reach places.
+
+[![Node.js CI](https://github.com/pixijs/floss/workflows/Node.js%20CI/badge.svg)](https://github.com/pixijs/floss/actions?query=workflow%3A%22Node.js+CI%22) [![npm version](https://badge.fury.io/js/floss.svg)](https://badge.fury.io/js/floss)
+
+Uses Electron to provide a Mocha unit-testing environment which can be run headlessly or to debugged with DevTools. This was largely inspired by the [electron-mocha](https://github.com/jprichardson/electron-mocha) and [mocha-electron](https://github.com/tscanlin/mochatron) projects but didn't quite have the debugging features needed to develop tests.
+
+## Installation
+
+Install globally:
+
+```bash
+npm install -g floss electron
+```
+
+Install locally within a project:
+
+```bash
+npm install floss electron --save-dev
+```
+
+### Debug Mode
+
+Open tests in an Electron window where test can can be debugged with `debugger` and dev tools.
+
+```js
+await floss({
+    path: 'test/*.js',
+    debug: true
+});
+```
+
+### Mocha Reporter
+
+The `reporter` and `reporterOptions` are pass-through options for Mocha to specify a different reporter when running Floss in non-debug mode.
+
+```js
+await floss({
+    path: 'test/*.js',
+    reporter: 'xunit',
+    reporterOptions: {
+    	filename: 'report.xml'
+    }
+});
+```
+
+### Custom Options
+
+Additional properties can be passed to the test code by adding more values to the run options.
+
+```js
+await floss({
+    path: 'test/*.js',
+    customUrl: 'http://localhost:8080' // <- custom
+});
+```
+
+The test code and use the global `options` property to have access to the run options.
+
+```js
+console.log(options.customUrl); // logs: http://localhost:8080
+```
+
+### Electron Arguments
+
+Commandline arguments can be passed to Electron directly by using `args`. In the example below, you may wan to disable Electron's user-gesture policy if you are testing HTML video or audio playback.
+
+```js
+await floss({
+    path: 'test/index.js',
+    args: ['--autoplay-policy=no-user-gesture-required']
+});
+```
+
+## Command Line Usage
+
+### Arguments
+
+* **--path** or **-p** (String) Path to the file to test
+* **--debug** or **-d**  (Boolean) Enable to run in headful mode, default `false`.
+* **--quiet** or **-q** (Boolean) Prevent console[log/info/error/warn/dir] messages from appearing in `stdout`.
+* **--electron** or **-e**  (String) Path to the electron to use.
+* **--reporter** or **-R**  (String) Mocha reporter type, default `spec`.
+* **--reporterOptions** or **-O**  (String) Mocha reporter options.
+* **--require** or **-r** (String) Module to require (e.g., `ts-node/register`).
+* **-- [args]** Additional arguments can be passed to Electron after `--`
+
+### Usage
+
+Command Line usage when installed globally:
+
+```bash
+floss --path "test/*.js"
+```
+
+Or installed locally:
+
+```bash
+node node_modules/.bin/floss --path "test/*.js"
+```
+
+Alernatively, within the **package.json**'s' scripts:
+
+```json
+{
+    "scripts": {
+        "test": "floss --path \"test/*.js\""
+    }
+}
+```
+
+### Debug Mode
+
+Open tests in an Electron window where test can can be debugged with `debugger` and dev tools.
+
+```bash
+floss --path "test/*.js" --debug
+```
+
+### Using TypeScript
+
+Support can easily be added for writing tests in TypeScript using [ts-node](https://www.npmjs.com/package/ts-node).
+
+```bash
+floss --path "test/*.ts" --require ts-node/register
+```
+
+### Istanbul Code Coverage
+
+Floss supports `nyc`. To use it, just use floss as you would mocha:
+
+```bash
+nyc floss --path "test/*.js"
+```
+
+### Mocha Reporter
+
+Can use the same reporter options as the API mentioned above. The `reporterOptions` are expressed as a querystring, for instance `varname=foo&another=bar`.
+
+```bash
+floss --path "test/*.js" \
+    --reporter=xunit \
+    --reporterOptions output=report.xml
+```
+
+### Electron Arguments
+
+Supports passing additional arguments to Electron after `--`.
+
+```bash
+floss --path "test/*.js" -- --autoplay-policy=no-user-gesture-required
+```
+
+## Custom Electron Version
+
+Some application may require a specific version of Electron. Floss uses Electron 10.0.0+, but you can specific the path to your own version. The custom version can be used either through the commandline argument `--electron`, by setting the Node environmental variable `ELECTRON_PATH` or by setting the run option `electron`.
+
+```bash
+floss --path "test/.js" \
+	--electron /usr/local/bin/electron
+```
+
+```bash
+ELECTRON_PATH=/usr/local/bin/electron floss --path "test/*.js"
+```
+
+## GitHub Actions Integration
+
+```yml
+name: Node.js CI
+on:
+  push:
+    branches: [ '**' ]
+    tags: [ '**' ]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v1
+      with:
+        node-version: '12'
+    - run: npm install
+    - uses: GabrielBB/xvfb-action@v1.0
+      with:
+        run: npm test
+```

package/lib/common.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Events shareed between renderer and main process.
+ */
+declare const enum FlossEvent {
+    Error = "floss-error",
+    Done = "floss-done",
+    Start = "floss-start"
+}
+export { FlossEvent };

package/lib/common.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbW1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/lib/floss.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/floss.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander = require("commander");
+const _1 = require("./");
+/**
+ * Parse the commandline arguments.
+ */
+const getProgram = () => commander
+    .requiredOption('-p, --path [path/to/folder/or/file.js]', 'Either a path to a directory '
+    + 'containing index.js or a path to a single test file')
+    .option('-d, --debug', 'Launch electron in debug mode')
+    .option('-e, --electron [path/to/Electron]', 'Path to version of Electron to test on')
+    .option('-R, --reporter [spec]', 'Mocha reporter for headless mode only')
+    .option('-O, --reporterOptions [filename=report.xml]', 'Additional arguments for reporter '
+    + 'options, query-string formatted')
+    .option('-r, --require [module]', 'Require module')
+    .option('-q, --quiet', 'Prevent console.(log/info/error/warn) messages from appearing in STDOUT')
+    .parseAsync(process.argv);
+/**
+ * Main entry-point for the CLI
+ */
+async function main() {
+    try {
+        const program = await getProgram();
+        const options = program.opts();
+        options.args = [...program.args];
+        // Sanitize undefined properties
+        for (const prop in options) {
+            const p = prop;
+            if (options[p] === undefined) {
+                delete options[p];
+            }
+        }
+        await _1.floss(options);
+        process.exit(0);
+    }
+    catch (err) {
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZmxvc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsdUNBQXVDO0FBQ3ZDLHlCQUEyQjtBQUczQjs7R0FFRztBQUNILE1BQU0sVUFBVSxHQUFHLEdBQUcsRUFBRSxDQUNwQixTQUFTO0tBQ0osY0FBYyxDQUFDLHdDQUF3QyxFQUFFLCtCQUErQjtNQUNuRixxREFBcUQsQ0FBQztLQUMzRCxNQUFNLENBQUMsYUFBYSxFQUFFLCtCQUErQixDQUFDO0tBQ3RELE1BQU0sQ0FBQyxtQ0FBbUMsRUFBRSx3Q0FBd0MsQ0FBQztLQUNyRixNQUFNLENBQUMsdUJBQXVCLEVBQUUsdUNBQXVDLENBQUM7S0FDeEUsTUFBTSxDQUFDLDZDQUE2QyxFQUFFLG9DQUFvQztNQUNyRixpQ0FBaUMsQ0FBQztLQUN2QyxNQUFNLENBQUMsd0JBQXdCLEVBQUUsZ0JBQWdCLENBQUM7S0FDbEQsTUFBTSxDQUFDLGFBQWEsRUFBRSx5RUFBeUUsQ0FBQztLQUNoRyxVQUFVLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBRWxDOztHQUVHO0FBQ0gsS0FBSyxVQUFVLElBQUk7SUFFZixJQUNBO1FBQ0ksTUFBTSxPQUFPLEdBQUcsTUFBTSxVQUFVLEVBQUUsQ0FBQztRQUNuQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxFQUFrQixDQUFDO1FBRS9DLE9BQU8sQ0FBQyxJQUFJLEdBQUcsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUVqQyxnQ0FBZ0M7UUFDaEMsS0FBSyxNQUFNLElBQUksSUFBSSxPQUFPLEVBQzFCO1lBQ0ksTUFBTSxDQUFDLEdBQUcsSUFBMEIsQ0FBQztZQUVyQyxJQUFJLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxTQUFTLEVBQzVCO2dCQUNJLE9BQU8sT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQ3JCO1NBQ0o7UUFFRCxNQUFNLFFBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNyQixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ25CO0lBQ0QsT0FBTyxHQUFHLEVBQ1Y7UUFDSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ25CO0FBQ0wsQ0FBQztBQUVELElBQUksRUFBRSxDQUFDIn0=

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+interface FlossOptions {
+    path: string;
+    debug?: boolean;
+    electron?: string;
+    reporter?: string;
+    reporterOptions?: any;
+    require?: string;
+    args?: string[];
+}
+/**
+ * API to launch the Floss application.
+ * @module floss
+ * @param {Object|String} options The options map or path.
+ * @param {String} [options.path] Path to the JS file to run, can be a glob.
+ * @param {Boolean} [options.debug] `true` opens in headful mode.
+ * @param {String} [options.electron] Path to custom electron version. If undefined
+ *        will use environment variable `ELECTRON_PATH` or electron
+ *        installed alongside.
+ * @param {String} [options.require] Additional module to require.
+ * @param {String} [options.reporter=spec] Mocha reporter (non-debug mode only)
+ * @param {String|Object} [options.reporterOptions] Additional options for the reporter
+ *        useful for specifying an output file if using the 'xunit' reporter.
+ *        Options can be a querystring format, e.g., `"foo=2&bar=something"`
+ * @param {String[]} [options.args] Additional Electron arguments, can be useful
+ *        for things like disable autoplay gestures, e.g.,
+ *        `["--autoplay-policy=no-user-gesture-required"]`
+ * @param {Function} done Called when completed. Passes error if failed.
+ */
+declare function floss(options: string | FlossOptions): Promise<void>;
+export { floss };
+export type { FlossOptions };

package/lib/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Floss Tests</title>
+        <link id="mocha-css" rel="stylesheet" />
+        <style>
+            body { background-color: white; }
+        </style>
+    </head>
+    <body>
+        <div id="mocha"></div>
+        <div id="messages"></div>
+        <div id="fixtures"></div>
+        <script>
+            const Renderer = require('./renderer');
+            new Renderer('mocha-css');
+        </script>
+    </body>
+</html>

package/lib/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.floss = void 0;
+const path = require("path");
+const child_process_1 = require("child_process");
+let electron;
+try {
+    // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+    electron = require('electron');
+}
+catch (err) {
+    // silence is golden
+}
+/**
+ * API to launch the Floss application.
+ * @module floss
+ * @param {Object|String} options The options map or path.
+ * @param {String} [options.path] Path to the JS file to run, can be a glob.
+ * @param {Boolean} [options.debug] `true` opens in headful mode.
+ * @param {String} [options.electron] Path to custom electron version. If undefined
+ *        will use environment variable `ELECTRON_PATH` or electron
+ *        installed alongside.
+ * @param {String} [options.require] Additional module to require.
+ * @param {String} [options.reporter=spec] Mocha reporter (non-debug mode only)
+ * @param {String|Object} [options.reporterOptions] Additional options for the reporter
+ *        useful for specifying an output file if using the 'xunit' reporter.
+ *        Options can be a querystring format, e.g., `"foo=2&bar=something"`
+ * @param {String[]} [options.args] Additional Electron arguments, can be useful
+ *        for things like disable autoplay gestures, e.g.,
+ *        `["--autoplay-policy=no-user-gesture-required"]`
+ * @param {Function} done Called when completed. Passes error if failed.
+ */
+function floss(options) {
+    if (typeof options === 'string') {
+        options = { path: options };
+    }
+    const opts = Object.assign({
+        path: '',
+        debug: false,
+        quiet: false,
+        args: [],
+        electron: process.env.ELECTRON_PATH || electron
+    }, options);
+    if (!opts.path) {
+        throw new Error('No path specified for Floss.');
+    }
+    else if (typeof opts.path !== 'string') {
+        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.
+        try {
+            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);
+    // copy the environment and remove things that would prevent Floss from running properly
+    const envCopy = Object.assign({}, process.env);
+    delete envCopy.ELECTRON_RUN_AS_NODE;
+    delete envCopy.ELECTRON_NO_ATTACH_CONSOLE;
+    return new Promise((resolve, reject) => {
+        let execPath = opts.electron;
+        // In the case where floss is running in windows with the cmdline option --electron electron
+        // options.electron will just be "electron" at this point.
+        // Due to limitations with how nodejs spawns windows processes we need to add .cmd to the end of the command
+        // https://github.com/nodejs/node/issues/3675
+        const isWindows = (/^win/).test(process.platform);
+        if (isWindows && !path.extname(execPath)) {
+            execPath += '.cmd';
+        }
+        const childProcess = child_process_1.spawn(execPath, [app, args, ...opts.args], {
+            stdio: 'pipe',
+            env: envCopy
+        });
+        childProcess.stdout.on('data', (data) => {
+            process.stdout.write(data);
+        });
+        childProcess.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error('Mocha tests failed.'));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+exports.floss = floss;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/main.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/main.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path = require("path");
+const electron_1 = require("electron");
+const chalk = require("chalk");
+// Get the configuration path
+const configPath = path.join(electron_1.app.getPath('userData'), 'config.json');
+/**
+ * Restore the bounds of the window.
+ */
+const restoreBounds = () => {
+    try {
+        return JSON.parse(fs_1.readFileSync(configPath, 'utf8'));
+    }
+    catch (e) {
+        return {
+            width: 1024,
+            height: 768
+        };
+    }
+};
+const createWindow = () => {
+    const args = JSON.parse(process.argv.slice(2)[0]);
+    // Get the window bounds
+    const options = Object.assign(Object.assign({}, restoreBounds()), { show: args.debug, background: '#fff', webPreferences: {
+            nodeIntegration: true,
+            enableRemoteModule: true,
+            contextIsolation: false,
+        } });
+    // Create the browser window.
+    const mainWindow = new electron_1.BrowserWindow(options);
+    electron_1.ipcMain
+        .on("floss-done" /* Done */, () => process.exit(0))
+        .on("floss-error" /* Error */, (_event, message) => {
+        if (message) {
+            console.error(chalk.red(`\n[floss] Error: ${message}\n`));
+        }
+        process.exit(1);
+    });
+    // and load the index.html of the app.
+    mainWindow.loadFile(path.join(__dirname, 'index.html'));
+    const { webContents } = mainWindow;
+    // don't show the dev tools if you're not in headless mode. this is to
+    // avoid having breakpoints and "pause on caught / uncaught exceptions" halting
+    // the runtime.  plus, if you're in headless mode, having the devtools open is probably
+    // not very useful anyway
+    if (args.debug) {
+        webContents.openDevTools({ mode: 'bottom' });
+    }
+    webContents.on('did-finish-load', () => {
+        webContents.send("floss-start" /* Start */, JSON.stringify(args));
+    });
+    mainWindow.on('close', () => {
+        fs_1.writeFileSync(configPath, JSON.stringify(mainWindow.getBounds()));
+    });
+};
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+electron_1.app.whenReady().then(createWindow);
+// Quit when all windows are closed.
+electron_1.app.on('window-all-closed', () => electron_1.app.quit());
+//# sourceMappingURL=data:application/json;base64,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

package/lib/node-runner.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "____esModule", { value: true });
+exports.runInNode = void 0;
+const path = require("path");
+const fs = require("fs");
+const glob = require("glob");
+const querystring = require("querystring");
+/**
+ * Run tests in Node.js using Mocha with jsdom environment.
+ * This provides an alternative execution path when Electron is not available
+ * (e.g., on HarmonyOS where Electron builds don't exist).
+ *
+ * Uses real Mocha Node.js API and real jsdom DOM implementation.
+ * Not a stub - provides fully functional test execution.
+ *
+ * @param {Object} opts - The floss options (path, debug, quiet, reporter, reporterOptions, require)
+ * @returns {Promise<void>} Resolves on success, rejects on failure
+ */
+function runInNode(opts) {
+    return new Promise((resolve, reject) => {
+        try {
+            // Set up jsdom environment for DOM-dependent tests
+            // jsdom provides a real DOM implementation (not a stub)
+            const { JSDOM } = require('jsdom');
+            const dom = new JSDOM('<!DOCTYPE html><html><body><div id="mocha"></div><div id="messages"></div><div id="fixtures"></div></body></html>', {
+                url: 'http://localhost/',
+                pretendToBeVisual: true,
+                runScripts: 'outside-only'
+            });
+            // Make DOM globals available for test files that need them
+            global.window = dom.window;
+            global.document = dom.window.document;
+            // navigator may be read-only in newer Node.js versions
+            try {
+                global.navigator = dom.window.navigator;
+            }
+            catch (e) {
+                // navigator is a getter in Node.js >= 21, skip it
+            }
+            // Load mocha browser support if available (sets up global mocha for bdd)
+            try {
+                require('mocha/mocha');
+            }
+            catch (e) {
+                // mocha browser bundle not available, that's fine for headless mode
+            }
+            // In headless mode, use Node.js Mocha API (same as renderer.js does)
+            const Mocha = require('mocha');
+            // Parse reporter options (same logic as renderer.js)
+            let reporterOptions;
+            if (typeof opts.reporterOptions === 'string') {
+                reporterOptions = querystring.parse(opts.reporterOptions);
+            }
+            // Create Mocha instance with same config as renderer.js headless mode
+            const mochaInst = new Mocha({
+                reporter: opts.reporter || 'spec',
+                reporterOptions,
+                color: true,
+            });
+            // Resolve test files using glob (same as renderer.js)
+            const files = glob.sync(opts.path);
+            // Add files to Mocha (same addFile logic as renderer.js)
+            const resolvedFiles = files
+                .map((file) => {
+                let testPath = path.resolve(file);
+                if (!fs.existsSync(testPath)) {
+                    return null;
+                }
+                // if a single directory, find the index.js file and include that
+                if (fs.statSync(testPath).isDirectory()) {
+                    const indexFile = path.join(testPath, 'index.js');
+                    const 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;
+                }
+                // if it is a single file, only include that file
+                return testPath;
+            })
+                .filter((file) => file !== null);
+            // Require additional module if specified (same as renderer.js)
+            if (opts.require) {
+                require(opts.require);
+            }
+            // Add resolved files to Mocha
+            resolvedFiles.forEach((file) => mochaInst.addFile(file));
+            // Run tests
+            mochaInst.run((errorCount) => {
+                if (errorCount > 0) {
+                    // No error needed, Mocha will report this (same as renderer.js)
+                    reject(new Error('Mocha tests failed.'));
+                }
+                else {
+                    resolve();
+                }
+            });
+        }
+        catch (e) {
+            reject(new Error(`Node.js test runner error: ${e.message}`));
+        }
+    });
+}
+exports.runInNode = runInNode;

package/lib/renderer.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/renderer.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pathNode = require("path");
+const fs = require("fs");
+const resolve = require("resolve");
+const electron_1 = require("electron");
+const querystring = require("querystring");
+const glob = require("glob");
+// enables the browser mocha support - the mocha global is properly set up
+// require('mocha/mocha');
+let nycInst;
+if (process.env.NYC_CONFIG) {
+    // do what nyc does in nyc/bin/wrap.js
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+        const NYC = require('nyc');
+        let config = {};
+        if (process.env.NYC_CONFIG)
+            config = JSON.parse(process.env.NYC_CONFIG);
+        config.isChildProcess = true;
+        config._processInfo = {
+            pid: process.pid,
+            ppid: process.ppid,
+            parent: process.env.NYC_PROCESS_ID || null,
+            root: process.env.NYC_ROOT_ID
+        };
+        if (process.env.NYC_PROCESSINFO_EXTERNAL_ID) {
+            config._processInfo.externalId = process.env.NYC_PROCESSINFO_EXTERNAL_ID;
+            delete process.env.NYC_PROCESSINFO_EXTERNAL_ID;
+        }
+        nycInst = new NYC(config);
+        nycInst.wrap();
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+class Renderer {
+    constructor(linkId) {
+        electron_1.ipcRenderer.on("floss-start" /* Start */, (_ev, data) => {
+            this.options = global.options = JSON.parse(data);
+            const { path, debug, quiet, require: additionalRequire, } = this.options;
+            // Do this before to catch any errors outside mocha running
+            // for instance errors on the page like test's requires
+            this.setupConsoleOutput(quiet, !debug);
+            // Include this AFTER the console binding because
+            // mocha has a static console reference in the base reporter
+            // eslint-disable-next-line global-require
+            require('mocha/mocha');
+            if (additionalRequire) {
+                // eslint-disable-next-line global-require
+                require(additionalRequire);
+            }
+            const files = glob.sync(path);
+            if (debug) {
+                this.headful(files);
+            }
+            else {
+                this.headless(files);
+            }
+        });
+        // Add the stylesheet
+        const mochaPath = pathNode.dirname(resolve.sync('mocha', { basedir: __dirname }));
+        const link = document.getElementById(linkId);
+        link.href = pathNode.join(mochaPath, 'mocha.css');
+    }
+    /**
+     * Run tests using devtools and Electron window.
+     */
+    headful(files) {
+        mocha.setup({
+            ui: 'bdd',
+            timeout: 0
+        });
+        files
+            .map((file) => this.addFile(file))
+            .filter((file) => file !== null)
+            // eslint-disable-next-line global-require
+            .forEach((file) => require(file));
+        mocha.run(() => {
+            // write the coverage file if we need to, as NYC won't do so in our setup
+            if (nycInst) {
+                nycInst.writeCoverageFile();
+            }
+        });
+    }
+    headless(files) {
+        try {
+            mocha.setup({
+                ui: 'bdd',
+            });
+            // Format the reporter options
+            let reporterOptions;
+            // Parse string as an object
+            if (typeof this.options.reporterOptions === 'string') {
+                reporterOptions = querystring.parse(this.options.reporterOptions);
+            }
+            // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+            const Mocha = require('mocha');
+            const mochaInst = new Mocha({
+                reporter: this.options.reporter,
+                reporterOptions,
+                color: true,
+            });
+            files.map((file) => this.addFile(file))
+                .filter((file) => file !== null)
+                .forEach((file) => mochaInst.addFile(file));
+            mochaInst.run((errorCount) => {
+                // write the coverage file if we need to, as NYC won't do so in our setup
+                if (nycInst) {
+                    try {
+                        nycInst.writeCoverageFile();
+                    }
+                    catch (e) {
+                        this.failed('Unable to write coverage file.');
+                        return;
+                    }
+                }
+                if (errorCount > 0) {
+                    // No error needed, Mocha will report this
+                    this.failed();
+                }
+                else {
+                    this.success();
+                }
+            });
+        }
+        catch (e) {
+            // write the coverage file if we need to, as NYC won't do so in our setup
+            if (nycInst) {
+                nycInst.writeCoverageFile();
+            }
+            this.failed(e.message);
+        }
+    }
+    /**
+     * Report when we're done, this will close floss.
+     */
+    success() {
+        electron_1.ipcRenderer.send("floss-done" /* Done */);
+    }
+    /**
+     * Report if we failed, this will close floss with non-zero errorCode.
+     */
+    failed(message) {
+        electron_1.ipcRenderer.send("floss-error" /* Error */, message);
+    }
+    /**
+     * Create new bindings for `console` functions
+     * Use default console[name] and also send IPC
+     * log so we can log to stdout
+     */
+    setupConsoleOutput(isQuiet, isHeadless) {
+        const remoteConsole = electron_1.remote.getGlobal('console');
+        if (!isQuiet && isHeadless) {
+            for (const name in console) {
+                const n = name;
+                if (typeof console[n] === 'function') {
+                    console[n] = remoteConsole[n];
+                }
+            }
+        }
+        // if we don't do this, we get socket errors and our tests crash
+        Object.defineProperty(process, 'stdout', {
+            value: {
+                write: (str) => electron_1.remote.process.stdout.write(str),
+            }
+        });
+    }
+    /**
+     * Resolve test path into absolute path.
+     * @param testPath - Path to test directory of file.
+     */
+    addFile(testPath) {
+        testPath = pathNode.resolve(testPath);
+        if (!fs.existsSync(testPath)) {
+            return null;
+        }
+        // if a single directory, find the index.js file and include that
+        if (fs.statSync(testPath).isDirectory()) {
+            const indexFile = pathNode.join(testPath, 'index.js');
+            const indexTs = pathNode.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;
+        }
+        // if it is a single file, only include that file
+        return testPath;
+    }
+}
+module.exports = Renderer;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@ohos-ports/floss",
+  "version": "5.0.1-beta.0",
+  "description": "Unit-testing for those hard to reach places",
+  "bin": "./lib/floss.js",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "author": "Matt Karl <matt@mattkarl.com>",
+  "contributors": [
+    "Matt Bittarelli <matt.bittarelli@jibo.com>",
+    "Andrew Start <start.andrew@gmail.com>"
+  ],
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint src/*.ts --fix",
+    "types": "tsc -noEmit",
+    "copy": "copyfiles -f src/index.html lib",
+    "clean": "rimraf lib/*",
+    "prebuild": "run-s clean lint copy",
+    "build": "tsc",
+    "prewatch": "run-s copy",
+    "watch": "tsc -w --incremental --tsBuildInfoFile .tsbuildinfo",
+    "test": "run-s test:*",
+    "test:basic": "node lib/floss.js -p test/basic",
+    "test:failure": "node lib/floss.js -p test/failure || true",
+    "test:multiple": "node lib/floss.js -p \"test/multiple/*.js\"",
+    "test:typescript": "node lib/floss.js -p test/typescript -r ts-node/register",
+    "test:coverage": "nyc node lib/floss.js -p test/coverage",
+    "test:options": "node lib/floss.js -p test/options -- --foo=bar",
+    "test:args": "node lib/floss.js -p test/args -- --autoplay-policy=no-user-gesture-required",
+    "preversion": "run-s build test",
+    "postpublish": "git push && git push --tags",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:pixijs/floss.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pixijs/floss/issues"
+  },
+  "homepage": "https://github.com/pixijs/floss",
+  "engines": {
+    "node": ">=10.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mocha",
+    "mocha-electron",
+    "electron-mocha",
+    "electron",
+    "test",
+    "tests",
+    "unit-tests",
+    "unit-testing",
+    "travis",
+    "travis-ci"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.0",
+    "commander": "^7.0.0",
+    "glob": "^7.1.6",
+    "jsdom": "^30.0.1",
+    "mocha": "^8.0.0",
+    "resolve": "^1.19.0"
+  },
+  "peerDependencies": {
+    "electron": ">=12 <14",
+    "nyc": ">=13"
+  },
+  "devDependencies": {
+    "@pixi/eslint-config": "^2.0.1",
+    "@types/glob": "^7.1.3",
+    "@types/mocha": "^8.0.0",
+    "@types/resolve": "^1.17.1",
+    "chai": "^4.2.0",
+    "copyfiles": "^2.4.1",
+    "electron": "^12.0.0",
+    "eslint": "^7.18.0",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^14.0.0",
+    "rimraf": "^3.0.2",
+    "ts-node": "^9.1.1",
+    "typescript": "^3.9.0"
+  }
+}