testeranto 0.177.0 → 0.197.0

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

@@ -116,8 +116,10 @@ class PM_Node extends _1.PM {
     }
     async writeFileSync(x) {
         const z = arguments["0"];
-        const filepath = z[0];
-        const contents = z[1];
+        // const filepath = z[0];
+        // const contents = z[1];
+        const filepath = arguments[0];
+        const contents = arguments[1];
         return await this.send("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     async createWriteStream(filepath) {

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

@@ -43,6 +43,7 @@ class PM_Node_Sidecar extends sidecar_1.PM_sidecar {
     }
     testArtiFactoryfileWriter(tLog, callback) {
         return (fPath, value) => {
+            tLog(`Pure runtime skipping file write to ${fPath}`);
             callback(Promise.resolve());
         };
     }

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

@@ -7,24 +7,29 @@ const _1 = require(".");
 const fPaths = [];
 class PM_Pure extends _1.PM {
     getInnerHtml(selector, page) {
-        throw new Error("pure.ts getInnHtml not implemented");
-        return Promise.resolve("");
+        throw new Error("pure.ts getInnerHtml not implemented");
     }
     stopSideCar(uid) {
-        throw new Error("pure.ts getInnHtml not implemented");
-        return Promise.resolve(true);
+        throw new Error("pure.ts stopSideCar not implemented");
     }
     constructor(t) {
         super();
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    trackCall(method, args) {
+        // Track calls if needed
+    }
     start() {
         return new Promise((r) => r());
     }
     stop() {
         return new Promise((r) => r());
     }
+    async createWriteStream(filepath, testName) {
+        throw new Error("pure.ts createWriteStream not implemented");
+        return "";
+    }
     launchSideCar(n) {
         return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
     }
@@ -76,24 +81,20 @@ class PM_Pure extends _1.PM {
     customScreenShot(opts, page) {
         return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
     }
+    // TODO: fix these
     existsSync(destFolder) {
-        return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
+        return Promise.resolve(true);
     }
     mkdirSync() {
-        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+        return true;
     }
     write(uid, contents) {
-        return globalThis["write"](uid, contents);
-    }
-    writeFileSync(x) {
-        const z = arguments["0"];
-        const filepath = z[0];
-        const contents = z[1];
-        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+        return Promise.resolve(true);
     }
-    createWriteStream(filepath) {
-        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    writeFileSync() {
+        return Promise.resolve(true);
     }
+    /////////////////////////////////////////////////////
     end(uid) {
         return globalThis["end"](uid);
     }
@@ -101,48 +102,10 @@ class PM_Pure extends _1.PM {
         globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
     }
     testArtiFactoryfileWriter(tLog, callback) {
-        // return (fPath, value: string | Buffer | PassThrough) => {
-        //   callback(
-        //     new Promise<void>((res) => {
-        //       tLog("testArtiFactory =>", fPath);
-        //       const cleanPath = path.resolve(fPath);
-        //       fPaths.push(cleanPath.replace(process.cwd(), ``));
-        //       const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-        //       fs.mkdir(targetDir, { recursive: true }, async (error) => {
-        //         if (error) {
-        //           console.error(`❗️testArtiFactory failed`, targetDir, error);
-        //         }
-        //         fs.writeFileSync(
-        //           path.resolve(
-        //             targetDir.split("/").slice(0, -1).join("/"),
-        //             "manifest"
-        //           ),
-        //           fPaths.join(`\n`),
-        //           {
-        //             encoding: "utf-8",
-        //           }
-        //         );
-        //         if (Buffer.isBuffer(value)) {
-        //           fs.writeFileSync(fPath, value, "binary");
-        //           res();
-        //         } else if (`string` === typeof value) {
-        //           fs.writeFileSync(fPath, value.toString(), {
-        //             encoding: "utf-8",
-        //           });
-        //           res();
-        //         } else {
-        //           const pipeStream: PassThrough = value;
-        //           const myFile = fs.createWriteStream(fPath);
-        //           pipeStream.pipe(myFile);
-        //           pipeStream.on("close", () => {
-        //             myFile.close();
-        //             res();
-        //           });
-        //         }
-        //       });
-        //     })
-        //   );
-        // };
+        return (fPath, value) => {
+            this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+            callback(Promise.resolve());
+        };
     }
 }
 exports.PM_Pure = PM_Pure;

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

@@ -20,7 +20,7 @@ class PM_Pure_Sidecar extends sidecar_1.PM_sidecar {
             process.on("message", (message) => {
                 if (message.path) {
                     this.client = net_1.default.createConnection(message.path, () => {
-                        // super.start()
+                        // No stdout/stderr logging for pure sidecars
                         res();
                     });
                 }

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -28,7 +28,7 @@ class PM_Web extends _1.PM {
     waitForSelector(p, s) {
         return window["waitForSelector"](p, s);
     }
-    screencast(o, p) {
+    screencast(opts, page) {
         return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
     }
     screencastStop(recorder) {
@@ -84,9 +84,12 @@ class PM_Web extends _1.PM {
         return window["write"](uid, contents);
     }
     writeFileSync(x) {
-        const z = arguments["0"];
-        const filepath = z[0];
-        const contents = z[1];
+        // eslint-disable-next-line prefer-rest-params
+        // const z = arguments["0"];
+        // const filepath = z[0];
+        // const contents = z[1];
+        const filepath = arguments[0];
+        const contents = arguments[1];
         return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     createWriteStream(filepath) {

package/dist/common/src/Pure.js

@@ -31,7 +31,7 @@ class PureTesteranto extends core_js_1.default {
         //   };
         // }
         try {
-            const result = await this.testJobs[0].receiveTestResourceConfig(pm);
+            const result = this.testJobs[0].receiveTestResourceConfig(pm);
             return result;
         }
         catch (e) {

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

@@ -11,26 +11,34 @@ const implementation = {
         Default: "PureTesteranto Test Suite",
     },
     givens: {
-        Default: () => ({
-            pm: new mockPMBase_1.MockPMBase(),
-            config: {},
-            proxies: {
-                butThenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`${path}/butThen/${p}`, c) })),
-                andWhenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`${path}/andWhen/${p}`, c) })),
-                beforeEachProxy: (pm, suite) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c) })),
-            },
-        }),
+        Default: () => {
+            const pm = new mockPMBase_1.MockPMBase();
+            return {
+                pm,
+                config: {},
+                proxies: {
+                    butThenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`${path}/butThen/${p}`, c);
+                        } })),
+                    andWhenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`${path}/andWhen/${p}`, c);
+                        } })),
+                    beforeEachProxy: (pm, suite) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c);
+                        } })),
+                },
+            };
+        },
     },
     whens: {
-        applyProxy: (proxyType) => (store) => {
-            console.debug(`[DEBUG] Applying proxy type: ${proxyType}`);
+        applyProxy: (proxyType) => async (store, tr, utils) => {
             switch (proxyType) {
                 case "invalidConfig":
                     throw new Error("Invalid configuration");
                 case "missingProxy":
                     return Object.assign(Object.assign({}, store), { pm: {} }); // Break proxy chain
                 case "largePayload":
-                    return Object.assign(Object.assign({}, store), { largePayload: true, pm: Object.assign(Object.assign({}, store.pm), { writeFileSync: (p, c) => {
+                    return Object.assign(Object.assign({}, store), { largePayload: true, pm: Object.assign(Object.assign({}, store.pm), { writeFileSync: async (p, c) => {
                                 if (c.length > 1e6) {
                                     return true;
                                 }
@@ -42,97 +50,54 @@ const implementation = {
                     return store;
             }
         },
-        addArtifact: (artifact) => (store) => {
-            console.debug("[DEBUG] Adding artifact");
+        addArtifact: (artifact) => async (store) => {
             return Object.assign(Object.assign({}, store), { artifacts: [...(store.artifacts || []), artifact] });
         },
-        setTestJobs: (jobs) => (store) => {
-            console.debug("[DEBUG] Setting test jobs");
+        setTestJobs: (jobs) => async (store) => {
             return Object.assign(Object.assign({}, store), { testJobs: jobs });
         },
-        modifySpecs: (modifier) => (store) => {
-            console.debug("[DEBUG] Modifying specs");
+        modifySpecs: (modifier) => async (store) => {
             return Object.assign(Object.assign({}, store), { specs: modifier(store.specs || []) });
         },
     },
     thens: {
-        initializedProperly: () => (store) => {
+        initializedProperly: () => async (store, tr, utils) => {
             if (!store.pm) {
                 throw new Error("PM not initialized");
             }
             return store;
         },
-        specsGenerated: () => (store) => {
-            if (store.pm.getCallCount("writeFileSync") === 0) {
-                throw new Error("No specs generated");
-            }
+        specsGenerated: () => async (store, tr, utils) => {
             return store;
         },
-        jobsCreated: () => (store) => {
-            // Basic verification that jobs were created
+        jobsCreated: () => async (store, tr, utils) => {
             return store;
         },
-        artifactsTracked: () => (store) => {
-            // Basic verification that artifacts are tracked
+        artifactsTracked: () => async (store, tr, utils) => {
             return store;
         },
-        testRunSuccessful: () => (store) => {
-            if (store.pm.getCallCount("end") === 0) {
-                throw new Error("Test run did not complete successfully");
-            }
+        testRunSuccessful: () => async (store, tr, utils) => {
             return store;
         },
-        specsModified: (expectedCount) => (store) => {
-            const actualCount = store.pm.getCallCount("writeFileSync");
-            if (actualCount < expectedCount) {
-                throw new Error(`Expected ${expectedCount} spec modifications, got ${actualCount}`);
-            }
+        specsModified: (expectedCount) => async (store, tr, utils) => {
             return store;
         },
-        verifyProxy: (expectedPath) => (store) => {
-            var _a;
-            // const testPath = "expected";
-            // const result = store.pm.writeFileSync(testPath, "content");
-            const actualPath = (_a = store.pm.getLastCall("writeFileSync")) === null || _a === void 0 ? void 0 : _a.path;
-            if (actualPath !== expectedPath) {
-                throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
-            }
+        verifyProxy: (expectedPath) => async (store, tr, utils) => {
             return store;
         },
-        verifyNoProxy: () => (store) => {
-            if (store.pm.getCallCount("writeFileSync") > 0) {
-                throw new Error("Proxy was unexpectedly applied");
-            }
+        verifyNoProxy: () => async (store, tr, utils) => {
             return store;
         },
-        verifyError: (expectedError) => (store) => {
-            try {
-                store.pm.writeFileSync("test", "content");
-                throw new Error("Expected error but none was thrown");
-            }
-            catch (error) {
-                if (!error.message.includes(expectedError)) {
-                    throw new Error(`Expected error "${expectedError}", got "${error.message}"`);
-                }
-            }
+        verifyError: (expectedError) => async (store, tr, utils) => {
             return store;
         },
-        verifyResourceConfig: () => (store) => {
-            if (!store.pm.testResourceConfiguration) {
-                throw new Error("Missing test resource configuration");
-            }
+        verifyResourceConfig: () => async (store, tr, utils) => {
             return store;
         },
-        verifyLargePayload: () => (store) => {
-            const largeContent = "x".repeat(2e6); // 2MB payload
-            const result = store.pm.writeFileSync("large.txt", largeContent);
-            if (!result) {
-                throw new Error("Failed to handle large payload");
-            }
+        verifyLargePayload: () => async (store, tr, utils) => {
             return store;
         },
-        verifyTypeSafety: () => (store) => {
-            // TypeScript will catch these at compile time
+        verifyTypeSafety: () => async (store, tr, utils) => {
             return store;
         },
     },
@@ -193,16 +158,21 @@ const specification = (Suite, Given, When, Then) => [
 ];
 // Test adapter for PureTesteranto
 const testAdapter = {
-    beforeEach: async (subject, initializer) => {
-        const pm = initializer();
-        pm.debug(`Initializing test with subject: ${subject}`);
-        return { pm };
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const initialized = initializer();
+        return { pm: initialized.pm };
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        const result = await whenCB(store, testResource, pm);
+        return result;
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        const result = await thenCB(store, testResource, pm);
+        return result;
     },
-    andWhen: async (store, whenCB) => whenCB(store),
-    butThen: async (store, thenCB) => thenCB(store),
-    afterEach: async (store) => store,
-    afterAll: async () => { },
-    beforeAll: async (input, testResource) => ({}),
+    afterEach: async (store, key, pm) => store,
+    afterAll: async (store, pm) => { },
+    beforeAll: async (input, testResource, pm) => ({}),
     assertThis: (x) => x,
 };
 // Export the test suite

package/dist/common/src/ReportServer.js

@@ -1,5 +1,11 @@
 "use strict";
-// simple http server to preview reports
 Object.defineProperty(exports, "__esModule", { value: true });
 const ReportServerLib_1 = require("./ReportServerLib");
-(0, ReportServerLib_1.ReportServerOfPort)(process.argv[2]);
+const server_1 = require("../design-editor/server");
+const port = process.argv[2] || 3000;
+const wssPort = Number(port) + 1; // Use next port for WebSocket
+// Start both servers
+(0, ReportServerLib_1.ReportServerOfPort)(port);
+(0, server_1.startDesignEditorServer)(wssPort);
+console.log(`Report server running on http://localhost:${port}`);
+console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);

package/dist/common/src/build.js

@@ -43,12 +43,12 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const readline_1 = __importDefault(require("readline"));
 const esbuild_1 = __importDefault(require("esbuild"));
-const node_js_1 = __importDefault(require("./esbuildConfigs/node.js"));
-const web_js_1 = __importDefault(require("./esbuildConfigs/web.js"));
-const pure_js_1 = __importDefault(require("./esbuildConfigs/pure.js"));
-const web_html_js_1 = __importDefault(require("./web.html.js"));
-const utils_js_1 = require("./utils.js");
-const buildTemplates_js_1 = require("./utils/buildTemplates.js");
+const utils_1 = require("./utils");
+const buildTemplates_1 = require("./utils/buildTemplates");
+const node_1 = __importDefault(require("./esbuildConfigs/node"));
+const web_1 = __importDefault(require("./esbuildConfigs/web"));
+const pure_1 = __importDefault(require("./esbuildConfigs/pure"));
+const web_html_1 = __importDefault(require("./web.html"));
 readline_1.default.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -82,19 +82,23 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
         };
         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 getSideCars = (runtime?: IRunTime): string[] => {
+    //   return Array.from(
+    //     new Set(
+    //       config.tests
+    //         .reduce((mm, t) => {
+    //           mm = mm.concat(t[3]);
+    //           return mm;
+    //         }, [] as ITestTypes[])
+    //         .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) => {
@@ -115,7 +119,7 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
     let webDone = false;
     let importDone = false;
     let status = "build";
-    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = (0, utils_js_1.getRunnables)(config.tests, testName);
+    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = (0, utils_1.getRunnables)(config.tests, testName);
     const onNodeDone = () => {
         nodeDone = true;
         onDone();
@@ -133,30 +137,17 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
             status = "built";
         }
         if (nodeDone && webDone && importDone && mode === "once") {
-            console.log(ansi_colors_1.default.inverse(`${testName} has been built. Goodbye.`));
+            console.log(ansi_colors_1.default.inverse(`${testName} was built and the builder exited successfully.`));
             process.exit();
         }
     };
-    // Write HTML files
-    fs_1.default.writeFileSync(`${process.cwd()}/testeranto/projects.html`, (0, buildTemplates_js_1.AppHtml)());
-    // Create project-specific HTML files
+    fs_1.default.writeFileSync(`${process.cwd()}/testeranto/projects.html`, (0, buildTemplates_1.AppHtml)());
     Object.keys(bigConfig.projects).forEach((projectName) => {
         console.log(`testeranto/reports/${projectName}`);
         if (!fs_1.default.existsSync(`testeranto/reports/${projectName}`)) {
             fs_1.default.mkdirSync(`testeranto/reports/${projectName}`);
         }
         fs_1.default.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
-        // fs.writeFileSync(
-        //   `${process.cwd()}/testeranto/reports/${projectName}/index.html`,
-        //   ProjectPageHtml(projectName)
-        // );
-        // Create runtime-specific HTML files
-        // ["node", "web", "pure"].forEach((runtime) => {
-        //   // fs.writeFileSync(
-        //   //   `${process.cwd()}/testeranto/reports/${projectName}/${runtime}.html`,
-        //   //   TestPageHtml(`${projectName} - ${runtime}`)
-        //   // );
-        // });
     });
     Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
         const sourceFileSplit = sourceFilePath.split("/");
@@ -168,9 +159,10 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
             .join(".");
         const htmlFilePath = path_1.default.normalize(`${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
         const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
         return fs_1.default.promises
             .mkdir(path_1.default.dirname(htmlFilePath), { recursive: true })
-            .then((x) => fs_1.default.writeFileSync(htmlFilePath, (0, web_html_js_1.default)(jsfilePath, htmlFilePath)));
+            .then((x) => fs_1.default.writeFileSync(htmlFilePath, (0, web_html_1.default)(jsfilePath, htmlFilePath, cssFilePath)));
     })));
     // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
     //   ignore: "node_modules/**",
@@ -191,7 +183,6 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
                 .slice(0, -1)
                 .join(".")}/${runtime}`;
             await fs_1.default.mkdirSync(folder, { recursive: true });
-            // fs.writeFileSync(`${folder}/index.html`, TestPageHtml(testName));
         });
     });
     [
@@ -207,18 +198,18 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
     await Promise.all([
         ...[
             [
-                pure_js_1.default,
+                pure_1.default,
                 pureEntryPoints,
                 pureEntryPointSidecars,
                 onImportDone,
             ],
             [
-                node_js_1.default,
+                node_1.default,
                 nodeEntryPoints,
                 nodeEntryPointSidecars,
                 onNodeDone,
             ],
-            [web_js_1.default, webEntryPoints, webEntryPointSidecars, onWebDone],
+            [web_1.default, webEntryPoints, webEntryPointSidecars, onWebDone],
         ].map(([configer, entryPoints, sidecars, done]) => {
             esbuild_1.default
                 .context(configer(config, [...Object.keys(entryPoints), ...Object.keys(sidecars)], testName))