testeranto 0.47.34 → 0.47.52

package/src/Types.ts

@@ -1,19 +1,224 @@
-export type IBaseConfig = {
-  clearScreen: boolean;
-  devMode: boolean;
-  features: string;
-  plugins: any[];
-  minify: boolean;
-  outbase: string;
-  outdir: string;
-  ports: string[];
-  tests: string;
-};
+import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+  BaseGiven,
+} from "./lib/abstractBase.js";
+import Testeranto from "./lib/core.js";
+import {
+  INodeTestInterface,
+  ITestInterface,
+  IWebTestInterface,
+} from "./lib/types.js";
+
+export type IPartialInterface<
+  I extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = Partial<ITestInterface<I>>;
+
+export type IPartialNodeInterface<
+  I extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = Partial<INodeTestInterface<I>>;
+export type IPartialWebInterface<
+  I extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = Partial<IWebTestInterface<I>>;
+
+export type IEntry<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (
+  input: ITestShape["iinput"],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape, object>,
+  testInterface: IPartialInterface<ITestShape>,
+  testResourceRequirement: ITTestResourceRequest
+) => Promise<Testeranto<ITestShape>>;
+
+export type ITestSpecification<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (
+  Suite: {
+    [K in keyof ITestShape["suites"]]: (
+      name: string,
+      givens: IGivens<ITestShape>,
+      checks: BaseCheck<ITestShape>[]
+    ) => BaseSuite<ITestShape>;
+  },
+  Given: {
+    [K in keyof ITestShape["givens"]]: (
+      whens: BaseWhen<ITestShape>[],
+      thens: BaseThen<ITestShape>[],
+      ...xtrasB: ITestShape["givens"][K]
+    ) => BaseGiven<ITestShape>;
+  },
+  When: {
+    [K in keyof ITestShape["whens"]]: (
+      ...xtrasC: ITestShape["whens"][K]
+    ) => BaseWhen<ITestShape>;
+  },
+  Then: {
+    [K in keyof ITestShape["thens"]]: (
+      ...xtrasD: ITestShape["thens"][K]
+    ) => BaseThen<ITestShape>;
+  },
+  Check: ITestCheckCallback<ITestShape>
+) => any[];
 
-export type IRunTime = `node` | `web`;
+export type ITestImplementation<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >,
+  IMod = object
+> = Modify<
+  {
+    suites: {
+      [K in keyof ITestShape["suites"]]: string;
+    };
+    givens: {
+      [K in keyof ITestShape["givens"]]: (
+        ...Ig: ITestShape["givens"][K]
+      ) => ITestShape["given"];
+    };
+    whens: {
+      [K in keyof ITestShape["whens"]]: (
+        ...Iw: ITestShape["whens"][K]
+      ) => (zel: ITestShape["iselection"]) => ITestShape["when"];
+    };
+    thens: {
+      [K in keyof ITestShape["thens"]]: (
+        ...It: ITestShape["thens"][K]
+      ) => (ssel: ITestShape["iselection"]) => ITestShape["then"];
+    };
+    checks: {
+      [K in keyof ITestShape["checks"]]: (
+        ...Ic: ITestShape["checks"][K]
+      ) => ITestShape["given"];
+    };
+  },
+  IMod
+>;
 
-export type ITestTypes = [
-  string,
-  IRunTime,
-  ITestTypes[]
-];
+type Modify<T, R> = Omit<T, keyof R> & R;
+
+// export type IBaseTest<Shape = any, II = Shape> = {
+//   iinput: II;
+//   isubject: Shape;
+//   istore: Shape;
+//   iselection: Shape;
+//   // iinitial;
+
+//   given;
+//   when;
+//   then;
+
+//   suites: Record<string, any>;
+//   givens: Record<string, any>;
+//   whens: Record<string, any>;
+//   thens: Record<string, any>;
+//   checks: Record<string, any>;
+// };
+
+export type IBaseTest<
+  IInput,
+  ISubject,
+  IStore,
+  ISelection,
+  IGiven,
+  IWhen,
+  IThen,
+  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>
+> = {
+  iinput: IInput;
+  isubject: ISubject;
+  istore: IStore;
+  iselection: ISelection;
+  given: IGiven;
+  when: IWhen;
+  then: IThen;
+  suites: ISuites;
+  givens: IGivens;
+  whens: IWhens;
+  thens: IThens;
+  checks: IChecks;
+};

