testeranto 0.129.0 → 0.134.0

package/dist/module/src/build.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import ansiC from "ansi-colors";
 import fs from "fs";
 import path from "path";
@@ -11,7 +13,7 @@ import { getRunnables } from "./utils.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-let testName = process.argv[2];
+const testName = process.argv[2];
 let mode = process.argv[3];
 if (mode !== "once" && mode !== "dev") {
     console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
@@ -41,6 +43,19 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         };
         return Array.from(meta(config.tests, new Set()));
     };
+    const getSideCars = (runtime) => {
+        return Array.from(new Set(config.tests
+            .reduce((mm, t) => {
+            mm = mm.concat(t[3]);
+            return mm;
+        }, [])
+            .filter((t) => {
+            return t[1] === runtime;
+        })
+            .map((t) => {
+            return t[0];
+        })));
+    };
     const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/testeranto/bundles/" + testName });
     console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
     process.stdin.on("keypress", (str, key) => {
@@ -61,7 +76,11 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     let webDone = false;
     let importDone = false;
     let status = "build";
-    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(config.tests, testName);
+    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = getRunnables(config.tests, testName);
+    // const { nodeEntryPointsSidecars, webEntryPointsSidecars, importEntryPointsSideCars } = getRunnableSidecars(
+    //   config.tests,
+    //   testName
+    // );
     const onNodeDone = () => {
         nodeDone = true;
         onDone();
@@ -83,6 +102,7 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             process.exit();
         }
     };
+    console.log(`testeranto/reports/${testName}`);
     if (!fs.existsSync(`testeranto/reports/${testName}`)) {
         fs.mkdirSync(`testeranto/reports/${testName}`);
     }
@@ -161,11 +181,24 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     //   });
     // });
     const x = [
-        ["pure", Object.keys(importEntryPoints)],
+        ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
         ["web", Object.keys(webEntryPoints)],
+        // [
+        //   "pure",
+        //   [...Object.keys(pureEntryPoints), ...Object.keys(pureEntryPointSidecars)],
+        // ],
+        // [
+        //   "node",
+        //   [...Object.keys(nodeEntryPoints), ...Object.keys(nodeEntryPointSidecars)],
+        // ],
+        // [
+        //   "web",
+        //   [...Object.keys(webEntryPoints), ...Object.keys(webEntryPointSidecars)],
+        // ],
     ];
     x.forEach(async ([runtime, keys]) => {
+        console.log(runtime, keys);
         keys.forEach(async (k) => {
             const folder = `testeranto/reports/${testName}/${k
                 .split(".")
@@ -183,8 +216,8 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <meta name="author" content="" />
 
-  <link rel="stylesheet" href="../../../../../TestReport.css" />
-  <script src="../../../../../TestReport.js"></script>
+  <link rel="stylesheet" href="../../../../../../TestReport.css" />
+  <script src="../../../../../../TestReport.js"></script>
 
 </head>
 
@@ -194,14 +227,34 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             `);
         });
     });
