testeranto 0.114.1 → 0.125.0

package/dist/module/{esbuildConfigs → src/esbuildConfigs}/web.js

@@ -2,9 +2,9 @@ import path from "path";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
-export default (config, entryPoints) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", entryPoints);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: config.outdir + "/web", alias: {
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: `testeranto/bundles/web/${testName}`, alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
             "path",
@@ -29,7 +29,10 @@ export default (config, entryPoints) => {
             inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
-                setup(build) {
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> web build starting...`);
+                    });
                     build.onEnd((result) => {
                         console.log(`> web build ended with ${result.errors.length} errors`);
                         if (result.errors.length > 0) {
@@ -40,6 +43,6 @@ export default (config, entryPoints) => {
                     });
                 },
             },
-            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+            ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
         ] });
 };

package/dist/module/src/examples/react/component/index.js

@@ -0,0 +1,26 @@
+import React from "react";
+export class ClassicalComponent extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            count: 0,
+        };
+    }
+    render() {
+        return (React.createElement("div", { style: { border: "3px solid black" } },
+            React.createElement("h1", { id: "theHeader" }, "Hello Marcus"),
+            React.createElement("pre", { id: "theProps" }, JSON.stringify(this.props)),
+            React.createElement("p", null,
+                "foo: ",
+                this.props.foo),
+            React.createElement("pre", { id: "theStat" }, JSON.stringify(this.state)),
+            React.createElement("p", null,
+                "count: ",
+                this.state.count,
+                " times"),
+            React.createElement("button", { id: "theButton", onClick: async () => {
+                    this.setState({ count: this.state.count + 1 });
+                } }, "Click")));
+    }
+}
+export default ClassicalComponent;

package/dist/module/src/examples/react/component/test.js

@@ -0,0 +1,32 @@
+export const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("a classical react component", {
+            test0: Given.AnEmptyState([`I click 4 times and the count is 3`], [
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheHeader(),
+                // When.IClickTheButton(),
+            ], [
+                Then.ThePropsIs({ foo: "bar", children: [] }),
+                Then.TheStatusIs({ count: 3 }),
+            ]),
+            test1: Given.AnEmptyState([`Count is 1 by default`], [When.IClickTheButton()], [
+                Then.ThePropsIs({ foo: "bar", children: [] }),
+                Then.TheStatusIs({ count: 1 }),
+            ]),
+            test2: Given.AnEmptyState([`0`], [
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+            ], [Then.TheStatusIs({ count: 9 })]),
+            test3: Given.AnEmptyState([`0`], [When.IClickTheButton(), When.IClickTheButton()], [Then.TheStatusIs({ count: 2 })]),
+        }, []),
+    ];
+};

package/dist/module/src/init-docs.js

@@ -0,0 +1,4 @@
+import Init from "./Init";
+console.log("Initializing a testeranto project");
+Init();
+console.log("testeranto project initialized");

package/dist/module/{lib → src/lib}/abstractBase.js

@@ -4,7 +4,7 @@ export class BaseSuite {
         this.index = index;
         this.givens = givens;
         this.checks = checks;
-        this.fails = [];
+        this.fails = 0;
     }
     features() {
         const features = Object.keys(this.givens)
@@ -13,18 +13,17 @@ export class BaseSuite {
             .filter((value, index, array) => {
             return array.indexOf(value) === index;
         });
-        // .reduce((mm, lm) => {
-        //   mm[lm] = lm;
-        //   return mm;
-        // }, {});
         return features || [];
     }
     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,
+            failed: this.failed,
             features: this.features(),
         };
     }
@@ -32,46 +31,50 @@ export class BaseSuite {
         return new Promise((res) => res(s));
     }
     assertThat(t) {
-        return t;
+        return !!t;
     }
     afterAll(store, artifactory, pm) {
         return store;
     }
     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);
             }
             catch (e) {
-                console.error(e);
-                this.fails.push(giver);
+                this.failed = true;
+                this.fails = this.fails + 1;
+                // console.error(e);
+                // this.fails.push(giver);
                 // 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 +85,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 +101,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;
@@ -119,10 +109,7 @@ export class BaseGiven {
         this.givenCB = givenCB;
         this.initialValues = initialValues;
     }
-    beforeAll(store, 
-    // artifactory: ITestArtifactory
-    // subject,
-    initializer, artifactory, testResource, initialValues, pm) {
+    beforeAll(store) {
         return store;
     }
     toObj() {
@@ -132,7 +119,7 @@ export class BaseGiven {
             whens: this.whens.map((w) => w.toObj()),
             thens: this.thens.map((t) => t.toObj()),
             error: this.error ? [this.error, this.error.stack] : null,
-            // fail: this.fail ? [this.fail] : false,
+            failed: this.failed,
             features: this.features,
         };
     }
@@ -144,29 +131,35 @@ export class BaseGiven {
         tLog(`\n ${this.key}`);
         tLog(`\n Given: ${this.name}`);
         const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        const beforeEachProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "writeFileSync") {
+                    return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
+                }
+                if (prop === "customScreenShot") {
+                    return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
+                }
+                if (prop === "screencast") {
+                    return (opts, p) => target.screencast(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
+                }
+                /* @ts-ignore:next-line */
+                return Reflect.get(...arguments);
+            },
+        });
+        this.uberCatcher((e) => {
+            console.error(e);
+            this.error = e.error;
+            tLog(e.stack);
+        });
         try {
-            // tLog(`\n Given this.store`, this.store);
-            const beforeEachProxy = new Proxy(pm, {
-                get(target, prop, receiver) {
-                    if (prop === "writeFileSync") {
-                        return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
-                    }
-                    if (prop === "customScreenShot") {
-                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
-                    }
-                    if (prop === "screencast") {
-                        return (opts, p) => target.screencast(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
-                    }
-                    /* @ts-ignore:next-line */
-                    return Reflect.get(...arguments);
-                },
-            });
-            this.uberCatcher((e) => {
-                console.error(e);
-                this.error = e.error;
-                tLog(e.stack);
-            });
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, beforeEachProxy);
+        }
+        catch (e) {
+            this.error = e;
+            throw e;
+        }
+        try {
+            // tLog(`\n Given this.store`, this.store);
             for (const [whenNdx, whenStep] of this.whens.entries()) {
                 await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
@@ -176,11 +169,10 @@ export class BaseGiven {
             }
         }
         catch (e) {
-            console.error(e);
-            this.error = e;
+            // this.error = e;
+            this.failed = true;
             tLog(e.stack);
-            // tLog("\u0007"); // bell
-            // throw e;
+            throw e;
         }
         finally {
             try {
@@ -201,7 +193,10 @@ export class BaseGiven {
                 afterEachProxy);
             }
             catch (e) {
-                console.error("afterEach failed! no error will be recorded!", e);
+                this.failed = e;
+                throw e;
+                // console.error("afterEach failed!", e);
+                // this.error = e.message;
             }
         }
         return this.store;
@@ -220,7 +215,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 +257,17 @@ 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 1", e);
+                this.error = e;
+                throw e;
+            }
+        };
         try {
             const butThenProxy = new Proxy(pm, {
                 get(target, prop, receiver) {
@@ -277,45 +281,45 @@ export class BaseThen {
                     return Reflect.get(...arguments);
                 },
             });
-            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
-                this.error = true;
+            return this.butThen(store, this.go, testResourceConfiguration, butThenProxy).catch((e) => {
+                this.error = e;
                 throw e;
             });
         }
         catch (e) {
-            console.log("test failed", e);
-            this.error = e.message;
+            console.log("test failed 2", e);
+            this.error = e;
             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(),
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory, pm) {
+        return store;
+    }
+    beforeAll(store) {
+        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 → src/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;
@@ -26,23 +25,22 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
+                    const start = await puppetMaster.start();
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
-                    const tLog = (...l) => {
-                        puppetMaster.write(access, `${l.toString()}\n`);
+                    const tLog = async (...l) => {
+                        const x = await puppetMaster.write(access, `${l.toString()}\n`);
+                        // console.log("x", x);
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
-                    const logPromise = new Promise((res, rej) => {
-                        puppetMaster.end(access);
+                    const logPromise = new Promise(async (res, rej) => {
+                        await puppetMaster.end(access);
                         res(true);
                     });
-                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
-                        return suiteDone.givens[k].error;
-                    }).length;
-                    puppetMaster.writeFileSync(`bdd_errors.txt`, numberOfFailures.toString());
-                    const o = this.toObj();
-                    puppetMaster.writeFileSync(`littleBoard.html`, `
-            <!DOCTYPE html>
+                    const fails = suiteDone.fails;
+                    const b = await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
+                    await puppetMaster.writeFileSync(`littleBoard.html`, `
+<!DOCTYPE html>
 <html lang="en">
 
 <head>
@@ -52,19 +50,19 @@ 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>
+  <div id="root"/>
+</body>
             `);
-                    puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
+                    await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
                     return {
-                        failed: numberOfFailures,
+                        failed: fails > 0,
+                        fails,
                         artifacts: this.artifacts || [],
                         logPromise,
                         features: suiteDone.features(),
@@ -73,6 +71,12 @@ export class BaseBuilder {
             };
         });
     }
+    // testsJson() {
+    //   puppetMaster.writeFileSync(
+    //     `tests.json`,
+    //     JSON.stringify({ features: suiteDone.features() }, null, 2)
+    //   );
+    // }
     Specs() {
         return this.specs;
     }

package/dist/module/{lib → src/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 → src/lib}/core.js

@@ -6,16 +6,10 @@ export default class Testeranto extends ClassBuilder {
         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);
+                return fullTestInterface.afterAll(store, pm);
             }
             assertThat(t) {
-                fullTestInterface.assertThis(t);
+                return fullTestInterface.assertThis(t);
             }
             async setup(s, artifactory, tr, pm) {
                 return (fullTestInterface.beforeAll ||
@@ -29,15 +23,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) {
@@ -47,20 +36,6 @@ export default class Testeranto extends ClassBuilder {
                 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) {
@@ -72,42 +47,17 @@ export default class Testeranto extends ClassBuilder {
                     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;
+            constructor(name, features, checkCallback, x, i, c) {
+                super(name, features, checkCallback, x, c);
+                this.initialValues = i;
             }
-            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 → src/lib}/index.js

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