testeranto 0.62.0 → 0.70.0

package/src/lib/core.ts

@@ -1,7 +1,11 @@
-import type {
-  IBaseTest, ITestImplementation, ITestInterface, ITestSpecification, IUtils
-} from "../Types";
+import { IStore } from "../SubPackages/react/jsx";
+import {
+  IBaseTest,
+  ITestSpecification,
+  ITestImplementation,
+} from "../Types.js";
 
+import { ITestInterface, IUtils } from "./types.js";
 import {
   DefaultTestInterface,
   ILogWriter,
@@ -9,24 +13,27 @@ import {
   ITTestResourceRequest,
   ITestArtifactory,
   ITestJob,
-  defaultTestResourceRequirement
+  defaultTestResourceRequirement,
 } from "./index.js";
 import {
-  BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+  BaseCheck,
 } from "./abstractBase.js";
-import {
-  ClassBuilder
-} from "./classBuilder.js";
-import { IStore } from "../SubPackages/react/jsx";
+import { ClassBuilder } from "./classBuilder.js";
 
-export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
+export default abstract class Testeranto<
+  ITestShape extends IBaseTest
+> extends ClassBuilder<ITestShape> {
   constructor(
-    input: ITestShape['iinput'],
+    input: ITestShape["iinput"],
     testSpecification: ITestSpecification<ITestShape>,
-    testImplementation: ITestImplementation<ITestShape, object>,
+    testImplementation: ITestImplementation<ITestShape>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
     logWriter: ILogWriter,
-    testInterface: Partial<ITestInterface<ITestShape>>,
+    testInterface: Partial<ITestInterface<ITestShape>>
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
 
@@ -35,39 +42,30 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
       testSpecification,
       input,
 
-      class extends BaseSuite<
-        ITestShape
-      > {
-
+      class extends BaseSuite<ITestShape> {
         assertThat(t) {
           fullTestInterface.assertThis(t);
         }
 
         async setup(
-          s: ITestShape['iinput'],
+          s: ITestShape["iinput"],
           artifactory: ITestArtifactory,
           tr,
-          // utils: ITestInterface<ITestShape>
-        ): Promise<
-          ITestShape['isubject']
-        > {
-          return (fullTestInterface.beforeAll || (async (
-            input: ITestShape['iinput'],
-            artifactory: ITestArtifactory,
-            tr,
-            // utils: ITestInterface<ITestShape>
-          ) => input as any))(
-            s,
-            this.testResourceConfiguration,
-            artifactory
-          );
+          utils
+        ): Promise<ITestShape["isubject"]> {
+          return (
+            fullTestInterface.beforeAll ||
+            (async (
+              input: ITestShape["iinput"],
+              artifactory: ITestArtifactory,
+              tr,
+              utils: ITestInterface<ITestShape>
+            ) => input as any)
+          )(s, this.testResourceConfiguration, artifactory, utils);
         }
       } as any,
 
-      class Given extends BaseGiven<
-        ITestShape
-      > {
-
+      class Given extends BaseGiven<ITestShape> {
         async givenThat(subject, testResource, artifactory, initializer) {
           return fullTestInterface.beforeEach(
             subject,
@@ -76,61 +74,87 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
               // TODO does not work?
               artifactory(`beforeEach/${fPath}`, value),
             testResource,
-            this.initialValues,
+            this.initialValues
             // utils,
           );
         }
 
         afterEach(
-          store: ITestShape['istore'],
+          store: ITestShape["istore"],
           key: string,
-          artifactory
+          artifactory,
+          utils
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(fullTestInterface.afterEach(store, key, (fPath: string, value: unknown) =>
-              artifactory(`after/${fPath}`, value)))
+            res(
+              fullTestInterface.afterEach(
+                store,
+                key,
+                (fPath: string, value: unknown) =>
+                  artifactory(`after/${fPath}`, value),
+                utils
+              )
+            )
           );
         }
-        afterAll(
-          store: IStore,
-          artifactory: ITestArtifactory,
-          utils: IUtils,
-        ) {
-          return fullTestInterface.afterAll(store, (fPath: string, value: unknown) =>
-          // TODO does not work?
-          { artifactory(`afterAll4-${this.name}/${fPath}`, value) },
+        afterAll(store: IStore, artifactory: ITestArtifactory, utils: IUtils) {
+          const pagesHandler = {
+            get(target, prop) {
+              console.log(`Getting pages property ${prop}`);
+              return target[prop];
+            },
+          };
+
+          const browserHandler = {
+            get(target, prop) {
+              console.log(`Getting browser property ${prop}`);
+              if (prop === "pages") {
+                // return target[prop];
+                return new Proxy(target[prop], pagesHandler);
+              } else {
+                return target[prop];
+              }
+            },
+          };
+          const proxy = new Proxy(utils.browser, browserHandler);
+
+          return fullTestInterface.afterAll(
+            store,
+            (fPath: string, value: unknown) =>
+              // TODO does not work?
+              {
+                artifactory(`afterAll4-${this.name}/${fPath}`, value);
+              },
             utils
+            // {
+            //   ...utils,
+            //   browser: proxy,
+            // }
           );
         }
       } as any,
 
-      class When extends BaseWhen<
-        ITestShape
-      > {
+      class When extends BaseWhen<ITestShape> {
         async andWhen(store, whenCB, testResource) {
           return await fullTestInterface.andWhen(store, whenCB, testResource);
         }
       } as any,
 
-      class Then extends BaseThen<
-        ITestShape
-      > {
-
+      class Then extends BaseThen<ITestShape> {
         async butThen(
           store: any,
           thenCB,
           testResourceConfiguration?: any
-        ): Promise<ITestShape['iselection']> {
+        ): Promise<ITestShape["iselection"]> {
           return await fullTestInterface.butThen(
             store,
             thenCB,
-            testResourceConfiguration);
+            testResourceConfiguration
+          );
         }
       } as any,
 
-      class Check extends BaseCheck<
-        ITestShape
-      > {
+      class Check extends BaseCheck<ITestShape> {
         initialValues: any;
 
         constructor(
@@ -149,27 +173,36 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
           return fullTestInterface.beforeEach(
             subject,
             this.initialValues,
-            (fPath: string, value: unknown) => artifactory(`before/${fPath}`, value),
+            (fPath: string, value: unknown) =>
+              artifactory(`before/${fPath}`, value),
             testResourceConfiguration,
             this.initialValues
           );
         }
 
         afterEach(
-          store: ITestShape['istore'],
+          store: ITestShape["istore"],
           key: string,
-          artifactory
+          artifactory,
+          utils
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(fullTestInterface.afterEach(store, key, (fPath: string, value: unknown) =>
-              // TODO does not work?
-              artifactory(`afterEach2-${this.name}/${fPath}`, value)))
+            res(
+              fullTestInterface.afterEach(
+                store,
+                key,
+                (fPath: string, value: unknown) =>
+                  // TODO does not work?
+                  artifactory(`afterEach2-${this.name}/${fPath}`, value),
+                utils
+              )
+            )
           );
         }
       } as any,
 
       testResourceRequirement,
-      logWriter,
+      logWriter
     );
   }
 
@@ -178,5 +211,4 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
     partialTestResource: ITTestResourceConfiguration,
     utils: IUtils
   );
-
 }

package/src/lib/index.ts

@@ -1,23 +1,39 @@
+import { IBaseTest } from "../Types.js";
 
-import { IBaseTest, ITestInterface, IUtils } from "../Types.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase.js";
+
+import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
 
 export const BaseTestInterface: ITestInterface<IBaseTest> = {
-  beforeAll: (async (s) => s),
-  beforeEach: async function (subject: any, initialValues: any, testResource: any) { return subject as any; },
-  afterEach: (async (s) => s),
-  afterAll: ((store: IBaseTest['istore']) => undefined),
-  butThen: (async (store: IBaseTest['istore'], thenCb) => thenCb(store)),
-  andWhen: ((a) => a),
-  assertThis: (() => null),
+  beforeAll: async (s) => s,
+  beforeEach: async function (
+    subject: any,
+    initialValues: any,
+    testResource: any
+  ) {
+    return subject as any;
+  },
+  afterEach: async (s) => s,
+  afterAll: (store: IBaseTest["istore"]) => undefined,
+  butThen: async (store: IBaseTest["istore"], thenCb) => thenCb(store),
+  andWhen: (a) => a,
+  assertThis: () => null,
 };
 
-export const DefaultTestInterface = (p: Partial<ITestInterface<any>>): ITestInterface<any> => {
+export const DefaultTestInterface = (
+  p: Partial<ITestInterface<any>>
+): ITestInterface<any> => {
   return {
     ...BaseTestInterface,
-    ...p
-  }
-}
+    ...p,
+  };
+};
 
 export type ITTestResourceConfiguration = {
   name: string;
@@ -39,51 +55,47 @@ export type ITTestResourceRequest = {
 export type ITLog = (...string) => void;
 
 export type ILogWriter = {
-  createWriteStream: (line: string) => any | any,
-  writeFileSync: (fp: string, contents: string) => any
-  mkdirSync: (fp: string) => any
-  testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise) => void) =>
-    (fPath: string, value: unknown) =>
-      void
-}
+  createWriteStream: (line: string) => any | any;
+  writeFileSync: (fp: string, contents: string) => any;
+  mkdirSync: (fp: string) => any;
+  testArtiFactoryfileWriter: (
+    tLog: ITLog,
+    n: (Promise) => void
+  ) => (fPath: string, value: unknown) => void;
+};
 
 export type ITestArtificer = (key: string, data: any) => void;
 
 type ITest = {
   toObj(): object;
   name: string;
-  givens: IGivens<
-    IBaseTest
-  >;
-  checks: BaseCheck<
-    IBaseTest
-  >[];
+  givens: IGivens<IBaseTest>;
+  checks: BaseCheck<IBaseTest>[];
   testResourceConfiguration: ITTestResourceConfiguration;
 };
 
-export type ITestJob = {
+export type ITestJob<T = INodeUtils | IWebUtils> = {
   toObj(): object;
   test: ITest;
-  runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<
-    BaseSuite<
-      IBaseTest
-    >
-  >;
+  runner: (
+    x: ITTestResourceConfiguration,
+    t: ITLog
+  ) => Promise<BaseSuite<IBaseTest>>;
   testResourceRequirement: ITTestResourceRequirement;
   receiveTestResourceConfig: (
     testResource,
-    utils: IUtils
+    utils: T
   ) => Promise<{
-    failed: number,
-    artifacts: Promise<unknown>[],
-    logPromise: Promise<unknown>
-  }>
+    failed: number;
+    artifacts: Promise<unknown>[];
+    logPromise: Promise<unknown>;
+  }>;
 };
 
 export type ITestResults = Promise<{ test: ITest }>[];
 
 export const defaultTestResourceRequirement: ITTestResourceRequest = {
-  ports: 0
+  ports: 0,
 };
 
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
@@ -94,23 +106,12 @@ export type ITestCheckCallback<ITestShape extends IBaseTest> = {
     features: string[],
     callbackA: (
       whens: {
-        [K in keyof ITestShape["whens"]]: (
-          ...unknown
-        ) => BaseWhen<
-          ITestShape
-        >;
+        [K in keyof ITestShape["whens"]]: (...unknown) => BaseWhen<ITestShape>;
       },
       thens: {
-        [K in keyof ITestShape["thens"]]: (
-          ...unknown
-        ) => BaseThen<
-          ITestShape
-        >;
+        [K in keyof ITestShape["thens"]]: (...unknown) => BaseThen<ITestShape>;
       }
     ) => Promise<any>,
     ...xtrasA: ITestShape["checks"][K]
-  ) => BaseCheck<
-    ITestShape
-  >;
+  ) => BaseCheck<ITestShape>;
 };
