testeranto 0.114.1 → 0.125.0

package/.aider.conf.yml

@@ -0,0 +1,5 @@
+auto-commits: false
+
+model: deepseek
+api-key:
+ - deepseek=sk-44ac90c2cca746e2b152dd3f97cbf36c

package/.aider.input.history

@@ -85,3 +85,12 @@
 
 # 2025-03-02 11:50:27.903469
 +"Fix
+
+# 2025-04-08 13:05:12.707328
++n
+
+# 2025-04-08 13:08:34.609966
++y
+
+# 2025-04-08 13:13:35.658911
++a

package/README.md

@@ -12,7 +12,7 @@ npm: [npmjs.com/package/testeranto](https://www.npmjs.com/package/testeranto)
 
 dev: [github.dev/adamwong246/testeranto](https://github.dev/adamwong246/testeranto)
 
-example test report: [chromapdx.github.io/kokomoBay](https://chromapdx.github.io/kokomoBay/docs/index.html)
+example test report: [chromapdx.github.io/kokomoBay](https://chromapdx.github.io/kokomoBay/testeranto/index.html)
 
 example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 
@@ -22,6 +22,7 @@ example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 - Testeranto tests are specified in a strongly-typed gherkin-like syntax. Rather than testing your code directly, Testeranto requires you wrap your code with a semantic interface which is based on TS type signatures.
 - Testeranto can be run in the frontend or the backend, or both.
 - Testeranto can be used to test anything that can be bundled with esbuild.
+- Testeranto is _reasonably_ efficient. It is less performant than other similar js testing libraries.
 
 ## tech of note
 
@@ -30,3 +31,16 @@ example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 - puppeteer - provides access to both node and chrome runtimes
 - esbuild - used to quickly generate test bundles
 - aider - AI to automatically fix broken tests
+
+## Do's and Don't
+
+When writing your test, be careful when using platform specific features, like "fs" on node, or "window" in the browser. If you need to write to a file, or to log information, use the `utils`. Instead of platform specific libraries, like node's "assert", use a cross-platform alternative like "chai".
+
+## Platforms
+
+Testeranto runs tests in multiple runtimes. You can run the same test (more or less) in multiple contexts. Depending on your test subject, not all may be applicable
+
+1. Node - the test is run in node v8 via fork.
+2. Web - the test is run in chrome, in a page. If you code relies upon `window` or `document`, you should use this style.
+3. Pure - the test is dynamically imported into the main thread. It will not have access to IO (console.log, etc) but it is more performant.
+4. WebWorker - the test is tested in a web worker, in the browser, but not in a page.

package/bundle.js

@@ -92,7 +92,7 @@ await esbuild.build({
 /////////////////////////
 
 await esbuild.build({
-  entryPoints: ['src/ReportClient.tsx', 'src/TestReport.tsx'],
+  entryPoints: ['src/ReportClient.tsx', 'src/TestReport.tsx', 'src/Project.tsx'],
   bundle: true,
   format: "iife",
   platform: "browser",

package/dist/common/src/Init.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+exports.default = async () => {
+    [
+        `testeranto/`,
+        `testeranto/bundles/`,
+        `testeranto/bundles/node`,
+        `testeranto/bundles/web`,
+        `testeranto/bundles/pure`,
+        `testeranto/reports`,
+        `testeranto/reports/`,
+        `testeranto/features/`,
+    ].forEach((f) => {
+        try {
+            fs_1.default.mkdirSync(`${process.cwd()}/${f}`);
+        }
+        catch (e) {
+            // console.error(e);
+        }
+    });
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.js`, `testeranto/Project.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `testeranto/ReportClient.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.css`, `testeranto/Project.css`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `testeranto/ReportClient.css`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `testeranto/TestReport.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `testeranto/TestReport.css`);
+};

package/dist/common/src/Node.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.NodeTesteranto = void 0;
+const core_js_1 = __importDefault(require("./lib/core.js"));
+const index_js_1 = require("./lib/index.js");
+const node_js_1 = require("./PM/node.js");
+class NodeTesteranto extends core_js_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
+            // no-op
+        });
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = JSON.parse(partialTestResource);
+        const pm = new node_js_1.PM_Node(t);
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
+        // const { failed, artifacts, logPromise, features } =
+        //   await this.testJobs[0].receiveTestResourceConfig(pm);
+        // // pm.customclose();
+        // return { features, failed };
+    }
+}
+exports.NodeTesteranto = NodeTesteranto;
+const testeranto = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
+    const t = new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+    try {
+        const f = await t.receiveTestResourceConfig(process.argv[2]);
+        console.error("goodbye node error", f.fails);
+        process.exit(f.fails);
+    }
+    catch (e) {
+        console.error("goodbye node error", e);
+        process.exit(-1);
+        // fs.writeFileSync(`tests.json`, JSON.stringify(t.,
+        //  null, 2));
+        // process.send({ message: "Hello from child!" });
+        // process.on("message", (message) => {
+        //   const client = net.createConnection(message.path, () => {
+        //     console.error("goodbye node error", e);
+        //     process.exit(-1);
+        //   });
+        // });
+    }
+    return t;
+};
+exports.default = testeranto;

package/dist/common/src/PM/base.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Base = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fileStreams3 = [];
+const fPaths = [];
+const files = {};
+const recorders = {};
+const screenshots = {};
+class PM_Base {
+    constructor(configs) {
+        this.configs = configs;
+    }
+    customclose() {
+        throw new Error("Method not implemented.");
+    }
+    waitForSelector(p, s) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = page.$(s);
+                const y = await x;
+                res(y !== null);
+                // return page.focus(selector);
+            });
+        });
+    }
+    closePage(p) {
+        // throw new Error("Method not implemented.");
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                page.close();
+                res({});
+                // return page.focus(selector);
+            });
+        });
+    }
+    newPage() {
+        return this.browser.newPage();
+    }
+    goto(p, url) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                await (page === null || page === void 0 ? void 0 : page.goto(url));
+                res({});
+                // return page.focus(selector);
+            });
+        });
+    }
+    $(selector, p) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = page.$(selector);
+                const y = await x;
+                res(y !== null);
+            });
+        });
+    }
+    async pages() {
+        return (await this.browser.pages()).map((p) => {
+            return p.mainFrame()._id;
+        });
+    }
+    async screencast(ssOpts, testName, page) {
+        const p = ssOpts.path;
+        const dir = path_1.default.dirname(p);
+        fs_1.default.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async customScreenShot(ssOpts, testName, page) {
+        const p = ssOpts.path;
+        const dir = path_1.default.dirname(p);
+        fs_1.default.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async end(uid) {
+        await fileStreams3[uid].end();
+        return true;
+    }
+    existsSync(destFolder) {
+        return fs_1.default.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs_1.default.existsSync(fp)) {
+            return fs_1.default.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    async writeFileSync(filepath, contents, testName) {
+        return new Promise(async (res) => {
+            fs_1.default.mkdirSync(path_1.default.dirname(filepath), {
+                recursive: true,
+            });
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            await fs_1.default.writeFileSync(filepath, contents);
+            res(true);
+        });
+    }
+    async createWriteStream(filepath, testName) {
+        return new Promise((res) => {
+            const f = fs_1.default.createWriteStream(filepath);
+            fileStreams3.push(f);
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            res(fileStreams3.length - 1);
+        });
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path_1.default.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs_1.default.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    fs_1.default.writeFileSync(path_1.default.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs_1.default.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs_1.default.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs_1.default.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    async write(uid, contents) {
+        return new Promise((res) => {
+            const x = fileStreams3[uid].write(contents);
+            res(x);
+        });
+    }
+    page() {
+        throw new Error("Method not implemented.");
+    }
+    click(selector, page) {
+        return page.click(selector);
+    }
+    async focusOn(selector, p) {
+        this.doInPage(p, (page) => {
+            return page.focus(selector);
+        });
+    }
+    async typeInto(value, p) {
+        this.doInPage(p, (page) => {
+            return page.keyboard.type(value);
+        });
+    }
+    getValue(value, p) {
+        this.doInPage(p, (page) => {
+            return page.keyboard.type(value);
+        });
+    }
+    getAttribute(selector, attribute, p) {
+        this.doInPage(p, (page) => {
+            return page.$eval(selector, (input) => input.getAttribute("value"));
+        });
+    }
+    isDisabled(selector, p) {
+        this.doInPage(p, async (page) => {
+            return await page.$eval(selector, (input) => {
+                return input.disabled;
+            });
+        });
+    }
+    screencastStop(s) {
+        return recorders[s].stop();
+    }
+    async doInPage(p, cb) {
+        (await this.browser.pages()).forEach((page) => {
+            if (page.mainFrame()._id === p) {
+                return cb(page);
+            }
+        });
+    }
+}
+exports.PM_Base = PM_Base;