testeranto 0.49.10 → 0.62.0

package/dist/common/lib/abstractBase.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCheck = exports.BaseThen = exports.BaseWhen = exports.BaseGiven = exports.BaseSuite = void 0;
+class BaseSuite {
+    constructor(name, index, givens = {}, checks = []) {
+        this.name = name;
+        this.index = index;
+        this.givens = givens;
+        this.checks = checks;
+        this.fails = [];
+    }
+    toObj() {
+        return {
+            name: this.name,
+            givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+            fails: this.fails,
+        };
+    }
+    setup(s, artifactory, tr, utils) {
+        return new Promise((res) => res(s));
+    }
+    assertThat(t) {
+        // console.log("base assertThat")
+        return t;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog, utils) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        tLog("test resources: ", testResourceConfiguration);
+        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, utils);
+        tLog("\nSuite:", this.index, this.name);
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            try {
+                this.store = await giver.give(subject, k, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+            }
+            catch (e) {
+                console.error(e);
+                this.fails.push(giver);
+                return this;
+            }
+        }
+        for (const [ndx, thater] of this.checks.entries()) {
+            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+        }
+        // @TODO fix me
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            giver.afterAll(this.store, artifactory, utils);
+        }
+        ////////////////
+        return this;
+    }
+}
+exports.BaseSuite = BaseSuite;
+class BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        this.name = name;
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+    }
+    beforeAll(store, artifactory) {
+        return store;
+    }
+    afterAll(store, artifactory, utils) {
+        return store;
+    }
+    toObj() {
+        return {
+            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,
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+        tLog(`\n Given: ${this.name}`);
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        try {
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB);
+            // tLog(`\n Given this.store`, this.store);
+            for (const whenStep of this.whens) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
+            }
+            for (const thenStep of this.thens) {
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, utils);
+                tester(t);
+            }
+        }
+        catch (e) {
+            this.error = e;
+            tLog(e);
+            tLog("\u0007"); // bell
+            // throw e;
+        }
+        finally {
+            try {
+                await this.afterEach(this.store, key, givenArtifactory);
+            }
+            catch (e) {
+                console.error("afterEach failed! no error will be recorded!", e);
+            }
+        }
+        return this.store;
+    }
+}
+exports.BaseGiven = BaseGiven;
+class BaseWhen {
+    constructor(name, whenCB) {
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, utils) {
+        tLog(" When:", this.name);
+        try {
+            return await this.andWhen(store, this.whenCB, testResourceConfiguration);
+        }
+        catch (e) {
+            this.error = true;
+            throw e;
+        }
+    }
+}
+exports.BaseWhen = BaseWhen;
+class BaseThen {
+    constructor(name, thenCB) {
+        this.name = name;
+        this.thenCB = thenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, utils) {
+        tLog(" Then:", this.name);
+        try {
+            const x = (await this.butThen(store, this.thenCB, testResourceConfiguration));
+            return x;
+        }
+        catch (e) {
+            console.log("test failed", e);
+            this.error = true;
+            throw e;
+        }
+    }
+}
+exports.BaseThen = BaseThen;
+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) {
+        return;
+    }
+    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+        tLog(`\n Check: ${this.name}`);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
+        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
+            a[key] = async (payload) => {
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+            };
+            return a;
+        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
+            a[key] = async (payload) => {
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                tester(t);
+            };
+            return a;
+        }, {}));
+        await this.afterEach(store, key);
+        return;
+    }
+}
+exports.BaseCheck = BaseCheck;

