testeranto 0.75.0 → 0.79.3

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) {

package/dist/common/lib/basebuilder.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseBuilder = void 0;
 class BaseBuilder {
-    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification
-    // puppetMaster: PM
-    ) {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification) {
         this.input = input;
         this.artifacts = [];
         this.artifacts = [];
@@ -15,12 +13,9 @@ class BaseBuilder {
         this.thenOverides = thenOverides;
         this.checkOverides = checkOverides;
         this.testSpecification = testSpecification;
-        // this.puppetMaster = puppetMaster;
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
         this.testJobs = this.specs.map((suite) => {
-            const suiteRunner = (suite) => async (
-            // testResourceConfiguration: ITTestResourceConfiguration,
-            puppetMaster, tLog) => {
+            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
                 await puppetMaster.startPuppeteer({
                     browserWSEndpoint: puppetMaster.testResourceConfiguration.browserWSEndpoint,
                 }, puppetMaster.testResourceConfiguration.fs);
@@ -31,44 +26,15 @@ class BaseBuilder {
             const runner = suiteRunner(suite);
             return {
                 test: suite,
-                // testResourceRequirement,
                 toObj: () => {
                     return suite.toObj();
                 },
                 runner,
-                receiveTestResourceConfig: async function (
-                // testResourceConfiguration = {
-                //   name: "",
-                //   fs: ".",
-                //   ports: [],
-                //   browserWSEndpoint: "",
-                // },
-                puppetMaster) {
-                    // console.log(
-                    //   `testResourceConfiguration! ${JSON.stringify(
-                    //     testResourceConfiguration,
-                    //     null,
-                    //     2
-                    //   )}`
-                    // );
-                    // console.log("puppetMaster", puppetMaster);
-                    await puppetMaster
-                        .mkdirSync();
-                    //  if (!puppetMaster.existsSync(destFolder)) {
-                    //    puppetMaster.mkdirSync(destFolder, { recursive: true });
-                    //  }
-                    // puppetMaster.writeFileSync(
-                    //   // puppetMaster.testResourceConfiguration.fs + `/tests.json`,
-                    //   `tests.json`,
-                    //   JSON.stringify(this.toObj(), null, 2)
-                    // );
+                receiveTestResourceConfig: async function (puppetMaster) {
+                    await puppetMaster.mkdirSync();
                     const logFilePath = "log.txt";
-                    // puppetMaster.testResourceConfiguration.fs + `/log.txt`;
                     const access = await puppetMaster.createWriteStream(logFilePath);
-                    // console.log("access", access);
                     const tLog = (...l) => {
-                        // access.write(`${l.toString()}\n`);
-                        // console.log("tLog", l);
                         puppetMaster.write(access, `${l.toString()}\n`);
                     };
                     const suiteDone = await runner(puppetMaster, tLog);

package/dist/common/lib/classBuilder.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassBuilder = void 0;
 const basebuilder_js_1 = require("./basebuilder.js");
 class ClassBuilder extends basebuilder_js_1.BaseBuilder {
-    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement
-    // puppetMaster: PM
-    ) {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement) {
         const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
             a[key] = (somestring, givens, checks) => {
                 return new suiteKlasser.prototype.constructor(somestring, index, givens, checks);

package/dist/common/lib/core.js

@@ -4,9 +4,7 @@ const index_js_1 = require("./index.js");
 const abstractBase_js_1 = require("./abstractBase.js");
 const classBuilder_js_1 = require("./classBuilder.js");
 class Testeranto extends classBuilder_js_1.ClassBuilder {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testInterface
-    // puppetMaster: PM
-    ) {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testInterface) {
         const fullTestInterface = (0, index_js_1.DefaultTestInterface)(testInterface);
         super(testImplementation, testSpecification, input, class extends abstractBase_js_1.BaseSuite {
             afterAll(store, artifactory, pm) {
@@ -53,8 +51,8 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
                 return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
             }
         }, class Then extends abstractBase_js_1.BaseThen {
-            async butThen(store, thenCB, testResourceConfiguration) {
-                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration);
+            async butThen(store, thenCB, testResourceConfiguration, pm) {
+                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration, pm);
             }
         }, class Check extends abstractBase_js_1.BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {

package/dist/common/mongooseSchemas.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomSchema = exports.HuddleSchema = exports.chatCatMessageSchema = exports.channelsFeature = exports.featuresSchema = exports.ganttSchema = exports.kanbanSchema = exports.userSchema = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+exports.userSchema = new mongoose_1.default.Schema({
+    email: String,
+    channels: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: "Channel" }],
+    dmgroups: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: "Dmgroup" }],
+});
+exports.userSchema.virtual("features", {
+    ref: "Feature",
+    localField: "_id",
+    foreignField: "owner",
+});
+exports.kanbanSchema = new mongoose_1.default.Schema({
+    title: String,
+});
+exports.ganttSchema = new mongoose_1.default.Schema({
+    name: String,
+    type: String,
+    start: Date,
+    end: Date,
+});
+exports.featuresSchema = new mongoose_1.default.Schema({
+    title: String,
+    state: String,
+});
+exports.channelsFeature = new mongoose_1.default.Schema({});
+exports.chatCatMessageSchema = new mongoose_1.default.Schema({
+    user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    room: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "ChatCatRoom",
+        required: true,
+        maxlength: 100,
+    },
+    timestamp: {
+        type: Date,
+        default: Date.now(),
+    },
+    text: {
+        type: String,
+        maxlength: 1000,
+    },
+});
+exports.HuddleSchema = new mongoose_1.default.Schema({});
+exports.RoomSchema = new mongoose_1.default.Schema({
+    name: { type: String, required: true },
+});