testeranto 0.114.1 → 0.125.0

package/src/SubPackages/react-test-renderer/jsx/node.ts

@@ -1,20 +1,14 @@
 import test from "../../../Node.js";
-import { Ibdd_in, Ibdd_out } from "../../../Types.js";
+import {
+  Ibdd_out,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types.js";
 
-import type { ITestImpl, ITestSpec } from "../jsx-promised";
-
-import { IInput, testInterface } from "./index.js";
+import { I, IInput, testInterface } from "./index.js";
 
 export default <
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
+  II extends I,
   O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
@@ -23,8 +17,8 @@ export default <
     Record<string, any>
   >
 >(
-  testImplementations: ITestImpl<I, O>,
-  testSpecifications: ITestSpec<I, O>,
+  testImplementations: ITestImplementation<II, O>,
+  testSpecifications: ITestSpecification<II, O>,
   testInput: IInput,
   testInterface2 = testInterface
 ) => {

package/src/SubPackages/react-test-renderer/jsx/pure.ts

@@ -0,0 +1,31 @@
+import test from "../../../Pure.js";
+import {
+  Ibdd_out,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types.js";
+
+import { I, IInput, testInterface } from "./index.js";
+
+export default <
+  II extends I,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<II, O>,
+  testSpecifications: ITestSpecification<II, O>,
+  testInput: IInput,
+  testInterface2 = testInterface
+) => {
+  return test<I, O>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface2
+  );
+};

package/src/SubPackages/react-test-renderer/jsx/web.ts

@@ -1,20 +1,15 @@
-import { Ibdd_in, Ibdd_out } from "../../../Types.js";
 import test from "../../../Web.js";
 
-import { ITestImpl, ITestSpec } from "../jsx-promised";
+import {
+  Ibdd_out,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types.js";
 
-import { IInput, testInterface } from "./index.js";
+import { I, IInput, testInterface } from "./index.js";
 
 export default <
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
+  II extends I,
   O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
@@ -23,8 +18,8 @@ export default <
     Record<string, any>
   >
 >(
-  testImplementations: ITestImpl<I, O>,
-  testSpecifications: ITestSpec<I, O>,
+  testImplementations: ITestImplementation<II, O>,
+  testSpecifications: ITestSpecification<II, O>,
   testInput: IInput,
   testInterface2 = testInterface
 ) => {

package/src/TestReport.tsx

@@ -26,8 +26,8 @@ const TestPane = ({ given }: {
   given: {
     key: string,
     name: string,
-    error: string[],
-    features: string[],
+    error?: string[],
+    features?: string[],
     whens: {
       name: string;
       error: string;
@@ -41,6 +41,7 @@ const TestPane = ({ given }: {
 
   return <div>    <Tab.Container id="TestPane-tabs" defaultActiveKey="first">
     <Row>
+
       <Col sm={3}>
         <Nav variant="pills" className="flex-column">
 
@@ -61,7 +62,7 @@ const TestPane = ({ given }: {
 
 
       </Col>
-      <Col sm={9}>
+      <Col sm={6}>
         <Tab.Content>
 
           <Tab.Pane eventKey={`bdd-features`}>
@@ -87,18 +88,18 @@ const TestPane = ({ given }: {
 
 const BddPage = () => {
 
-  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 [configs, setConfigs] = useState<IBuiltConfig>();
+  // useEffect(() => {
+  //   (async () => {
+  //     fetch('../config.json')
+  //       .then(response => response.json())
+  //       .then(json => {
+  //         setConfigs(json)
+  //       })
+  //       .catch(error => console.error(error));
 
-    })();
-  }, []);
+  //   })();
+  // }, []);
 
 
   const [bddErrors, setBddErrors] = useState<{
@@ -119,9 +120,16 @@ const BddPage = () => {
     (async () => {
       setBddErrors(await (await fetch(`tests.json`)).json());
     })();
-  }, [configs]);
+  }, []);
 
-  if (!configs || !bddErrors) {
+  const [log, setLog] = useState<string>();
+  useEffect(() => {
+    (async () => {
+      setLog(await (await fetch(`log.txt`)).text());
+    })();
+  }, []);
+
+  if (!bddErrors || !log) {
     return <div>loading...</div>
   }
 
@@ -132,6 +140,13 @@ const BddPage = () => {
     <Row>
       <Tab.Container id="root-tab-container" defaultActiveKey="first">
         <Row>
+
+          <Col sm={3}>
+            <pre><code>{log}</code></pre>
+
+
+          </Col>
+
           <Col sm={3}>
             <Nav variant="pills" className="flex-column">
 
@@ -147,7 +162,7 @@ const BddPage = () => {
 
             </Nav>
           </Col>
-          <Col sm={9}>
+          <Col sm={6}>
             <Tab.Content>
               {
                 ...bddErrors.givens.map((g) =>
@@ -169,8 +184,11 @@ const BddPage = () => {
 document.addEventListener("DOMContentLoaded", function () {
   const elem = document.getElementById("root");
   if (elem) {
-    ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+    if (elem) {
+      const root = ReactDom.createRoot(elem);
+      root.render(React.createElement(BddPage, {}));
+    }
   }
 });
 
-console.log("hello BddPage!")
+console.log("hello BddPage!")

package/src/Types.ts

@@ -1,4 +1,6 @@
-import { ITTestResourceConfiguration, ITestArtificer } from "./lib/index.js";
+import { Plugin } from "esbuild";
+
+import { ITTestResourceConfiguration } from "./lib/index.js";
 import {
   IGivens,
   BaseCheck,
@@ -7,133 +9,84 @@ import {
   BaseThen,
   BaseGiven,
 } from "./lib/abstractBase.js";
+import { IPM, ITestCheckCallback } from "./lib/types.js";
 import { PM } from "./PM/index.js";
-import { ITestCheckCallback } from "./lib/types.js";
-
-export type ITestInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = {
-  assertThis: (x: I["then"]) => void;
+
+export type ITestInterface<I extends IT = IT> = {
+  assertThis: (x: I["then"]) => any;
   andWhen: (
     store: I["istore"],
     whenCB: I["when"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["istore"]>;
   butThen: (
     store: I["istore"],
     thenCB: I["then"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["iselection"]>;
-  afterAll: (store: I["istore"], pm: PM) => any;
-  afterEach: (store: I["istore"], key: string, pm: PM) => Promise<unknown>;
+  afterAll: (store: I["istore"], pm: IPM) => any;
+  afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
   beforeAll: (
     input: I["iinput"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["isubject"]>;
   beforeEach: (
     subject: I["isubject"],
     initializer: (c?) => I["given"],
     testResource: ITTestResourceConfiguration,
     initialValues,
-    pm: PM
+    pm: IPM
   ) => Promise<I["istore"]>;
 };
 
-export type IWebTestInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = ITestInterface<I>;
-
-export type INodeTestInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = ITestInterface<I>;
-
-export type IPartialInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<ITestInterface<I>>;
-
-export type IPartialNodeInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<INodeTestInterface<I>>;
-export type IPartialWebInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<IWebTestInterface<I>>;
+export type IWebTestInterface<I extends IT> = ITestInterface<I>;
+
+export type INodeTestInterface<I extends IT> = ITestInterface<I>;
+
+export type IPartialInterface<I extends IT> = Partial<ITestInterface<I>>;
+
+export type IPartialNodeInterface<I extends IT> = Partial<
+  INodeTestInterface<I>
+>;
+export type IPartialWebInterface<I extends IT> = Partial<IWebTestInterface<I>>;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export type ITestSpecification<
-  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>
-  >
-> = (
+export type IT = Ibdd_in<
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+export type OT = Ibdd_out<
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>
+>;
+
+// export type MT<O extends OT> = Partial<{
+//   suites: { [K in keyof O["suites"]]: unknown };
+//   givens: { [K in keyof O["givens"]]: unknown };
+//   whens: { [K in keyof O["whens"]]: unknown };
+//   thens: { [K in keyof O["thens"]]: unknown };
+//   checks: { [K in keyof O["checks"]]: unknown };
+// }>;
+
+export type ITestSpecification<I extends IT, O extends OT> = (
   Suite: {
     [K in keyof O["suites"]]: (
       name: string,
       givens: IGivens<I>,
-      checks: BaseCheck<I, O>[]
+      checks: BaseCheck<I>[]
     ) => BaseSuite<I, O>;
   },
   Given: {
@@ -156,54 +109,44 @@ export type ITestSpecification<
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export type ITestImplementation<
-  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>
-  >
-> = {
-  suites: {
-    [K in keyof O["suites"]]: string;
-  };
-  givens: {
-    [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
-  };
-  whens: {
-    [K in keyof O["whens"]]: (
-      ...Iw: O["whens"][K]
-    ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
-  };
-  thens: {
-    [K in keyof O["thens"]]: (
-      ...It: O["thens"][K]
-    ) => (ssel: I["iselection"], utils: PM) => I["then"];
-  };
-  checks: {
-    [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
-  };
-};
+  I extends IT,
+  O extends OT,
+  modifier = {}
+> = Modify<
+  {
+    suites: {
+      [K in keyof O["suites"]]: string;
+    };
+    givens: {
+      [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+    };
+    whens: {
+      [K in keyof O["whens"]]: (
+        ...Iw: O["whens"][K]
+      ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
+    };
+    thens: {
+      [K in keyof O["thens"]]: (
+        ...It: O["thens"][K]
+      ) => (ssel: I["iselection"], utils: PM) => I["then"];
+    };
+    checks: {
+      [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+    };
+  },
+  modifier
+>;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export type Modify<T, R> = Omit<T, keyof R> & R;
 
 export type Ibdd_out<
-  ISuites extends Record<string, any>,
-  IGivens extends Record<string, any>,
-  IWhens extends Record<string, any>,
-  IThens extends Record<string, any>,
-  IChecks extends Record<string, any>
+  ISuites extends Record<string, any> = Record<string, any>,
+  IGivens extends Record<string, any> = Record<string, any>,
+  IWhens extends Record<string, any> = Record<string, any>,
+  IThens extends Record<string, any> = Record<string, any>,
+  IChecks extends Record<string, any> = Record<string, any>
 > = {
   suites: ISuites;
   givens: IGivens;
@@ -229,3 +172,34 @@ export type Ibdd_in<
   when: IWhen;
   then: IThen;
 };
+
+///////////////////////////////////////////////
+
+export type IPluginFactory = (
+  register: (entrypoint: string, sources: string[]) => any,
+  entrypoints: string[]
+) => Plugin;
+
+export type IRunTime = `node` | `web` | "pure";
+
+export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
+
+export type ITestconfig = {
+  clearScreen: boolean;
+  debugger: boolean;
+  externals: string[];
+  featureIngestor: (s: string) => Promise<string>;
+  importPlugins: IPluginFactory[];
+  minify: boolean;
+  nodePlugins: IPluginFactory[];
+  ports: string[];
+  src: string;
+  tests: ITestTypes[];
+  webPlugins: IPluginFactory[];
+};
+
+export type IBuiltConfig = { buildDir: string } & ITestconfig;
+
+export type IProject = {
+  projects: Record<string, ITestconfig>;
+};

package/src/Web.ts

@@ -1,15 +1,14 @@
 import { PM_Web } from "./PM/web";
 import type {
-  Ibdd_in,
-  Ibdd_out,
+  IT,
   ITestImplementation,
   ITestInterface,
   ITestSpecification,
   IWebTestInterface,
+  OT,
 } from "./Types";
 import Testeranto from "./lib/core.js";
 import {
-  IFinalResults,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
   defaultTestResourceRequirement,
@@ -22,28 +21,15 @@ let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
   // throw event;
 };
 
-export class WebTesteranto<
-  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>
-  >
-> extends Testeranto<I, O> {
+export class WebTesteranto<I extends IT, O extends OT, M> extends Testeranto<
+  I,
+  O,
+  M
+> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
-    testImplementation: ITestImplementation<I, O>,
+    testImplementation: ITestImplementation<I, O, M>,
     testResourceRequirement: ITTestResourceRequest,
     testInterface: Partial<ITestInterface<I>>
   ) {
@@ -92,39 +78,18 @@ export class WebTesteranto<
   async receiveTestResourceConfig(partialTestResource: any) {
     const t: ITTestResourceConfiguration = partialTestResource; //JSON.parse(partialTestResource);
     const pm = new PM_Web(t);
-    const { failed, artifacts, logPromise, features } =
-      await this.testJobs[0].receiveTestResourceConfig(pm);
-    return new Promise<IFinalResults>((res, rej) => {
-      res({ features, failed });
-    });
+    return await this.testJobs[0].receiveTestResourceConfig(pm);
   }
 }
 
-export default async <
-  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>
-  >
->(
+export default async <I extends IT, O extends OT, M>(
   input: I["iinput"],
   testSpecification: ITestSpecification<I, O>,
-  testImplementation: ITestImplementation<I, O>,
+  testImplementation: ITestImplementation<I, O, M>,
   testInterface: Partial<IWebTestInterface<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-): Promise<Testeranto<I, O>> => {
-  return new WebTesteranto<I, O>(
+): Promise<Testeranto<I, O, M>> => {
+  return new WebTesteranto<I, O, M>(
     input,
     testSpecification,
     testImplementation,