testeranto 0.94.0 → 0.110.0

package/src/PM/node.ts

@@ -1,12 +1,12 @@
 import fs from "fs";
 import path from "path";
-import puppeteer from "puppeteer-core";
+import { ScreencastOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
@@ -23,14 +23,27 @@ export class PM_Node extends PM {
     this.testResourceConfiguration = t;
   }
 
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
+  waitForSelector(p: string, s: string): any {
+    return globalThis["waitForSelector"](p, s);
   }
-  screencast(opts: object) {
+
+  closePage(p): string {
+    return globalThis["closePage"](p);
+  }
+
+  goto(cdpPage: CdpPage, url: string): any {
+    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  }
+
+  newPage(): CdpPage {
+    return globalThis["newPage"]();
+  }
+
+  $(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
 
-  isDisabled(selector: string): boolean {
+  isDisabled(selector: string): Promise<boolean> {
     throw new Error("Method not implemented.");
   }
 
@@ -57,8 +70,30 @@ export class PM_Node extends PM {
     return globalThis["click"](selector);
   }
 
-  customScreenShot(opts: object) {
-    return globalThis["customScreenShot"](opts);
+  screencast(opts: ScreencastOptions, page: CdpPage) {
+    return globalThis["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      page.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(p: string) {
+    return globalThis["screencastStop"](p);
+  }
+
+  customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage) {
+    return globalThis["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      cdpPage.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
   }
 
   existsSync(destFolder: string): boolean {

package/src/PM/web.ts

@@ -3,7 +3,8 @@ import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { ScreenshotOptions } from "puppeteer-core";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 
 type PuppetMasterServer = Record<string, Promise<any>>;
 
@@ -16,14 +17,41 @@ export class PM_Web extends PM {
     this.testResourceConfiguration = t;
   }
 
+  waitForSelector(p: string, s: string): any {
+    return window["waitForSelector"](p, s);
+  }
+
+  screencast(opts: ScreencastOptions) {
+    return window["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(recorder: string) {
+    return window["screencastStop"](recorder);
+  }
+
+  closePage(p): string {
+    return window["closePage"](p);
+  }
+
+  goto(p, url: string): any {
+    return window["goto"](p, url);
+  }
+
+  newPage(): CdpPage {
+    return window["newPage"]();
+  }
+
   $(selector: string): boolean {
     return window["$"](selector);
   }
-  screencast(opts: object) {
-    throw new Error("Method not implemented.");
-  }
 
-  isDisabled(selector: string): boolean {
+  isDisabled(selector: string): Promise<boolean> {
     return window["isDisabled"](selector);
   }
 
@@ -64,7 +92,7 @@ export class PM_Web extends PM {
     return window["existsSync"](destFolder);
   }
 
-  mkdirSync() {
+  mkdirSync(x) {
     return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
   }
 

package/src/ReportClient.tsx

@@ -0,0 +1,155 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+
+import 'bootstrap/dist/css/bootstrap.min.css';
+import "./style.css"
+
+import { IRunTime, ITestTypes, IBuiltConfig } from "./lib";
+import { Footer } from "./Footer";
+
+
+type ICollation = {
+  name: string;
+  runTime: IRunTime;
+  tr: {
+    ports: number;
+  };
+  sidecars: ITestTypes[];
+  status: string;
+  staticAnalysis: string;
+  typeErrors: string;
+  bddErrors: string;
+};
+
+type ICollations = ICollation[];
+
+const BigBoard = () => {
+
+  const [configs, setConfigs] = useState<IBuiltConfig>();
+  useEffect(() => {
+    (async () => {
+      fetch('/kokomoBay/docs/testeranto.json')
+        .then(response => response.json())
+        .then(json => {
+          setConfigs(json)
+        })
+        .catch(error => console.error(error));
+
+    })();
+  }, []);
+
+  const [bigBoard, setBigBoard] = useState<Record<string, object>>({});
+  useEffect(() => {
+    (async () => {
+      fetch('/kokomoBay/docs/bigBoard.json')
+        .then(response => response.json())
+        .then(json => {
+          setBigBoard(json)
+        })
+        .catch(error => console.error(error));
+
+    })();
+  }, []);
+
+  const [staticAnalysis, setStaticAnalysis] = useState<Record<string, string>>({});
+  useEffect(() => {
+    (async () => {
+
+      let accumulator = {};
+      for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+        accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/lint_errors.txt`)).text()
+      }
+      setStaticAnalysis(accumulator);
+
+
+    })();
+  }, [configs, bigBoard]);
+
+  const [typeErrors, setTypeErrors] = useState<Record<string, string>>({});
+  useEffect(() => {
+    (async () => {
+
+      let accumulator = {};
+      for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+        accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/type_errors.txt`)).text()
+      }
+      setTypeErrors(accumulator);
+
+
+    })();
+  }, [configs, bigBoard]);
+
+  const [bddErrors, setBddErrors] = useState<Record<string, string>>({});
+  useEffect(() => {
+    (async () => {
+
+      let accumulator = {};
+      for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+        accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/bdd_errors.txt`)).text()
+      }
+      setBddErrors(accumulator);
+
+
+    })();
+  }, [configs, bigBoard]);
+
+  if (!configs || !staticAnalysis || !typeErrors || !bddErrors) {
+    return <div>loading...</div>
+  }
+
+  const collated: ICollations = configs.tests.map((c) => {
+    return {
+      ...bigBoard[c[0]],
+      name: c[0],
+      runTime: c[1],
+      tr: c[2],
+      sidecars: c[3],
+      staticAnalysis: staticAnalysis[c[0]],
+      typeErrors: typeErrors[c[0]],
+      bddErrors: bddErrors[c[0]],
+    } as ICollation
+  });
+
+  return <div >
+    <table>
+      <tr>
+        <td>name</td>
+        <td>run time</td>
+        <td>BDD errors</td>
+        <td>Lint errors</td>
+        <td>Type errors</td>
+        <td>prompt</td>
+      </tr>
+      {
+        ...collated.map((c) => {
+          return <tr>
+            <td>{c.name}</td>
+            <td>{c.runTime}</td>
+            <td><a href={`${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/littleBoard.html`}>{c.bddErrors}</a></td>
+            <td><a href={`${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/lint_errors.json`}>{c.staticAnalysis}</a></td>
+            <td><a href={`${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/type_errors.txt`}>{c.typeErrors}</a></td>
+
+
+            <td>
+              <pre>
+                aider --model deepseek/deepseek-chat --load {`docs/${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/prompt.txt`}
+              </pre>
+            </td>
+
+
+          </tr>
+        })
+      }
+    </table>
+    <Footer />
+  </div>
+}
+
+document.addEventListener("DOMContentLoaded", function () {
+  const elem = document.getElementById("root");
+  if (elem) {
+    ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}, []));
+  }
+});
+
+console.log("hello BigBoard!")

package/src/ReportServer.ts

@@ -0,0 +1,21 @@
+import staticServer from "node-static";
+import http from "http";
+
+const main = async () => {
+  process.chdir("../"); // Navigate one level up
+
+  const fileServer = new staticServer.Server(".", {});
+
+  http
+    .createServer(function (request, response) {
+      request
+        .addListener("end", function () {
+          fileServer.serve(request, response);
+        })
+        .resume();
+    })
+    .listen(8080);
+
+  console.log("Server running on port 8080");
+};
+main();

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

@@ -3,7 +3,8 @@ import React from "react";
 import Testeranto from "../../../Node.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -13,31 +14,74 @@ 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 IImpl<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestImplementation<I, O>;
 
-export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+export type ISpec<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestSpecification<I, O>;
 
-export default <ITestShape extends IBaseTest, IState>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ISpec<I, O>,
   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);
-      },
-    }
-  );
+  return Testeranto<I, O>(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

@@ -3,7 +3,8 @@ import React from "react";
 import Testeranto from "../../../Web.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -11,33 +12,75 @@ import {
 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 IImpl<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestImplementation<I, O>;
 
-export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+export type ISpec<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestSpecification<I, O>;
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ISpec<I, O>,
   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);
-      },
-    }
-  );
+  return Testeranto<I, O>(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

@@ -2,7 +2,8 @@ import { CElement } from "react";
 import React from "react";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   IPartialInterface,
   ITestImplementation,
   ITestSpecification,
@@ -16,30 +17,50 @@ 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 ITestImpl<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestImplementation<I, O>;
 
-export type ITestSpec<ITestShape extends IBaseTest> =
-  ITestSpecification<ITestShape>;
+export type ITestSpec<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = ITestSpecification<I, O>;
 
 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(React.createElement(subject));
-  //   });
-  // },
-  andWhen: async (s: IStore, whenCB): Promise<IStore> => {
+  andWhen: async (s, whenCB) => {
     await whenCB(s());
     return new Promise((resolve, rej) => {
       resolve(React.createElement(s));
     });
-    // return whenCB(s);
   },
   butThen: async (subject, thenCB) => {
     await thenCB(subject());

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

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Node.js";
-import { IBaseTest, IPartialInterface } from "../../../Types";
+import { Ibdd_in, Ibdd_out, IPartialInterface } from "../../../Types";
 
 import {
   ITestImpl,
@@ -8,20 +8,33 @@ import {
   testInterface as baseInterface,
 } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImpl<ITestShape>,
-  testSpecifications: ITestSpec<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImpl<I, O>,
+  testSpecifications: ITestSpec<I, O>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape> = baseInterface
+  testInterface: IPartialInterface<I> = baseInterface
 ) => {
-  return Testeranto<ITestShape>(
+  return Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,
     testInterface
-    // {
-    //   ...baseInterface,
-    //   ...testInterface,
-    // }
   );
 };