testeranto 0.49.10 → 0.62.0

package/dist/module/lib/browser.js

@@ -0,0 +1,22 @@
+export 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;
+            }));
+        });
+    }
+}

package/dist/module/lib/classBuilder.js

@@ -0,0 +1,37 @@
+import { BaseBuilder } from "./basebuilder.js";
+export class ClassBuilder extends 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);
+    }
+}

package/dist/module/lib/core.js

@@ -0,0 +1,49 @@
+import { DefaultTestInterface, defaultTestResourceRequirement } from "./index.js";
+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, logWriter, testInterface) {
+        const fullTestInterface = DefaultTestInterface(testInterface);
+        super(testImplementation, testSpecification, input, class extends 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 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 BaseWhen {
+            async andWhen(store, whenCB, testResource) {
+                return await fullTestInterface.andWhen(store, whenCB, testResource);
+            }
+        }, class Then extends BaseThen {
+            async butThen(store, thenCB, testResourceConfiguration) {
+                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration);
+            }
+        }, class Check extends 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);
+    }
+}

package/dist/module/lib/index.js

@@ -0,0 +1,15 @@
+export const 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),
+};
+export const DefaultTestInterface = (p) => {
+    return Object.assign(Object.assign({}, BaseTestInterface), p);
+};
+export const defaultTestResourceRequirement = {
+    ports: 0
+};

package/dist/module/nodeWriterElectron.js

@@ -0,0 +1,52 @@
+// import fs from "fs";
+const fs = require("fs");
+// import path from "path";
+const path = require("path");
+const fPaths = [];
+export const 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/module/preload.js

@@ -1,26 +1,27 @@
-import { NodeWriter } from "./NodeWriter";
 import { ipcRenderer } from "electron";
+console.log("hello preloader");
+import { NodeWriter } from "./NodeWriter";
 window.NodeWriter = NodeWriter;
 window.exit = (x) => {
     ipcRenderer.invoke('quit-app', x);
 };
-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);
-};
+// 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/module/report.html.js

@@ -0,0 +1,29 @@
+export 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>
+`;