@brillout/test-e2e 0.1.3

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./dist/cli.js')

package/dist/Logs.d.ts

@@ -0,0 +1,29 @@
+export { expectBrowserError };
+export declare const Logs: {
+    add: typeof add;
+    flush: typeof flush;
+    clear: typeof clear;
+    getBrowserErrors: typeof getBrowserErrors;
+    flushEagerly: boolean;
+};
+declare type LogType = 'stdout' | 'stderr' | 'Browser Error' | 'Browser Log' | 'Run Start' | 'Jest' | 'process' | 'Connection Error';
+declare type TestContext = null | {
+    testName: string;
+    cmd: string;
+};
+declare type LogEntry = {
+    logType: LogType;
+    logText: string;
+    logTimestamp: string;
+    testContext: TestContext;
+    isExpectedError: boolean;
+};
+declare function getBrowserErrors(): LogEntry[];
+declare function clear(): void;
+declare function flush(): void;
+declare function add({ logType, logText, testContext }: {
+    logType: LogType;
+    logText: string;
+    testContext: TestContext;
+}): void;
+declare function expectBrowserError(browserLogFilter: (browserLog: LogEntry) => boolean): void;

package/dist/Logs.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logs = exports.expectBrowserError = void 0;
+exports.Logs = {
+    add,
+    flush,
+    clear,
+    getBrowserErrors,
+    flushEagerly: false,
+};
+const utils_1 = require("./utils");
+const kolorist_1 = require("kolorist");
+let logEntries = [];
+let logEntriesNotPrinted = [];
+function getBrowserErrors() {
+    return logEntries.filter(({ logType, isExpectedError }) => logType === 'Browser Error' && !isExpectedError);
+}
+function clear() {
+    logEntries = [];
+    logEntriesNotPrinted = [];
+}
+function flush() {
+    logEntriesNotPrinted.forEach((logEntry) => printLog(logEntry));
+    logEntriesNotPrinted = [];
+}
+function add({ logType, logText, testContext }) {
+    const logTimestamp = getTimestamp();
+    const logEntry = {
+        logType,
+        logText,
+        testContext,
+        logTimestamp,
+        isExpectedError: false,
+    };
+    logEntriesNotPrinted.push(logEntry);
+    logEntries.push(logEntry);
+    if (exports.Logs.flushEagerly) {
+        flush();
+    }
+}
+function expectBrowserError(browserLogFilter) {
+    const found = !!logEntries.find((logEntry) => {
+        if (browserLogFilter(logEntry)) {
+            logEntry.isExpectedError = true;
+            return true;
+        }
+        return false;
+    });
+    //expect(found).toBe(true)
+    (0, utils_1.assert)(found === true);
+}
+exports.expectBrowserError = expectBrowserError;
+function getTimestamp() {
+    const now = new Date();
+    const time = now.toTimeString().split(' ')[0];
+    const milliseconds = now.getTime().toString().split('').slice(-3).join('');
+    const timestamp = time + '.' + milliseconds;
+    return timestamp;
+}
+function printLog(logEntry) {
+    const { logType, logText, logTimestamp, testContext } = logEntry;
+    let prefix = logType;
+    if (logType === 'stderr' || logType === 'Browser Error')
+        prefix = (0, kolorist_1.bold)((0, kolorist_1.red)(logType));
+    if (logType === 'stdout' || logType === 'Browser Log')
+        prefix = (0, kolorist_1.bold)((0, kolorist_1.blue)(logType));
+    let msg = logText;
+    if (!msg)
+        msg = ''; // don't know why but sometimes `logText` is `undefined`
+    if (!msg.endsWith('\n'))
+        msg = msg + '\n';
+    if (testContext) {
+        const { testName, cmd } = testContext;
+        msg = `[${testName}][${cmd}] ${msg}`;
+    }
+    process.stderr.write(`[${logTimestamp}][${prefix}]${msg}`);
+}

package/dist/buildTs.d.ts

@@ -0,0 +1,2 @@
+export { buildTs };
+declare function buildTs(entry: string, outfile: string): Promise<void>;

package/dist/buildTs.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTs = void 0;
+const esbuild_1 = __importDefault(require("esbuild"));
+async function buildTs(entry, outfile) {
+    await esbuild_1.default.build({
+        platform: 'node',
+        entryPoints: [entry],
+        sourcemap: true,
+        outfile,
+        logLevel: 'warning',
+        format: 'esm',
+        target: 'es2020',
+        bundle: true,
+        external: ['./node_modules/*', '@brillout/test-e2e'],
+        minify: false,
+    });
+}
+exports.buildTs = buildTs;

