testeranto 0.62.0 → 0.70.0

package/src/Types.ts

@@ -1,351 +1,117 @@
-import { BrowserWindow } from "electron";
-import { Page, Browser, ScreenshotOptions } from "puppeteer-core";
-
+import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
 import {
-  ITTestResourceConfiguration,
-  ITTestResourceRequest,
-  ITestArtificer,
-  ITestCheckCallback
-} from "./lib/index.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+  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;
-  webPlugins: any[];
-  nodePlugins: any[];
-  minify: boolean;
-  outbase: string;
-  ports: string[];
-  debugger: boolean;
-};
+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 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'],
+  input: ITestShape["iinput"],
   testSpecification: ITestSpecification<ITestShape>,
   testImplementation: ITestImplementation<ITestShape, object>,
   testInterface: IPartialInterface<ITestShape>,
-  testResourceRequirement: ITTestResourceRequest,
+  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 = [
-  string,
-  IRunTime,
-  ITestTypes[]
-];
-
-export type ITestSpecification<
-  ITestShape extends IBaseTest
-> = (
+export type ITestSpecification<ITestShape extends IBaseTest> = (
   Suite: {
     [K in keyof ITestShape["suites"]]: (
       name: string,
-      givens: IGivens<
-        ITestShape
-      >,
-      checks: BaseCheck<
-        ITestShape
-      >[]
-    ) => BaseSuite<
-      ITestShape
-    >;
+      givens: IGivens<ITestShape>,
+      checks: BaseCheck<ITestShape>[]
+    ) => BaseSuite<ITestShape>;
   },
   Given: {
     [K in keyof ITestShape["givens"]]: (
       features: string[],
-      whens: BaseWhen<
-        ITestShape
-      >[],
-      thens: BaseThen<
-        ITestShape
-      >[],
+      whens: BaseWhen<ITestShape>[],
+      thens: BaseThen<ITestShape>[],
       ...xtrasB: ITestShape["givens"][K]
-    ) => BaseGiven<
-      ITestShape
-    >;
+    ) => BaseGiven<ITestShape>;
   },
   When: {
     [K in keyof ITestShape["whens"]]: (
       ...xtrasC: ITestShape["whens"][K]
-    ) => BaseWhen<
-      ITestShape
-    >;
+    ) => BaseWhen<ITestShape>;
   },
   Then: {
     [K in keyof ITestShape["thens"]]: (
       ...xtrasD: ITestShape["thens"][K]
-    ) => BaseThen<
-      ITestShape
-    >;
+    ) => 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
-> = 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;
+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[]>;
+
+  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;
-};
+// export type ITTestShape = {
+
+// };

package/src/Web.ts

@@ -1,30 +1,35 @@
 import type {
   IBaseTest,
   ITestImplementation,
-  ITestInterface,
-  ITestSpecification
+  ITestSpecification,
 } from "./Types";
 import Testeranto from "./lib/core.js";
 import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
   ITestJob,
-  defaultTestResourceRequirement
+  defaultTestResourceRequirement,
 } from "./lib/index.js";
+import {
+  INodeUtils,
+  ITestInterface,
+  IWebTestInterface,
+  IWebUtils,
+} from "./lib/types";
 
-const remote = require('@electron/remote')
+// 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
-> {
+class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
   constructor(
     input: TestShape["iinput"],
     testSpecification: ITestSpecification<TestShape>,
-    testImplementation: ITestImplementation<TestShape, object>,
+    testImplementation: ITestImplementation<TestShape>,
     testResourceRequirement: ITTestResourceRequest,
-    testInterface: Partial<ITestInterface<TestShape>>,
+    testInterface: Partial<ITestInterface<TestShape>>
   ) {
     super(
       input,
@@ -32,31 +37,25 @@ class WebTesteranto<
       testImplementation,
       testResourceRequirement,
       (window as any).NodeWriter,
-      testInterface,
-      // BrowserWindow
+      testInterface
     );
 
-    if (process.argv[2]) {
-      const testResourceArg = decodeURIComponent(
-        new URLSearchParams(location.search).get('requesting') || ''
-      );
-
-      try {
-        const partialTestResource = JSON.parse(
-          testResourceArg
-        ) as ITTestResourceConfiguration;
+    const testResourceArg = decodeURIComponent(
+      new URLSearchParams(location.search).get("requesting") || ""
+    );
 
-        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+    try {
+      const partialTestResource = JSON.parse(
+        testResourceArg
+      ) as ITTestResourceConfiguration;
 
-      } catch (e) {
-        console.error(e);
-        // process.exit(-1);
-      }
-    } else {
-      // no-op
+      this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+    } catch (e) {
+      console.error(e);
+      // process.exit(-1);
     }
 
-    const requesting = new URLSearchParams(location.search).get('requesting');
+    const requesting = new URLSearchParams(location.search).get("requesting");
     if (requesting) {
       const testResourceArg = decodeURIComponent(requesting);
 
@@ -67,49 +66,51 @@ class WebTesteranto<
 
         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(
+  async receiveTestResourceConfig(
+    t: ITestJob<IWebUtils>,
+    partialTestResource: ITTestResourceConfiguration
+  ) {
+    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(
       partialTestResource,
-      remote
+      {
+        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 () => {
-      var window = remote.getCurrentWindow();
+      // 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 <ITestShape extends IBaseTest>(
-  input: ITestShape['iinput'],
+  input: ITestShape["iinput"],
   testSpecification: ITestSpecification<ITestShape>,
-  testImplementation: ITestImplementation<ITestShape, object>,
-  testInterface: Partial<ITestInterface<ITestShape>>,
-  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+  testImplementation: ITestImplementation<ITestShape>,
+  testInterface: Partial<IWebTestInterface<ITestShape>>,
+  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
 ): Promise<Testeranto<ITestShape>> => {
   return new WebTesteranto<ITestShape>(
     input,
     testSpecification,
     testImplementation,
     testResourceRequirement,
-    testInterface,
-  )
-
+    testInterface
+  );
 };

package/src/cjs-shim.js

@@ -3,8 +3,8 @@ 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);
+globalThis.__filename = url.fileURLToPath(import.meta.url);
+globalThis.__dirname = path.dirname(__filename);
 
 // const p = `${import.meta.url}/..`;
 // globalThis.require = createRequire(`${import.meta.url}/..`);