testeranto 0.70.0 → 0.73.0

package/src/Report.tsx

@@ -11,7 +11,7 @@ import { Sigma, RandomizeNodePositions, RelativeSize } from 'react-sigma';
 import 'bootstrap/dist/css/bootstrap.min.css';
 
 import { TesterantoFeatures } from "./Features.js";
-import { ITestTypes } from "./lib/types.js";
+import { IRunTime, ITestTypes } from "./lib/types.js";
 
 type IGraphData = {
   nodes: { id: string, label: string }[],
@@ -45,14 +45,34 @@ document.addEventListener("DOMContentLoaded", function () {
 });
 
 const Report = () => {
+
+  const [state, setState] = useState<{
+    tests: ITestTypes[],
+    buildDir: string,
+    features: TesterantoFeatures
+    results: any
+  }>({
+    tests: [],
+    buildDir: "",
+    features: new TesterantoFeatures({}, {
+      undirected: [],
+      directed: [],
+      dags: []
+    }),
+    results: {}
+  });
+
   const [tests, setTests] = useState<
     {
-      tests: ITestTypes[]
+      tests: ITestTypes[],
+      buildDir: string,
     }
 
   >({
-    tests: []
+    tests: [],
+    buildDir: ""
   });
+
   const [features, setFeatures] = useState<TesterantoFeatures>(
     new TesterantoFeatures({}, {
       undirected: [],
@@ -61,34 +81,102 @@ const Report = () => {
     })
   );
 
-  useEffect(() => {
-    const importFeatures = async () => {
-      const module = await import('features.test.js');
-      console.log("imported features", module.default);
-      setFeatures(module.default);
-    };
-    importFeatures();
-  }, []);
+  const [results, setResults] = useState<Record<string, { exitcode, log, testresults, manifest }>>(
+    {}
+  );
 
+  const importState = async () => {
+    const features = await import('features.test.js');
+    const config = await (await fetch("./testeranto.json")).json();
+    const results = await Promise.all(config.tests.map((test) => {
+      return new Promise(async (res, rej) => {
+        const src: string = test[0];
+        const runtime: IRunTime = test[1];
+        const s: string = [tests.buildDir, runtime as string].concat(src.split(".").slice(0, - 1).join(".")).join("/");
+        const exitcode = await (await fetch(config.buildDir + "/" + s + "/exitcode")).text()
+        const log = await (await fetch(config.buildDir + "/" + s + "/log.txt")).text()
+        const testresults = await (await fetch(config.buildDir + "/" + s + "/tests.json")).json()
+        const manifest = await (await fetch(config.buildDir + "/" + s + "/manifest.json")).json()
+
+        res({ src, exitcode, log, testresults, manifest })
+      })
+    }))
+    // const results = await config.tests.reduce(async (p, test) => {
+    //   const src: string = test[0];
+    //   const runtime: IRunTime = test[1];
+    //   console.log(runtime)
+    //   const s: string = [tests.buildDir, runtime as string].concat(src.split(".").slice(0, - 1).join(".")).join("/");
+    //   // const srr
+    //   console.log("s", s)
+
+    //   const exitcode = await (await fetch(config.buildDir + "/" + s + "/exitcode")).text()
+    //   const log = await (await fetch(config.buildDir + "/" + s + "/log.txt")).text()
+    //   const testresults = await (await fetch(config.buildDir + "/" + s + "/tests.json")).text()
+
+    //   // setResults({ src, exitcode, log, testresults })
+    //   // console.log("a", await a.text())
+    //   p[src] = { exitcode, log, testresults }
+    //   return p
+    // }, {});
+
+    console.log("results", results)
+
+
+    setState({ tests: config.tests as any, results, features: features as any, buildDir: config.buildDir })
+  };
+
+  const importFeatures = async () => {
+    const module = await import('features.test.js');
+    setFeatures(module.default);
+  };
+
+  const importTests = async () => {
+    const x = await fetch("./testeranto.json")
+    const y = await x.json();
+    setTests(y as any);
+  };
+
+  useEffect(() => { importState(); }, []);
+
+  useEffect(() => { importFeatures(); }, []);
+  useEffect(() => { importTests(); }, []);
 
   useEffect(() => {
-    const importTests = async () => {
-      const x = await fetch("./testeranto.json")
-      const y = await x.json();
-      console.log("imported tests", y);
-      setTests(y as any);
+    const collateResults = async () => {
+      console.log("collating", tests, features);
+      const r = tests.tests.reduce(async (p, test) => {
+        const src: string = test[0];
+        const runtime: IRunTime = test[1];
+        console.log(runtime)
+        const s: string = [tests.buildDir, runtime as string].concat(src.split(".").slice(0, - 1).join(".")).join("/");
+        // const srr
+        // console.log(s)
+
+        const exitcode = await (await fetch(s + "/exitcode")).text()
+        const log = await (await fetch(s + "/log.txt")).text()
+        const testresults = await (await fetch(s + "/tests.json")).text()
+
+        // setResults({ src, exitcode, log, testresults })
+        // console.log("a", await a.text())
+        p[src] = { exitcode, log, testresults }
+      }, {});
+
+      setResults(r);
+      // const x = await fetch("./testeranto.json")
+      // const y = await x.json();
+      // setTests(y as any);
       // const module = await import('tests.json', {
       //   with: {
       //     type: 'json'
       //   }
       // });
       // console.log("imported tests", module.default);
-      // setTests(module.default);
+      // setResults("foo");
     };
-
-    importTests();
+    collateResults();
   }, []);
 
+  console.log("state.results", state.results);
 
   return (
     <div>
@@ -96,6 +184,7 @@ const Report = () => {
         {`
 pre, code, p {
   max-width: 30rem;
+  text-wrap: auto;
 }
 footer {
   background-color: lightgray;
@@ -108,11 +197,16 @@ footer {
           `}
       </style>
 
-      {features && tests && < Tabs defaultActiveKey="home" >
+      {features && tests && < Tabs defaultActiveKey="config" >
+
+
 
-        <Tab eventKey="home" title="config">
-          <pre>{JSON.stringify(features, null, 2)}</pre>
-          <pre>{JSON.stringify(tests, null, 2)}</pre>
+        <Tab eventKey="config" title="config">
+          <pre>{JSON.stringify(state, null, 2)}</pre>
+        </Tab>
+
+        <Tab eventKey="results" title="results">
+          <pre>{JSON.stringify(state.results, null, 2)}</pre>
         </Tab>
 
         <Tab eventKey="features" title="features">
@@ -168,7 +262,7 @@ footer {
                   </Tab>
 
                   <Tab eventKey="feature.tests" title="tests">
-                    <pre id="theProps">{JSON.stringify(tests, null, 2)}</pre>
+                    <pre id="theProps">{JSON.stringify(tests.tests, null, 2)}</pre>
                   </Tab>
                 </Tabs>
               </Col>
@@ -221,7 +315,7 @@ footer {
                           </Tab>
 
                           <Tab eventKey="feature.tests" title="tests">
-                            <pre id="theProps">{JSON.stringify(tests, null, 2)}</pre>
+                            <pre id="theProps">{JSON.stringify(tests.tests, null, 2)}</pre>
                           </Tab>
                         </Tabs>
                       </Col>
@@ -270,7 +364,7 @@ footer {
                           </Tab>
 
                           <Tab eventKey="feature.tests" title="tests">
-                            <pre id="theProps">{JSON.stringify(tests, null, 2)}</pre>
+                            <pre id="theProps">{JSON.stringify(tests.tests, null, 2)}</pre>
                           </Tab>
                         </Tabs>
                       </Col>
@@ -317,7 +411,7 @@ footer {
                           </Tab>
 
                           <Tab eventKey="feature.tests" title="tests">
-                            <pre id="theProps">{JSON.stringify(tests, null, 2)}</pre>
+                            <pre id="theProps">{JSON.stringify(tests.tests, null, 2)}</pre>
                           </Tab>
                         </Tabs>
                       </Col>
@@ -332,33 +426,53 @@ footer {
           </Tab.Container>
         </Tab>
 
-        <Tab eventKey="results" title="tests">
+        <Tab eventKey="tests" title="tests">
           <Tab.Container id="left-tabs-example5" defaultActiveKey="feature-0">
             <Row>
               <Col sm={2}>
                 {/* <Tree tests={features.tests} /> */}
-                {/* <Nav variant="pills" className="flex-column">
-                    {
-                      features.tests.map((t, ndx) =>
-                        <Nav.Item key={ndx}>
-                          <Nav.Link eventKey={`test-${ndx}`}>
-                            {t[0]} - {t[1]}
-                          </Nav.Link>
-                        </Nav.Item>
-                      )
-                    }
-                  </Nav> */}
+                <Nav variant="pills" className="flex-column">
+                  {
+                    tests.tests.map((t, ndx) =>
+                      <Nav.Item key={ndx}>
+                        <Nav.Link eventKey={`test-${ndx}`}>
+                          {t[0]} - {t[1]}
+                        </Nav.Link>
+                      </Nav.Item>
+                    )
+                  }
+                </Nav>
               </Col>
               <Col sm={6}>
                 <Tab.Content>
-                  {/* {tests.tests.map((t, ndx) => {
-                    return (
-                      <Tab.Pane eventKey={`feature-${ndx}`} key={ndx}>
-                        <pre>{JSON.stringify(t, null, 2)}</pre>
+
+                  {
+                    tests.tests.map((t, ndx) =>
+                      <Tab.Pane eventKey={`test-${ndx}`}>
+                        {/* <pre>{JSON.stringify(t, null, 2)}</pre> */}
+                        {/* <pre>{JSON.stringify(state.results, null, 2)}</pre> */}
+                        <pre>{JSON.stringify(Object.entries(state.results).filter(([k, v]: [string, { src: string }]) => {
+                          console.log(v.src, tests.tests[ndx][0])
+                          return v.src === tests.tests[ndx][0]
+                        }), null, 2)}</pre>
+
+                        {/* {tests.tests.map((t, ndx) => {
+                          return (
+                            <Tab.Pane eventKey={`feature-${ndx}`} key={ndx}>
+                              <pre>{JSON.stringify(t, null, 2)}</pre>
+                            </Tab.Pane>
+                          )
+                        }
+                        )} */}
+
                       </Tab.Pane>
+
                     )
                   }
-                  )} */}
+
+
+
+
                 </Tab.Content>
               </Col>
 

package/src/Reporter.ts

@@ -0,0 +1,134 @@
+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`);
+
+  // const destinationOfRuntime = (f: string, r: IRunTime) => {
+  //   return path
+  //     .normalize(`${configs.buildDir}/${r}/${f}`)
+  //     .split(".")
+  //     .slice(0, -1)
+  //     .join(".");
+  // };
+
+  // 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

@@ -30,9 +30,9 @@ export default <ITestShape extends IBaseTest>(
     testImplementations,
     {
       beforeAll(x) {
-        process.parentPort.postMessage(
-          `/docs/web/src/ClassicalComponent/test.html`
-        );
+        // process.parentPort.postMessage(
+        //   `/docs/web/src/ClassicalComponent/test.html`
+        // );
 
         return x;
       },

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

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

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

@@ -18,10 +18,13 @@ type ISelection = {
 type IStore = {
   htmlElement: HTMLElement;
   reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
 type ISubject = {
   htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
 export default <ITestShape extends IBaseTest, IWhen, IGiven>(
@@ -29,76 +32,132 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
   testSpecifications: ITestSpecification<ITestShape>,
   testImplementations: ITestImplementation<ITestShape, any>
 ) => {
+  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);
+    }
+  }
+
+  const t = Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+        console.log("mark5", initialProps);
+        return await new Promise((resolve, rej) => {
+          const htmlElement = document.getElementById("root");
+          if (htmlElement) {
+            const domRoot = ReactDom.createRoot(htmlElement);
+            // Ignore these type errors
+            domRoot.render(
+              createElement(
+                TesterantoComponent,
+                {
+                  ...initialProps,
+                  done: (reactElement) => {
+                    resolve({
+                      htmlElement,
+                      reactElement,
+                      domRoot,
+                    });
+                  },
+                },
+                []
+              )
+            );
+
+            // resolve({ htmlElement });
+          }
+        });
+      },
+      // beforeEach: async (
+      //   s,
+      //   initializer,
+      //   testResource,
+      //   artificer,
+      //   initialValues
+      // ): Promise<IStore> => {
+      //   return new Promise((resolve, rej) => {
+      //     console.log("beforeEach" + TesterantoComponent);
+
+      //     // const domRoot = ReactDom.createRoot(htmlElement);
+      //     // // Ignore these type errors
+      //     // domRoot.render(
+      //     //   createElement(
+      //     //     TesterantoComponent,
+      //     //     {
+      //     //       ...initializer,
+      //     //       done: (reactElement) => {
+      //     //         resolve({
+      //     //           htmlElement,
+      //     //           reactElement,
+      //     //           domRoot,
+      //     //         });
+      //     //       },
+      //     //     },
+      //     //     []
+      //     //   )
+      //     // );
+      //   });
+      // },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB(s);
+      },
+      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
+        return thenCB(s);
+      },
+      afterEach: async function (store: IStore, ndx, artificer, utils) {
+        console.log("afterEach", store);
+        utils.writeFileSync("aftereachlog", store.toString());
+
+        const page = (await utils.browser.pages()).filter((x) => {
+          const parsedUrl = new URL(x.url());
+          parsedUrl.search = "";
+          const strippedUrl = parsedUrl.toString();
+
+          return (
+            strippedUrl ===
+            "file:///Users/adam/Code/kokomoBay/docs/web/src/ClassicalComponent/react-dom/client.web.test.html"
+          );
+          // return true;
+        })[0];
+
+        const x = await page.screenshot({
+          path: "afterEachLog.jpg",
+        });
+        console.log("x", x);
+        // debugger;
+        // const div_root = document.getElementById("root");
+        // store.domRoot && store.domRoot.unmount(); //React 18
+        //  store.remove();
+        // store.htmlElement.remove();
+        // store.htmlElement = document.createElement("root");
+        return store;
+      },
+      afterAll: async (store: IStore, artificer, utils) => {
+        // setTimeout(() => {
+        //   console.log("This will run after 1 second");
+        // }, 1000); // 1000 milliseconds = 1 second
+        // store.htmlElement.remove();
+        // store.htmlElement = document.createElement("root");
+        return store;
+      },
+    }
+  );
+
   document.addEventListener("DOMContentLoaded", function () {
     const elem = document.getElementById("root");
     if (elem) {
-      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>(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (initialProps, artificer): Promise<ISubject> => {
-            console.log("mark5", initialProps);
-            return await new Promise((resolve, rej) => {
-              const elem = document.getElementById("root");
-              if (elem) {
-                resolve({ htmlElement: elem });
-              }
-            });
-          },
-          beforeEach: async (
-            { htmlElement },
-            initializer,
-            testResource,
-            artificer,
-            initialValues
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-              // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
-              // Ignore these type errors
-              ReactDom.createRoot(htmlElement).render(
-                createElement(
-                  TesterantoComponent,
-                  {
-                    ...initializer,
-                    done: (reactElement) => {
-                      resolve({
-                        htmlElement,
-                        reactElement,
-                      });
-                    },
-                  },
-                  []
-                )
-              );
-            });
-          },
-          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-            return whenCB(s);
-          },
-          butThen: async function (s: IStore): Promise<ISelection> {
-            return s;
-          },
-          afterEach: async function (store: IStore, ndx, artificer) {
-            return {};
-          },
-          afterAll: (store: IStore, artificer) => {
-            return;
-          },
-        }
-      );
+      return t;
     }
   });
+
+  return t;
 };