testeranto 0.47.11 → 0.47.13

package/dist/module/Report.js

@@ -0,0 +1,186 @@
+import React, { useEffect, useState } from "react";
+import ReactDom from "react-dom/client";
+import Col from 'react-bootstrap/Col';
+import Nav from 'react-bootstrap/Nav';
+import Row from 'react-bootstrap/Row';
+import Tab from 'react-bootstrap/Tab';
+import Tabs from 'react-bootstrap/Tabs';
+import { Sigma, RandomizeNodePositions, RelativeSize } from 'react-sigma';
+import 'bootstrap/dist/css/bootstrap.min.css';
+import { TesterantoFeatures } from "./Features";
+const graphToIGraphData = (g) => {
+    return {
+        nodes: g.nodes().map((n) => {
+            return {
+                id: n,
+                label: n
+            };
+        }),
+        edges: g.mapEdges((id, attributes, source, target) => {
+            return {
+                id,
+                label: id,
+                source,
+                target,
+            };
+        })
+    };
+};
+document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+        ReactDom.createRoot(elem).render(React.createElement(Report, {}));
+    }
+});
+const Report = () => {
+    const [tests, setTests] = useState([]);
+    const [features, setFeatures] = useState(new TesterantoFeatures({}, {
+        undirected: [],
+        directed: [],
+        dags: []
+    }));
+    useEffect(() => {
+        const importTests = async () => {
+            const module = await import('tests.test.js');
+            setTests(module.default);
+        };
+        importTests();
+    }, []);
+    useEffect(() => {
+        const importFeatures = async () => {
+            const module = await import('features.test.js');
+            setFeatures(module.default);
+        };
+        importFeatures();
+    }, []);
+    return (React.createElement("div", null,
+        React.createElement("style", null, `
+pre, code, p {
+  max-width: 30rem;
+}
+footer {
+  background-color: lightgray;
+  margin: 0.5rem;
+  padding: 0.5rem;
+  position: fixed;
+  bottom: 0;
+  right: 0;
+}
+          `),
+        features && tests && React.createElement(Tabs, { defaultActiveKey: "home" },
+            React.createElement(Tab, { eventKey: "home", title: "config" },
+                React.createElement("pre", null, JSON.stringify(features, null, 2)),
+                React.createElement("pre", null, JSON.stringify(tests, null, 2))),
+            React.createElement(Tab, { eventKey: "features", title: "features" },
+                React.createElement(Tab.Container, { id: "left-tabs-example5", defaultActiveKey: "feature-0" },
+                    React.createElement(Row, null,
+                        React.createElement(Col, { sm: 2 },
+                            React.createElement(Nav, { variant: "pills", className: "flex-column" }, Object.keys(features.features).map((featureKey, ndx) => React.createElement(Nav.Item, { key: ndx },
+                                React.createElement(Nav.Link, { eventKey: `feature-${ndx}` }, featureKey))))),
+                        React.createElement(Col, { sm: 6 },
+                            React.createElement(Tab.Content, null, Object.keys(features.features).map((featureKey, ndx) => {
+                                const feature = features[featureKey];
+                                return (React.createElement(Tab.Pane, { eventKey: `feature-${ndx}`, key: ndx },
+                                    React.createElement("pre", null, JSON.stringify(feature, null, 2))));
+                            }))),
+                        React.createElement(Col, { sm: 4 },
+                            React.createElement(Tabs, { defaultActiveKey: "feature.networks" },
+                                React.createElement(Tab, { eventKey: "feature.networks", title: "networks" },
+                                    React.createElement(Tabs, { defaultActiveKey: "dag" },
+                                        React.createElement(Tab, { eventKey: "dag", title: "DAG" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.dags, null, 2)))),
+                                        React.createElement(Tab, { eventKey: "directed", title: "Directed" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.directed, null, 2)))),
+                                        React.createElement(Tab, { eventKey: "undirected", title: "Undirected" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.undirected, null, 2)))))),
+                                React.createElement(Tab, { eventKey: "feature.tests", title: "tests" },
+                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(tests, null, 2)))))))),
+            React.createElement(Tab, { eventKey: "networks", title: "networks" },
+                React.createElement(Tab.Container, { id: "left-tabs-example88", defaultActiveKey: `dag` },
+                    React.createElement(Row, null,
+                        React.createElement(Tabs, { defaultActiveKey: "dag" },
+                            React.createElement(Tab, { eventKey: "dag", title: "DAG" },
+                                React.createElement(Tab.Content, null,
+                                    React.createElement(Row, null,
+                                        React.createElement(Col, { sm: 2 },
+                                            React.createElement(Nav, { variant: "pills", className: "flex-column" }, features.graphs.dags.map((g, ndx2) => React.createElement(Nav.Item, { key: ndx2 },
+                                                React.createElement(Nav.Link, { eventKey: `networks-dags-${ndx2}` }, g.name))))),
+                                        React.createElement(Col, { sm: 6 },
+                                            React.createElement(Tab.Content, null, features.graphs.dags[0] && React.createElement(React.Fragment, null,
+                                                React.createElement(Sigma, { graph: graphToIGraphData(features.graphs.dags[0].graph), settings: { drawEdges: true, clone: false } },
+                                                    React.createElement(RelativeSize, { initialSize: 25 }),
+                                                    React.createElement(RandomizeNodePositions, null)),
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.dags[0].graph, null, 2))))),
+                                        React.createElement(Col, { sm: 4 },
+                                            React.createElement(Tabs, { defaultActiveKey: "networks.features" },
+                                                React.createElement(Tab, { eventKey: "networks.features", title: "features" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(features, null, 2))),
+                                                React.createElement(Tab, { eventKey: "feature.tests", title: "tests" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(tests, null, 2)))))))),
+                            React.createElement(Tab, { eventKey: "directed", title: "Directed" },
+                                React.createElement(Tab.Content, null,
+                                    React.createElement(Row, null,
+                                        React.createElement(Col, { sm: 2 },
+                                            React.createElement(Nav, { variant: "pills", className: "flex-column" }, features.graphs.directed.map((g, ndx2) => React.createElement(Nav.Item, { key: ndx2 },
+                                                React.createElement(Nav.Link, { eventKey: `networks-directed-${ndx2}` }, g.name))))),
+                                        React.createElement(Col, { sm: 6 },
+                                            React.createElement(Tab.Content, null, features.graphs.directed[0] && React.createElement(React.Fragment, null,
+                                                React.createElement(Sigma, { graph: graphToIGraphData(features.graphs.directed[0].graph), settings: { drawEdges: true, clone: false } },
+                                                    React.createElement(RelativeSize, { initialSize: 25 }),
+                                                    React.createElement(RandomizeNodePositions, null)),
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.directed[0].graph, null, 2))))),
+                                        React.createElement(Col, { sm: 4 },
+                                            React.createElement(Tabs, { defaultActiveKey: "networks.features" },
+                                                React.createElement(Tab, { eventKey: "networks.features", title: "features" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(features, null, 2))),
+                                                React.createElement(Tab, { eventKey: "feature.tests", title: "tests" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(tests, null, 2)))))))),
+                            React.createElement(Tab, { eventKey: "undirected", title: "Undirected" },
+                                React.createElement(Tab.Content, null,
+                                    React.createElement(Row, null,
+                                        React.createElement(Col, { sm: 2 },
+                                            React.createElement(Nav, { variant: "pills", className: "flex-column" }, features.graphs.undirected.map((g, ndx2) => React.createElement(Nav.Item, { key: ndx2 },
+                                                React.createElement(Nav.Link, { eventKey: `networks-undirected-${ndx2}` }, g.name))))),
+                                        React.createElement(Col, { sm: 6 },
+                                            React.createElement(Tab.Content, null, features.graphs.undirected[0] && React.createElement(React.Fragment, null,
+                                                React.createElement(Sigma, { graph: graphToIGraphData(features.graphs.undirected[0].graph), settings: { drawEdges: true, clone: false } },
+                                                    React.createElement(RelativeSize, { initialSize: 25 }),
+                                                    React.createElement(RandomizeNodePositions, null)),
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.undirected[0].graph, null, 2))))),
+                                        React.createElement(Col, { sm: 4 },
+                                            React.createElement(Tabs, { defaultActiveKey: "networks.features" },
+                                                React.createElement(Tab, { eventKey: "networks.features", title: "features" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(features, null, 2))),
+                                                React.createElement(Tab, { eventKey: "feature.tests", title: "tests" },
+                                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(tests, null, 2)))))))))))),
+            React.createElement(Tab, { eventKey: "results", title: "tests" },
+                React.createElement(Tab.Container, { id: "left-tabs-example5", defaultActiveKey: "feature-0" },
+                    React.createElement(Row, null,
+                        React.createElement(Col, { sm: 2 }),
+                        React.createElement(Col, { sm: 6 },
+                            React.createElement(Tab.Content, null, tests.map((t, ndx) => {
+                                return (React.createElement(Tab.Pane, { eventKey: `feature-${ndx}`, key: ndx },
+                                    React.createElement("pre", null, JSON.stringify(t, null, 2))));
+                            }))),
+                        React.createElement(Col, { sm: 4 },
+                            React.createElement(Tabs, { defaultActiveKey: "feature.networks" },
+                                React.createElement(Tab, { eventKey: "feature.networks", title: "networks" },
+                                    React.createElement(Tabs, { defaultActiveKey: "dag" },
+                                        React.createElement(Tab, { eventKey: "dag", title: "DAG" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.dags, null, 2)))),
+                                        React.createElement(Tab, { eventKey: "directed", title: "Directed" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.directed, null, 2)))),
+                                        React.createElement(Tab, { eventKey: "undirected", title: "Undirected" },
+                                            React.createElement(Tab.Content, null,
+                                                React.createElement("pre", null, JSON.stringify(features.graphs.undirected, null, 2)))))),
+                                React.createElement(Tab, { eventKey: "tests.features", title: "features" },
+                                    React.createElement("pre", { id: "theProps" }, JSON.stringify(features, null, 2))))))))),
+        React.createElement("footer", null,
+            "made with \u2764\uFE0F and ",
+            React.createElement("a", { href: "https://adamwong246.github.io/testeranto/" }, "testeranto "))));
+};

