testeranto 0.75.0 → 0.79.4

package/dist/common/TaskManBackEnd.js

@@ -0,0 +1,174 @@
+"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 mongodb_1 = require("mongodb");
+const mongoose_1 = __importDefault(require("mongoose"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const mongooseSchemas_1 = require("./mongooseSchemas");
+// export const chatChannel = new mongoose.Schema<IChatChannel>({
+//   // name: { type: String, required: true },
+//   users: [
+//     {
+//       type: mongoose.Schema.Types.ObjectId,
+//       ref: "User",
+//       required: true,
+//     },
+//   ],
+// });
+const app = (0, express_1.default)();
+const port = 3000;
+function findTextFiles(dir, fileList = []) {
+    const files = fs_1.default.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path_1.default.join(dir, file);
+        const fileStat = fs_1.default.statSync(filePath);
+        if (fileStat.isDirectory() && file !== "node_modules") {
+            findTextFiles(filePath, fileList); // Recursive call for subdirectories
+        }
+        else if (path_1.default.extname(file) === ".txt") {
+            fileList.push(filePath);
+        }
+        else if (path_1.default.extname(file) === ".md") {
+            fileList.push(filePath);
+        }
+    }
+    return fileList;
+}
+function listToTree(fileList) {
+    const root = {
+        name: "root",
+        children: [],
+    };
+    for (const path of fileList) {
+        const parts = path.split("/");
+        let current = root;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (!part)
+                continue; // Skip empty parts (e.g., from leading '/')
+            let child = current.children.find((c) => c.name === part);
+            if (!child) {
+                child = { name: part, children: [] };
+                current.children.push(child);
+            }
+            current = child;
+        }
+    }
+    return root.children;
+}
+new mongodb_1.MongoClient(`mongodb://${process.env.MONGO_HOST || "127.0.0.1"}:27017`)
+    .connect()
+    .then(async (conn) => {
+    const db = conn.db("taskman");
+    await mongoose_1.default.connect(`mongodb://${process.env.MONGO_HOST || "127.0.0.1"}:27017/taskman`);
+    const usersModel = mongoose_1.default.model("User", mongooseSchemas_1.userSchema);
+    const kanbanModel = mongoose_1.default.model("Kanban", mongooseSchemas_1.kanbanSchema);
+    const ganttModel = mongoose_1.default.model("Gantt", mongooseSchemas_1.ganttSchema);
+    const featuresModel = mongoose_1.default.model("Features", mongooseSchemas_1.featuresSchema);
+    // const roomsModel = mongoose.model<any>("Rooms", RoomSchema);
+    // const huddleModdle = mongoose.model<any>("Huddles", HuddleSchema);
+    const MessagesModel = mongoose_1.default.model("Messages", mongooseSchemas_1.chatCatMessageSchema);
+    const ChatChannel = mongoose_1.default.model("ChatChannel", mongooseSchemas_1.channelsFeature);
+    const huddleModdle = ChatChannel.discriminator("Huddle", mongooseSchemas_1.HuddleSchema);
+    const roomsModel = ChatChannel.discriminator("Room", mongooseSchemas_1.RoomSchema);
+    app.get("/TaskManFrontend.js", (req, res) => {
+        res.sendFile(`${process.cwd()}/dist/prebuild/TaskManFrontEnd.js`);
+    });
+    app.get("/TaskManFrontEnd.css", (req, res) => {
+        res.sendFile(`${process.cwd()}/dist/prebuild/TaskManFrontEnd.css`);
+    });
+    // app.get(`/preMergeCheck`, async (req, res) => {
+    //   const commit = req.params["commit"];
+    //   // res.json(await keyedModels[key].find({}));
+    // });
+    // app.get("/TaskManFrontend.js", (req, res) => {
+    //   res.sendFile(
+    //     `${process.cwd()}/node_modules/testeranto/dist/prebuild/TaskManFrontEnd.js`
+    //   );
+    // });
+    // app.get("/TaskManFrontEnd.css", (req, res) => {
+    //   res.sendFile(
+    //     `${process.cwd()}/node_modules/testeranto/dist/prebuild/TaskManFrontEnd.css`
+    //   );
+    // });
+    app.get("/testeranto.json", (req, res) => {
+        res.sendFile(`${process.cwd()}/docs/testeranto.json`);
+    });
+    app.get("/", (req, res) => {
+        res.send(`<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <title>TaskMan</title>
+
+  <link rel="stylesheet" href="/TaskManFrontEnd.css" />
+  <script type="module" src="/TaskManFrontEnd.js"></script>
+</head>
+
+<body><div id="root">react is loading</div></body>
+
+</html>`);
+    });
+    app.listen(port, () => {
+        console.log(`Example app listening on port ${port}`);
+    });
+    ///////////////////////////////////////////////
+    const keyedModels = {
+        users: usersModel,
+        kanbans: kanbanModel,
+        features: featuresModel,
+        gantts: ganttModel,
+        rooms: roomsModel,
+        huddles: huddleModdle,
+        messages: MessagesModel,
+    };
+    Object.keys(keyedModels).forEach((key) => {
+        app.get(`/${key}.json`, async (req, res) => {
+            console.log("GET", key, keyedModels[key]);
+            res.json(await keyedModels[key].find({}));
+        });
+        app.get(`/${key}/:id.json`, async (req, res) => {
+            res.json(await keyedModels[key]
+                .find({ id: { $eq: req.params["id"] } })
+                .toArray());
+        });
+        app.post(`/${key}/:id.json`, async (req, res) => {
+            res.json(await keyedModels[key]
+                .find({ id: { $eq: req.params["id"] } })
+                .toArray());
+        });
+        app.post(`/${key}.json`, async (req, res) => {
+            res.json(await keyedModels[key]
+                .find({ id: { $eq: req.params["id"] } })
+                .toArray());
+        });
+    });
+    app.use("/docs", express_1.default.static(path_1.default.join(process.cwd(), "docs")));
+    app.get("/docGal/fs.json", (req, res) => {
+        const directoryPath = "./"; // Replace with the desired directory path
+        // const textFiles = findTextFiles(directoryPath);
+        res.json(listToTree(findTextFiles(directoryPath)));
+        //     res.send(`<!DOCTYPE html>
+        // <html lang="en">
+        // <head>
+        //   <meta name="description" content="Webpage description goes here" />
+        //   <meta charset="utf-8" />
+        //   <meta name="viewport" content="width=device-width, initial-scale=1" />
+        //   <meta name="author" content="" />
+        //   <title>TaskMan</title>
+        //   <link rel="stylesheet" href="/TaskManFrontEnd.css" />
+        //   <script type="module" src="/TaskManFrontEnd.js"></script>
+        // </head>
+        // <body><div id="root">react is loading</div></body>
+        // </html>`);
+    });
+});