package/src/Web.ts

@@ -1,233 +1,102 @@
+import { PM_Web } from "./PM/web";
+import type {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "./Types";
+import Testeranto from "./lib/core.js";
 import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
-  ITTestShape,
-  ITestArtificer,
-  ITestJob,
-  ITestSpecification,
   defaultTestResourceRequirement,
-} from "./core";
-import TesterantoLevelTwo from "./core";
-
-const webSocket = new WebSocket("ws://localhost:8080");
-
-const receiveTestResourceConfigUnscheduled = async (t, testresource) => {
-  const {
-    failed,
-    artifacts,
-    logPromise
-  } = await t.receiveTestResourceConfig(testresource);
-
-  Promise.all([...artifacts, logPromise]).then(async () => {
-    // ipcRenderer.invoke('quit-app', failed);
-    (window as any).exit(failed)
-  })
-}
-
-const receiveTestResourceConfigScheduled = async (t, testresource) => {
-  const {
-    failed,
-    artifacts,
-    logPromise
-  } = await t.receiveTestResourceConfig(testresource);
-
-  webSocket.send(
-    JSON.stringify({
-      type: "testeranto:adios",
-      data: {
-        failed,
-        testResourceConfiguration:
-          t.test.testResourceConfiguration,
-        results: t.toObj(),
-      },
-    })
-  );
+} from "./lib/index.js";
+import { ITestInterface, IWebTestInterface } from "./lib/types";
+
+class WebTesteranto<
+  TestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> extends Testeranto<TestShape> {
+  constructor(
+    input: TestShape["iinput"],
+    testSpecification: ITestSpecification<TestShape>,
+    testImplementation: ITestImplementation<TestShape>,
+    testResourceRequirement: ITTestResourceRequest,
+    testInterface: Partial<ITestInterface<TestShape>>
+  ) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testInterface
+    );
+  }
 
-  Promise.all([...artifacts, logPromise]).then(async () => {
-    // ipcRenderer.invoke('quit-app', failed);
-    (window as any).exit(failed)
-  })
+  async receiveTestResourceConfig(partialTestResource: any) {
+    const t: ITTestResourceConfiguration = partialTestResource; //JSON.parse(partialTestResource);
+    const pm = new PM_Web(t);
+    const { failed, artifacts, logPromise } =
+      await this.testJobs[0].receiveTestResourceConfig(pm);
+    pm.customclose();
+    // Promise.all([...artifacts, logPromise]).then(async () => {
+    //   console.log("hello world");
+    //   pm.customclose();
+    //   // we can't close the window becuase we might be taking a screenshot
+    //   // window.close();
+    //   // console.log(
+    //   //   "(window as any).browser",
+    //   //   JSON.stringify(await (window as any).browser)
+    //   // );
+    //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
+    //   // window.close();
+    //   // var customWindow = window.open("", "_blank", "");
+    //   // customWindow.close();
+    //   // this.puppetMaster.browser.page
+    //   // window["customclose"]();
+    //   // console.log("goodbye", window["customclose"]());
+    // });
+  }
 }
 
 export default async <
