testeranto 0.70.0 → 0.73.0

package/dist/common/lib/basebuilder.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseBuilder = void 0;
 class BaseBuilder {
-    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, logWriter, testResourceRequirement, testSpecification) {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification
+    // puppetMaster: PM
+    ) {
         this.input = input;
         this.artifacts = [];
         this.artifacts = [];
@@ -13,47 +15,72 @@ class BaseBuilder {
         this.thenOverides = thenOverides;
         this.checkOverides = checkOverides;
         this.testSpecification = testSpecification;
+        // this.puppetMaster = puppetMaster;
         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);
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (
+            // testResourceConfiguration: ITTestResourceConfiguration,
+            puppetMaster, tLog) => {
+                await puppetMaster.startPuppeteer({
+                    browserWSEndpoint: puppetMaster.testResourceConfiguration.browserWSEndpoint,
+                }, puppetMaster.testResourceConfiguration.fs);
+                return await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                    this.artifacts.push(p);
+                })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+            };
+            const runner = suiteRunner(suite);
             return {
                 test: suite,
-                testResourceRequirement,
+                // 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 });
+                receiveTestResourceConfig: async function (
+                // testResourceConfiguration = {
+                //   name: "",
+                //   fs: ".",
+                //   ports: [],
+                //   browserWSEndpoint: "",
+                // },
+                puppetMaster) {
+                    // console.log(
+                    //   `testResourceConfiguration! ${JSON.stringify(
+                    //     testResourceConfiguration,
+                    //     null,
+                    //     2
+                    //   )}`
+                    // );
+                    // console.log("puppetMaster", puppetMaster);
+                    await puppetMaster
+                        .mkdirSync();
+                    //  if (!puppetMaster.existsSync(destFolder)) {
+                    //    puppetMaster.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);
+                    // puppetMaster.writeFileSync(
+                    //   // puppetMaster.testResourceConfiguration.fs + `/tests.json`,
+                    //   `tests.json`,
+                    //   JSON.stringify(this.toObj(), null, 2)
+                    // );
+                    const logFilePath = "log.txt";
+                    // puppetMaster.testResourceConfiguration.fs + `/log.txt`;
+                    const access = await puppetMaster.createWriteStream(logFilePath);
+                    // console.log("access", access);
+                    const tLog = (...l) => {
+                        // access.write(`${l.toString()}\n`);
+                        // console.log("tLog", l);
+                        puppetMaster.write(access, `${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(puppetMaster, tLog);
                     const logPromise = new Promise((res, rej) => {
-                        access.on("finish", () => {
-                            res(true);
-                        });
+                        puppetMaster.end(access);
+                        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());
+                    puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
+                    puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
                     console.log(`exiting gracefully with ${numberOfFailures} failures.`);
                     return {
                         failed: numberOfFailures,

package/dist/common/lib/classBuilder.js

@@ -3,7 +3,9 @@ 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) {
+    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);
@@ -34,7 +36,9 @@ class ClassBuilder extends basebuilder_js_1.BaseBuilder {
             };
             return a;
         }, {});
-        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, logWriter, testResourceRequirement, testSpecification);
+        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification
+        // puppetMaster
+        );
     }
 }
 exports.ClassBuilder = ClassBuilder;

package/dist/common/lib/core.js

@@ -4,59 +4,53 @@ 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) {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testInterface
+    // puppetMaster: PM
+    ) {
         const fullTestInterface = (0, index_js_1.DefaultTestInterface)(testInterface);
         super(testImplementation, testSpecification, input, class extends abstractBase_js_1.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, utils) {
+            async setup(s, artifactory, tr, pm) {
                 return (fullTestInterface.beforeAll ||
-                    (async (input, artifactory, tr, utils) => input))(s, this.testResourceConfiguration, artifactory, utils);
+                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, artifactory, pm);
             }
         }, class Given extends abstractBase_js_1.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
-                // utils,
-                );
+                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues, pm);
             }
-            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,
-                // }
-                );
+            afterEach(store, key, artifactory, pm) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), pm)));
             }
         }, class When extends abstractBase_js_1.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 abstractBase_js_1.BaseThen {
             async butThen(store, thenCB, testResourceConfiguration) {
@@ -67,15 +61,17 @@ class Testeranto extends classBuilder_js_1.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, utils) {
+            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), utils)));
+                artifactory(`afterEach2-${this.name}/${fPath}`, value), pm)));
             }
-        }, testResourceRequirement, logWriter);
+        }, testResourceRequirement
+        // puppetMaster
+        );
     }
 }
 exports.default = Testeranto;

package/dist/common/lib/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultTestInterface = exports.BaseTestInterface = void 0;
+// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
 exports.BaseTestInterface = {
     beforeAll: async (s) => s,
-    beforeEach: async function (subject, initialValues, testResource) {
+    beforeEach: async function (subject, initialValues, x, testResource, pm) {
         return subject;
     },
     afterEach: async (s) => s,

package/dist/common/preload.js

@@ -1,19 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
-const NodeWriter_1 = require("./NodeWriter");
-const puppeteerConfiger_1 = __importDefault(require("./puppeteerConfiger"));
-window.NodeWriter = NodeWriter_1.NodeWriter;
-window.browser = new Promise(async (res, rej) => {
-    const browser = await (0, puppeteerConfiger_1.default)("2999").then(async (json) => {
-        const b = await puppeteer_core_1.default.connect({
-            browserWSEndpoint: json.webSocketDebuggerUrl,
-            defaultViewport: null,
-        });
-        console.log("connected!", b.isConnected());
-        return res(b);
-    });
-});
+// 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);
+//   });
+// });