testeranto 0.75.0 → 0.79.4

package/dist/module/esbuildConfigs/node.js

@@ -1,6 +1,7 @@
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin";
 export default (config, entryPoints) => {
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(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",
@@ -15,6 +16,7 @@ export default (config, entryPoints) => {
             ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
             ...(config.nodePlugins || []),
+            inputFilesPlugin("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/module/esbuildConfigs/web.js

@@ -1,5 +1,6 @@
 import path from "path";
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 export default (config, entryPoints) => {
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
         // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
@@ -9,7 +10,7 @@ export default (config, entryPoints) => {
         // splitting: true,
         outdir: config.outdir + "/web", alias: {
             react: path.resolve("./node_modules/react"),
-        }, external: [
+        }, metafile: true, external: [
             "testeranto.json",
             "features.test.ts",
             // "url",
@@ -33,6 +34,7 @@ export default (config, entryPoints) => {
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
+            inputFilesPlugin("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/module/lib/abstractBase.js

@@ -31,7 +31,62 @@ export 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);
@@ -58,17 +113,24 @@ export 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);
                                                     // }
@@ -158,7 +220,6 @@ export 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);
@@ -168,8 +229,8 @@ export 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);
             }
         }
@@ -214,12 +275,34 @@ export 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 {
@@ -266,11 +349,69 @@ export 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);
             },
         });
@@ -295,10 +436,74 @@ export 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/module/lib/basebuilder.js

@@ -1,7 +1,5 @@
 export 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 = [];
@@ -12,12 +10,9 @@ export 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);
@@ -28,44 +23,15 @@ export 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/module/lib/classBuilder.js

@@ -1,8 +1,6 @@
 import { BaseBuilder } from "./basebuilder.js";
 export class ClassBuilder extends 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/module/lib/core.js

@@ -2,9 +2,7 @@ import { DefaultTestInterface, defaultTestResourceRequirement, } from "./index.j
 import { BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck, } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
 export default class Testeranto extends ClassBuilder {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface
-    // puppetMaster: PM
-    ) {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface) {
         const fullTestInterface = DefaultTestInterface(testInterface);
         super(testImplementation, testSpecification, input, class extends BaseSuite {
             afterAll(store, artifactory, pm) {
@@ -51,8 +49,8 @@ export default class Testeranto extends ClassBuilder {
                 return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
             }
         }, class Then extends 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 BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {

package/dist/module/mongooseSchemas.js

@@ -0,0 +1,50 @@
+import mongoose from "mongoose";
+export const userSchema = new mongoose.Schema({
+    email: String,
+    channels: [{ type: mongoose.Schema.Types.ObjectId, ref: "Channel" }],
+    dmgroups: [{ type: mongoose.Schema.Types.ObjectId, ref: "Dmgroup" }],
+});
+userSchema.virtual("features", {
+    ref: "Feature",
+    localField: "_id",
+    foreignField: "owner",
+});
+export const kanbanSchema = new mongoose.Schema({
+    title: String,
+});
+export const ganttSchema = new mongoose.Schema({
+    name: String,
+    type: String,
+    start: Date,
+    end: Date,
+});
+export const featuresSchema = new mongoose.Schema({
+    title: String,
+    state: String,
+});
+export const channelsFeature = new mongoose.Schema({});
+export const chatCatMessageSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    room: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "ChatCatRoom",
+        required: true,
+        maxlength: 100,
+    },
+    timestamp: {
+        type: Date,
+        default: Date.now(),
+    },
+    text: {
+        type: String,
+        maxlength: 1000,
+    },
+});
+export const HuddleSchema = new mongoose.Schema({});
+export const RoomSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+});