testeranto 0.49.10 → 0.70.0

package/dist/module/lib/basebuilder.js

@@ -0,0 +1,82 @@
+export 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);
+                    //  if (!fs.existsSync(destFolder)) {
+                    //    fs.mkdirSync(destFolder, { recursive: true });
+                    //  }
+                    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) => access.write(`${l.toString()}\n`);
+                    const suiteDone = await runner(testResourceConfiguration, tLog, y);
+                    const logPromise = new Promise((res, rej) => {
+                        access.on("finish", () => {
+                            res(true);
+                        });
+                    });
+                    access.end();
+                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+                        return suiteDone.givens[k].error;
+                    }).length;
+                    logWriter.writeFileSync(`${testResourceConfiguration.fs}/exitcode`, numberOfFailures.toString());
+                    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;
+    }
+}

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, 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,78 @@
+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, utils) {
+                return (fullTestInterface.beforeAll ||
+                    (async (input, artifactory, tr, utils) => input))(s, this.testResourceConfiguration, artifactory, utils);
+            }
+        }, 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
+                // utils,
+                );
+            }
+            afterEach(store, key, artifactory, utils) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), utils)));
+            }
+            afterAll(store, artifactory, utils) {
+                const pagesHandler = {
+                    get(target, prop) {
+                        console.log(`Getting pages property ${prop}`);
+                        return target[prop];
+                    },
+                };
+                const browserHandler = {
+                    get(target, prop) {
+                        console.log(`Getting browser property ${prop}`);
+                        if (prop === "pages") {
+                            // return target[prop];
+                            return new Proxy(target[prop], pagesHandler);
+                        }
+                        else {
+                            return target[prop];
+                        }
+                    },
+                };
+                const proxy = new Proxy(utils.browser, browserHandler);
+                return fullTestInterface.afterAll(store, (fPath, value) => {
+                    artifactory(`afterAll4-${this.name}/${fPath}`, value);
+                }, utils
+                // {
+                //   ...utils,
+                //   browser: proxy,
+                // }
+                );
+            }
+        }, 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, utils) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`afterEach2-${this.name}/${fPath}`, value), utils)));
+            }
+        }, testResourceRequirement, logWriter);
+    }
+}

package/dist/module/lib/index.js

@@ -0,0 +1,17 @@
+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/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/preload.js

@@ -1,26 +1,14 @@
+import puppeteer from "puppeteer-core";
 import { NodeWriter } from "./NodeWriter";
-import { ipcRenderer } from "electron";
+import puppeteerConfiger from "./puppeteerConfiger";
 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);
-};
+window.browser = new Promise(async (res, rej) => {
+    const browser = await puppeteerConfiger("2999").then(async (json) => {
+        const b = await puppeteer.connect({
+            browserWSEndpoint: json.webSocketDebuggerUrl,
+            defaultViewport: null,
+        });
+        console.log("connected!", b.isConnected());
+        return res(b);
+    });
+});

package/dist/module/puppeteerConfiger.js

@@ -0,0 +1,19 @@
+import http from "http";
+export default async (port) => new Promise((resolve, reject) => {
+    let json = "";
+    const request = http.request({
+        host: "127.0.0.1",
+        path: "/json/version",
+        port,
+    }, (response) => {
+        response.on("error", reject);
+        response.on("data", (chunk) => {
+            json += chunk.toString();
+        });
+        response.on("end", () => {
+            resolve(JSON.parse(json));
+        });
+    });
+    request.on("error", reject);
+    request.end();
+});

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>
+`;