package/dist/module/Types.js

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

package/dist/module/Web.js

@@ -0,0 +1,65 @@
+import { defaultTestResourceRequirement, } from "./core";
+import TesterantoLevelTwo from "./core";
+// import { ipcRenderer } from "electron";
+const webSocket = new WebSocket("ws://localhost:8080");
+const receiveTestResourceConfig = async (t, testresource) => {
+    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
+    webSocket.send(JSON.stringify({
+        type: "testeranto:adios",
+        data: {
+            failed,
+            testResourceConfiguration: t.test.testResourceConfiguration,
+            results: t.toObj(),
+        },
+    }));
+    Promise.all([...artifacts, logPromise]).then(async () => {
+        // ipcRenderer.invoke('quit-app', failed);
+        window.exit(failed);
+    });
+};
+export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
+    const mrt = new TesterantoLevelTwo(input, testSpecification, testImplementation, testInterface, testResourceRequirement, testInterface.assertioner || (async (t) => t), testInterface.beforeEach ||
+        async function (subject, initialValues, testResource) {
+            return subject;
+        }, testInterface.afterEach || (async (s) => s), testInterface.afterAll || ((store) => undefined), testInterface.butThen || (async (a) => a), testInterface.andWhen, testInterface.actionHandler ||
+        function (b) {
+            return b;
+        }, window.NodeWriter);
+    const tl2 = mrt;
+    const t = tl2.testJobs[0];
+    const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
+    try {
+        const partialTestResource = JSON.parse(testResourceArg);
+        if (partialTestResource.fs && partialTestResource.ports) {
+            receiveTestResourceConfig(t, partialTestResource);
+        }
+        else {
+            console.log("test configuration is incomplete", partialTestResource);
+            console.log("requesting test resources via ws", testResourceRequirement);
+            webSocket.addEventListener("open", (event) => {
+                webSocket.addEventListener("message", (event) => {
+                    console.log("Message from server ", event.data);
+                });
+                const r = JSON.stringify({
+                    type: "testeranto:hola",
+                    data: {
+                        testResourceRequirement,
+                    },
+                });
+                webSocket.send(r);
+                console.log("awaiting test resources via websocket...", r);
+                webSocket.onmessage = (async (msg) => {
+                    console.log("message: ", msg);
+                    const resourcesFromPm2 = msg.data.testResourceConfiguration;
+                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromPm2)));
+                    console.log("secondTestResource", secondTestResource);
+                    receiveTestResourceConfig(t, secondTestResource);
+                });
+            });
+        }
+    }
+    catch (e) {
+        console.error(e);
+        // process.exit(-1);
+    }
+};