package/dist/common/Types.js

@@ -1,4 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// export type ITTestShape = {
-// };

package/dist/common/esbuildConfigs/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = (config) => {
     return {
+        // packages: "external",
         target: "esnext",
         format: "esm",
         splitting: true,

package/dist/common/esbuildConfigs/inputFilesPlugin.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 });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.default = (platform, entryPoints) => {
+    return {
+        name: "metafileWriter",
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.errors.length === 0) {
+                    entryPoints.forEach((entryPoint) => {
+                        const filePath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                        const dirName = path_1.default.dirname(filePath);
+                        if (!fs_1.default.existsSync(dirName)) {
+                            fs_1.default.mkdirSync(dirName, { recursive: true });
+                        }
+                        fs_1.default.writeFileSync(filePath, JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
+                            .filter((s) => {
+                            if (!result.metafile.outputs[s].entryPoint) {
+                                return false;
+                            }
+                            return (path_1.default.resolve(result.metafile.outputs[s].entryPoint) ===
+                                path_1.default.resolve(entryPoint));
+                        })
+                            .reduce((mm, el) => {
+                            mm.push(result.metafile.outputs[el].inputs);
+                            return mm;
+                        }, [])[0])
+                            .filter((f) => {
+                            const regex = /^src\/.*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return passes;
+                        })
+                            .filter((f) => {
+                            const regex = /.*\.test\..*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return !passes;
+                        })));
+                    });
+                }
+            });
+        },
+    };
+};

