testeranto 0.49.10 → 0.62.0

package/src/lib/browser.ts

@@ -0,0 +1,34 @@
+import { Browser, Page } from "puppeteer-core";
+
+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();
+  // }
+}

package/src/lib/classBuilder.ts

@@ -0,0 +1,137 @@
+import type {
+  IBaseTest,
+  ICheckKlasser,
+  IGivenKlasser,
+  ISuiteKlasser,
+  ITestImplementation,
+  ITestSpecification,
+  IThenKlasser,
+  IWhenKlasser,
+} from "../Types";
+
+
+import {
+  BaseBuilder
+} from "./basebuilder.js";
+
+import {
+  ILogWriter,
+  ITTestResourceRequest
+} from ".";
+
+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,182 @@
+import type {
+  IBaseTest, ITestImplementation, ITestInterface, ITestSpecification, IUtils
+} from "../Types";
+
+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";
+import { IStore } from "../SubPackages/react/jsx";
+
+export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
+  constructor(
+    input: ITestShape['iinput'],
+    testSpecification: ITestSpecification<ITestShape>,
+    testImplementation: ITestImplementation<ITestShape, object>,
+    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: 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
+          );
+        }
+      } 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
+        ): Promise<unknown> {
+          return new Promise((res) =>
+            res(fullTestInterface.afterEach(store, key, (fPath: string, value: unknown) =>
+              artifactory(`after/${fPath}`, value)))
+          );
+        }
+        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) },
+            utils
+          );
+        }
+      } 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
+        ): 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)))
+          );
+        }
+      } as any,
+
+      testResourceRequirement,
+      logWriter,
+    );
+  }
+
+  abstract receiveTestResourceConfig(
+    t: ITestJob,
+    partialTestResource: ITTestResourceConfiguration,
+    utils: IUtils
+  );
+
+}

package/src/lib/index.ts

@@ -0,0 +1,116 @@
+
+import { IBaseTest, ITestInterface, IUtils } from "../Types.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.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 = {
+  toObj(): object;
+  test: ITest;
+  runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<
+    BaseSuite<
+      IBaseTest
+    >
+  >;
+  testResourceRequirement: ITTestResourceRequirement;
+  receiveTestResourceConfig: (
+    testResource,
+    utils: IUtils
+  ) => 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/nodeWriterElectron.ts

@@ -0,0 +1,71 @@
+// import fs from "fs";
+const fs = require("fs");
+// import path from "path";
+const path = require("path");
+import { PassThrough } from "stream";
+
+import { ILogWriter, ITLog } from "./lib/index.js";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export const NodeWriterElectron: ILogWriter = {
+  createWriteStream: (filepath: string): fs.WriteStream => {
+    return fs.createWriteStream(filepath);
+  },
+  writeFileSync: (fp: string, contents: string) => {
+    fs.writeFileSync(
+      fp,
+      contents
+    );
+  },
+  mkdirSync: async (fp: string) => {
+    await fs.mkdirSync(fp, { recursive: true });
+  },
+  testArtiFactoryfileWriter:
+    (tLog: ITLog, callback: (Promise) => void) =>
+      (fPath, value: string | Buffer | PassThrough) => {
+        callback(new Promise<void>((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+
+          const cleanPath = path.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`❗️testArtiFactory failed`, targetDir, error);
+            }
+
+            fs.writeFileSync(
+              path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"),
+              fPaths.join(`\n`),
+              {
+                encoding: "utf-8",
+              }
+            );
+
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8",
+              });
+              res();
+            } else {
+              /* @ts-ignore:next-line */
+              const pipeStream: PassThrough = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        }))
+
+      }
+}

package/src/preload.ts

@@ -1,31 +1,33 @@
-import { NodeWriter } from "./NodeWriter";
 import { ipcRenderer } from "electron";
 
+console.log("hello preloader");
+import { NodeWriter } from "./NodeWriter";
+
 (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.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.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.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);
-};
+// var oldLog = console.info;
+// console.info = function (message) {
+//   ipcRenderer.invoke('web-info', message.toString());
+//   oldLog.apply(console, arguments);
+// };

package/src/report.html.ts

@@ -0,0 +1,29 @@
+export default () => `
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <link rel="stylesheet" href="./Report.css">
+
+  <script type="importmap">
+    {
+    "imports": {
+      "features.test.js": "./features.test.js",
+      "testeranto.json": "./testeranto.json"
+    }
+  }
+  </script>
+
+  <script type="module" src="./Report.js"></script>
+</head>
+
+<body><div id="root">react is loading</div></body>
+
+</html>
+`;

package/src/web.html.ts

@@ -0,0 +1,20 @@
+export default (jsfilePath: string, htmlFilePath: string) => `
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <script type="module" src="${jsfilePath}"></script>
+
+</head>
+
+<body>
+  <h1>${htmlFilePath}</h1>
+  <div id="root">
+
+  </div>
+</body>
+
+<footer></footer>
+
+</html>
+`