testeranto 0.111.0 → 0.112.1

package/dist/module/lib/core.js

@@ -0,0 +1,114 @@
+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, testInterface, uberCatcher) {
+        const fullTestInterface = DefaultTestInterface(testInterface);
+        super(testImplementation, testSpecification, input, class extends BaseSuite {
+            afterAll(store, artifactory, pm) {
+                return fullTestInterface.afterAll(store, 
+                // (fPath: string, value: unknown) =>
+                //   // TODO does not work?
+                //   {
+                //     artifactory(`afterAll4-${this.name}/${fPath}`, value);
+                //   },
+                pm);
+            }
+            assertThat(t) {
+                fullTestInterface.assertThis(t);
+            }
+            async setup(s, artifactory, tr, pm) {
+                return (fullTestInterface.beforeAll ||
+                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, 
+                // artifactory,
+                pm);
+            }
+        }, class Given extends BaseGiven {
+            constructor() {
+                super(...arguments);
+                this.uberCatcher = uberCatcher;
+            }
+            async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
+                return fullTestInterface.beforeEach(subject, initializer, 
+                // artifactory,
+                testResource, initialValues, pm);
+            }
+            afterEach(store, key, artifactory, pm) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, 
+                // (fPath: string, value: unknown) =>
+                //   artifactory(`after/${fPath}`, value),
+                pm)));
+            }
+        }, class When extends BaseWhen {
+            async andWhen(store, whenCB, testResource, pm) {
+                try {
+                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                }
+                catch (e) {
+                    throw e;
+                }
+                // return fullTestInterface
+                //   .andWhen(store, whenCB, testResource, pm)
+                //   .catch((e) => {
+                //     throw e;
+                //   });
+                // return new Promise((res, rej) => {
+                //   fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                // });
+                // return await fullTestInterface.andWhen(
+                //   store,
+                //   whenCB,
+                //   testResource,
+                //   pm
+                // );
+            }
+        }, class Then extends BaseThen {
+            async butThen(store, thenCB, testResource, pm) {
+                return await fullTestInterface
+                    .butThen(store, thenCB, testResource, pm)
+                    .then((v) => {
+                    return v;
+                }, (e) => {
+                    console.log(" ERROR ", e);
+                    throw e;
+                });
+                // try {
+                //   console.log("mark 4");
+                //   return await fullTestInterface.butThen(
+                //     store,
+                //     thenCB,
+                //     testResource,
+                //     pm
+                //   );
+                // } catch (e) {
+                //   console.log("mar123");
+                //   throw e;
+                // }
+                // return await fullTestInterface.butThen(
+                //   store,
+                //   thenCB,
+                //   testResourceConfiguration,
+                //   pm
+                // );
+            }
+        }, 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, pm) {
+                return fullTestInterface.beforeEach(subject, this.initialValues, 
+                // (fPath: string, value: unknown) =>
+                //   artifactory(`before/${fPath}`, value),
+                testResourceConfiguration, this.initialValues, pm);
+            }
+            afterEach(store, key, artifactory, pm) {
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, 
+                // (fPath: string, value: unknown) =>
+                //   // TODO does not work?
+                //   artifactory(`afterEach2-${this.name}/${fPath}`, value),
+                pm)));
+            }
+        }, testResourceRequirement);
+    }
+}

package/dist/module/lib/index.js

@@ -0,0 +1,17 @@
+export const BaseTestInterface = {
+    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,
+};

package/dist/module/lib/types.js

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

package/dist/module/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

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/run.js

@@ -0,0 +1,24 @@
+import ansiC from "ansi-colors";
+import readline from "readline";
+import { PM_Main } from "./PM/main";
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log(ansiC.inverse("Press 'x' to shutdown forcefully."));
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "x") {
+        console.log(ansiC.inverse("Shutting down forcefully..."));
+        process.exit(-1);
+    }
+});
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+    const rawConfig = module.default;
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + rawConfig.outdir });
+    const pm = new PM_Main(config);
+    pm.start();
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "q") {
+            pm.stop();
+        }
+    });
+});