package/dist/common/esbuildConfigs/node.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = __importDefault(require("./index.js"));
+const inputFilesPlugin_1 = __importDefault(require("./inputFilesPlugin"));
 exports.default = (config, entryPoints) => {
-    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, supported: {
             "dynamic-import": true,
         }, define: {
             "process.env.FLUENTFFMPEG_COV": "0",
@@ -20,6 +21,7 @@ exports.default = (config, entryPoints) => {
             ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
             ...(config.nodePlugins || []),
+            (0, inputFilesPlugin_1.default)("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/common/esbuildConfigs/web.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const index_js_1 = __importDefault(require("./index.js"));
+const inputFilesPlugin_js_1 = __importDefault(require("./inputFilesPlugin.js"));
 exports.default = (config, entryPoints) => {
     return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { 
         // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
@@ -14,7 +15,7 @@ exports.default = (config, entryPoints) => {
         // splitting: true,
         outdir: config.outdir + "/web", alias: {
             react: path_1.default.resolve("./node_modules/react"),
-        }, external: [
+        }, metafile: true, external: [
             "testeranto.json",
             "features.test.ts",
             // "url",
@@ -38,6 +39,7 @@ exports.default = (config, entryPoints) => {
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
+            (0, inputFilesPlugin_js_1.default)("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/common/lib/abstractBase.js

@@ -34,7 +34,62 @@ class BaseSuite {
         const sNdx = this.index;
         const sName = this.name;
         for (const [gNdx, g] of Object.entries(this.givens)) {
-            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, pm);
+            const beforeAllProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "writeFileSync") {
+                        return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+                    }
+                    if (prop === "browser") {
+                        return new Proxy(target[prop], {
+                            get(bTarget, bProp, bReceiver) {
+                                if (bProp === "pages") {
+                                    return async () => {
+                                        return bTarget.pages().then((pages) => {
+                                            return pages.map((page) => {
+                                                return new Proxy(page, {
+                                                    get(pTarget, pProp, pReciever) {
+                                                        if (pProp === "screenshot") {
+                                                            return async (x) => {
+                                                                return pm.customScreenShot(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${sNdx}/beforeAll` +
+                                                                        "/" +
+                                                                        x.path }), page);
+                                                                // return await window["custom-screenshot"]({
+                                                                //   ...x,
+                                                                //   path:
+                                                                //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                                //     "/" +
+                                                                //     x.path,
+                                                                // });
+                                                            };
+                                                        }
+                                                        else if (pProp === "mainFrame") {
+                                                            return () => pTarget[pProp]();
+                                                        }
+                                                        else if (pProp === "close") {
+                                                            return () => pTarget[pProp]();
+                                                        }
+                                                        // else if (pProp === "mainFrame") {
+                                                        //   return () => target[pProp](...arguments);
+                                                        // }
+                                                        else {
+                                                            return Reflect.get(...arguments);
+                                                        }
+                                                    },
+                                                });
+                                            });
+                                        });
+                                        // return (await target.pages()).map((page) => {
+                                        //   return new Proxy(page, handler2);
+                                        // });
+                                    };
+                                }
+                            },
+                        });
+                    }
+                    return Reflect.get(...arguments);
+                },
+            });
+            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy);
             const giver = this.givens[gNdx];
             try {
                 this.store = await giver.give(subject, gNdx, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
@@ -61,17 +116,24 @@ class BaseSuite {
                                                 get(pTarget, pProp, pReciever) {
                                                     if (pProp === "screenshot") {
                                                         return async (x) => {
-                                                            // console.log(
-                                                            //   "custom-screenshot-MARK-afterAllProxy",
-                                                            //   // arguments,
-                                                            //   // x,
-                                                            //   window["custom-screenshot"].toString()
-                                                            // );
-                                                            return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                            return pm.customScreenShot(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
                                                                     "/" +
                                                                     x.path }));
+                                                            // return await window["custom-screenshot"]({
+                                                            //   ...x,
+                                                            //   path:
+                                                            //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                            //     "/" +
+                                                            //     x.path,
+                                                            // });
                                                         };
                                                     }
+                                                    else if (pProp === "mainFrame") {
+                                                        return () => pTarget[pProp]();
+                                                    }
+                                                    else if (pProp === "close") {
+                                                        return () => pTarget[pProp]();
+                                                    }
                                                     // else if (pProp === "mainFrame") {
                                                     //   return () => target[pProp](...arguments);
                                                     // }
@@ -162,7 +224,6 @@ class BaseGiven {
             const beforeEachProxy = new Proxy(pm, {
                 get(target, prop, receiver) {
                     if (prop === "writeFileSync") {
-                        console.log("beforeEachProx", arguments, target[prop]);
                         return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
                     }
                     return Reflect.get(...arguments);
@@ -172,8 +233,8 @@ class BaseGiven {
             for (const [whenNdx, whenStep] of this.whens.entries()) {
                 await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
-            for (const thenStep of this.thens) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm);
+            for (const [thenNdx, thenStep] of this.thens.entries()) {
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
                 tester(t);
             }
         }
@@ -218,12 +279,34 @@ class BaseGiven {
                                                                     //   "custom-screenshot-MARK-afterEachProxy",
                                                                     //   window["custom-screenshot"].toString()
                                                                     // );
-                                                                    return await pTarget[pProp](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                                                    return pm.customScreenShot(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
                                                                             "/" +
-                                                                            x.path }));
+                                                                            x.path }), page);
+                                                                    // return await pTarget[pProp]({
+                                                                    //   ...x,
+                                                                    //   path:
+                                                                    //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                                                    //     "/" +
+                                                                    //     x.path,
+                                                                    // });
                                                                 };
                                                             }
-                                                            // else if (pProp === "mainFrame") {
+                                                            else if (pProp === "mainFrame") {
+                                                                return () => pTarget[pProp]();
+                                                                // return target[pProp];
+                                                                // return Reflect.get(...arguments);
+                                                            }
+                                                            else if (pProp === "exposeFunction") {
+                                                                // return Reflect.get(target, prop, receiver);
+                                                                return (...a) => pTarget[pProp](...a);
+                                                                // return target[pProp];
+                                                            }
+                                                            else if (pProp === "removeExposedFunction") {
+                                                                // return Reflect.get(target, prop, receiver);
+                                                                return pTarget[pProp].bind(pTarget);
+                                                                // return target[pProp];
+                                                            }
+                                                            // else if (pProp === "#frameManager") {
                                                             //   return () => target[pProp](...arguments);
                                                             // }
                                                             else {
@@ -271,11 +354,69 @@ class BaseWhen {
         const andWhenProxy = new Proxy(pm, {
             get(target, prop, receiver) {
                 if (prop === "writeFileSync") {
-                    console.log("andWhenProxy", arguments, target[prop]);
                     return (fp, contents) => 
                     // target[prop](`${key}/andWhen/${fp}`, contents);
                     target[prop](`${key}/andWhen/${fp}`, contents);
                 }
+                /////////////////////
+                if (prop === "browser") {
+                    return new Proxy(target[prop], {
+                        get(bTarget, bProp, bReceiver) {
+                            if (bProp === "pages") {
+                                return async () => {
+                                    return bTarget.pages().then((pages) => {
+                                        return pages.map((page) => {
+                                            return new Proxy(page, {
+                                                get(pTarget, pProp, pReciever) {
+                                                    if (pProp === "screenshot") {
+                                                        return async (x) => {
+                                                            // console.log(
+                                                            //   "custom-screenshot-MARK-afterEachProxy",
+                                                            //   window["custom-screenshot"].toString()
+                                                            // );
+                                                            return pm.customScreenShot(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/${key}/afterEach` +
+                                                                    "/" +
+                                                                    x.path }), page);
+                                                            // return await pTarget[pProp]({
+                                                            //   ...x,
+                                                            //   path:
+                                                            //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                                            //     "/" +
+                                                            //     x.path,
+                                                            // });
+                                                        };
+                                                    }
+                                                    else if (pProp === "mainFrame") {
+                                                        return () => pTarget[pProp]();
+                                                        // return target[pProp];
+                                                        // return Reflect.get(...arguments);
+                                                    }
+                                                    else if (pProp === "exposeFunction") {
+                                                        // return Reflect.get(target, prop, receiver);
+                                                        return pTarget[pProp].bind(pTarget);
+                                                        // return target[pProp];
+                                                    }
+                                                    else if (pProp === "removeExposedFunction") {
+                                                        // return Reflect.get(target, prop, receiver);
+                                                        return pTarget[pProp].bind(pTarget);
+                                                        // return target[pProp];
+                                                    }
+                                                    else {
+                                                        return Reflect.get(...arguments);
+                                                    }
+                                                },
+                                            });
+                                        });
+                                    });
+                                    // return (await target.pages()).map((page) => {
+                                    //   return new Proxy(page, handler2);
+                                    // });
+                                };
+                            }
+                        },
+                    });
+                }
+                ///////////////////////
                 return Reflect.get(...arguments);
             },
         });
@@ -301,10 +442,74 @@ class BaseThen {
             error: this.error,
         };
     }
-    async test(store, testResourceConfiguration, tLog, pm) {
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" Then:", this.name);
         try {
-            const x = await this.butThen(store, this.thenCB, testResourceConfiguration);
+            const butThenProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "writeFileSync") {
+                        return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
+                    }
+                    if (prop === "browser") {
+                        return new Proxy(target[prop], {
+                            get(bTarget, bProp, bReceiver) {
+                                if (bProp === "pages") {
+                                    return async () => {
+                                        return bTarget.pages().then((pages) => {
+                                            return pages.map((page) => {
+                                                return new Proxy(page, {
+                                                    get(pTarget, pProp, pReciever) {
+                                                        if (pProp === "screenshot") {
+                                                            return async (x) => {
+                                                                return pm.customScreenShot(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/${filepath}/butThen` +
+                                                                        "/" +
+                                                                        x.path }), page);
+                                                                // return await window["custom-screenshot"]({
+                                                                //   ...x,
+                                                                //   path:
+                                                                //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                                //     "/" +
+                                                                //     x.path,
+                                                                // });
+                                                            };
+                                                        }
+                                                        else if (pProp === "close") {
+                                                            return () => pTarget[pProp]();
+                                                        }
+                                                        else if (pProp === "mainFrame") {
+                                                            return () => pTarget[pProp]();
+                                                        }
+                                                        else if (pProp === "exposeFunction") {
+                                                            // return Reflect.get(target, prop, receiver);
+                                                            return (...a) => pTarget[pProp](...a);
+                                                            // return target[pProp];
+                                                        }
+                                                        else if (pProp === "removeExposedFunction") {
+                                                            // return Reflect.get(target, prop, receiver);
+                                                            return pTarget[pProp].bind(pTarget);
+                                                            // return target[pProp];
+                                                        }
+                                                        else {
+                                                            return Reflect.get(...arguments);
+                                                        }
+                                                    },
+                                                });
+                                            });
+                                        });
+                                        // return (await target.pages()).map((page) => {
+                                        //   return new Proxy(page, handler2);
+                                        // });
+                                    };
+                                }
+                            },
+                        });
+                    }
+                    return Reflect.get(...arguments);
+                },
+            });
+            const x = await this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy
+            // pm
+            );
             return x;
         }
         catch (e) {