testeranto 0.70.0 → 0.74.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="config" title="config">
+          <pre>{JSON.stringify(state, null, 2)}</pre>
+        </Tab>
 
-        <Tab eventKey="home" title="config">
-          <pre>{JSON.stringify(features, null, 2)}</pre>
-          <pre>{JSON.stringify(tests, null, 2)}</pre>
+        <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}>
+              <Col sm={4}>
                 {/* <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}>
+              <Col sm={4}>
                 <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/index.ts

@@ -2,9 +2,11 @@ import { CElement } from "react";
 
 import {
   IBaseTest,
+  IPartialInterface,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
+import React from "react";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -20,10 +22,18 @@ export type ITestImpl<ITestShape extends IBaseTest> =
 export type ITestSpec<ITestShape extends IBaseTest> =
   ITestSpecification<ITestShape>;
 
-export const testInterface = {
-  beforeEach: async (x, ndx, testRsource, artificer): Promise<IStore> => {
+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) => {
-      resolve(x());
+      const x = React.createElement(subject);
+      console.log("react-element", x);
+      resolve(x);
     });
   },
   andWhen: function (s: IStore, whenCB): Promise<ISelection> {

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,
     }
-  )
+  );
 };