testeranto 0.49.9 → 0.62.0

package/src/lib/basebuilder.ts

@@ -0,0 +1,253 @@
+
+import {
+  IBaseTest,
+  ICheckKlasser,
+  IGivenKlasser,
+  ISuiteKlasser,
+  ITestSpecification,
+  IThenKlasser,
+  IUtils,
+  IWhenKlasser
+} from "../Types";
+
+import {
+
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+  BaseGiven
+} from "./abstractBase.js";
+
+import {
+  ITTestResourceRequest,
+  ITestJob,
+  ITLog,
+  ILogWriter,
+  ITTestResourceConfiguration,
+} from ".";
+export abstract class BaseBuilder<
+  ITestShape extends IBaseTest,
+  SuiteExtensions,
+  GivenExtensions,
+  WhenExtensions,
+  ThenExtensions,
+  CheckExtensions,
+> {
+
+  specs: any;
+
+  assertThis: (t: any) => {
+
+  }
+
+  testResourceRequirement: ITTestResourceRequest;
+  artifacts: Promise<unknown>[] = [];
+  testJobs: ITestJob[];
+  testSpecification: ITestSpecification<ITestShape>;
+  suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>;
+  givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>;
+  whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>;
+  thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>;
+  checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
+
+  constructor(
+    public readonly input: ITestShape['iinput'],
+    suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>,
+    givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>,
+    whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>,
+    thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>,
+    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
+    logWriter: ILogWriter,
+    testResourceRequirement: ITTestResourceRequest,
+    testSpecification: any,
+  ) {
+    this.artifacts = [];
+    this.testResourceRequirement = testResourceRequirement;
+    this.suitesOverrides = suitesOverrides;
+    this.givenOverides = givenOverides;
+    this.whenOverides = whenOverides;
+    this.thenOverides = thenOverides;
+    this.checkOverides = checkOverides;
+    this.testSpecification = testSpecification;
+
+    this.specs = testSpecification(
+      this.Suites(),
+      this.Given(),
+      this.When(),
+      this.Then(),
+      this.Check(),
+    );
+
+    const suiteRunner = (
+      suite: BaseSuite<ITestShape>,
+      utils: IUtils
+    ) =>
+      async (
+        testResourceConfiguration: ITTestResourceConfiguration,
+        tLog: ITLog,
+        utils: IUtils
+      ): Promise<BaseSuite<
+        ITestShape
+      >> => {
+        return await suite.run(
+          input,
+          testResourceConfiguration,
+          (
+            fPath: string,
+            value: unknown
+          ) =>
+            logWriter.testArtiFactoryfileWriter(tLog, (p: Promise<void>) => {
+              this.artifacts.push(p);
+            })(
+              testResourceConfiguration.fs + "/" + fPath,
+              value
+            ),
+          tLog,
+          utils
+        );
+      };
+
+    this.testJobs = this.specs.map((
+      suite: BaseSuite<ITestShape>,
+      utils: IUtils
+    ) => {
+      const runner = suiteRunner(suite, utils);
+
+      return {
+        test: suite,
+        testResourceRequirement,
+
+        toObj: () => {
+          return suite.toObj();
+        },
+
+        runner,
+
+        receiveTestResourceConfig: async function (
+          testResourceConfiguration = {
+            name: "",
+            fs: ".",
+            ports: [],
+            scheduled: false
+          },
+          y: IUtils
+        ) {
+          console.log(
+            `testResourceConfiguration ${JSON.stringify(
+              testResourceConfiguration,
+              null,
+              2
+            )}`
+          );
+          await logWriter.mkdirSync(testResourceConfiguration.fs);
+          logWriter.writeFileSync(
+            `${testResourceConfiguration.fs}/tests.json`,
+            JSON.stringify(this.toObj(), null, 2)
+          );
+
+          const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
+
+          const access = await logWriter.createWriteStream(logFilePath);
+
+          const tLog = (...l: string[]) => {
+            // console.log(...l);
+            access.write(`${l.toString()}\n`);
+          };
+          const suiteDone: BaseSuite<
+            ITestShape
+          > = await runner(testResourceConfiguration, tLog, y);
+          const resultsFilePath = (
+            `${testResourceConfiguration.fs}/results.json`
+          );
+
+          logWriter.writeFileSync(
+            resultsFilePath,
+            JSON.stringify(suiteDone.toObj(), null, 2)
+          );
+
+          const logPromise = new Promise((res, rej) => {
+            access.on("finish", () => { res(true); });
+          })
+          access.end();
+
+          const numberOfFailures = Object.keys(suiteDone.givens).filter(
+            (k) => {
+              // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
+              return suiteDone.givens[k].error
+            }
+          ).length;
+          console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+          return {
+            failed: numberOfFailures,
+            artifacts: this.artifacts || [],
+            logPromise
+          };
+        },
+      };
+    });
+  }
+
+  Specs() {
+    return this.specs;
+  }
+  Suites() {
+    return this.suitesOverrides;
+  }
+
+  Given(): Record<
+    keyof GivenExtensions,
+    (
+      name: string,
+      features: string[],
+      whens: BaseWhen<
+        ITestShape
+      >[],
+      thens: BaseThen<
+        ITestShape
+      >[],
+      gcb,
+    ) => BaseGiven<
+      ITestShape
+    >
+  > {
+    return this.givenOverides;
+  }
+
+  When(): Record<
+    keyof WhenExtensions,
+    (arg0: ITestShape['istore'], ...arg1: any) =>
+      BaseWhen<
+        ITestShape
+      >
+  > {
+    return this.whenOverides;
+  }
+
+  Then(): Record<
+    keyof ThenExtensions,
+    (
+      selection: ITestShape['iselection'],
+      expectation: any
+    ) => BaseThen<
+      ITestShape
+    >
+  > {
+    return this.thenOverides;
+  }
+
+  Check(): Record<
+    keyof CheckExtensions,
+    (
+      feature: string,
+      callback: (whens, thens) => any,
+      whens,
+      thens,
+      x
+    ) => BaseCheck<
+      ITestShape
+    >
+  > {
+    return this.checkOverides;
+  }
+}

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
+  >;
+};
+