testeranto 0.111.0 → 0.112.1

package/dist/module/esbuildConfigs/index.js

@@ -0,0 +1,19 @@
+export default (config) => {
+    return {
+        // packages: "external",
+        target: "esnext",
+        format: "esm",
+        splitting: true,
+        outExtension: { ".js": ".mjs" },
+        outbase: config.outbase,
+        jsx: "transform",
+        bundle: true,
+        minify: config.minify === true,
+        write: true,
+        loader: {
+            ".js": "jsx",
+            ".png": "binary",
+            ".jpg": "binary",
+        },
+    };
+};

package/dist/module/esbuildConfigs/inputFilesPlugin.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+const otherInputs = {};
+const register = (entrypoint, sources) => {
+    if (!otherInputs[entrypoint]) {
+        otherInputs[entrypoint] = new Set();
+    }
+    sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+export default (platform, entryPoints) => {
+    return {
+        register,
+        inputFilesPluginFactory: {
+            name: "metafileWriter",
+            setup(build) {
+                build.onEnd((result) => {
+                    // console.log("build.onEnd", entryPoints);
+                    fs.writeFileSync(`docs/${platform}/metafile.json`, JSON.stringify(result, null, 2));
+                });
+            },
+        },
+    };
+};

package/dist/module/esbuildConfigs/node.js

@@ -0,0 +1,32 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin";
+export default (config, entryPoints) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", entryPoints);
+    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",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`> node build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+        ] });
+};

package/dist/module/esbuildConfigs/web.js