package/dist/chai/JestChaiExpect.d.ts

@@ -0,0 +1,2 @@
+import type { ChaiPlugin } from './types';
+export declare const JestChaiExpect: ChaiPlugin;

package/dist/chai/JestChaiExpect.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JestChaiExpect = void 0;
+// Copied from https://github.com/vitest-dev/vitest/blob/f3524602ccc678badaae6bc5c3945008d8cfd82a/packages/vitest/src/integrations/chai/jest-expect.ts
+const JestChaiExpect = (chai, utils) => {
+    function def(name, fn) {
+        utils.addMethod(chai.Assertion.prototype, name, fn);
+    }
+    def('toContain', function (item) {
+        return this.contain(item);
+    });
+    def('toMatch', function (item) {
+        return this.match(item);
+    });
+    def('toBe', function (item) {
+        return this.equal(item);
+    });
+    def('toBeTruthy', function () {
+        const obj = utils.flag(this, 'object');
+        this.assert(Boolean(obj), 'expected #{this} to be truthy', 'expected #{this} to not be truthy', obj);
+    });
+    def('toBeFalsy', function () {
+        const obj = utils.flag(this, 'object');
+        this.assert(!obj, 'expected #{this} to be falsy', 'expected #{this} to not be falsy', obj);
+    });
+};
+exports.JestChaiExpect = JestChaiExpect;

package/dist/chai/expect.d.ts

@@ -0,0 +1,2 @@
+import type { Expect } from './types';
+export declare const expect: Expect;

package/dist/chai/expect.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = void 0;
+const JestChaiExpect_1 = require("./JestChaiExpect");
+const chai = __importStar(require("chai"));
+chai.use(JestChaiExpect_1.JestChaiExpect);
+exports.expect = chai.expect;

package/dist/chai/types.d.ts

@@ -0,0 +1,15 @@
+export type { ChaiPlugin };
+export type { Expect };
+import type { use as chaiUse } from 'chai';
+declare type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
+declare type ChaiPlugin = FirstFunctionArgument<typeof chaiUse>;
+declare type Assertion = Chai.Assertion & {
+    not: Assertion;
+    toContain: Assertion['contain'];
+    toMatch: Assertion['match'];
+    toBe: Assertion['equal'];
+    toBeFalsy(): void;
+    toBeTruthy(): void;
+    toBee: Assertion['equal'];
+};
+declare type Expect = (value: any) => Assertion;

package/dist/chai/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli.d.ts

@@ -0,0 +1 @@
+import 'source-map-support/register';

