testeranto 0.129.0 → 0.134.0

package/dist/common/src/defaultConfig.js

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleDetectorPlugin = void 0;
+exports.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/common/src/esbuildConfigs/pure.js

@@ -6,9 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = __importDefault(require("./index.js"));
 const inputFilesPlugin_js_1 = __importDefault(require("./inputFilesPlugin.js"));
 const featuresPlugin_js_1 = __importDefault(require("./featuresPlugin.js"));
+const node_module_1 = require("node:module");
+const consoleDetectorPlugin_js_1 = require("./consoleDetectorPlugin.js");
 exports.default = (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = (0, inputFilesPlugin_js_1.default)("pure", testName);
-    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { drop: ["console", "debugger"], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { drop: [], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
             "dynamic-import": true,
@@ -19,6 +21,18 @@ exports.default = (config, entryPoints, testName) => {
         }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
             featuresPlugin_js_1.default,
             inputFilesPluginFactory,
+            consoleDetectorPlugin_js_1.consoleDetectorPlugin,
+            {
+                name: "native-node-import-filter",
+                setup(build) {
+                    build.onResolve({ filter: /fs/ }, (args) => {
+                        if ((0, node_module_1.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/common/src/esbuildConfigs/web.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const esbuild_plugin_polyfill_node_1 = require("esbuild-plugin-polyfill-node");
 const path_1 = __importDefault(require("path"));
 const index_js_1 = __importDefault(require("./index.js"));
 const inputFilesPlugin_js_1 = __importDefault(require("./inputFilesPlugin.js"));
 const featuresPlugin_js_1 = __importDefault(require("./featuresPlugin.js"));
 exports.default = (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = (0, inputFilesPlugin_js_1.default)("web", testName);
-    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { outdir: `testeranto/bundles/web/${testName}`, alias: {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { treeShaking: true, outdir: `testeranto/bundles/web/${testName}`, alias: {
             react: path_1.default.resolve("./node_modules/react"),
         }, metafile: true, external: [
             "path",
@@ -32,6 +33,14 @@ exports.default = (config, entryPoints, testName) => {
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             featuresPlugin_js_1.default,
             inputFilesPluginFactory,
+            (0, esbuild_plugin_polyfill_node_1.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/common/src/{SubPackages/react-dom/jsx/index.js → lib/Sidecar.js}

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

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

@@ -57,7 +57,7 @@ class BaseSuite {
             catch (e) {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                // console.error(e);
+                console.error(e);
                 // this.fails.push(giver);
                 // return this;
             }
@@ -140,7 +140,7 @@ 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);
                 // })();
@@ -172,16 +172,18 @@ 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, (0, pmProxy_js_1.andWhenProxy)(pm, filepath)).catch((e) => {
-            this.error = true;
-            // throw e;
+            console.log("MARK9", e);
+            this.error = e;
+            throw e;
         });
     }
 }

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

@@ -28,15 +28,13 @@ 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/common/src/lib/classBuilder.js

@@ -11,11 +11,9 @@ class ClassBuilder extends basebuilder_js_1.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;
         }, {});
@@ -26,19 +24,8 @@ class ClassBuilder extends basebuilder_js_1.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/common/src/lib/core.js

@@ -32,12 +32,17 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
             }
         }, class When extends abstractBase_js_1.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 abstractBase_js_1.BaseThen {
             async butThen(store, thenCB, testResource, pm) {

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultTestInterface = exports.BaseTestInterface = void 0;
-exports.BaseTestInterface = {
+const BaseTestInterface = () => ({
     beforeAll: async (s) => s,
     beforeEach: async function (subject, initialValues, x, testResource, pm) {
         return subject;
@@ -11,9 +11,18 @@ exports.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,
+});
+exports.BaseTestInterface = BaseTestInterface;
 const DefaultTestInterface = (p) => {
     return Object.assign(Object.assign({}, exports.BaseTestInterface), p);
 };

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

@@ -8,7 +8,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/common/src/mothership/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const app = (0, express_1.default)();
+app.get("/", (req, res) => {
+    res.send("Hello World!");
+});
+exports.default = (port) => {
+    app.listen(port, () => {
+        console.log(`Example app listening on port ${port}`);
+    });
+    return app;
+};

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

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const index_1 = __importDefault(require("./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]);
+    },
+};
+exports.default = (0, Node_1.default)(index_1.default, specification, implementation, testInterface);

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+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(" -> "));
+    }
+}
+exports.Queue = Queue;

package/dist/common/src/utils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRunnables = exports.promptPather = exports.bddPather = exports.lintPather = exports.tscPather = exports.destinationOfRuntime = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
 const path_1 = __importDefault(require("path"));
 const destinationOfRuntime = (f, r, configs) => {
     return path_1.default
@@ -31,8 +32,11 @@ const promptPather = (entryPoint, platform, projectName) => {
 exports.promptPather = promptPather;
 const getRunnables = (tests, projectName, payload = {
     nodeEntryPoints: {},
+    nodeEntryPointSidecars: {},
     webEntryPoints: {},
-    importEntryPoints: {},
+    webEntryPointSidecars: {},
+    pureEntryPoints: {},
+    pureEntryPointSidecars: {},
 }) => {
     return tests.reduce((pt, cv, cndx, cry) => {
         if (cv[1] === "node") {
@@ -50,15 +54,40 @@ const getRunnables = (tests, projectName, payload = {
                 .join(".")}`);
         }
         else if (cv[1] === "pure") {
-            pt.importEntryPoints[cv[0]] = path_1.default.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
+            pt.pureEntryPoints[cv[0]] = path_1.default.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_1.default.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_1.default.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_1.default.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        });
         return pt;
     }, payload);
 };

package/dist/common/testeranto.config.js

@@ -1,50 +1,88 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const testeranto_config_1 = __importDefault(require("testeranto_with_reduxjs_toolkit/testeranto.config"));
+// import redux from "testeranto_with_reduxjs_toolkit/testeranto.config";
+// import solidity from "testeranto-solidity/testeranto.config";
 const config = {
     projects: {
-        redux: Object.assign(Object.assign({}, testeranto_config_1.default.projects.allTests), { src: "node_modules/testeranto_with_reduxjs_toolkit" }),
+        // redux: {
+        //   ...redux.projects.allTests,
+        //   src: "node_modules/testeranto_with_reduxjs_toolkit",
+        // },
         // solidity: {
         //   ...solidity.projects.solidity,
         //   src: "node_modules/testeranto-solidity",
         // },
-        // react: {
-        //   src: "src",
-        //   debugger: false,
-        //   minify: false,
-        //   clearScreen: false,
-        //   externals: [],
-        //   ports: [],
-        //   featureIngestor: async function (s: string) {
-        //     return "";
-        //   },
-        //   tests: [
-        //     [
-        //       "./src/SubPackages/react-test-renderer/component/test/node.ts",
-        //       "node",
-        //       { ports: 0 },
-        //       [],
-        //     ],
-        //     // [
-        //     //   "./src/SubPackages/react-test-renderer/component/test/web.ts",
-        //     //   "web",
-        //     //   { ports: 0 },
-        //     //   [],
-        //     // ],
-        //     // [
-        //     //   "./src/SubPackages/react-test-renderer/component/test/pure.ts",
-        //     //   "pure",
-        //     //   { ports: 0 },
-        //     //   [],
-        //     // ],
-        //   ],
-        //   webPlugins: [],
-        //   nodePlugins: [],
-        //   importPlugins: [],
-        // },
+        mothership: {
+            tests: [
+                // ["./src/mothership/test.ts", "node", { ports: 1 }, []],
+                [
+                    "./src/PM/__tests__/nodeSidecar.testeranto.ts",
+                    "node",
+                    { ports: 1 },
+                    [],
+                ],
+                // [
+                //   "./src/PM/__tests__/pureSidecar.testeranto.ts",
+                //   "node",
+                //   { ports: 1 },
+                //   [],
+                // ],
+                // [
+                //   "./src/PM/__tests__/webSidecar.testeranto.ts",
+                //   "node",
+                //   { ports: 1 },
+                //   [],
+                // ],
+            ],
+            clearScreen: false,
+            debugger: false,
+            externals: [],
+            externalTests: {},
+            featureIngestor: function (s) {
+                throw new Error("Function not implemented.");
+            },
+            importPlugins: [],
+            minify: false,
+            nodePlugins: [],
+            ports: ["3333"],
+            src: "",
+            webPlugins: [],
+        },
+        react: {
+            src: "src",
+            debugger: false,
+            minify: false,
+            clearScreen: false,
+            externals: [],
+            ports: [],
+            featureIngestor: async function (s) {
+                return "";
+            },
+            tests: [
+                [
+                    "./src/SubPackages/react-test-renderer/component/test/node.ts",
+                    "node",
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "./src/SubPackages/react-test-renderer/component/test/web.ts",
+                    "web",
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "./src/SubPackages/react-test-renderer/component/test/pure.ts",
+                    "pure",
+                    { ports: 0 },
+                    [],
+                ],
+            ],
+            webPlugins: [],
+            nodePlugins: [],
+            importPlugins: [],
+            externalTests: {},
+        },
     },
 };
 exports.default = config;