testeranto 0.62.0 → 0.73.0

package/dist/module/lib/classBuilder.js

@@ -1,16 +1,17 @@
 import { BaseBuilder } from "./basebuilder.js";
 export class ClassBuilder extends BaseBuilder {
-    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement, logWriter) {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement
+    // puppetMaster: PM
+    ) {
         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]) => {
+        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;
         }, {});
@@ -32,6 +33,8 @@ export class ClassBuilder extends BaseBuilder {
             };
             return a;
         }, {});
-        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, logWriter, testResourceRequirement, testSpecification);
+        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification
+        // puppetMaster
+        );
     }
 }

package/dist/module/lib/core.js

@@ -1,31 +1,54 @@
-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) {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface
+    // puppetMaster: PM
+    ) {
         const fullTestInterface = DefaultTestInterface(testInterface);
         super(testImplementation, testSpecification, input, class extends BaseSuite {
+            afterAll(store, artifactory, pm) {
+                // 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);
+                }, pm);
+            }
             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, pm) {
+                return (fullTestInterface.beforeAll ||
+                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, artifactory, pm);
             }
         }, class Given extends BaseGiven {
-            async givenThat(subject, testResource, artifactory, initializer) {
+            async givenThat(subject, testResource, artifactory, initializer, pm) {
                 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))));
+                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues, pm);
             }
-            afterAll(store, artifactory, utils) {
-                return fullTestInterface.afterAll(store, (fPath, value) => { artifactory(`afterAll4-${this.name}/${fPath}`, value); }, utils);
+            afterEach(store, key, artifactory, pm) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), pm)));
             }
         }, class When extends BaseWhen {
-            async andWhen(store, whenCB, testResource) {
-                return await fullTestInterface.andWhen(store, whenCB, testResource);
+            async andWhen(store, whenCB, testResource, pm) {
+                return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
             }
         }, class Then extends BaseThen {
             async butThen(store, thenCB, testResourceConfiguration) {
@@ -36,14 +59,16 @@ export default class Testeranto extends ClassBuilder {
                 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);
+            async checkThat(subject, testResourceConfiguration, artifactory, pm) {
+                return fullTestInterface.beforeEach(subject, this.initialValues, (fPath, value) => artifactory(`before/${fPath}`, value), testResourceConfiguration, this.initialValues, pm);
             }
-            afterEach(store, key, artifactory) {
+            afterEach(store, key, artifactory, pm) {
                 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), pm)));
             }
-        }, testResourceRequirement, logWriter);
+        }, testResourceRequirement
+        // puppetMaster
+        );
     }
 }

package/dist/module/lib/index.js

@@ -1,15 +1,18 @@
+// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
 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, x, testResource, pm) {
+        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/preload.js

@@ -1,27 +1,15 @@
-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);
-// };
+"use strict";
+// import puppeteer from "puppeteer-core";
+// import { NodeWriter } from "./NodeWriter";
+// import puppeteerConfiger from "./puppeteerConfiger";
+// (window as any).NodeWriter = NodeWriter;
+// (window as any).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();
+});