-

package/src/lib/types.ts

@@ -0,0 +1,206 @@
+import { IBaseTest } from "../Types";
+
+import puppeteer from "puppeteer-core";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase";
+import { ITTestResourceConfiguration, ITestArtificer } from ".";
+
+export type IRunTime = `node` | `web`;
+
+export type ITestTypes = [string, IRunTime, ITestTypes[]];
+
+export type IJsonConfig = {
+  outdir: string;
+  tests: ITestTypes[];
+  features: string;
+};
+
+export type IBaseConfig = {
+  clearScreen: boolean;
+  debugger: boolean;
+  devMode: boolean;
+  externals: string[];
+  features: string;
+  minify: boolean;
+  nodePlugins: any[];
+  outbase: string;
+  outdir: string;
+  ports: string[];
+  tests: ITestTypes[];
+  webPlugins: any[];
+};
+
+export type IBuiltConfig = { buildDir: string } & IBaseConfig;
+
+export type INodeUtils = {
+  browser: puppeteer.Browser;
+  ipc: Electron.ParentPort;
+};
+
+export type IWebUtils = {
+  browser: puppeteer.Browser;
+  ipc: Electron.IpcRenderer;
+};
+export type IUtils = INodeUtils | IWebUtils;
+
+export type IWebTestInterface<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: IWebUtils
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    utils: IWebUtils
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    utils: IWebUtils
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues
+    // utils: IUtils
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+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,
+    utils: INodeUtils
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    utils: INodeUtils
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    utils: INodeUtils
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues
+    // utils: IUtils
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+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 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>;