package/dist/module/core.js

@@ -0,0 +1,383 @@
+const defaultTestResource = { name: "", fs: ".", ports: [] };
+export const defaultTestResourceRequirement = {
+    ports: 0
+};
+export class BaseSuite {
+    constructor(name, index, givens = {}, checks = []) {
+        this.name = name;
+        this.index = index;
+        this.givens = givens;
+        this.checks = checks;
+        this.fails = [];
+    }
+    toObj() {
+        return {
+            name: this.name,
+            givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+            fails: this.fails,
+        };
+    }
+    setup(s, artifactory) {
+        return new Promise((res) => res(s));
+    }
+    test(t) {
+        return t;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
+        const subject = await this.setup(input, suiteArtifactory);
+        tLog("\nSuite:", this.index, this.name);
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            try {
+                this.store = await giver.give(subject, k, testResourceConfiguration, this.test, suiteArtifactory, tLog);
+            }
+            catch (e) {
+                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.test, suiteArtifactory, tLog);
+        }
+        // @TODO fix me
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            giver.afterAll(this.store, artifactory);
+        }
+        ////////////////
+        return this;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+export class BaseGiven {
+    constructor(name, features, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    beforeAll(store, artifactory) {
+        return store;
+    }
+    afterAll(store, artifactory) {
+        return store;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            whens: this.whens.map((w) => w.toObj()),
+            thens: this.thens.map((t) => t.toObj()),
+            error: this.error ? [this.error, this.error.stack] : null,
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog) {
+        tLog(`\n Given: ${this.name}`);
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        try {
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory);
+            // tLog(`\n Given this.store`, this.store);
+            for (const whenStep of this.whens) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog);
+            }
+            for (const thenStep of this.thens) {
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog);
+                tester(t);
+            }
+        }
+        catch (e) {
+            this.error = e;
+            tLog(e);
+            tLog("\u0007"); // bell
+            // throw e;
+        }
+        finally {
+            try {
+                await this.afterEach(this.store, key, givenArtifactory);
+            }
+            catch (e) {
+                console.error("afterEach failed! no error will be recorded!", e);
+            }
+        }
+        return this.store;
+    }
+}
+export class BaseWhen {
+    constructor(name, actioner) {
+        this.name = name;
+        this.actioner = actioner;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog) {
+        tLog(" When:", this.name);
+        try {
+            return await this.andWhen(store, this.actioner, testResourceConfiguration);
+        }
+        catch (e) {
+            this.error = true;
+            throw e;
+        }
+    }
+}
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.name = name;
+        this.thenCB = thenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog) {
+        tLog(" Then:", this.name);
+        try {
+            return this.thenCB(await this.butThen(store, testResourceConfiguration));
+        }
+        catch (e) {
+            console.log("test failed", e);
+            this.error = true;
+            throw e;
+        }
+        // try {
+        //   return await (this.thenCB(
+        //     await (async () => {
+        //       try {
+        //         return await (
+        //           (() => {
+        //             try {
+        //               return this.butThen(store, testResourceConfiguration)
+        //             } catch (e) {
+        //               this.error = true;
+        //               throw e
+        //             }
+        //           })()
+        //         );
+        //       } catch (e) {
+        //         this.error = true;
+        //         throw e
+        //       }
+        //     })()
+        //   ));
+        // } catch (e) {
+        //   this.error = true;
+        //   throw e
+        // }
+    }
+}
+export class BaseCheck {
+    constructor(name, features, checkCB, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.checkCB = checkCB;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    async afterEach(store, key, cb) {
+        return;
+    }
+    async check(subject, key, 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]) => {
+            a[key] = async (payload) => {
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog);
+            };
+            return a;
+        }, {}), 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, key);
+        return;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+class TesterantoLevelZero {
+    constructor(cc, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides) {
+        this.cc = cc;
+        this.constructorator = cc;
+        this.suitesOverrides = suitesOverrides;
+        this.givenOverides = givenOverides;
+        this.whenOverides = whenOverides;
+        this.thenOverides = thenOverides;
+        this.checkOverides = checkOverides;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    Check() {
+        return this.checkOverides;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+class TesterantoLevelOne {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement, logWriter) {
+        this.artifacts = [];
+        const classySuites = Object.entries(testImplementation.Suites).reduce((a, [key], index) => {
+            a[key] = (somestring, givens, checks) => {
+                return new suiteKlasser.prototype.constructor(somestring, index, givens, checks);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.keys(testImplementation.Givens)
+            .reduce((a, key) => {
+            a[key] = (features, whens, thens, ...xtrasW) => {
+                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.Givens[key](...xtrasW));
+            };
+            return a;
+        }, {});
+        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]) => {
+            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]) => {
+            a[key] = (somestring, features, callback) => {
+                return new checkKlasser.prototype.constructor(somestring, features, callback, classyWhens, classyThens);
+            };
+            return a;
+        }, {});
+        const classyTesteranto = new (class extends TesterantoLevelZero {
+        })(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks);
+        const suites = testSpecification(
+        /* @ts-ignore:next-line */
+        classyTesteranto.Suites(), classyTesteranto.Given(), classyTesteranto.When(), classyTesteranto.Then(), classyTesteranto.Check(), logWriter);
+        const suiteRunner = (suite) => async (testResourceConfiguration, tLog) => {
+            return await suite.run(input, testResourceConfiguration, (fPath, value) => logWriter.testArtiFactoryfileWriter(tLog, (p) => {
+                artifacts.push(p);
+            })(testResourceConfiguration.fs + "/" + fPath, value), tLog);
+        };
+        const artifacts = this.artifacts;
+        this.testJobs = suites.map((suite) => {
+            const runner = suiteRunner(suite);
+            return {
+                test: suite,
+                testResourceRequirement,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (testResourceConfiguration = defaultTestResource) {
+                    console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
+                    await logWriter.mkdirSync(testResourceConfiguration.fs);
+                    const logFilePath = (`${testResourceConfiguration.fs}/log.txt`);
+                    const access = await logWriter.createWriteStream(logFilePath);
+                    const tLog = (...l) => {
+                        console.log(...l);
+                        access.write(`${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(testResourceConfiguration, tLog);
+                    const resultsFilePath = (`${testResourceConfiguration.fs}/results.json`);
+                    logWriter.writeFileSync(resultsFilePath, JSON.stringify(suiteDone.toObj(), null, 2));
+                    const logPromise = new Promise((res, rej) => {
+                        access.on("finish", () => { res(true); });
+                    });
+                    access.end();
+                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+                        // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
+                        return suiteDone.givens[k].error;
+                    }).length;
+                    console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+                    return {
+                        failed: numberOfFailures,
+                        artifacts,
+                        logPromise
+                    };
+                },
+            };
+        });
+    }
+}
+////////////////////////////////////////////////////////////////////////////////////////////////
+export default class TesterantoLevelTwo extends TesterantoLevelOne {
+    constructor(input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement, assertioner, beforeEach, afterEach, afterAll, butThen, andWhen, actionHandler, logWriter) {
+        super(testImplementation, testSpecification, input, class extends BaseSuite {
+            async setup(s, artifactory) {
+                return (testInterface.beforeAll || (async (input, artificer) => input))(s, artifactory, this.testResourceConfiguration);
+            }
+            test(t) {
+                return assertioner(t);
+            }
+        }, class Given extends BaseGiven {
+            constructor(name, features, whens, thens, initialValues) {
+                super(name, features, whens, thens);
+                this.initialValues = initialValues;
+            }
+            async givenThat(subject, testResource, artifactory) {
+                return beforeEach(subject, this.initialValues, testResource, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`beforeEach/${fPath}`, value));
+            }
+            afterEach(store, key, artifactory) {
+                return new Promise((res) => res(afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value))));
+            }
+            afterAll(store, artifactory) {
+                return afterAll(store, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`afterAll4-${this.name}/${fPath}`, value));
+            }
+        }, class When extends BaseWhen {
+            constructor(name, actioner, payload) {
+                super(name, (store) => {
+                    return actionHandler(actioner);
+                });
+                this.payload = payload;
+            }
+            async andWhen(store, actioner, testResource) {
+                return await andWhen(store, actioner, testResource);
+            }
+        }, class Then extends BaseThen {
+            constructor(name, callback) {
+                super(name, callback);
+            }
+            async butThen(store, testResourceConfiguration) {
+                return await butThen(store, this.thenCB, testResourceConfiguration);
+            }
+        }, 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) {
+                return beforeEach(subject, this.initialValues, testResourceConfiguration, (fPath, value) => artifactory(`before/${fPath}`, value));
+            }
+            afterEach(store, key, artifactory) {
+                return new Promise((res) => res(afterEach(store, key, (fPath, value) => 
+                // TODO does not work?
+                artifactory(`afterEach2-${this.name}/${fPath}`, value))));
+            }
+        }, testResourceRequirement, logWriter);
+    }
+}