testeranto 0.49.10 → 0.62.0

package/src/Types.ts

@@ -1,16 +1,147 @@
+import { BrowserWindow } from "electron";
+import { Page, Browser, ScreenshotOptions } from "puppeteer-core";
+
+import {
+  ITTestResourceConfiguration,
+  ITTestResourceRequest,
+  ITestArtificer,
+  ITestCheckCallback
+} from "./lib/index.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import Testeranto from "./lib/core.js";
+
+export type IBuiltConfig = {
+  buildDir: string,
+  modules: {
+    module: unknown,
+    test: string,
+    runtime: IRunTime
+  }[]
+};
+
+export type INodeUtils = TBrowser;
+export type IWebUtils = BrowserWindow;
+export type IUtils = INodeUtils | IWebUtils;
+
+export type ISuiteKlasser<ITestShape extends IBaseTest> = (
+  name: string,
+  index: number,
+  givens: IGivens<ITestShape>,
+  checks: BaseCheck<ITestShape>[]
+) => BaseSuite<ITestShape>;
+
+export type IGivenKlasser<ITestShape extends IBaseTest> = (
+  name,
+  features,
+  whens,
+  thens,
+  givenCB
+) => BaseGiven<ITestShape>;
+
+export type IWhenKlasser<ITestShape extends IBaseTest> = (s, o) =>
+  BaseWhen<ITestShape>
+
+export type IThenKlasser<ITestShape extends IBaseTest> = (s, o) =>
+  BaseThen<ITestShape>;
+
+export type ICheckKlasser<ITestShape extends IBaseTest> = (
+  n,
+  f,
+  cb,
+  w,
+  t
+) => BaseCheck<ITestShape>;
+
+// export class TPage extends Page {
+//   // screenshot(options?: puppeteer.ScreenshotOptions) {
+//   //   return super.screenshot({
+//   //     ...options,
+//   //     path: "dist/" + (options ? options : { path: "" }).path,
+
+//   //   });
+//   // }
+// }
+
+export class TBrowser {
+  browser: Browser;
+  constructor(browser: Browser) {
+    this.browser = browser;
+  }
+  pages(): Promise<Page[]> {
+
+    return new Promise(async (res, rej) => {
+
+
+      res(
+        (await this.browser.pages()).map((p) => {
+          // const handler = {
+          //   apply: function (target, thisArg, argumentsList) {
+          //     console.log('screenshot was called with ' + JSON.stringify(argumentsList));
+          //     const x: ScreenshotOptions = argumentsList[0]
+          //     x.path = "./dist/" + x.path;
+          //     console.log('x.path' + x.path, target, thisArg);
+          //     return target(...argumentsList);
+          //   }
+          // };
+          // p.screenshot = new Proxy(p.screenshot, handler);
+          return p;
+        })
+      );
+    });
+
+  }
+  // pages(): Promise<TPage[]> {
+  //   return super.pages();
+  // }
+}
+
+export type ITTestShape = {
+  suites;
+  givens;
+  whens;
+  thens;
+  checks;
+};
+
+export type IJsonConfig = {
+  outdir: string,
+  tests: ITestTypes[]
+  features: string;
+};
+
 export type IBaseConfig = {
+  outdir: string,
+  tests: ITestTypes[]
+  features: string
+  externals: string[],
   clearScreen: boolean;
   devMode: boolean;
-  features: string;
   webPlugins: any[];
   nodePlugins: any[];
   minify: boolean;
   outbase: string;
-  outdir: string;
   ports: string[];
-  tests: string;
+  debugger: boolean;
 };
 
