testeranto 0.62.0 → 0.73.0

package/src/SubPackages/react-test-renderer/jsx-promised/index.ts

@@ -1,6 +1,10 @@
 import renderer, { act } from "react-test-renderer";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -10,17 +14,11 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type ITestImpl<
-  ITestShape extends IBaseTest
-> = ITestImplementation<
-  ITestShape, object
->
+export type ITestImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
 
-export type ITestSpec<
-  ITestShape extends IBaseTest
-> = ITestSpecification<
-  ITestShape
->
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 export const testInterface = {
   beforeEach: async (CComponent): Promise<renderer.ReactTestRenderer> => {
@@ -30,14 +28,13 @@ export const testInterface = {
         component = renderer.create(CComponent);
       });
       res(component);
-    })
-
+    });
   },
   andWhen: async function (
     renderer: renderer.ReactTestRenderer,
     whenCB: () => (any) => any
   ): Promise<renderer.ReactTestRenderer> {
     await act(() => whenCB()(renderer));
-    return renderer
-  }
-}
+    return renderer;
+  },
+};

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,115 +1,74 @@
+import { PM_Web } from "./PM/web";
 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 { ITestInterface, IWebTestInterface } from "./lib/types";
 
-const remote = 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,
       testSpecification,
       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;
-
-        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();
-    })
+  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);
+
+    console.log("test is done, awaiting test result write to fs");
+    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 <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}/..`);

package/src/esbuildConfigs/features.ts

@@ -1,6 +1,5 @@
-import { IBaseConfig } from "../Types";
-
 import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib/types";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {
@@ -14,5 +13,5 @@ export default (config: IBaseConfig): BuildOptions => {
     // external: ["graphology"],
 
     format: "esm",
-  }
-}
+  };
+};

package/src/esbuildConfigs/index.ts

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