+    [
+        [pureEntryPoints, pureEntryPointSidecars, "pure"],
+        [webEntryPoints, webEntryPointSidecars, "web"],
+        [nodeEntryPoints, nodeEntryPointSidecars, "node"],
+    ].forEach(([eps, eps2, runtime]) => {
+        [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
+            const fp = path.resolve(`testeranto`, `reports`, testName, ep.split(".").slice(0, -1).join("."), runtime);
+            fs.mkdirSync(fp, { recursive: true });
+        });
+    });
     await Promise.all([
         ...[
-            [esbuildImportConfiger, importEntryPoints, onImportDone],
-            [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
-            [esbuildWebConfiger, webEntryPoints, onWebDone],
-        ].map(([configer, entryPoints, done]) => {
+            [
+                esbuildImportConfiger,
+                pureEntryPoints,
+                pureEntryPointSidecars,
+                onImportDone,
+            ],
+            [
+                esbuildNodeConfiger,
+                nodeEntryPoints,
+                nodeEntryPointSidecars,
+                onNodeDone,
+            ],
+            [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
+        ].map(([configer, entryPoints, sidecars, done]) => {
             esbuild
-                .context(configer(config, Object.keys(entryPoints), testName))
+                .context(configer(config, [...Object.keys(entryPoints), ...Object.keys(sidecars)], testName))
                 .then(async (ctx) => {
                 if (mode === "dev") {
                     await ctx.watch().then((v) => {

package/dist/module/src/defaultConfig.js

@@ -9,6 +9,7 @@ const config = {
     nodePlugins: [],
     webPlugins: [],
     importPlugins: [],
+    externalTests: {},
     featureIngestor: function (s) {
         throw new Error("Function not implemented.");
     },

package/dist/module/src/esbuildConfigs/consoleDetectorPlugin.js

@@ -0,0 +1,24 @@
+export const consoleDetectorPlugin = {
+    name: 'console-detector',
+    setup(build) {
+        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
+            const contents = await require('fs').promises.readFile(args.path, 'utf8');
+            const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
+            const matches = contents.match(consolePattern);
+            if (matches) {
+                const uniqueMethods = [...new Set(matches)];
+                return {
+                    warnings: uniqueMethods.map(method => ({
+                        text: `Detected ${method} call - Pure runtime does not allow IO operations. Use Node runtime instead.`,
+                        location: {
+                            file: args.path,
+                            line: contents.split('\n').findIndex(line => line.includes(method)) + 1,
+                            column: 0
+                        }
+                    }))
+                };
+            }
+            return null;
+        });
+    }
+};

package/dist/module/src/esbuildConfigs/pure.js

@@ -1,9 +1,11 @@
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
+import { isBuiltin } from "node:module";
+import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: ["console", "debugger"], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: [], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
             "dynamic-import": true,
@@ -14,6 +16,18 @@ export default (config, entryPoints, testName) => {
         }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
+            consoleDetectorPlugin,
+            {
+                name: "native-node-import-filter",
+                setup(build) {
+                    build.onResolve({ filter: /fs/ }, (args) => {
+                        if (isBuiltin(args.path)) {
+                            throw new Error(`cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`);
+                        }
+                        return { path: args.path };
+                    });
+                },
+            },
             {
                 name: "rebuild-notify",
                 setup: (build) => {

package/dist/module/src/esbuildConfigs/web.js

@@ -1,10 +1,11 @@
+import { polyfillNode } from "esbuild-plugin-polyfill-node";
 import path from "path";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("web", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: `testeranto/bundles/web/${testName}`, alias: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { treeShaking: true, outdir: `testeranto/bundles/web/${testName}`, alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
             "path",
@@ -27,6 +28,14 @@ export default (config, entryPoints, testName) => {
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
+            polyfillNode({
+            // You might need to configure specific Node.js modules you want to polyfill
+            // Example:
+            // modules: {
+            //   'util': true,
+            //   'fs': false,
+            // }
+            }),
             {
                 name: "rebuild-notify",
                 setup: (build) => {

package/dist/module/src/lib/Sidecar.js

@@ -0,0 +1,2 @@
+export class Sidecar {
+}

package/dist/module/src/lib/abstractBase.js

@@ -54,7 +54,7 @@ export class BaseSuite {
             catch (e) {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                // console.error(e);
+                console.error(e);
                 // this.fails.push(giver);
                 // return this;
             }
@@ -136,7 +136,7 @@ export class BaseGiven {
             }
             for (const [thenNdx, thenStep] of this.thens.entries()) {
                 const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
-                return tester(t);
+                tester(t);
                 // ((t) => {
                 //   return tester(t);
                 // })();
@@ -167,16 +167,18 @@ export class BaseWhen {
         this.whenCB = whenCB;
     }
     toObj() {
+        console.log("toObj error", this.error);
         return {
             name: this.name,
-            error: this.error,
+            error: this.error && this.error.name + this.error.stack,
         };
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" When:", this.name);
         return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy(pm, filepath)).catch((e) => {
-            this.error = true;
-            // throw e;
+            console.log("MARK9", e);
+            this.error = e;
+            throw e;
         });
     }
 }

package/dist/module/src/lib/basebuilder.js

@@ -25,15 +25,13 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    const start = await puppetMaster.start();
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
                     const tLog = async (...l) => {
-                        const x = await puppetMaster.write(access, `${l.toString()}\n`);
                         // console.log("x", x);
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
-                    const logPromise = new Promise(async (res, rej) => {
+                    const logPromise = new Promise(async (res) => {
                         await puppetMaster.end(access);
                         res(true);
                     });

package/dist/module/src/lib/classBuilder.js

@@ -8,11 +8,9 @@ export class ClassBuilder extends BaseBuilder {
             return a;
         }, {});
         const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens) => {
+            a[key] = (features, whens, thens, ...initialValues) => {
                 // console.log("givEn", givEn.toString());
-                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key]
-                // givEn
-                );
+                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], initialValues);
             };
             return a;
         }, {});
@@ -23,19 +21,8 @@ export class ClassBuilder extends BaseBuilder {
             return a;
         }, {});
         const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (expected, x) => {
-                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, 
-                // () => {
-                //   thEn(expected);
-                //   // return new Promise((res), rej) => {
-                //   // }
-                //   // try {
-                //   //   thEn(expected);
-                //   // } catch (c) {
-                //   //   console.log("mark99");
-                //   // }
-                // },
-                thEn(expected));
+            a[key] = (expected, ...x) => {
+                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected, ...x));
             };
             return a;
         }, {});

package/dist/module/src/lib/core.js

@@ -30,12 +30,17 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
-                try {
-                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                }
-                catch (e) {
-                    throw e;
-                }
+                return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                // try {
+                //   return await fullTestInterface.andWhen(
+                //     store,
+                //     whenCB,
+                //     testResource,
+                //     pm
+                //   );
+                // } catch (e) {
+                //   console.log("mark22", e);
+                // }
             }
         }, class Then extends BaseThen {
             async butThen(store, thenCB, testResource, pm) {

package/dist/module/src/lib/index.js

@@ -1,4 +1,4 @@
-export const BaseTestInterface = {
+export const BaseTestInterface = () => ({
     beforeAll: async (s) => s,
     beforeEach: async function (subject, initialValues, x, testResource, pm) {
         return subject;
@@ -8,9 +8,17 @@ export const BaseTestInterface = {
     butThen: async (store, thenCb) => {
         return thenCb(store);
     },
-    andWhen: async (a) => a,
-    assertThis: (x) => null,
-};
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (error) {
+            console.error("Error in andWhen:", error);
+            throw error; // Re-throw to maintain test failure
+        }
+    },
+    assertThis: (x) => x,
+});
 export const DefaultTestInterface = (p) => {
     return Object.assign(Object.assign({}, BaseTestInterface), p);
 };

package/dist/module/src/lib/pmProxy.js

@@ -5,7 +5,7 @@ const prxy = function (pm, mappings) {
                 const method = mapping[0];
                 const arger = mapping[1];
                 if (prop === method) {
-                    return (x) => target[prop](arger(x));
+                    return (...x) => target[prop](arger(...x));
                 }
             }
             return (...x) => target[prop](...x);

package/dist/module/src/mothership/index.js

@@ -0,0 +1,11 @@
+import express from "express";
+const app = express();
+app.get("/", (req, res) => {
+    res.send("Hello World!");
+});
+export default (port) => {
+    app.listen(port, () => {
+        console.log(`Example app listening on port ${port}`);
+    });
+    return app;
+};

package/dist/module/src/mothership/test.js

@@ -0,0 +1,60 @@
+import Testeranto from "../Node";
+import appFactory from "./index";
+const specification = (Suite, Given, When, Then) => {
+    console.log("Suite", Suite);
+    return [
+        Suite.TheMothership("the mothership allows the coordination of test resources", {
+            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [
+            // Then.TheResourceIsClaimed("test")
+            ]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { TheMothership: (x) => x },
+    givens: { ItIsRunning: () => undefined },
+    whens: {
+        IClaimTheResource: (resource) => async (i, tr, p) => {
+            fetch(`http://localhost:${tr.ports[0]}/claim?${resource}`);
+        },
+        IReleaseTheResource: function (resource) {
+            throw new Error("Function not implemented.");
+        },
+        IResetTheResource: function (Iw_0) {
+            throw new Error("Function not implemented.");
+        },
+    },
+    thens: {
+        TheResourceIsClaimed: (resource) => async (z, u) => {
+            throw new Error("Function not implemented.");
+        },
+        TheResourceIsUnClaimed: function (It_0) {
+            throw new Error("Function not implemented.");
+        },
+    },
+    checks: { AnEmptyState: () => "any" },
+};
+const testInterface = {
+    // assertThis: function (x: any) {
+    //   throw new Error("Function not implemented.");
+    // },
+    // andWhen: function (store: any, whenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // butThen: function (store: any, thenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // afterAll: function (store: any, pm: IPM) {
+    //   throw new Error("Function not implemented.");
+    // },
+    // afterEach: function (store: any, key: string, pm: IPM): Promise<unknown> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // beforeAll: function (input: Express, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        return subject(testResource.ports[0]);
+    },
+};
+export default Testeranto(appFactory, specification, implementation, testInterface);

package/dist/module/src/utils/queue.js

@@ -0,0 +1,32 @@
+export class Queue {
+    constructor() {
+        this.items = [];
+    }
+    enqueue(element) {
+        this.items.push(element);
+    }
+    dequeue() {
+        if (this.isEmpty()) {
+            return "Queue is empty";
+        }
+        return this.items.shift();
+    }
+    peek() {
+        if (this.isEmpty()) {
+            return "Queue is empty";
+        }
+        return this.items[0];
+    }
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    size() {
+        return this.items.length;
+    }
+    clear() {
+        this.items = [];
+    }
+    print() {
+        console.log(this.items.join(" -> "));
+    }
+}

package/dist/module/src/utils.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import path from "path";
 export const destinationOfRuntime = (f, r, configs) => {
     return path
@@ -20,8 +21,11 @@ export const promptPather = (entryPoint, platform, projectName) => {
 };
 export const getRunnables = (tests, projectName, payload = {
     nodeEntryPoints: {},
+    nodeEntryPointSidecars: {},
     webEntryPoints: {},
-    importEntryPoints: {},
+    webEntryPointSidecars: {},
+    pureEntryPoints: {},
+    pureEntryPointSidecars: {},
 }) => {
     return tests.reduce((pt, cv, cndx, cry) => {
         if (cv[1] === "node") {
@@ -39,15 +43,40 @@ export const getRunnables = (tests, projectName, payload = {
                 .join(".")}`);
         }
         else if (cv[1] === "pure") {
-            pt.importEntryPoints[cv[0]] = path.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
+            pt.pureEntryPoints[cv[0]] = path.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
                 .split(".")
                 .slice(0, -1)
                 .concat("mjs")
                 .join(".")}`);
         }
-        // if (cv[3].length) {
-        //   getRunnables(cv[3], testName, payload);
-        // }
+        //////////////////////////////////////////////////////////
+        cv[3]
+            .filter((t) => t[1] === "node")
+            .forEach((t) => {
+            pt.nodeEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/node/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        });
+        cv[3]
+            .filter((t) => t[1] === "web")
+            .forEach((t) => {
+            pt.webEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/web/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        });
+        cv[3]
+            .filter((t) => t[1] === "pure")
+            .forEach((t) => {
+            pt.pureEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        });
         return pt;
     }, payload);
 };