testeranto 0.47.34 → 0.47.52

package/src/Puppeteer.ts

@@ -0,0 +1,141 @@
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import { jsonc } from "jsonc";
+import { v4 as uuidv4 } from "uuid";
+
+import { IBuiltConfig, IRunTime } from "./lib/types";
+
+import { PM_Main } from "./PM/main.js";
+import { destinationOfRuntime } from "./utils.js";
+
+var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+
+const node2web: Record<string, string[]> = {};
+const web2node: Record<string, string[]> = {};
+const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "q") {
+    process.exit();
+  }
+});
+
+export default async (partialConfig) => {
+  const config = {
+    ...partialConfig,
+    buildDir: process.cwd() + "/" + partialConfig.outdir,
+  };
+
+  fs.writeFileSync(
+    `${config.outdir}/testeranto.json`,
+    JSON.stringify(
+      {
+        ...config,
+        buildDir: process.cwd() + "/" + config.outdir,
+      },
+      null,
+      2
+    )
+  );
+
+  const pm = new PM_Main(config);
+
+  await pm.startPuppeteer(
+    {
+      waitForInitialPage: false,
+      executablePath: "/opt/homebrew/bin/chromium",
+      headless: true,
+      // dumpio: true,
+      args: [
+        "--disable-features=IsolateOrigins,site-per-process",
+        "--disable-site-isolation-trials",
+        "--allow-insecure-localhost",
+        "--allow-file-access-from-files",
+        "--allow-running-insecure-content",
+        // "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        // "--no-zygote",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        // "--disable-features=IsolateOrigins",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+        `--remote-debugging-port=3234`,
+
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--start-maximized",
+      ],
+    },
+    "."
+  );
+
+  config.tests.forEach(([test, runtime, tr, sidecars]) => {
+    if (runtime === "node") {
+      pm.launchNode(test, destinationOfRuntime(test, "node", config));
+    } else if (runtime === "web") {
+      pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
+    } else {
+      console.error("runtime makes no sense", runtime);
+    }
+  });
+
+  console.log("ready and watching for changes...", config.buildDir);
+  fs.watch(
+    config.buildDir,
+    {
+      recursive: true,
+    },
+    (eventType, changedFile) => {
+      if (changedFile) {
+        config.tests.forEach(([test, runtime, tr, sidecars]) => {
+          if (eventType === "change" || eventType === "rename") {
+            if (
+              changedFile ===
+              test
+                .replace("./", "node/")
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")
+            ) {
+              pm.launchNode(test, destinationOfRuntime(test, "node", config));
+            }
+
+            if (
+              changedFile ===
+              test
+                .replace("./", "web/")
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")
+            ) {
+              pm.launchWeb(
+                test,
+                destinationOfRuntime(test, "web", config),
+                sidecars
+              );
+            }
+          }
+        });
+      }
+    }
+  );
+};

package/src/Reporter.ts