+export type IPartialInterface<I extends IBaseTest> = Partial<ITestInterface<I>>;
+export type IPartialNodeInterface<I extends IBaseTest> = Partial<INodeTestInterface<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>>;
+
+// type If = {
+//   (modulePath: string | URL, options?: childProcess.ForkOptions): childProcess.ChildProcess;
+//   (modulePath: string | URL, args?: readonly string[], options?: childProcess.ForkOptions): childProcess.ChildProcess
+// };
+
+// const f: If = childProcess.fork;
+
 export type IRunTime = `node` | `web`;
 
 export type ITestTypes = [
@@ -18,3 +149,203 @@ export type ITestTypes = [
   IRunTime,
   ITestTypes[]
 ];
+
+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
+> = 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 ITestInterface<
+  ITestShape extends IBaseTest
+> = {
+  assertThis: (x: ITestShape['then']) => void,
+
+  andWhen: (
+    store: ITestShape['istore'],
+    whenCB: ITestShape['when'],
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape['istore']>;
+  butThen: (
+    store: ITestShape['istore'],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape['iselection']>;
+
+  afterAll: (
+    store: ITestShape['istore'],
+    artificer: ITestArtificer,
+    utils: IUtils
+  ) => any;
+  afterEach: (
+    store: ITestShape['istore'],
+    key: string,
+    artificer: ITestArtificer,
+    // utils: IUtils
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape['iinput'],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    // utils: IUtils
+  ) => Promise<ITestShape['isubject']>;
+  beforeEach: (
+    subject: ITestShape['isubject'],
+    initializer: (c?) => ITestShape['given'],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    // utils: IUtils
+  ) => Promise<ITestShape['istore']>;
+};
+
+export type INodeTestInterface<
+  ITestShape extends IBaseTest
+> = {
+  assertThis: (x: ITestShape['then']) => void,
+
+  andWhen: (
+    store: ITestShape['istore'],
+    whenCB: ITestShape['when'],
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape['istore']>;
+  butThen: (
+    store: ITestShape['istore'],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape['iselection']>;
+
+  afterAll: (
+    store: ITestShape['istore'],
+    artificer: ITestArtificer,
+    browser: INodeUtils
+  ) => any;
+  afterEach: (
+    store: ITestShape['istore'],
+    key: string,
+    artificer: ITestArtificer,
+    // utils: IUtils
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape['iinput'],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    // utils: IUtils
+  ) => Promise<ITestShape['isubject']>;
+  beforeEach: (
+    subject: ITestShape['isubject'],
+    initializer: (c?) => ITestShape['given'],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    // utils: IUtils
+  ) => Promise<ITestShape['istore']>;
+} & ITestInterface<ITestShape>;
+
+type Modify<T, R> = Omit<T, keyof R> & R;
+
+export type IBaseTest = {
+  iinput; // input
+  isubject;  // subject
+  istore; // store
+  iselection;
+  // 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 ITestShaper<
+  T extends IBaseTest,
+  modifier
+> = {
+  given;
+  when;
+  then;
+  suites;
+  givens;
+  whens;
+  thens;
+  checks;
+};

package/src/Web.ts

@@ -1,241 +1,115 @@
+import type {
+  IBaseTest,
+  ITestImplementation,
+  ITestInterface,
+  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);
-
-  webSocket.send(
-    JSON.stringify({
-      type: "testeranto:adios",
-      data: {
-        failed,
-        testResourceConfiguration:
-          t.test.testResourceConfiguration,
-        results: t.toObj(),
-      },
+  defaultTestResourceRequirement
+} from "./lib/index.js";
+
+const remote = require('@electron/remote')
+
+class WebTesteranto<
+  TestShape extends IBaseTest,
+> extends Testeranto<
+  TestShape
+> {
+  constructor(
+    input: TestShape["iinput"],
+    testSpecification: ITestSpecification<TestShape>,
+    testImplementation: ITestImplementation<TestShape, object>,
+    testResourceRequirement: ITTestResourceRequest,
+    testInterface: Partial<ITestInterface<TestShape>>,
+  ) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      (window as any).NodeWriter,
+      testInterface,
+      // BrowserWindow
+    );
+
+    if (process.argv[2]) {
+      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);
+      }
+    } else {
+      // no-op
+    }
+
+    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);
+      }
+    }
+    // const t: ITestJob = this.testJobs[0];
+
+
+
+  }
+
+  async receiveTestResourceConfig(t: ITestJob, partialTestResource: ITTestResourceConfiguration) {
+    const {
+      failed,
+      artifacts,
+      logPromise
+    } = await t.receiveTestResourceConfig(
+      partialTestResource,
+      remote
+    );
+
+    Promise.all([...artifacts, logPromise]).then(async () => {
+      var window = remote.getCurrentWindow();
+      // window.close();
     })
-  );
-
-  Promise.all([...artifacts, logPromise]).then(async () => {
-    // ipcRenderer.invoke('quit-app', failed);
-    (window as any).exit(failed)
-  })
-}
-
-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>;
-  },
-  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-) => {
-
-  console.log("web NodeWriter", (window as any).NodeWriter);
-
-  const mrt = new TesterantoLevelTwo(
+  }
+
+};
+
+export default async <ITestShape extends IBaseTest>(
+  input: ITestShape['iinput'],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape, object>,
+  testInterface: Partial<ITestInterface<ITestShape>>,
+  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+): 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') || ''
-  );
-
-  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);
-    }
+    testInterface,
+  )
 
-    // 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}/..`);