package/dist/cli.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+require("source-map-support/register");
+const runTestSuites_1 = require("./runTestSuites");
+initPromiseRejectionHandler();
+cli();
+function cli() {
+    const { filter, debug } = parseArgs();
+    (0, runTestSuites_1.runTestSuites)({ filter, debug });
+}
+function parseArgs() {
+    let debug = false;
+    const terms = [];
+    let exclude = false;
+    process.argv.slice(2).forEach((arg) => {
+        if (arg === '--debug') {
+            debug = true;
+        }
+        else if (arg === '--exclude') {
+            exclude = true;
+        }
+        else {
+            terms.push(arg);
+        }
+    });
+    const filter = terms.length === 0
+        ? null
+        : {
+            terms,
+            exclude,
+        };
+    return {
+        filter,
+        debug,
+    };
+}
+function initPromiseRejectionHandler() {
+    process.on('unhandledRejection', function (err) {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/editFile.d.ts

@@ -0,0 +1,6 @@
+export { editFile };
+export { editFileRevert };
+export { editFileAssertReverted };
+declare function editFile(filePathRelative: string, replacer: (fileContent: string) => string): void;
+declare function editFileRevert(): void;
+declare function editFileAssertReverted(): void;

package/dist/editFile.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editFileAssertReverted = exports.editFileRevert = exports.editFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const getTestInfo_1 = require("./getTestInfo");
+const filesContentOriginal = {};
+function editFile(filePathRelative, replacer) {
+    const filePath = getFilePath(filePathRelative);
+    const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+    if (!(filePath in filesContentOriginal)) {
+        filesContentOriginal[filePath] = fileContent;
+    }
+    const fileContentNew = replacer(fileContent);
+    // expect(fileContentNew).not.toBe(fileContent)
+    (0, utils_1.assert)(fileContentNew !== fileContent);
+    fs_1.default.writeFileSync(filePath, fileContentNew);
+}
+exports.editFile = editFile;
+function editFileRevert() {
+    Object.entries(filesContentOriginal).forEach(([filePath, fileContent]) => {
+        fs_1.default.writeFileSync(filePath, fileContent);
+        delete filesContentOriginal[filePath];
+    });
+}
+exports.editFileRevert = editFileRevert;
+function editFileAssertReverted() {
+    const filesDirty = Object.keys(filesContentOriginal);
+    try {
+        // expect(filesDirty).toEqual([])
+        (0, utils_1.assert)(filesDirty.length === 0);
+    }
+    catch (err) {
+        editFileRevert();
+        throw err;
+    }
+    (0, utils_1.assert)(filesDirty.length === 0);
+}
+exports.editFileAssertReverted = editFileAssertReverted;
+function getFilePath(filePathRelative) {
+    const { testFile } = (0, getTestInfo_1.getTestInfo)();
+    const cwd = path_1.default.dirname(testFile);
+    const filePath = require.resolve(filePathRelative, { paths: [cwd] });
+    return filePath;
+}

package/dist/findTestFiles.d.ts

@@ -0,0 +1,3 @@
+export { findTestFiles };
+import { FindFilter } from './utils';
+declare function findTestFiles(findFilter: null | FindFilter): Promise<string[]>;

package/dist/findTestFiles.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTestFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
+const cwd = process.cwd();
+// Unit tests `**/*.spec.*` are handled by Vitesse
+const testFilenamePattern = '**/*.test.ts';
+async function findTestFiles(findFilter) {
+    if (process.env.TEST_FILES) {
+        const testFiles = process.env.TEST_FILES.split(' ').map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
+        testFiles.forEach((testFile) => {
+            (0, utils_1.assert)(fs_1.default.existsSync(testFile), testFile);
+        });
+        return testFiles;
+    }
+    else {
+        const testFiles = (0, utils_1.findFiles)(testFilenamePattern, findFilter);
+        return testFiles;
+    }
+}
+exports.findTestFiles = findTestFiles;

package/dist/getBrowser.d.ts

@@ -0,0 +1,3 @@
+export { getBrowser };
+import { Browser } from 'playwright-chromium';
+declare function getBrowser(): Promise<Browser>;

package/dist/getBrowser.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowser = void 0;
+const playwright_chromium_1 = require("playwright-chromium");
+const logProgress_1 = require("./logProgress");
+let browser;
+async function getBrowser() {
+    if (!browser) {
+        const done = (0, logProgress_1.logProgress)('Launch Browser', true);
+        browser = await playwright_chromium_1.chromium.launch({ headless: true });
+        done();
+    }
+    return browser;
+}
+exports.getBrowser = getBrowser;

package/dist/getTestInfo.d.ts

@@ -0,0 +1,21 @@
+export { getTestInfo };
+export { setTestInfo };
+import type { Page } from 'playwright-chromium';
+declare type TestInfo = {
+    testFile: string;
+    tests?: {
+        testDesc: string;
+        testFn: Function;
+    }[];
+    testCmd?: string;
+    testTimeout?: number;
+    hasStartedRunning?: boolean;
+    runWasCalled?: true;
+    skipped?: string;
+    beforeAll?: () => Promise<void>;
+    afterAll?: () => Promise<void>;
+    afterEach?: (hasFailed: boolean) => void;
+    page?: Page;
+};
+declare function getTestInfo(): TestInfo;
+declare function setTestInfo(testInfo_: null | TestInfo): void;

package/dist/getTestInfo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTestInfo = exports.getTestInfo = void 0;
+const utils_1 = require("./utils");
+let testInfo = null;
+function getTestInfo() {
+    (0, utils_1.assert)(testInfo);
+    return testInfo;
+}
+exports.getTestInfo = getTestInfo;
+function setTestInfo(testInfo_) {
+    testInfo = testInfo_;
+}
+exports.setTestInfo = setTestInfo;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './setup';
+export { expect } from './chai/expect';
+export { test } from './test';
+export { page } from './page';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.page = exports.test = exports.expect = void 0;
+__exportStar(require("./setup"), exports);
+var expect_1 = require("./chai/expect");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return expect_1.expect; } });
+var test_1 = require("./test");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return test_1.test; } });
+var page_1 = require("./page");
+Object.defineProperty(exports, "page", { enumerable: true, get: function () { return page_1.page; } });

