testeranto 0.47.10 → 0.47.11

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "testeranto",
   "description": "teeny tiny tightly-typed typescript tests",
-  "version": "0.47.10",
+  "version": "0.47.11",
   "type": "module",
   "types": "./dist/index.d.mts",
   "module": "dist/module/index.js",
   "exports": {
+    "./src/subPackages/": {
+      "import": "./src/subPackages/",
+      "require": "./src/subPackages/"
+    },
     "./src/Types": {
       "import": "./dist/module/Types.js",
       "require": "./dist/common/Types.js"
@@ -102,6 +106,7 @@
     "puppeteer": "18.1.0",
     "react-bootstrap": "^2.7.0",
     "react-sigma": "^1.2.35",
+    "react-test-renderer": "^18.2.0",
     "ws": "^8.16.0"
   }
 }

package/src/subPackages/react/component.ts

@@ -0,0 +1,20 @@
+import React, { CElement } from "react";
+
+export type Input = typeof React.Component;
+export type InitialState = unknown;
+export type WhenShape = any;
+export type ThenShape = any;
+export type Selection = {
+  htmlElement: HTMLElement,
+  reactElement: CElement<any, any>,
+};
+
+export type Store = {
+  htmlElement: HTMLElement,
+  reactElement: CElement<any, any>,
+};
+
+export type Subject = {
+  htmlElement: HTMLElement
+};
+

package/src/subPackages/react/node.ts

@@ -0,0 +1,99 @@
+import React, {
+  CElement,
+} from "react";
+import ReactDom from "react-dom/client";
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../core";
+import Testeranto from "../../Node";
+
+import { InitialState, WhenShape, ThenShape, Subject, Store, Input, Selection } from "./component";
+
+export default <ITestShape extends ITTestShape>(
+  testImplementations: ITestImplementation<
+    InitialState,
+    Selection,
+    WhenShape,
+    ThenShape,
+    ITestShape
+  >,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: Input
+) => {
+  class TesterantoComponent extends testInput {
+    done: (t: TesterantoComponent) => void;
+    constructor(props) {
+      super(props);
+      this.done = props.done;
+    }
+    componentDidMount() {
+      super.componentDidMount && super.componentDidMount();
+      return this.done(this);
+    }
+  }
+
+  return Testeranto<
+    ITestShape,
+    Input,
+    Subject,
+    Store,
+    Selection,
+    ThenShape,
+    WhenShape,
+    InitialState
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (
+        prototype,
+        artificer
+      ): Promise<Subject> => {
+        return await new Promise((resolve, rej) => {
+          document.addEventListener("DOMContentLoaded", function () {
+            const elem = document.getElementById("root");
+            if (elem) {
+              resolve({ htmlElement: elem });
+            }
+          });
+        })
+      },
+      beforeEach: async (
+        { htmlElement },
+        ndx,
+        testRsource,
+        artificer
+      ): Promise<Store> => {
+        return new Promise((resolve, rej) => {
+          const reactElement = React.createElement(TesterantoComponent, {
+            done: (reactElement) => {
+              resolve(
+                {
+                  htmlElement,
+                  reactElement,
+                }
+              );
+            }
+          }, []);
+          ReactDom.createRoot(htmlElement).render(reactElement);
+        });
+      },
+      andWhen: function (s: Store, actioner): Promise<Selection> {
+        return actioner()(s);
+      },
+      butThen: async function (s: Store): Promise<Selection> {
+        return s;
+      },
+      afterEach: async function (
+        store: Store,
+        ndx,
+        artificer
+      ) {
+        return {};
+      },
+      afterAll: (store: Store, artificer) => {
+        return;
+      },
+    },
+  )
+};

package/src/subPackages/react/web.ts

