testeranto 0.38.3 → 0.38.9

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { IBaseConfig } from "./IBaseConfig";
 export type { IBaseConfig };
 declare type ITTestResourceConfiguration = {
-    "fs": string;
-    "ports": number[];
+    fs: string;
+    ports: number[];
 };
 export declare type ITTestResourceRequirement = {
-    "ports": number;
-    "fs": string;
+    ports: number;
+    fs: string;
 };
 declare type IRunner = (x: ITTestResourceConfiguration, t: ITLog) => Promise<boolean>;
 export declare type IT = {

package/dist/index.mjs

@@ -1,27 +1,30 @@
-import fs from 'fs';
-import path from 'path';
-const defaultTestResource = { "fs": ".", ports: [] };
-const defaultTestResourceRequirement = { "fs": ".", ports: 0 };
+import fs from "fs";
+import path from "path";
+const defaultTestResource = { fs: ".", ports: [] };
+const defaultTestResourceRequirement = {
+    fs: ".",
+    ports: 0,
+};
 const fPaths = [];
 const testArtiFactoryfileWriter = (tLog) => (fp) => (givenNdx) => (key, value) => {
     tLog("testArtiFactory =>", key);
     const fPath = `${fp}/${givenNdx}/${key}`;
     const cleanPath = path.resolve(fPath);
     fPaths.push(cleanPath.replace(process.cwd(), ``));
-    const targetDir = cleanPath.split('/').slice(0, -1).join('/');
+    const targetDir = cleanPath.split("/").slice(0, -1).join("/");
     fs.mkdir(targetDir, { recursive: true }, async (error) => {
         if (error) {
             console.error(`❗️testArtiFactory failed`, targetDir, error);
         }
-        fs.writeFileSync(path.resolve(targetDir.split('/').slice(0, -1).join('/'), "manifest"), fPaths.join(`\n`), {
-            encoding: 'utf-8'
+        fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+            encoding: "utf-8",
         });
         if (Buffer.isBuffer(value)) {
             fs.writeFileSync(fPath, value, "binary");
         }
-        else if (`string` === (typeof value)) {
+        else if (`string` === typeof value) {
             fs.writeFileSync(fPath, value.toString(), {
-                encoding: 'utf-8'
+                encoding: "utf-8",
             });
         }
         else {
@@ -46,7 +49,7 @@ export class BaseSuite {
         return {
             name: this.name,
             givens: this.givens.map((g) => g.toObj()),
-            fails: this.fails
+            fails: this.fails,
         };
     }
     setup(s, artifactory) {
@@ -91,7 +94,6 @@ export class BaseGiven {
     afterAll(store, artifactory) {
         return;
     }
-    ;
     toObj() {
         return {
             name: this.name,
@@ -118,7 +120,8 @@ export class BaseGiven {
         }
         catch (e) {
             this.error = e;
-            tLog('\u0007'); // bell
+            tLog(e);
+            tLog("\u0007"); // bell
             // throw e;
         }
         finally {
@@ -215,20 +218,18 @@ export class BaseCheck {
     async check(subject, ndx, testResourceConfiguration, tester, artifactory, tLog) {
         tLog(`\n Check: ${this.name}`);
         const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
-        await this.checkCB((Object.entries(this.whens)
-            .reduce((a, [key, when]) => {
+        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
             a[key] = async (payload) => {
                 return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog);
             };
             return a;
-        }, {})), (Object.entries(this.thens)
-            .reduce((a, [key, then]) => {
+        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
             a[key] = async (payload) => {
                 const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog);
                 tester(t);
             };
             return a;
-        }, {})));
+        }, {}));
         await this.afterEach(store, ndx);
         return;
     }
@@ -262,36 +263,31 @@ export class TesterantoLevelZero {
 }
 export class TesterantoLevelOne {
     constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement, nameKey) {
-        const classySuites = Object.entries(testImplementation.Suites)
-            .reduce((a, [key]) => {
+        const classySuites = Object.entries(testImplementation.Suites).reduce((a, [key]) => {
             a[key] = (somestring, givens, checks) => {
                 return new suiteKlasser.prototype.constructor(somestring, givens, checks);
             };
             return a;
         }, {});
-        const classyGivens = Object.entries(testImplementation.Givens)
-            .reduce((a, [key, z]) => {
+        const classyGivens = Object.entries(testImplementation.Givens).reduce((a, [key, z]) => {
             a[key] = (features, whens, thens, ...xtrasW) => {
                 return new givenKlasser.prototype.constructor(z.name, features, whens, thens, z(...xtrasW));
             };
             return a;
         }, {});
-        const classyWhens = Object.entries(testImplementation.Whens)
-            .reduce((a, [key, whEn]) => {
+        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]) => {
+        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]) => {
+        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);
             };
@@ -331,7 +327,7 @@ export class TesterantoLevelOne {
                     const numberOfFailures = suiteDone.givens.filter((g) => g.error).length;
                     console.log(`exiting gracefully with ${numberOfFailures} failures.`);
                     process.exitCode = numberOfFailures;
-                }
+                },
             };
         });
         return toReturn;
@@ -340,28 +336,30 @@ export class TesterantoLevelOne {
 export default async (input, testSpecification, testImplementation, testInterface, nameKey, testResourceRequirement = defaultTestResourceRequirement) => {
     const butThen = testInterface.butThen || (async (a) => a);
     const { andWhen } = testInterface;
-    const actionHandler = testInterface.actionHandler || function (b) {
-        return b;
-    };
+    const actionHandler = testInterface.actionHandler ||
+        function (b) {
+            return b;
+        };
     const assertioner = testInterface.assertioner || (async (t) => t);
     const beforeAll = testInterface.beforeAll || (async (input) => input);
-    const beforeEach = testInterface.beforeEach || async function (subject, initialValues, testResource) {
-        return subject;
-    };
+    const beforeEach = testInterface.beforeEach ||
+        async function (subject, initialValues, testResource) {
+            return subject;
+        };
     const afterEach = testInterface.afterEach || (async (s) => s);
     const afterAll = testInterface.afterAll || ((store) => undefined);
     class MrT extends TesterantoLevelOne {
         constructor() {
             super(testImplementation, 
             /* @ts-ignore:next-line */
-            testSpecification, input, (class extends BaseSuite {
+            testSpecification, input, class extends BaseSuite {
                 async setup(s, artifactory) {
                     return beforeAll(s, artifactory);
                 }
                 test(t) {
                     return assertioner(t);
                 }
-            }), class Given extends BaseGiven {
+            }, class Given extends BaseGiven {
                 constructor(name, features, whens, thens, initialValues) {
                     super(name, features, whens, thens);
                     this.initialValues = initialValues;
@@ -421,23 +419,23 @@ export default async (input, testSpecification, testImplementation, testInterfac
                 console.log("requesting test resources from pm2 ...", testResourceRequirement);
                 /* @ts-ignore:next-line */
                 process.send({
-                    type: 'testeranto:hola',
+                    type: "testeranto:hola",
                     data: {
-                        testResourceRequirement
-                    }
+                        testResourceRequirement,
+                    },
                 });
                 console.log("awaiting test resources from pm2...");
-                process.on('message', async function (packet) {
+                process.on("message", async function (packet) {
                     const resourcesFromPm2 = packet.data.testResourceConfiguration;
-                    const secondTestResource = (Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromPm2))), JSON.parse(JSON.stringify(partialTestResource))));
+                    const secondTestResource = Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromPm2))), JSON.parse(JSON.stringify(partialTestResource)));
                     if (await t.receiveTestResourceConfig(secondTestResource)) {
                         /* @ts-ignore:next-line */
                         process.send({
-                            type: 'testeranto:adios',
+                            type: "testeranto:adios",
                             data: {
                                 testResourceConfiguration: mrt[0].test.testResourceConfiguration,
-                                results: mrt[0].toObj()
-                            }
+                                results: mrt[0].toObj(),
+                            },
                         }, (err) => {
                             if (!err) {
                                 console.log(`✅`);
@@ -452,9 +450,9 @@ export default async (input, testSpecification, testImplementation, testInterfac
             }
             else {
                 console.log("Pass run-time test resources by STDIN");
-                process.stdin.on('data', async (data) => {
+                process.stdin.on("data", async (data) => {
                     const resourcesFromStdin = JSON.parse(data.toString());
-                    const secondTestResource = (Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromStdin))), JSON.parse(JSON.stringify(partialTestResource))));
+                    const secondTestResource = Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromStdin))), JSON.parse(JSON.stringify(partialTestResource)));
                     await t.receiveTestResourceConfig(secondTestResource);
                     // process.exit(0); // :-)
                 });