testeranto 0.49.10 → 0.70.0

package/src/lib/classBuilder.ts

@@ -0,0 +1,118 @@
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../Types.js";
+
+import { BaseBuilder } from "./basebuilder.js";
+
+import { ILogWriter, ITTestResourceRequest } from ".";
+import {
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "./types.js";
+
+export abstract class ClassBuilder<
+  ITestShape extends IBaseTest
+> extends BaseBuilder<ITestShape, any, any, any, any, any> {
+  constructor(
+    testImplementation: ITestImplementation<ITestShape, any>,
+    testSpecification: ITestSpecification<ITestShape>,
+    input: ITestShape["iinput"],
+    suiteKlasser: ISuiteKlasser<ITestShape>,
+    givenKlasser: IGivenKlasser<ITestShape>,
+    whenKlasser: IWhenKlasser<ITestShape>,
+    thenKlasser: IThenKlasser<ITestShape>,
+    checkKlasser: ICheckKlasser<ITestShape>,
+    testResourceRequirement: ITTestResourceRequest,
+    logWriter: ILogWriter
+  ) {
+    const classySuites = Object.entries(testImplementation.suites).reduce(
+      (a, [key], index) => {
+        a[key] = (somestring, givens, checks) => {
+          return new suiteKlasser.prototype.constructor(
+            somestring,
+            index,
+            givens,
+            checks
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyGivens = Object.entries(testImplementation.givens).reduce(
+      (a, [key, givEn]) => {
+        a[key] = (features, whens, thens, givEn) => {
+          return new givenKlasser.prototype.constructor(
+            key,
+            features,
+            whens,
+            thens,
+            testImplementation.givens[key],
+            givEn
+          );
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyWhens = Object.entries(testImplementation.whens).reduce(
+      (a, [key, whEn]: [string, (x) => any]) => {
+        a[key] = (payload?: any) => {
+          return new whenKlasser.prototype.constructor(
+            `${whEn.name}: ${payload && payload.toString()}`,
+            whEn(payload)
+          );
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyThens = Object.entries(testImplementation.thens).reduce(
+      (a, [key, thEn]: [string, (x) => any]) => {
+        a[key] = (expected: any, x) => {
+          return new thenKlasser.prototype.constructor(
+            `${thEn.name}: ${expected && expected.toString()}`,
+            thEn(expected)
+          );
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyChecks = Object.entries(testImplementation.checks).reduce(
+      (a, [key, z]) => {
+        a[key] = (somestring, features, callback) => {
+          return new checkKlasser.prototype.constructor(
+            somestring,
+            features,
+            callback,
+            classyWhens,
+            classyThens
+          );
+        };
+        return a;
+      },
+      {}
+    );
+
+    super(
+      input,
+      classySuites,
+      classyGivens,
+      classyWhens,
+      classyThens,
+      classyChecks,
+      logWriter,
+      testResourceRequirement,
+      testSpecification
+    );
+  }
+}

package/src/lib/core.ts

@@ -0,0 +1,214 @@
+import { IStore } from "../SubPackages/react/jsx";
+import {
+  IBaseTest,
+  ITestSpecification,
+  ITestImplementation,
+} from "../Types.js";
+
+import { ITestInterface, IUtils } from "./types.js";
+import {
+  DefaultTestInterface,
+  ILogWriter,
+  ITTestResourceConfiguration,
+  ITTestResourceRequest,
+  ITestArtifactory,
+  ITestJob,
+  defaultTestResourceRequirement,
+} from "./index.js";
+import {
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+  BaseCheck,
+} from "./abstractBase.js";
+import { ClassBuilder } from "./classBuilder.js";
+
+export default abstract class Testeranto<
+  ITestShape extends IBaseTest
+> extends ClassBuilder<ITestShape> {
+  constructor(
+    input: ITestShape["iinput"],
+    testSpecification: ITestSpecification<ITestShape>,
+    testImplementation: ITestImplementation<ITestShape>,
+    testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+    logWriter: ILogWriter,
+    testInterface: Partial<ITestInterface<ITestShape>>
+  ) {
+    const fullTestInterface = DefaultTestInterface(testInterface);
+
+    super(
+      testImplementation,
+      testSpecification,
+      input,
+
+      class extends BaseSuite<ITestShape> {
+        assertThat(t) {
+          fullTestInterface.assertThis(t);
+        }
+
+        async setup(
+          s: ITestShape["iinput"],
+          artifactory: ITestArtifactory,
+          tr,
+          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> {
+        async givenThat(subject, testResource, artifactory, initializer) {
+          return fullTestInterface.beforeEach(
+            subject,
+            initializer,
+            (fPath: string, value: unknown) =>
+              // TODO does not work?
+              artifactory(`beforeEach/${fPath}`, value),
+            testResource,
+            this.initialValues
+            // utils,
+          );
+        }
+
+        afterEach(
+          store: ITestShape["istore"],
+          key: string,
+          artifactory,
+          utils
+        ): Promise<unknown> {
+          return new Promise((res) =>
+            res(
+              fullTestInterface.afterEach(
+                store,
+                key,
+                (fPath: string, value: unknown) =>
+                  artifactory(`after/${fPath}`, value),
+                utils
+              )
+            )
+          );
+        }
+        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> {
+        async andWhen(store, whenCB, testResource) {
+          return await fullTestInterface.andWhen(store, whenCB, testResource);
+        }
+      } as any,
+
+      class Then extends BaseThen<ITestShape> {
+        async butThen(
+          store: any,
+          thenCB,
+          testResourceConfiguration?: any
+        ): Promise<ITestShape["iselection"]> {
+          return await fullTestInterface.butThen(
+            store,
+            thenCB,
+            testResourceConfiguration
+          );
+        }
+      } as any,
+
+      class Check extends BaseCheck<ITestShape> {
+        initialValues: any;
+
+        constructor(
+          name: string,
+          features: string[],
+          checkCallback: (a, b) => any,
+          whens,
+          thens,
+          initialValues: any
+        ) {
+          super(name, features, checkCallback, whens, thens);
+          this.initialValues = initialValues;
+        }
+
+        async checkThat(subject, testResourceConfiguration, artifactory) {
+          return fullTestInterface.beforeEach(
+            subject,
+            this.initialValues,
+            (fPath: string, value: unknown) =>
+              artifactory(`before/${fPath}`, value),
+            testResourceConfiguration,
+            this.initialValues
+          );
+        }
+
+        afterEach(
+          store: ITestShape["istore"],
+          key: string,
+          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),
+                utils
+              )
+            )
+          );
+        }
+      } as any,
+
+      testResourceRequirement,
+      logWriter
+    );
+  }
+
+  abstract receiveTestResourceConfig(
+    t: ITestJob,
+    partialTestResource: ITTestResourceConfiguration,
+    utils: IUtils
+  );
+}

package/src/lib/index.ts

@@ -0,0 +1,117 @@
+import { IBaseTest } from "../Types.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,
+};
+
+export const DefaultTestInterface = (
+  p: Partial<ITestInterface<any>>
+): ITestInterface<any> => {
+  return {
+    ...BaseTestInterface,
+    ...p,
+  };
+};
+
+export type ITTestResourceConfiguration = {
+  name: string;
+  fs: string;
+  ports: number[];
+  scheduled: boolean;
+};
+
+export type ITTestResourceRequirement = {
+  name: string;
+  ports: number;
+  fs: string;
+};
+
+export type ITTestResourceRequest = {
+  ports: number;
+};
+
+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;
+};
+
+export type ITestArtificer = (key: string, data: any) => void;
+
+type ITest = {
+  toObj(): object;
+  name: string;
+  givens: IGivens<IBaseTest>;
+  checks: BaseCheck<IBaseTest>[];
+  testResourceConfiguration: ITTestResourceConfiguration;
+};
+
+export type ITestJob<T = INodeUtils | IWebUtils> = {
+  toObj(): object;
+  test: ITest;
+  runner: (
+    x: ITTestResourceConfiguration,
+    t: ITLog
+  ) => Promise<BaseSuite<IBaseTest>>;
+  testResourceRequirement: ITTestResourceRequirement;
+  receiveTestResourceConfig: (
+    testResource,
+    utils: T
+  ) => Promise<{
+    failed: number;
+    artifacts: Promise<unknown>[];
+    logPromise: Promise<unknown>;
+  }>;
+};
+
+export type ITestResults = Promise<{ test: ITest }>[];
+
+export const defaultTestResourceRequirement: ITTestResourceRequest = {
+  ports: 0,
+};
+
+export type ITestArtifactory = (key: string, value: unknown) => unknown;
+
+export type ITestCheckCallback<ITestShape extends IBaseTest> = {
+  [K in keyof ITestShape["checks"]]: (
+    name: string,
+    features: string[],
+    callbackA: (
+      whens: {
+        [K in keyof ITestShape["whens"]]: (...unknown) => BaseWhen<ITestShape>;
+      },
+      thens: {
+        [K in keyof ITestShape["thens"]]: (...unknown) => BaseThen<ITestShape>;
+      }
+    ) => Promise<any>,
+    ...xtrasA: ITestShape["checks"][K]
+  ) => 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,31 +1,17 @@
+import puppeteer from "puppeteer-core";
+
 import { NodeWriter } from "./NodeWriter";
-import { ipcRenderer } from "electron";
+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);
+  });
+});