testeranto 0.49.10 → 0.70.0

package/src/Types.ts

@@ -1,20 +1,117 @@
-export type IBaseConfig = {
-  clearScreen: boolean;
-  devMode: boolean;
-  features: string;
-  webPlugins: any[];
-  nodePlugins: 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> = Partial<ITestInterface<I>>;
+
+export type IPartialNodeInterface<I extends IBaseTest> = Partial<
+  INodeTestInterface<I>
+>;
+export type IPartialWebInterface<I extends IBaseTest> = Partial<
+  IWebTestInterface<I>
+>;
+
+export type IEntry<ITestShape extends IBaseTest> = (
+  input: ITestShape["iinput"],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape, object>,
+  testInterface: IPartialInterface<ITestShape>,
+  testResourceRequirement: ITTestResourceRequest
+) => Promise<Testeranto<ITestShape>>;
+
+export type ITestSpecification<ITestShape extends IBaseTest> = (
+  Suite: {
+    [K in keyof ITestShape["suites"]]: (
+      name: string,
+      givens: IGivens<ITestShape>,
+      checks: BaseCheck<ITestShape>[]
+    ) => BaseSuite<ITestShape>;
+  },
+  Given: {
+    [K in keyof ITestShape["givens"]]: (
+      features: string[],
+      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 ITestImplementation<
+  ITestShape extends IBaseTest,
+  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
+>;
+
+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 IRunTime = `node` | `web`;
+// export type ITTestShape = {
 
-export type ITestTypes = [
-  string,
-  IRunTime,
-  ITestTypes[]
-];
+// };

package/src/Web.ts

@@ -1,241 +1,116 @@
+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";
-
-let webSocket: WebSocket;
-try {
-  webSocket = new WebSocket("ws://localhost:8080");
-} catch (e) {
-  console.error(e)
-}
-
-
-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);
+} from "./lib/index.js";
+import {
+  INodeUtils,
+  ITestInterface,
+  IWebTestInterface,
+  IWebUtils,
+} from "./lib/types";
+
+// const remote = require("@electron/remote");
+// import remote from "@electron/remote";
+// const electron = require("electron");
+// const remote =
+//   process.type === "browser" ? electron : require("@electron/remote");
+
+class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
+  constructor(
+    input: TestShape["iinput"],
+    testSpecification: ITestSpecification<TestShape>,
+    testImplementation: ITestImplementation<TestShape>,
+    testResourceRequirement: ITTestResourceRequest,
+    testInterface: Partial<ITestInterface<TestShape>>
+  ) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      (window as any).NodeWriter,
+      testInterface
+    );
+
+    const testResourceArg = decodeURIComponent(
+      new URLSearchParams(location.search).get("requesting") || ""
+    );
+
+    try {
+      const partialTestResource = JSON.parse(
+        testResourceArg
+      ) as ITTestResourceConfiguration;
+
+      this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+    } catch (e) {
+      console.error(e);
+      // process.exit(-1);
+    }
 
-  webSocket.send(
-    JSON.stringify({
-      type: "testeranto:adios",
-      data: {
-        failed,
-        testResourceConfiguration:
-          t.test.testResourceConfiguration,
-        results: t.toObj(),
-      },
-    })
-  );
+    const requesting = new URLSearchParams(location.search).get("requesting");
+    if (requesting) {
+      const testResourceArg = decodeURIComponent(requesting);
+
+      try {
+        const partialTestResource = JSON.parse(
+          testResourceArg
+        ) as ITTestResourceConfiguration;
+
+        console.log("initial test resource", partialTestResource);
+        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+      } catch (e) {
+        console.error(e);
+        // process.exit(-1);
+      }
+    }
+  }
 
-  Promise.all([...artifacts, logPromise]).then(async () => {
-    // ipcRenderer.invoke('quit-app', failed);
-    (window as any).exit(failed)
-  })
+  async receiveTestResourceConfig(
+    t: ITestJob<IWebUtils>,
+    partialTestResource: ITTestResourceConfiguration
+  ) {
+    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(
+      partialTestResource,
+      {
+        browser: await (window as any).browser,
+        ipc: (window as any).ipcRenderer,
+      }
+    );
+
+    console.log("test is done, awaiting test result write to fs");
+    Promise.all([...artifacts, logPromise]).then(async () => {
+      // 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();
+      // currentWindow.close();
+    });
+  }
 }
 
-export default async <
-  TestShape extends ITTestShape,
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  WhenShape,
-  IThenShape,
-  IState
->(
-  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>;
-  },
+export default async <ITestShape extends IBaseTest>(
+  input: ITestShape["iinput"],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape>,
+  testInterface: Partial<IWebTestInterface<ITestShape>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-) => {
-
-  console.log("web NodeWriter", (window as any).NodeWriter);
-
-  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}/..`);