@@ -0,0 +1,99 @@
+import React, {
+  CElement,
+} from "react";
+import ReactDom from "react-dom/client";
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../core";
+import Testeranto from "../../Web";
+
+import { InitialState, WhenShape, ThenShape, Subject, Store, Input, Selection } from "./component";
+
+export default <ITestShape extends ITTestShape>(
+  testImplementations: ITestImplementation<
+    InitialState,
+    Selection,
+    WhenShape,
+    ThenShape,
+    ITestShape
+  >,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: Input
+) => {
+  class TesterantoComponent extends testInput {
+    done: (t: TesterantoComponent) => void;
+    constructor(props) {
+      super(props);
+      this.done = props.done;
+    }
+    componentDidMount() {
+      super.componentDidMount && super.componentDidMount();
+      return this.done(this);
+    }
+  }
+
+  return Testeranto<
+    ITestShape,
+    Input,
+    Subject,
+    Store,
+    Selection,
+    ThenShape,
+    WhenShape,
+    InitialState
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (
+        prototype,
+        artificer
+      ): Promise<Subject> => {
+        return await new Promise((resolve, rej) => {
+          document.addEventListener("DOMContentLoaded", function () {
+            const elem = document.getElementById("root");
+            if (elem) {
+              resolve({ htmlElement: elem });
+            }
+          });
+        })
+      },
+      beforeEach: async (
+        { htmlElement },
+        ndx,
+        testRsource,
+        artificer
+      ): Promise<Store> => {
+        return new Promise((resolve, rej) => {
+          const reactElement = React.createElement(TesterantoComponent, {
+            done: (reactElement) => {
+              resolve(
+                {
+                  htmlElement,
+                  reactElement,
+                }
+              );
+            }
+          }, []);
+          ReactDom.createRoot(htmlElement).render(reactElement);
+        });
+      },
+      andWhen: function (s: Store, actioner): Promise<Selection> {
+        return actioner()(s);
+      },
+      butThen: async function (s: Store): Promise<Selection> {
+        return s;
+      },
+      afterEach: async function (
+        store: Store,
+        ndx,
+        artificer
+      ) {
+        return {};
+      },
+      afterAll: (store: Store, artificer) => {
+        return;
+      },
+    },
+  )
+};

package/src/subPackages/react-test-render/node.ts

@@ -0,0 +1,52 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import Testeranto from "../../Web";
+import { ITestImplementation, ITestSpecification, ITTestShape } from "../../core";
+
+import { WhenShape, ThenShape, Input } from "./component";
+
+export const ReactTestRendererTesteranto = <
+  ITestShape extends ITTestShape,
+  PropShape,
+  StateShape
+>(
+  testImplementations: ITestImplementation<
+    PropShape,
+    renderer.ReactTestRenderer,
+    WhenShape,
+    ThenShape,
+    ITestShape
+  >,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: Input,
+) =>
+  Testeranto<
+    ITestShape,
+    Input,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
+        let component;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+        });
+        return component;
+      },
+      andWhen: async function (renderer: renderer.ReactTestRenderer, actioner: any): Promise<renderer.ReactTestRenderer> {
+        await act(() => actioner()(renderer));
+        return renderer
+      }
+    }
+  )

package/src/subPackages/react-test-render/web.ts

@@ -0,0 +1,52 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import Testeranto from "../../Web";
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../core";
+
+import { WhenShape, ThenShape, Input } from "./component";
+
+export const ReactTestRendererTesteranto = <
+  ITestShape extends ITTestShape,
+  PropShape,
+  StateShape
+>(
+  testImplementations: ITestImplementation<
+    PropShape,
+    renderer.ReactTestRenderer,
+    WhenShape,
+    ThenShape,
+    ITestShape
+  >,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: Input,
+) =>
+  Testeranto<
+    ITestShape,
+    Input,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
+        let component;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+        });
+        return component;
+      },
+      andWhen: async function (renderer: renderer.ReactTestRenderer, actioner: any): Promise<renderer.ReactTestRenderer> {
+        await act(() => actioner()(renderer));
+        return renderer
+      }
+    }
+  )

package/dist/common/Features.js

@@ -1,85 +0,0 @@
-"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

@@ -1,82 +0,0 @@
-"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

@@ -1,56 +0,0 @@
-"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();
-                    });
-                }
-            });
-        }));
-    }
-};