package/dist/logProgress.d.ts

@@ -0,0 +1,2 @@
+export { logProgress };
+declare function logProgress(text: string, isSetup?: true): (failed?: boolean) => void;

package/dist/logProgress.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logProgress = void 0;
+const getTestInfo_1 = require("./getTestInfo");
+const utils_1 = require("./utils");
+const iconSuccess = '🟢';
+const iconPending = '🟠';
+const iconFail = '🔴';
+function logProgress(text, isSetup) {
+    const prefix = getPrefix(isSetup);
+    if (utils_1.isTTY) {
+        const done = () => { };
+        return done;
+    }
+    process.stdout.write(`${prefix}${iconPending} ${text}`);
+    let alreadyDone = false;
+    const done = (failed) => {
+        if (alreadyDone)
+            return;
+        alreadyDone = true;
+        clear();
+        const iconDone = failed ? iconFail : iconSuccess;
+        process.stdout.write(`${prefix}${iconDone} ${text}\n`);
+    };
+    return done;
+}
+exports.logProgress = logProgress;
+function getPrefix(isSetup) {
+    if (isSetup) {
+        return '';
+    }
+    if (!(0, getTestInfo_1.getTestInfo)()) {
+        return '';
+    }
+    return ' | ';
+}
+function clear() {
+    // @ts-ignore
+    process.stdout.clearLine();
+    process.stdout.cursorTo(0);
+}

package/dist/page.d.ts

@@ -0,0 +1,3 @@
+export { page };
+import type { Page } from 'playwright-chromium';
+declare const page: Page;

package/dist/page.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.page = void 0;
+const utils_1 = require("./utils");
+const getTestInfo_1 = require("./getTestInfo");
+const page = new Proxy({}, {
+    get(_, prop) {
+        const { page } = (0, getTestInfo_1.getTestInfo)();
+        (0, utils_1.assert)(page);
+        return page[prop];
+    },
+});
+exports.page = page;

package/dist/runTestSuites.d.ts

@@ -0,0 +1,6 @@
+export { runTestSuites };
+import { FindFilter } from './utils';
+declare function runTestSuites({ filter, debug }: {
+    filter: null | FindFilter;
+    debug: boolean;
+}): Promise<void>;

package/dist/runTestSuites.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTestSuites = void 0;
+const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
+const getTestInfo_1 = require("./getTestInfo");
+const runTests_1 = require("./runTests");
+const getBrowser_1 = require("./getBrowser");
+const buildTs_1 = require("./buildTs");
+const findTestFiles_1 = require("./findTestFiles");
+async function runTestSuites({ filter, debug }) {
+    const testFiles = await (0, findTestFiles_1.findTestFiles)(filter);
+    const browser = await (0, getBrowser_1.getBrowser)();
+    for (const testFile of testFiles) {
+        (0, utils_1.assert)(testFile.endsWith('.ts'));
+        const testFileJs = testFile.replace('.ts', '.mjs');
+        await (0, buildTs_1.buildTs)(testFile, testFileJs);
+        (0, getTestInfo_1.setTestInfo)({ testFile });
+        try {
+            await import(workaroundBug(testFileJs));
+            await (0, runTests_1.runTests)(browser);
+        }
+        finally {
+            if (!debug) {
+                fs_1.default.unlinkSync(`${testFileJs}`);
+                fs_1.default.unlinkSync(`${testFileJs}.map`);
+            }
+        }
+        (0, getTestInfo_1.setTestInfo)(null);
+        (0, utils_1.assert)(testFileJs.endsWith('.mjs'));
+    }
+    await browser.close();
+}
+exports.runTestSuites = runTestSuites;
+// https://stackoverflow.com/questions/69665780/error-err-unsupported-esm-url-scheme-only-file-and-data-urls-are-supported-by/70057245#70057245
+function workaroundBug(testFileJs) {
+    return `file://${testFileJs}`;
+}

package/dist/runTests.d.ts

@@ -0,0 +1,3 @@
+export { runTests };
+import type { Browser } from 'playwright-chromium';
+declare function runTests(browser: Browser): Promise<void>;