testeranto 0.113.1 → 0.121.1

package/dist/module/lib/abstractBase.js

@@ -21,9 +21,11 @@ export class BaseSuite {
     }
     toObj() {
         const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+        const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
         return {
             name: this.name,
             givens,
+            checks,
             fails: this.fails,
             features: this.features(),
         };
@@ -39,29 +41,28 @@ export class BaseSuite {
     }
     async run(input, testResourceConfiguration, artifactory, tLog, pm) {
         this.testResourceConfiguration = testResourceConfiguration;
-        tLog("test resources: ", JSON.stringify(testResourceConfiguration));
+        // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
         const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
         // console.log("\nSuite:", this.index, this.name);
         tLog("\nSuite:", this.index, this.name);
         const sNdx = this.index;
         const sName = this.name;
+        const beforeAllProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "customScreenShot") {
+                    return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { 
+                        // path: `${filepath}/${opts.path}`,
+                        path: `suite-${sNdx}/beforeAll/${opts.path}` }), p);
+                }
+                if (prop === "writeFileSync") {
+                    return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+                }
+                /* @ts-ignore:next-line */
+                return Reflect.get(...arguments);
+            },
+        });
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy);
         for (const [gKey, g] of Object.entries(this.givens)) {
-            // console.log("gKey", gKey);
-            const beforeAllProxy = new Proxy(pm, {
-                get(target, prop, receiver) {
-                    if (prop === "customScreenShot") {
-                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { 
-                            // path: `${filepath}/${opts.path}`,
-                            path: `suite-${sNdx}/beforeAll/${opts.path}` }), p);
-                    }
-                    if (prop === "writeFileSync") {
-                        return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
-                    }
-                    /* @ts-ignore:next-line */
-                    return Reflect.get(...arguments);
-                },
-            });
-            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy);
             const giver = this.givens[gKey];
             try {
                 this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
@@ -72,6 +73,9 @@ export class BaseSuite {
                 // return this;
             }
         }
+        for (const [ndx, thater] of this.checks.entries()) {
+            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm);
+        }
         try {
             this.afterAll(this.store, artifactory, 
             // afterAllProxy
@@ -82,17 +86,6 @@ export class BaseSuite {
             // this.fails.push(this);
             // return this;
         }
-        // for (const [ndx, thater] of this.checks.entries()) {
-        //   await thater.check(
-        //     subject,
-        //     thater.name,
-        //     testResourceConfiguration,
-        //     this.assertThat,
-        //     suiteArtifactory,
-        //     tLog,
-        //     pm
-        //   );
-        // }
         // @TODO fix me
         // for (const k of Object.keys(this.givens)) {
         //   const giver = this.givens[k];
@@ -109,9 +102,7 @@ export class BaseSuite {
     }
 }
 export class BaseGiven {
-    constructor(name, features, whens, thens, givenCB, initialValues
-    // key: string
-    ) {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
         this.name = name;
         this.features = features;
         this.whens = whens;
@@ -201,7 +192,8 @@ export class BaseGiven {
                 afterEachProxy);
             }
             catch (e) {
-                console.error("afterEach failed! no error will be recorded!", e);
+                console.error("afterEach failed!", e);
+                this.error = e.message;
             }
         }
         return this.store;
@@ -220,7 +212,6 @@ export class BaseWhen {
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" When:", this.name);
-        const name = this.name;
         const andWhenProxy = new Proxy(pm, {
             get(target, prop, receiver) {
                 if (prop === "customScreenShot") {
@@ -263,7 +254,16 @@ export class BaseThen {
         };
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        tLog(" Then:", this.name);
+        this.go = async (s) => {
+            tLog(" Then!!!:", this.name);
+            try {
+                await this.thenCB(s);
+            }
+            catch (e) {
+                console.log("test failed", e);
+                this.error = e.message;
+            }
+        };
         try {
             const butThenProxy = new Proxy(pm, {
                 get(target, prop, receiver) {
@@ -277,7 +277,7 @@ export class BaseThen {
                     return Reflect.get(...arguments);
                 },
             });
-            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
+            return this.butThen(store, this.go, testResourceConfiguration, butThenProxy).catch((e) => {
                 this.error = true;
                 throw e;
             });
@@ -288,34 +288,40 @@ export class BaseThen {
             throw e;
         }
     }
+    check() { }
 }
 export class BaseCheck {
-    constructor(name, features, checkCB, whens, thens) {
+    constructor(name, features, checker, x, checkCB) {
         this.name = name;
         this.features = features;
         this.checkCB = checkCB;
-        this.whens = whens;
-        this.thens = thens;
+        this.checker = checker;
     }
-    async afterEach(store, key, cb, pm) {
-        return;
+    toObj() {
+        return {
+            key: this.key,
+            name: this.name,
+            functionAsString: this.checkCB.toString(),
+            // thens: this.thens.map((t) => t.toObj()),
+            // error: this.error ? [this.error, this.error.stack] : null,
+            // fail: this.fail ? [this.fail] : false,
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory, pm) {
+        return store;
+    }
+    beforeAll(store, 
+    // artifactory: ITestArtifactory
+    // subject,
+    initializer, artifactory, testResource, initialValues, pm) {
+        return store;
     }
     async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
+        this.key = key;
         tLog(`\n Check: ${this.name}`);
-        const store = await this.checkThat(subject, testResourceConfiguration, artifactory, pm);
-        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
-            a[key] = async (payload) => {
-                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");
-            };
-            return a;
-        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
-            a[key] = async (payload) => {
-                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm);
-                tester(t);
-            };
-            return a;
-        }, {}));
-        await this.afterEach(store, key, () => { }, pm);
+        this.store = await this.checkThat(subject, testResourceConfiguration, artifactory, this.checkCB, this.initialValues, pm);
+        await this.checker(this.store, pm);
         return;
     }
 }

package/dist/module/lib/basebuilder.js

@@ -1,6 +1,5 @@
 export class BaseBuilder {
     constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification) {
-        this.input = input;
         this.artifacts = [];
         this.artifacts = [];
         this.testResourceRequirement = testResourceRequirement;
@@ -42,7 +41,7 @@ export class BaseBuilder {
                     puppetMaster.writeFileSync(`bdd_errors.txt`, numberOfFailures.toString());
                     const o = this.toObj();
                     puppetMaster.writeFileSync(`littleBoard.html`, `
-            <!DOCTYPE html>
+<!DOCTYPE html>
 <html lang="en">
 
 <head>
@@ -52,15 +51,15 @@ export class BaseBuilder {
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <meta name="author" content="" />
 
-  <link rel="stylesheet" href="/kokomoBay/docs/TestReport.css" />
-  <script src="/kokomoBay/docs/TestReport.js"></script>
+  <link rel="stylesheet" href="/kokomoBay/testeranto/TestReport.css" />
+  <script src="/kokomoBay/testeranto/TestReport.js"></script>
 
 </head>
 
-  <body>
-    <h1>Test report</h1>
-            <div id="root"/>
-  </body>
+<body>
+  <h1>Test report</h1>
+  <div id="root"/>
+</body>
             `);
                     puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
                     return {

package/dist/module/lib/classBuilder.js

@@ -8,8 +8,11 @@ export class ClassBuilder extends BaseBuilder {
             return a;
         }, {});
         const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens, givEn) => {
-                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], givEn);
+            a[key] = (features, whens, thens) => {
+                // console.log("givEn", givEn.toString());
+                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key]
+                // givEn
+                );
             };
             return a;
         }, {});