@@ -0,0 +1,126 @@
+import readline from "readline";
+import fs from "fs";
+import { jsonc } from "jsonc";
+import puppeteer from "puppeteer-core";
+
+import { IBuiltConfig, IRunTime } from "./lib/types";
+
+// import { PM_Main } from "./PM/main.js";
+
+// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+
+// const node2web: Record<string, string[]> = {};
+// const web2node: Record<string, string[]> = {};
+// const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "q") {
+    process.exit();
+  }
+});
+
+const main = async () => {
+  const configs = jsonc.parse(
+    (await fs.readFileSync("./docs/testeranto.json")).toString()
+  ) as IBuiltConfig;
+
+  // const pm = new PM_Main(configs);
+
+  // await puppeteer.launch(options);
+  const browser = await puppeteer.launch(
+    {
+      waitForInitialPage: false,
+      executablePath: "/opt/homebrew/bin/chromium",
+      headless: false,
+      args: [
+        "--allow-file-access-from-files",
+        "--allow-running-insecure-content",
+        // "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        "--no-zygote",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        // "--remote-allow-origins=ws://localhost:3234",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        // "--disable-features=IsolateOrigins",
+        // "--single-process",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+        // `--remote-debugging-port=3234`,
+      ],
+    }
+    // "."
+  );
+
+  console.log("Creating new page...");
+  const page = await browser.newPage();
+
+  await page.setViewport({ width: 0, height: 0 });
+
+  console.log("Requesting url...");
+  await page.goto(`file://${process.cwd()}/docs/report.html?local=true`);
+
+  // configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+  //   if (runtime === "node") {
+  //     pm.launchNode(test, destinationOfRuntime(test, "node"));
+  //   } else if (runtime === "web") {
+  //     pm.launchWeb(test, destinationOfRuntime(test, "web"));
+  //   } else {
+  //     console.error("runtime makes no sense", runtime);
+  //   }
+  // });
+
+  // console.log("ready and watching for changes...", configs.buildDir);
+  // fs.watch(
+  //   configs.buildDir,
+  //   {
+  //     recursive: true,
+  //   },
+  //   (eventType, changedFile) => {
+  //     if (changedFile) {
+  //       configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+  //         if (eventType === "change" || eventType === "rename") {
+  //           if (
+  //             changedFile ===
+  //             test
+  //               .replace("./", "node/")
+  //               .split(".")
+  //               .slice(0, -1)
+  //               .concat("mjs")
+  //               .join(".")
+  //           ) {
+  //             pm.launchNode(test, destinationOfRuntime(test, "node"));
+  //           }
+
+  //           if (
+  //             changedFile ===
+  //             test
+  //               .replace("./", "web/")
+  //               .split(".")
+  //               .slice(0, -1)
+  //               .concat("mjs")
+  //               .join(".")
+  //           ) {
+  //             pm.launchWeb(test, destinationOfRuntime(test, "web"));
+  //           }
+  //         }
+  //       });
+  //     }
+  //   }
+  // );
+};
+
+main();

package/src/SubPackages/puppeteer.ts

@@ -0,0 +1,51 @@
+import React from "react";
+
+import Testeranto from "../Node.js";
+
+import {
+  IBaseTest,
+  IPartialNodeInterface,
+  ITestImplementation,
+  ITestSpecification,
+} from "../Types";
+
+type IInput = string;
+type ISelection = any;
+type IStore = any;
+type ISubject = any;
+
+export type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
+
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testInput: IInput,
+  testSpecifications: ISpec<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape>,
+  testInterface?: IPartialNodeInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll(x) {
+        // process.parentPort.postMessage(
+        //   `/docs/web/src/ClassicalComponent/test.html`
+        // );
+
+        return x;
+      },
+      beforeEach: async (): Promise<IStore> => {
+        return new Promise((resolve, rej) => {
+          resolve(React.createElement(testInput, {}, []));
+        });
+      },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB()(s);
+      },
+
+      ...testInterface,
+    }
+  );
+};

package/src/SubPackages/react/component/node.ts

@@ -0,0 +1,43 @@
+import React from "react";
+
+import Testeranto from "../../../Node.js";
+
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+
+type IInput = typeof React.Component;
+type ISelection = React.CElement<any, any>;
+type IStore = React.CElement<any, any>;
+type ISubject = React.CElement<any, any>;
+
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
+>;
+
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest, IState>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeEach: async (): Promise<IStore> => {
+        return new Promise((resolve, rej) => {
+          resolve(React.createElement(testInput, {}, []));
+        });
+      },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB()(s);
+      },
+    }
+  );
+};

package/src/SubPackages/react/component/web.ts