-  TestShape extends ITTestShape,
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  WhenShape,
-  IThenShape,
-  IState
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
 >(
-  input: IInput,
-  testSpecification: ITestSpecification<
-    TestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
-  testImplementation,
-  testInterface: {
-    actionHandler?: (b: (...any) => any) => any;
-    andWhen: (
-      store: IStore,
-      actioner,
-      testResource: ITTestResourceConfiguration
-    ) => Promise<ISelection>;
-    butThen?: (
-      store: IStore,
-      callback,
-      testResource: ITTestResourceConfiguration
-    ) => Promise<ISelection>;
-    assertioner?: (t: IThenShape) => any;
-
-    afterAll?: (store: IStore, artificer: ITestArtificer) => any;
-    afterEach?: (
-      store: IStore,
-      key: string,
-      artificer: ITestArtificer
-    ) => Promise<unknown>;
-    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<ISubject>;
-    beforeEach?: (
-      subject: ISubject,
-      initialValues,
-      testResource: ITTestResourceConfiguration,
-      artificer: ITestArtificer
-    ) => Promise<IStore>;
-  },
+  input: ITestShape["iinput"],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape>,
+  testInterface: Partial<IWebTestInterface<ITestShape>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-) => {
-
-  const mrt = new TesterantoLevelTwo(
+): Promise<Testeranto<ITestShape>> => {
+  return new WebTesteranto<ITestShape>(
     input,
     testSpecification,
     testImplementation,
-    testInterface,
     testResourceRequirement,
-    testInterface.assertioner || (async (t) => t as any),
-    testInterface.beforeEach ||
-    async function (subject: any, initialValues: any, testResource: any) {
-      return subject as any;
-    },
-    testInterface.afterEach || (async (s) => s),
-    testInterface.afterAll || ((store: IStore) => undefined),
-    testInterface.butThen || (async (a) => a as any),
-    testInterface.andWhen,
-    testInterface.actionHandler ||
-    function (b: (...any: any[]) => any) {
-      return b;
-    },
-    (window as any).NodeWriter
-  );
-
-  const tl2: TesterantoLevelTwo<any, any, any, any, any, any, any, any> = mrt;
-  const t: ITestJob = tl2.testJobs[0];
-  const testResourceArg = decodeURIComponent(
-    new URLSearchParams(location.search).get('requesting') || ''
+    testInterface
   );
-
-  try {
-    const partialTestResource = JSON.parse(
-      testResourceArg
-    ) as ITTestResourceConfiguration;
-
-    console.log("initial test resource", partialTestResource);
-
-    if (partialTestResource.scheduled) {
-      console.log("test is scheduled");
-
-      console.log("awaiting test resources via WS...");
-      webSocket.addEventListener("open", (event) => {
-        webSocket.addEventListener("message", (event) => {
-          console.log("Message from server ", event.data);
-        });
-
-        const r = JSON.stringify({
-          type: "testeranto:hola",
-          data: {
-            requirement: {
-              ...testResourceRequirement,
-              name: partialTestResource.name
-            }
-          },
-        });
-
-        webSocket.send(r);
-
-        console.log("awaiting test resources via websocket...", r);
-        webSocket.onmessage = (
-          async (msg: MessageEvent<any>) => {
-            console.log("message: ", msg);
-
-            const resourcesFromWs = JSON.parse(msg.data);
-            console.log("secondary test resource", resourcesFromWs);
-
-            const secondTestResource = {
-              fs: ".",
-              ...JSON.parse(JSON.stringify(partialTestResource)),
-              ...JSON.parse(JSON.stringify(resourcesFromWs)),
-            } as ITTestResourceConfiguration;
-
-            console.log("final test resource", secondTestResource);
-            receiveTestResourceConfigScheduled(t, secondTestResource);
-          }
-        );
-      });
-    } else {
-      receiveTestResourceConfigUnscheduled(t, partialTestResource);
-    }
-
-    // const partialTestResource = JSON.parse(
-    //   testResourceArg
-    // ) as ITTestResourceConfiguration;
-
-    // if (partialTestResource.fs && partialTestResource.ports) {
-    //   receiveTestResourceConfig(t, partialTestResource);
-
-
-    // } else {
-    //   console.log("test configuration is incomplete", partialTestResource);
-    //   console.log(
-    //     "requesting test resources via ws",
-    //     testResourceRequirement
-    //   );
-
-    //   webSocket.addEventListener("open", (event) => {
-    //     webSocket.addEventListener("message", (event) => {
-    //       console.log("Message from server ", event.data);
-    //     });
-
-    //     const r = JSON.stringify({
-    //       type: "testeranto:hola",
-    //       data: {
-    //         testResourceRequirement,
-    //       },
-    //     });
-
-    //     webSocket.send(r);
-
-    //     console.log("awaiting test resources via websocket...", r);
-    //     webSocket.onmessage = (
-    //       async (msg: MessageEvent<any>) => {
-    //         console.log("message: ", msg);
-
-    //         const resourcesFromPm2 = msg.data.testResourceConfiguration;
-    //         const secondTestResource = {
-    //           fs: ".",
-    //           ...JSON.parse(JSON.stringify(partialTestResource)),
-    //           ...JSON.parse(JSON.stringify(resourcesFromPm2)),
-    //         } as ITTestResourceConfiguration;
-
-    //         console.log("secondTestResource", secondTestResource);
-    //         receiveTestResourceConfig(t, secondTestResource);
-    //       }
-    //     );
-    //   });
-    // }
-
-  } catch (e) {
-    console.error(e);
-    // process.exit(-1);
-  }
 };

package/src/cjs-shim.js

@@ -0,0 +1,12 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import url from 'node:url';
+
+// globalThis.require = createRequire(import.meta.url);
+globalThis.__filename = url.fileURLToPath(import.meta.url);
+globalThis.__dirname = path.dirname(__filename);
+
+// const p = `${import.meta.url}/..`;
+// globalThis.require = createRequire(`${import.meta.url}/..`);
+// globalThis.__filename = url.fileURLToPath(`${import.meta.url}/..`);
+// globalThis.__dirname = path.dirname(`${__filename}/..`);

package/src/esbuildConfigs/features.ts

@@ -0,0 +1,17 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib/types";
+
+export default (config: IBaseConfig): BuildOptions => {
+  return {
+    bundle: true,
+    entryPoints: [config.features],
+    minify: config.minify === true,
+    outbase: config.outbase,
+    write: true,
+
+    outfile: `${config.outdir}/features.test.js`,
+    // external: ["graphology"],
+
+    format: "esm",
+  };
+};

package/src/esbuildConfigs/index.ts

@@ -0,0 +1,23 @@
+import { BuildOptions } from "esbuild";
+
+import { IBaseConfig } from "../lib/types";
+
+export default (config: IBaseConfig): BuildOptions => {
+  return {
+    // packages: "external",
+    target: "esnext",
+    format: "esm",
+    splitting: true,
+    outExtension: { ".js": ".mjs" },
+    outbase: config.outbase,
+    jsx: "transform",
+    bundle: true,
+    minify: config.minify === true,
+    write: true,
+    loader: {
+      ".js": "jsx",
+      ".png": "binary",
+      ".jpg": "binary",
+    },
+  };
+};

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+
+export default (
+  platform: "web" | "node",
+  entryPoints: Set<string> | string[]
+) => {
+  return {
+    name: "metafileWriter",
+    setup(build) {
+      build.onEnd((result) => {
+        if (result.errors.length === 0) {
+          entryPoints.forEach((entryPoint) => {
+            const filePath = path.join(
+              "./docs/",
+              platform,
+              entryPoint.split(".").slice(0, -1).join("."),
+              `inputFiles.json`
+            );
+
+            const dirName = path.dirname(filePath);
+
+            if (!fs.existsSync(dirName)) {
+              fs.mkdirSync(dirName, { recursive: true });
+            }
+
+            fs.writeFileSync(
+              filePath,
+              JSON.stringify(
+                Object.keys(
+                  Object.keys(result.metafile.outputs)
+                    .filter((s: string) => {
+                      if (!result.metafile.outputs[s].entryPoint) {
+                        return false;
+                      }
+                      return (
+                        path.resolve(result.metafile.outputs[s].entryPoint) ===
+                        path.resolve(entryPoint)
+                      );
+                    })
+                    .reduce((mm: string[], el) => {
+                      mm.push(result.metafile.outputs[el].inputs);
+                      return mm;
+                    }, [])[0]
+                )
+                  .filter((f: string) => {
+                    const regex = /^src\/.*/g;
+                    const matches = f.match(regex);
+                    const passes = matches?.length === 1;
+                    return passes;
+                  })
+                  .filter((f: string) => {
+                    const regex = /.*\.test\..*/g;
+                    const matches = f.match(regex);
+                    const passes = matches?.length === 1;
+                    return !passes;
+                  })
+              )
+            );
+          });
+        }
+      });
+    },
+  };
+};