testeranto 0.47.11 → 0.47.13

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/Node.js

@@ -0,0 +1,82 @@
+"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");
+const receiveTestResourceConfig = async (t, testresource) => {
+    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
+    /* @ts-ignore:next-line */
+    process.send({
+        type: "testeranto:adios",
+        data: {
+            failed,
+            testResourceConfiguration: t.test.testResourceConfiguration,
+            results: t.toObj(),
+        },
+    }, async (err) => {
+        if (!err) {
+            Promise.all([...artifacts, logPromise]).then(async () => {
+                process.exit(await failed ? 1 : 0);
+            });
+        }
+        else {
+            console.error(err);
+            process.exit(1);
+        }
+    });
+};
+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 tl2 = mrt;
+    const t = tl2.testJobs[0];
+    const testResourceArg = process.argv[2] || `{}`;
+    try {
+        const partialTestResource = JSON.parse(testResourceArg);
+        if (testResourceRequirement.ports == 0) {
+            receiveTestResourceConfig(t, partialTestResource);
+        }
+        else {
+            console.log("test configuration is incomplete", partialTestResource);
+            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);
+                receiveTestResourceConfig(t, secondTestResource);
+            });
+        }
+    }
+    catch (e) {
+        console.error(e);
+        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 = {
+//       ...JSON.parse(JSON.stringify(resourcesFromStdin)),
+//       ...JSON.parse(JSON.stringify(partialTestResource)),
+//     } as ITTestResourceConfiguration;
+//     await t.receiveTestResourceConfig(secondTestResource);
+//   });
+// }

package/dist/common/NodeWriter.js

@@ -0,0 +1,56 @@
+"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, callback) => (fPath, value) => {
+        callback(new Promise((res, rej) => {
+            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");
+                    res();
+                }
+                else if (`string` === typeof value) {
+                    fs_1.default.writeFileSync(fPath, value.toString(), {
+                        encoding: "utf-8",
+                    });
+                    res();
+                }
+                else {
+                    /* @ts-ignore:next-line */
+                    const pipeStream = value;
+                    const myFile = fs_1.default.createWriteStream(fPath);
+                    pipeStream.pipe(myFile);
+                    pipeStream.on("close", () => {
+                        myFile.close();
+                        res();
+                    });
+                }
+            });
+        }));
+    }
+};