@@ -0,0 +1,43 @@
+import React from "react";
+
+import Testeranto from "../../../Web.js";
+
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+
+type IInput = typeof React.Component;
+type ISelection = React.CElement<any, any>;
+type Store = React.CElement<any, any>;
+// type Subject = React.CElement<any, any>;
+
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
+>;
+
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeEach: async (): Promise<Store> => {
+        return new Promise((resolve, rej) => {
+          resolve(React.createElement(testInput, {}, []));
+        });
+      },
+      andWhen: function (s: Store, whenCB): Promise<ISelection> {
+        return whenCB()(s);
+      },
+    }
+  );
+};

package/src/SubPackages/react/jsx/index.ts

@@ -0,0 +1,42 @@
+import { CElement } from "react";
+
+import {
+  IBaseTest,
+  IPartialInterface,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+import React from "react";
+
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = () => JSX.Element;
+export type ISelection = CElement<any, any>;
+export type IStore = CElement<any, any>;
+export type ISubject = CElement<any, any>;
+
+export type ITestImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
+
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+
+export const testInterface: IPartialInterface<any> = {
+  // beforeAll: async (proto, testResource, artificer, pm): Promise<IStore> => {
+  //   return React.createElement(proto);
+  //   // return new Promise((resolve, rej) => {
+  //   //   resolve(x());
+  //   // });
+  // },
+  beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+    return new Promise((resolve, rej) => {
+      const x = React.createElement(subject);
+      console.log("react-element", x);
+      resolve(x);
+    });
+  },
+  andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+    return whenCB(s);
+  },
+};

package/src/SubPackages/react/jsx/node.ts

@@ -0,0 +1,26 @@
+import Testeranto from "../../../Node.js";
+import { IBaseTest, IPartialInterface } from "../../../Types";
+
+import {
+  ITestImpl,
+  ITestSpec,
+  IInput,
+  testInterface as baseInterface,
+} from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface: IPartialInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      ...baseInterface,
+      ...testInterface,
+    }
+  );
+};

package/src/SubPackages/react/jsx/web.ts

@@ -0,0 +1,30 @@
+import {
+  IBaseTest,
+  IPartialInterface,
+  IPartialWebInterface,
+} from "../../../Types";
+import Testeranto from "../../../Web.js";
+
+import {
+  ITestImpl,
+  ITestSpec,
+  IInput,
+  testInterface as baseInterface,
+} from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface: IPartialWebInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      ...baseInterface,
+      ...testInterface,
+    }
+  );
+};

package/src/{subPackages → SubPackages}/react-dom/component/node.ts

@@ -1,9 +1,17 @@
 import React, { ReactNode, createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream'
+import {
+  renderToStaticMarkup,
+  renderToStaticNodeStream,
+} from "react-dom/server";
+import Stream from "stream";
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Node";
+import Testeranto from "../../../Node.js";
+
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
@@ -13,37 +21,14 @@ export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    InitialState
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -71,28 +56,23 @@ export default <ITestShape extends ITTestShape>(
           resolve(createElement(testInput));
         });
       },
-      andWhen: async function (s: IStore, actioner): Promise<ISelection> {
-        // return actioner()(s);
-        return s
+      andWhen: async function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB(s);
+        // return s
       },
       butThen: async function (s: IStore): Promise<ISelection> {
         return s;
       },
-      afterEach: async function (
-        store: IStore,
-        ndx,
-        artificer
-      ) {
+      afterEach: async function (store: IStore, ndx, artificer) {
         return {};
       },
       afterAll: (store: IStore, artificer) => {
         return;
       },
-    },
-  )
+    }
+  );
 };
 
-
 // type IInput = typeof React.Component;
 // type InitialState = unknown;
 // type IWhenShape = any;
@@ -142,7 +122,7 @@ export default <ITestShape extends ITTestShape>(
 //           resolve(ReactDOMServer.renderToStaticMarkup(element));
 //         });
 //       },
-//       andWhen: function (s: IStore, actioner): Promise<ISelection> {
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
 //         throw new Error(`"andWhens" are not permitted`);
 //       }
 //     },