package/src/preload.ts

@@ -1,33 +1,17 @@
-import { ipcRenderer } from "electron";
+import puppeteer from "puppeteer-core";
 
-console.log("hello preloader");
 import { NodeWriter } from "./NodeWriter";
+import puppeteerConfiger from "./puppeteerConfiger";
 
 (window as any).NodeWriter = NodeWriter;
-(window as any).exit = (x) => {
-  ipcRenderer.invoke('quit-app', x);
-}
 
-// var oldLog = console.log;
-// console.log = function (message) {
-//   ipcRenderer.invoke('web-log', message.toString());
-//   oldLog.apply(console, arguments);
-// };
-
-// var oldLog = console.error;
-// console.error = function (message) {
-//   ipcRenderer.invoke('web-error', message.toString());
-//   oldLog.apply(console, arguments);
-// };
-
-// var oldLog = console.warn;
-// console.warn = function (message) {
-//   ipcRenderer.invoke('web-warn', message.toString());
-//   oldLog.apply(console, arguments);
-// };
-
-// var oldLog = console.info;
-// console.info = function (message) {
-//   ipcRenderer.invoke('web-info', message.toString());
-//   oldLog.apply(console, arguments);
-// };
+(window as any).browser = new Promise(async (res, rej) => {
+  const browser = await puppeteerConfiger("2999").then(async (json) => {
+    const b = await puppeteer.connect({
+      browserWSEndpoint: json.webSocketDebuggerUrl,
+      defaultViewport: null,
+    });
+    console.log("connected!", b.isConnected());
+    return res(b);
+  });
+});