@@ -0,0 +1,45 @@
+import path from "path";
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+export default (config, entryPoints) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", entryPoints);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: config.outdir + "/web", alias: {
+            react: path.resolve("./node_modules/react"),
+        }, metafile: true, external: [
+            "path",
+            "fs",
+            "stream",
+            "http",
+            "constants",
+            "net",
+            "assert",
+            "tls",
+            "os",
+            "child_process",
+            "readline",
+            "zlib",
+            "crypto",
+            "https",
+            "util",
+            "process",
+            "dns",
+        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`> web build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+        ] });
+};

package/dist/module/init-docs.js

@@ -0,0 +1,15 @@
+import fs from "fs";
+import Init from "./Init";
+console.log("Initializing a testeranto project");
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file, so I will create one for you.");
+    fs.writeFileSync("testeranto.mts", fs.readFileSync("node_modules/testeranto/src/defaultConfig.ts"));
+    import(process.cwd() + "/" + "testeranto.mts").then((module) => {
+        Init(module.default);
+    });
+}
+else {
+    import(process.cwd() + "/" + process.argv[2]).then((module) => {
+        Init(module.default);
+    });
+}

package/dist/module/lib/abstractBase.js

@@ -0,0 +1,321 @@
+export class BaseSuite {
+    constructor(name, index, givens = {}, checks = []) {
+        this.name = name;
+        this.index = index;
+        this.givens = givens;
+        this.checks = checks;
+        this.fails = [];
+    }
+    features() {
+        const features = Object.keys(this.givens)
+            .map((k) => this.givens[k].features)
+            .flat()
+            .filter((value, index, array) => {
+            return array.indexOf(value) === index;
+        });
+        // .reduce((mm, lm) => {
+        //   mm[lm] = lm;
+        //   return mm;
+        // }, {});
+        return features || [];
+    }
+    toObj() {
+        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+        return {
+            name: this.name,
+            givens,
+            fails: this.fails,
+            features: this.features(),
+        };
+    }
+    setup(s, artifactory, tr, pm) {
+        return new Promise((res) => res(s));
+    }
+    assertThat(t) {
+        return t;
+    }
+    afterAll(store, artifactory, pm) {
+        return store;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        tLog("test resources: ", JSON.stringify(testResourceConfiguration));
+        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
+        // console.log("\nSuite:", this.index, this.name);
+        tLog("\nSuite:", this.index, this.name);
+        const sNdx = this.index;
+        const sName = this.name;
+        for (const [gKey, g] of Object.entries(this.givens)) {
+            // console.log("gKey", gKey);
+            const beforeAllProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "customScreenShot") {
+                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { 
+                            // path: `${filepath}/${opts.path}`,
+                            path: `suite-${sNdx}/beforeAll/${opts.path}` }), p);
+                    }
+                    if (prop === "writeFileSync") {
+                        return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+                    }
+                    /* @ts-ignore:next-line */
+                    return Reflect.get(...arguments);
+                },
+            });
+            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy);
+            const giver = this.givens[gKey];
+            try {
+                this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
+            }
+            catch (e) {
+                console.error(e);
+                this.fails.push(giver);
+                // return this;
+            }
+        }
+        try {
+            this.afterAll(this.store, artifactory, 
+            // afterAllProxy
+            pm);
+        }
+        catch (e) {
+            console.error(e);
+            // this.fails.push(this);
+            // return this;
+        }
+        // for (const [ndx, thater] of this.checks.entries()) {
+        //   await thater.check(
+        //     subject,
+        //     thater.name,
+        //     testResourceConfiguration,
+        //     this.assertThat,
+        //     suiteArtifactory,
+        //     tLog,
+        //     pm
+        //   );
+        // }
+        // @TODO fix me
+        // for (const k of Object.keys(this.givens)) {
+        //   const giver = this.givens[k];
+        //   try {
+        //     giver.afterAll(this.store, artifactory, pm);
+        //   } catch (e) {
+        //     console.error(e);
+        //     this.fails.push(giver);
+        //     return this;
+        //   }
+        // }
+        ////////////////
+        return this;
+    }
+}
+export class BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues
+    // key: string
+    ) {
+        this.name = name;
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+    }
+    beforeAll(store, 
+    // artifactory: ITestArtifactory
+    // subject,
+    initializer, artifactory, testResource, initialValues, pm) {
+        return store;
+    }
+    toObj() {
+        return {
+            key: this.key,
+            name: this.name,
+            whens: this.whens.map((w) => w.toObj()),
+            thens: this.thens.map((t) => t.toObj()),
+            error: this.error ? [this.error, this.error.stack] : null,
+            // fail: this.fail ? [this.fail] : false,
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory, pm) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
+        this.key = key;
+        tLog(`\n ${this.key}`);
+        tLog(`\n Given: ${this.name}`);
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        try {
+            // tLog(`\n Given this.store`, this.store);
+            const beforeEachProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "writeFileSync") {
+                        return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
+                    }
+                    if (prop === "customScreenShot") {
+                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
+                    }
+                    if (prop === "screencast") {
+                        return (opts, p) => target.screencast(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
+                    }
+                    /* @ts-ignore:next-line */
+                    return Reflect.get(...arguments);
+                },
+            });
+            this.uberCatcher((e) => {
+                console.error(e);
+                this.error = e.error;
+                tLog(e.stack);
+            });
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, beforeEachProxy);
+            for (const [whenNdx, whenStep] of this.whens.entries()) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
+            }
+            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);
+            }
+        }
+        catch (e) {
+            console.error(e);
+            this.error = e;
+            tLog(e.stack);
+            // tLog("\u0007"); // bell
+            // throw e;
+        }
+        finally {
+            try {
+                const afterEachProxy = new Proxy(pm, {
+                    get(target, prop, receiver) {
+                        if (prop === "customScreenShot") {
+                            return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/afterEach/${opts.path}` }), p);
+                        }
+                        if (prop === "writeFileSync") {
+                            return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterEach/${fp}`, contents);
+                        }
+                        /* @ts-ignore:next-line */
+                        return Reflect.get(...arguments);
+                    },
+                });
+                await this.afterEach(this.store, this.key, givenArtifactory, 
+                // pm
+                afterEachProxy);
+            }
+            catch (e) {
+                console.error("afterEach failed! no error will be recorded!", e);
+            }
+        }
+        return this.store;
+    }
+}
+export class BaseWhen {
+    constructor(name, whenCB) {
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        tLog(" When:", this.name);
+        const name = this.name;
+        const andWhenProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "customScreenShot") {
+                    return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `${filepath}/${opts.path}` }), p);
+                }
+                if (prop === "writeFileSync") {
+                    return (fp, contents) => target[prop](`${filepath}/andWhen/${fp}`, contents);
+                }
+                /* @ts-ignore:next-line */
+                return Reflect.get(...arguments);
+            },
+        });
+        return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy).catch((e) => {
+            this.error = true;
+            // throw e;
+        });
+        // try {
+        //   return await this.andWhen(
+        //     store,
+        //     this.whenCB,
+        //     testResourceConfiguration,
+        //     andWhenProxy
+        //   );
+        // } catch (e) {
+        //   this.error = true;
+        //   throw e;
+        // }
+    }
+}
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.name = name;
+        this.thenCB = thenCB;
+        this.error = false;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        tLog(" Then:", this.name);
+        try {
+            const butThenProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "customScreenShot") {
+                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `${filepath}/${opts.path}` }), p);
+                    }
+                    if (prop === "writeFileSync") {
+                        return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
+                    }
+                    /* @ts-ignore:next-line */
+                    return Reflect.get(...arguments);
+                },
+            });
+            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
+                this.error = true;
+                throw e;
+            });
+        }
+        catch (e) {
+            console.log("test failed", e);
+            this.error = e.message;
+            throw e;
+        }
+    }
+}
+export class BaseCheck {
+    constructor(name, features, checkCB, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.checkCB = checkCB;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    async afterEach(store, key, cb, pm) {
+        return;
+    }
+    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
+        tLog(`\n Check: ${this.name}`);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory, pm);
+        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
+            a[key] = async (payload) => {
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");
+            };
+            return a;
+        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
+            a[key] = async (payload) => {
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm);
+                tester(t);
+            };
+            return a;
+        }, {}));
+        await this.afterEach(store, key, () => { }, pm);
+        return;
+    }
+}

package/dist/module/lib/basebuilder.js

@@ -0,0 +1,94 @@
+export class BaseBuilder {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification) {
+        this.input = input;
+        this.artifacts = [];
+        this.artifacts = [];
+        this.testResourceRequirement = testResourceRequirement;
+        this.suitesOverrides = suitesOverrides;
+        this.givenOverides = givenOverides;
+        this.whenOverides = whenOverides;
+        this.thenOverides = thenOverides;
+        this.checkOverides = checkOverides;
+        this.testSpecification = testSpecification;
+        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
+                const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                    this.artifacts.push(p);
+                })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                return x;
+            };
+            const runner = suiteRunner(suite);
+            return {
+                test: suite,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (puppetMaster) {
+                    const logFilePath = "log.txt";
+                    const access = await puppetMaster.createWriteStream(logFilePath);
+                    const tLog = (...l) => {
+                        puppetMaster.write(access, `${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(puppetMaster, tLog);
+                    const logPromise = new Promise((res, rej) => {
+                        puppetMaster.end(access);
+                        res(true);
+                    });
+                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+                        return suiteDone.givens[k].error;
+                    }).length;
+                    puppetMaster.writeFileSync(`bdd_errors.txt`, numberOfFailures.toString());
+                    const o = this.toObj();
+                    puppetMaster.writeFileSync(`littleBoard.html`, `
+            <!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <link rel="stylesheet" href="/kokomoBay/docs/TestReport.css" />
+  <script src="/kokomoBay/docs/TestReport.js"></script>
+
+</head>
+
+  <body>
+    <h1>Test report</h1>
+            <div id="root"/>
+  </body>
+            `);
+                    puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
+                    return {
+                        failed: numberOfFailures,
+                        artifacts: this.artifacts || [],
+                        logPromise,
+                        features: suiteDone.features(),
+                    };
+                },
+            };
+        });
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    Check() {
+        return this.checkOverides;
+    }
+}

package/dist/module/lib/classBuilder.js

@@ -0,0 +1,36 @@
+import { BaseBuilder } from "./basebuilder.js";
+export class ClassBuilder extends BaseBuilder {
+    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);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
+            a[key] = (features, whens, thens, givEn) => {
+                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], givEn);
+            };
+            return a;
+        }, {});
+        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
+            a[key] = (payload) => {
+                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(payload));
+            };
+            return a;
+        }, {});
+        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
+            a[key] = (expected, x) => {
+                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected));
+            };
+            return a;
+        }, {});
+        const classyChecks = Object.entries(testImplementation.checks).reduce((a, [key, z]) => {
+            a[key] = (somestring, features, callback) => {
+                return new checkKlasser.prototype.constructor(somestring, features, callback, classyWhens, classyThens);
+            };
+            return a;
+        }, {});
+        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification);
+    }
+}