@@ -25,9 +28,9 @@ export class ClassBuilder extends BaseBuilder {
             };
             return a;
         }, {});
-        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);
+        const classyChecks = Object.entries(testImplementation.checks).reduce((a, [key, chEck]) => {
+            a[key] = (name, features, checker) => {
+                return new checkKlasser.prototype.constructor(key, features, chEck, checker);
             };
             return a;
         }, {});

package/dist/module/lib/core.js

@@ -29,15 +29,10 @@ export default class Testeranto extends ClassBuilder {
                 this.uberCatcher = uberCatcher;
             }
             async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                return fullTestInterface.beforeEach(subject, initializer, 
-                // artifactory,
-                testResource, initialValues, pm);
+                return fullTestInterface.beforeEach(subject, initializer, 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)));
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, pm)));
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
@@ -93,21 +88,14 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class Check extends BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {
-                super(name, features, checkCallback, whens, thens);
+                super(name, features, whens, thens, checkCallback, initialValues);
                 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);
+            async checkThat(subject, testResourceConfiguration, artifactory, initializer, initialValues, pm) {
+                return fullTestInterface.beforeEach(subject, initializer, testResourceConfiguration, 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)));
+                return new Promise((res) => res(fullTestInterface.afterEach(store, key, pm)));
             }
         }, testResourceRequirement);
     }

package/dist/module/lib/index.js

@@ -5,7 +5,12 @@ export const BaseTestInterface = {
     },
     afterEach: async (s) => s,
     afterAll: (store) => undefined,
-    butThen: async (store, thenCb) => thenCb(store),
+    butThen: async (store, thenCb) => {
+        try {
+            thenCb(store);
+        }
+        catch (e) { }
+    },
     andWhen: (a) => a,
     assertThis: () => null,
 };

package/dist/module/run.js

@@ -1,5 +1,6 @@
 import ansiC from "ansi-colors";
 import readline from "readline";
+import path from "path";
 import { PM_Main } from "./PM/main";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
@@ -11,10 +12,17 @@ process.stdin.on("keypress", (str, key) => {
         process.exit(-1);
     }
 });
+const mode = process.argv[3];
+if (mode !== "once" && mode !== "dev") {
+    console.error("the 2nd argument should be 'dev' or 'once' ");
+    process.exit(-1);
+}
 import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+    const testName = path.basename(process.argv[2]).split(".")[0];
+    console.log("testeranto is running", testName, mode);
     const rawConfig = module.default;
-    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + rawConfig.outdir });
-    const pm = new PM_Main(config);
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + `testeranto/${testName}.json` });
+    const pm = new PM_Main(config, testName, mode);
     pm.start();
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {