testeranto 0.38.3 → 0.40.1

package/README.md

@@ -1,7 +1,5 @@
 # testeranto
 
-![demo](testerantoDemo.gif)
-
 home: [adamwong246.github.io/testeranto](https://adamwong246.github.io/testeranto/)
 
 source: [github.com/adamwong246/testeranto](https://github.com/adamwong246/testeranto)
@@ -22,11 +20,9 @@ If so, then testeranto might be the testing tool you have been looking for!
 
 ## about
 
-Testeranto.ts an Acceptance Test Driven Development ([ATDD](https://en.wikipedia.org/wiki/Acceptance_test-driven_development)) framework. It focuses on testing features which cross application boundaries using strongly typed tests and specified in a gherkin-like syntax. Testeranto includes a framework to help write your tests, a test runner to schedule the tests and a reporter to display the results.
-
-## 3 distinguishing features of testeranto
+Testeranto.ts an Acceptance Test Driven Development ([ATDD](https://en.wikipedia.org/wiki/Acceptance_test-driven_development)) framework. It focuses on strongly-typed tests, specified in a gherkin-like syntax. Testeranto includes a framework to help write your tests, a test runner to schedule the tests and a reporter to display the results.
 
-0. Testeranto can execute many types of tests. It abstracts away the differences between a "small" unit test and a "big" integration test. Features can thus be tracked across many test suites.
+## 2 distinguishing features of testeranto
 
 1. Rather than testing your code directly, Testeranto requires you wrap your code with a semantic interface which is based on TS type signatures. These interfaces can be shared and your code is now tested through the gherkin-ish directives provided by that interface.
 
@@ -44,10 +40,6 @@ Testeranto includes a test runner which bundles and executes your tests, taking
 
 Testeranto includes a test reporter which displays the state of your code in a web app. ([see example](https://chromapdx.github.io/kokomoBay/report.html)) This reporter can also be run locally for the developer's convenience.
 
-Testeranto can very feasibly be used to test any code- a ruby HTTP server, for example. While testeranto itself and it's test implementations are typescript, the subject of the test can be any stateful software.
-
-Testeranto allows you to test the same code in multiple ways. You can test your unbundled TS in a unit-test fashion, and also bundle that same code, then testing it through a interface like puppeteer, fetch, curl, etc.
-
 Testeranto exposes an extended gherkin syntax. You can use the given-when-then lingua-franca, AND you can also use an imperative `Check` which is a bit more flexible.
 
 Rather than the traditional method of specifying tests in plain text, Testeranto tests and features are just TS, editable and type-checkable from [github's online editor](https://github.dev/ChromaPDX/kokomoBay)!

package/dist/common/Features.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectedGraph = exports.TesterantoFeatures = exports.TesterantoGraphDirectedAcyclic = exports.TesterantoGraphDirected = exports.TesterantoGraphUndirected = exports.BaseFeature = void 0;
+const graphology_1 = __importDefault(require("graphology"));
+/* @ts-ignore:next-line */
+const { DirectedGraph, UndirectedGraph } = graphology_1.default;
+exports.DirectedGraph = DirectedGraph;
+class TesterantoGraph {
+    constructor(name) {
+        this.name = name;
+    }
+}
+class BaseFeature {
+    constructor(name) {
+        this.name = name;
+    }
+}
+exports.BaseFeature = BaseFeature;
+class TesterantoGraphUndirected {
+    constructor(name) {
+        this.name = name;
+        this.graph = new UndirectedGraph();
+    }
+    connect(a, b, relation) {
+        this.graph.mergeEdge(a, b, { type: relation });
+    }
+}
+exports.TesterantoGraphUndirected = TesterantoGraphUndirected;
+class TesterantoGraphDirected {
+    constructor(name) {
+        this.name = name;
+        this.graph = new DirectedGraph();
+    }
+    connect(to, from, relation) {
+        this.graph.mergeEdge(to, from, { type: relation });
+    }
+}
+exports.TesterantoGraphDirected = TesterantoGraphDirected;
+class TesterantoGraphDirectedAcyclic {
+    constructor(name) {
+        this.name = name;
+        this.graph = new DirectedGraph();
+    }
+    connect(to, from, relation) {
+        this.graph.mergeEdge(to, from, { type: relation });
+    }
+}
+exports.TesterantoGraphDirectedAcyclic = TesterantoGraphDirectedAcyclic;
+class TesterantoFeatures {
+    constructor(features, graphs) {
+        this.features = features;
+        this.graphs = graphs;
+    }
+    networks() {
+        return [
+            ...this.graphs.undirected.values(),
+            ...this.graphs.directed.values(),
+            ...this.graphs.dags.values(),
+        ];
+    }
+    toObj() {
+        return {
+            features: Object.entries(this.features).map(([name, feature]) => {
+                return Object.assign(Object.assign({}, feature), { inNetworks: this.networks()
+                        .filter((network) => {
+                        return network.graph.hasNode(feature.name);
+                    })
+                        .map((network) => {
+                        return {
+                            network: network.name,
+                            neighbors: network.graph.neighbors(feature.name),
+                        };
+                    }) });
+            }),
+            networks: this.networks().map((network) => {
+                return Object.assign({}, network);
+            }),
+        };
+    }
+}
+exports.TesterantoFeatures = TesterantoFeatures;
+exports.default = {};

package/dist/common/IBaseConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/Node.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_js_1 = require("./core.js");
+const core_js_2 = __importDefault(require("./core.js"));
+const NodeWriter_js_1 = require("./NodeWriter.js");
+exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = core_js_1.defaultTestResourceRequirement) => {
+    const mrt = new core_js_2.default(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;
+        }, NodeWriter_js_1.NodeWriter);
+    const t = mrt[0];
+    const testResourceArg = process.argv[2] || `{}`;
+    try {
+        const partialTestResource = JSON.parse(testResourceArg);
+        if (testResourceRequirement.ports == 0) {
+            const failed = await t.receiveTestResourceConfig(partialTestResource);
+            // process.exit(failed ? 1 : 0);
+        }
+        else {
+            console.log("test configuration is incomplete", partialTestResource);
+            if (process.send) {
+                console.log("requesting test resources via IPC ...", testResourceRequirement);
+                /* @ts-ignore:next-line */
+                process.send({
+                    type: "testeranto:hola",
+                    data: {
+                        requirement: Object.assign(Object.assign({}, testResourceRequirement), { name: partialTestResource.name })
+                    },
+                });
+                console.log("awaiting test resources via IPC...");
+                process.on("message", async function (packet) {
+                    console.log("message: ", packet);
+                    const resourcesFromPm2 = packet.data.testResourceConfiguration;
+                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromPm2)));
+                    console.log("secondTestResource", secondTestResource);
+                    const failed = await t.receiveTestResourceConfig(secondTestResource);
+                    /* @ts-ignore:next-line */
+                    process.send({
+                        type: "testeranto:adios",
+                        data: {
+                            testResourceConfiguration: t.test.testResourceConfiguration,
+                            results: t.toObj(),
+                        },
+                    }, (err) => {
+                        if (!err) {
+                            // process.exit(failed ? 1 : 0);
+                        }
+                        else {
+                            console.error(err);
+                            // process.exit(1);
+                        }
+                    });
+                });
+            }
+            else {
+                console.log("Pass run-time test resources by STDIN", process.stdin);
+                process.stdin.on("data", async (data) => {
+                    console.log("data: ", data);
+                    const resourcesFromStdin = JSON.parse(data.toString());
+                    const secondTestResource = Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromStdin))), JSON.parse(JSON.stringify(partialTestResource)));
+                    await t.receiveTestResourceConfig(secondTestResource);
+                });
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+        process.exit(-1);
+    }
+};

package/dist/common/NodeWriter.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeWriter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fPaths = [];
+exports.NodeWriter = {
+    createWriteStream: (filepath) => {
+        return fs_1.default.createWriteStream(filepath);
+    },
+    writeFileSync: (fp, contents) => {
+        fs_1.default.writeFileSync(fp, contents);
+    },
+    mkdirSync: async (fp) => {
+        await fs_1.default.mkdirSync(fp, { recursive: true });
+    },
+    testArtiFactoryfileWriter: (tLog) => (fPath, value) => {
+        tLog("testArtiFactory =>", fPath);
+        const cleanPath = path_1.default.resolve(fPath);
+        fPaths.push(cleanPath.replace(process.cwd(), ``));
+        const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+        fs_1.default.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+                console.error(`❗️testArtiFactory failed`, targetDir, error);
+            }
+            fs_1.default.writeFileSync(path_1.default.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                encoding: "utf-8",
+            });
+            if (Buffer.isBuffer(value)) {
+                fs_1.default.writeFileSync(fPath, value, "binary");
+            }
+            else if (`string` === typeof value) {
+                fs_1.default.writeFileSync(fPath, value.toString(), {
+                    encoding: "utf-8",
+                });
+            }
+            else {
+                /* @ts-ignore:next-line */
+                const pipeStream = value;
+                const myFile = fs_1.default.createWriteStream(fPath);
+                pipeStream.pipe(myFile);
+                pipeStream.on("close", () => {
+                    myFile.close();
+                });
+            }
+        });
+    }
+};