testeranto 0.62.0 → 0.70.0

package/dist/module/esbuildConfigs/web.js

@@ -1,18 +1,18 @@
 import path from "path";
 import baseEsBuildConfig from "./index.js";
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 export default (config, entryPoints) => {
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
-        // inject: ['./node_modules/testeranto/dist/cjs-shim.js'],
+        // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
         // banner: {
-        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
         // },
+        // splitting: true,
         outdir: config.outdir + "/web", alias: {
-            react: path.resolve("./node_modules/react")
+            react: path.resolve("./node_modules/react"),
         }, external: [
             "testeranto.json",
             "features.test.ts",
-            // "url", 
+            // "url",
             "react",
             "electron",
             "path",
@@ -28,18 +28,21 @@ export default (config, entryPoints) => {
             "readline",
             "zlib",
             "crypto",
-            "https"
+            "https",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
             {
-                name: 'rebuild-notify',
+                name: "rebuild-notify",
                 setup(build) {
-                    build.onEnd(result => {
+                    build.onEnd((result) => {
                         console.log(`web build ended with ${result.errors.length} errors`);
-                        console.log(result);
-                        result.errors.length !== 0 && process.exit(-1);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
                     });
-                }
+                },
             },
         ] });
 };

package/dist/module/lib/abstractBase.js

@@ -43,7 +43,14 @@ export class BaseSuite {
         // @TODO fix me
         for (const k of Object.keys(this.givens)) {
             const giver = this.givens[k];
-            giver.afterAll(this.store, artifactory, utils);
+            try {
+                giver.afterAll(this.store, artifactory, utils);
+            }
+            catch (e) {
+                console.error(e);
+                this.fails.push(giver);
+                return this;
+            }
         }
         ////////////////
         return this;
@@ -73,7 +80,7 @@ export class BaseGiven {
             features: this.features,
         };
     }
-    async afterEach(store, key, artifactory) {
+    async afterEach(store, key, artifactory, utils) {
         return store;
     }
     async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
@@ -98,7 +105,7 @@ export class BaseGiven {
         }
         finally {
             try {
-                await this.afterEach(this.store, key, givenArtifactory);
+                await this.afterEach(this.store, key, givenArtifactory, utils);
             }
             catch (e) {
                 console.error("afterEach failed! no error will be recorded!", e);
@@ -143,7 +150,7 @@ export class BaseThen {
     async test(store, testResourceConfiguration, tLog, utils) {
         tLog(" Then:", this.name);
         try {
-            const x = (await this.butThen(store, this.thenCB, testResourceConfiguration));
+            const x = await this.butThen(store, this.thenCB, testResourceConfiguration);
             return x;
         }
         catch (e) {
@@ -161,7 +168,7 @@ export class BaseCheck {
         this.whens = whens;
         this.thens = thens;
     }
-    async afterEach(store, key, cb) {
+    async afterEach(store, key, cb, utils) {
         return;
     }
     async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
@@ -179,7 +186,7 @@ export class BaseCheck {
             };
             return a;
         }, {}));
-        await this.afterEach(store, key);
+        await this.afterEach(store, key, () => { }, utils);
         return;
     }
 }

package/dist/module/lib/basebuilder.js

@@ -29,33 +29,33 @@ export class BaseBuilder {
                     name: "",
                     fs: ".",
                     ports: [],
-                    scheduled: false
+                    scheduled: false,
                 }, y) {
                     console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
-                    await logWriter.mkdirSync(testResourceConfiguration.fs);
+                    // 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) => {
-                        // console.log(...l);
-                        access.write(`${l.toString()}\n`);
-                    };
+                    const tLog = (...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.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;
+                    logWriter.writeFileSync(`${testResourceConfiguration.fs}/exitcode`, numberOfFailures.toString());
                     console.log(`exiting gracefully with ${numberOfFailures} failures.`);
                     return {
                         failed: numberOfFailures,
                         artifacts: this.artifacts || [],
-                        logPromise
+                        logPromise,
                     };
                 },
             };

package/dist/module/lib/classBuilder.js

@@ -7,10 +7,9 @@ export class ClassBuilder extends BaseBuilder {
             };
             return a;
         }, {});
-        const classyGivens = Object.entries(testImplementation.givens)
-            .reduce((a, [key, givEn]) => {
+        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 new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], givEn);
             };
             return a;
         }, {});

package/dist/module/lib/core.js

@@ -1,5 +1,5 @@
-import { DefaultTestInterface, defaultTestResourceRequirement } from "./index.js";
-import { BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase.js";
+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) {
@@ -8,20 +8,49 @@ export default class Testeranto extends ClassBuilder {
             assertThat(t) {
                 fullTestInterface.assertThis(t);
             }
-            async setup(s, artifactory, tr) {
-                return (fullTestInterface.beforeAll || (async (input, artifactory, tr) => input))(s, this.testResourceConfiguration, artifactory);
+            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);
+                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues
+                // utils,
+                );
             }
-            afterEach(store, key, artifactory) {
-                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value))));
+            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) {
-                return fullTestInterface.afterAll(store, (fPath, value) => { artifactory(`afterAll4-${this.name}/${fPath}`, value); }, 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) {
@@ -39,10 +68,10 @@ export default class Testeranto extends ClassBuilder {
             async checkThat(subject, testResourceConfiguration, artifactory) {
                 return fullTestInterface.beforeEach(subject, this.initialValues, (fPath, value) => artifactory(`before/${fPath}`, value), testResourceConfiguration, this.initialValues);
             }
-            afterEach(store, key, artifactory) {
+            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))));
+                artifactory(`afterEach2-${this.name}/${fPath}`, value), utils)));
             }
         }, testResourceRequirement, logWriter);
     }

package/dist/module/lib/index.js

@@ -1,15 +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),
+    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
+    ports: 0,
 };

package/dist/module/lib/types.js

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

package/dist/module/preload.js

@@ -1,27 +1,14 @@
-import { ipcRenderer } from "electron";
-console.log("hello preloader");
+import puppeteer from "puppeteer-core";
 import { NodeWriter } from "./NodeWriter";
+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();
+});