package/dist/common/lib/basebuilder.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseBuilder = void 0;
+class BaseBuilder {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, logWriter, 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());
+        const suiteRunner = (suite, utils) => async (testResourceConfiguration, tLog, utils) => {
+            return await suite.run(input, testResourceConfiguration, (fPath, value) => logWriter.testArtiFactoryfileWriter(tLog, (p) => {
+                this.artifacts.push(p);
+            })(testResourceConfiguration.fs + "/" + fPath, value), tLog, utils);
+        };
+        this.testJobs = this.specs.map((suite, utils) => {
+            const runner = suiteRunner(suite, utils);
+            return {
+                test: suite,
+                testResourceRequirement,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (testResourceConfiguration = {
+                    name: "",
+                    fs: ".",
+                    ports: [],
+                    scheduled: false
+                }, y) {
+                    console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
+                    await logWriter.mkdirSync(testResourceConfiguration.fs);
+                    logWriter.writeFileSync(`${testResourceConfiguration.fs}/tests.json`, JSON.stringify(this.toObj(), null, 2));
+                    const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
+                    const access = await logWriter.createWriteStream(logFilePath);
+                    const tLog = (...l) => {
+                        // console.log(...l);
+                        access.write(`${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(testResourceConfiguration, tLog, y);
+                    const resultsFilePath = (`${testResourceConfiguration.fs}/results.json`);
+                    logWriter.writeFileSync(resultsFilePath, JSON.stringify(suiteDone.toObj(), null, 2));
+                    const logPromise = new Promise((res, rej) => {
+                        access.on("finish", () => { res(true); });
+                    });
+                    access.end();
+                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+                        // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
+                        return suiteDone.givens[k].error;
+                    }).length;
+                    console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+                    return {
+                        failed: numberOfFailures,
+                        artifacts: this.artifacts || [],
+                        logPromise
+                    };
+                },
+            };
+        });
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    Check() {
+        return this.checkOverides;
+    }
+}
+exports.BaseBuilder = BaseBuilder;

package/dist/common/lib/browser.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TBrowser = void 0;
+class TBrowser {
+    constructor(browser) {
+        this.browser = browser;
+    }
+    pages() {
+        return new Promise(async (res, rej) => {
+            res((await this.browser.pages()).map((p) => {
+                // const handler = {
+                //   apply: function (target, thisArg, argumentsList) {
+                //     console.log('screenshot was called with ' + JSON.stringify(argumentsList));
+                //     const x: ScreenshotOptions = argumentsList[0]
+                //     x.path = "./dist/" + x.path;
+                //     console.log('x.path' + x.path, target, thisArg);
+                //     return target(...argumentsList);
+                //   }
+                // };
+                // p.screenshot = new Proxy(p.screenshot, handler);
+                return p;
+            }));
+        });
+    }
+}
+exports.TBrowser = TBrowser;

package/dist/common/lib/classBuilder.js

@@ -0,0 +1,41 @@
+"use strict";
+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, logWriter) {
+        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, givEn]) => {
+            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, logWriter, testResourceRequirement, testSpecification);
+    }
+}
+exports.ClassBuilder = ClassBuilder;

package/dist/common/lib/core.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, logWriter, testInterface) {
+        const fullTestInterface = (0, index_js_1.DefaultTestInterface)(testInterface);
+        super(testImplementation, testSpecification, input, class extends abstractBase_js_1.BaseSuite {
+            assertThat(t) {
+                fullTestInterface.assertThis(t);
+            }
+            async setup(s, artifactory, tr) {
+                return (fullTestInterface.beforeAll || (async (input, artifactory, tr) => input))(s, this.testResourceConfiguration, artifactory);
+            }
+        }, class Given extends abstractBase_js_1.BaseGiven {
+            async givenThat(subject, testResource, artifactory, initializer) {
+                return fullTestInterface.beforeEach(subject, initializer, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues);
+            }
+            afterEach(store, key, artifactory) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value))));
+            }
+            afterAll(store, artifactory, utils) {
+                return fullTestInterface.afterAll(store, (fPath, value) => { artifactory(`afterAll4-${this.name}/${fPath}`, value); }, utils);
+            }
+        }, class When extends abstractBase_js_1.BaseWhen {
+            async andWhen(store, whenCB, testResource) {
+                return await fullTestInterface.andWhen(store, whenCB, testResource);
+            }
+        }, class Then extends abstractBase_js_1.BaseThen {
+            async butThen(store, thenCB, testResourceConfiguration) {
+                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration);
+            }
+        }, class Check extends abstractBase_js_1.BaseCheck {
+            constructor(name, features, checkCallback, whens, thens, initialValues) {
+                super(name, features, checkCallback, whens, thens);
+                this.initialValues = initialValues;
+            }
+            async checkThat(subject, testResourceConfiguration, artifactory) {
+                return fullTestInterface.beforeEach(subject, this.initialValues, (fPath, value) => artifactory(`before/${fPath}`, value), testResourceConfiguration, this.initialValues);
+            }
+            afterEach(store, key, artifactory) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`afterEach2-${this.name}/${fPath}`, value))));
+            }
+        }, testResourceRequirement, logWriter);
+    }
+}
+exports.default = Testeranto;

package/dist/common/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTestResourceRequirement = exports.DefaultTestInterface = exports.BaseTestInterface = void 0;
+exports.BaseTestInterface = {
+    beforeAll: (async (s) => s),
+    beforeEach: async function (subject, initialValues, testResource) { return subject; },
+    afterEach: (async (s) => s),
+    afterAll: ((store) => undefined),
+    butThen: (async (store, thenCb) => thenCb(store)),
+    andWhen: ((a) => a),
+    assertThis: (() => null),
+};
+const DefaultTestInterface = (p) => {
+    return Object.assign(Object.assign({}, exports.BaseTestInterface), p);
+};
+exports.DefaultTestInterface = DefaultTestInterface;
+exports.defaultTestResourceRequirement = {
+    ports: 0
+};

package/dist/common/nodeWriterElectron.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeWriterElectron = void 0;
+// import fs from "fs";
+const fs = require("fs");
+// import path from "path";
+const path = require("path");
+const fPaths = [];
+exports.NodeWriterElectron = {
+    createWriteStream: (filepath) => {
+        return fs.createWriteStream(filepath);
+    },
+    writeFileSync: (fp, contents) => {
+        fs.writeFileSync(fp, contents);
+    },
+    mkdirSync: async (fp) => {
+        await fs.mkdirSync(fp, { recursive: true });
+    },
+    testArtiFactoryfileWriter: (tLog, callback) => (fPath, value) => {
+        callback(new Promise((res, rej) => {
+            tLog("testArtiFactory =>", fPath);
+            const cleanPath = path.resolve(fPath);
+            fPaths.push(cleanPath.replace(process.cwd(), ``));
+            const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+            fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                if (error) {
+                    console.error(`❗️testArtiFactory failed`, targetDir, error);
+                }
+                fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                    encoding: "utf-8",
+                });
+                if (Buffer.isBuffer(value)) {
+                    fs.writeFileSync(fPath, value, "binary");
+                    res();
+                }
+                else if (`string` === typeof value) {
+                    fs.writeFileSync(fPath, value.toString(), {
+                        encoding: "utf-8",
+                    });
+                    res();
+                }
+                else {
+                    /* @ts-ignore:next-line */
+                    const pipeStream = value;
+                    const myFile = fs.createWriteStream(fPath);
+                    pipeStream.pipe(myFile);
+                    pipeStream.on("close", () => {
+                        myFile.close();
+                        res();
+                    });
+                }
+            });
+        }));
+    }
+};

package/dist/common/preload.js

@@ -1,28 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const NodeWriter_1 = require("./NodeWriter");
 const electron_1 = require("electron");
+console.log("hello preloader");
+const NodeWriter_1 = require("./NodeWriter");
 window.NodeWriter = NodeWriter_1.NodeWriter;
 window.exit = (x) => {
     electron_1.ipcRenderer.invoke('quit-app', x);
 };
-var oldLog = console.log;
-console.log = function (message) {
-    electron_1.ipcRenderer.invoke('web-log', message.toString());
-    oldLog.apply(console, arguments);
-};
-var oldLog = console.error;
-console.error = function (message) {
-    electron_1.ipcRenderer.invoke('web-error', message.toString());
-    oldLog.apply(console, arguments);
-};
-var oldLog = console.warn;
-console.warn = function (message) {
-    electron_1.ipcRenderer.invoke('web-warn', message.toString());
-    oldLog.apply(console, arguments);
-};
-var oldLog = console.info;
-console.info = function (message) {
-    electron_1.ipcRenderer.invoke('web-info', message.toString());
-    oldLog.apply(console, arguments);
-};
+// var oldLog = console.log;
+// console.log = function (message) {
+//   ipcRenderer.invoke('web-log', message.toString());
+//   oldLog.apply(console, arguments);
+// };
+// var oldLog = console.error;
+// console.error = function (message) {
+//   ipcRenderer.invoke('web-error', message.toString());
+//   oldLog.apply(console, arguments);
+// };
+// var oldLog = console.warn;
+// console.warn = function (message) {
+//   ipcRenderer.invoke('web-warn', message.toString());
+//   oldLog.apply(console, arguments);
+// };
+// var oldLog = console.info;
+// console.info = function (message) {
+//   ipcRenderer.invoke('web-info', message.toString());
+//   oldLog.apply(console, arguments);
+// };

package/dist/common/report.html.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => `
+<!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="./Report.css">
+
+  <script type="importmap">
+    {
+    "imports": {
+      "features.test.js": "./features.test.js",
+      "testeranto.json": "./testeranto.json"
+    }
+  }
+  </script>
+
+  <script type="module" src="./Report.js"></script>
+</head>
+
+<body><div id="root">react is loading</div></body>
+
+</html>
+`;