testeranto 0.47.34 → 0.47.52

package/src/lib/basebuilder.ts

@@ -0,0 +1,214 @@
+import { PassThrough } from "stream";
+
+import { ITTestResourceRequest, ITestJob, ITLog } from ".";
+import { IBaseTest, ITestSpecification } from "../Types.js";
+
+import {
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "./types.js";
+import {
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+  BaseGiven,
+} from "./abstractBase.js";
+import { PM } from "../PM/index.js";
+
+export abstract class BaseBuilder<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >,
+  SuiteExtensions,
+  GivenExtensions,
+  WhenExtensions,
+  ThenExtensions,
+  CheckExtensions
+> {
+  specs: any;
+
+  assertThis: (t: ITestShape["then"]) => {};
+
+  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>>;
+  puppetMaster: PM;
+
+  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>>,
+    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()
+    );
+
+    this.testJobs = this.specs.map((suite: BaseSuite<ITestShape>) => {
+      const suiteRunner =
+        (suite: BaseSuite<ITestShape>) =>
+        async (
+          puppetMaster: PM,
+          tLog: ITLog
+        ): Promise<BaseSuite<ITestShape>> => {
+          await puppetMaster.startPuppeteer(
+            {
+              browserWSEndpoint:
+                puppetMaster.testResourceConfiguration.browserWSEndpoint,
+            },
+            puppetMaster.testResourceConfiguration.fs
+          );
+
+          return await suite.run(
+            input,
+            puppetMaster.testResourceConfiguration,
+            (fPath: string, value: string | Buffer | PassThrough) =>
+              puppetMaster.testArtiFactoryfileWriter(
+                tLog,
+                (p: Promise<void>) => {
+                  this.artifacts.push(p);
+                }
+              )(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value),
+            tLog,
+            puppetMaster
+          );
+        };
+
+      const runner = suiteRunner(suite);
+
+      return {
+        test: suite,
+
+        toObj: () => {
+          return suite.toObj();
+        },
+
+        runner,
+
+        receiveTestResourceConfig: async function (puppetMaster: PM) {
+          await puppetMaster.mkdirSync();
+
+          const logFilePath = "log.txt";
+          const access = await puppetMaster.createWriteStream(logFilePath);
+          const tLog = (...l: string[]) => {
+            puppetMaster.write(access, `${l.toString()}\n`);
+          };
+
+          const suiteDone: BaseSuite<ITestShape> = await runner(
+            puppetMaster,
+            tLog
+          );
+
+          const logPromise = new Promise((res, rej) => {
+            puppetMaster.end(access);
+            res(true);
+          });
+
+          const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+            return suiteDone.givens[k].error;
+          }).length;
+          puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
+
+          puppetMaster.writeFileSync(
+            `tests.json`,
+            JSON.stringify(this.toObj(), null, 2)
+          );
+          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/classBuilder.ts

@@ -0,0 +1,131 @@
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../Types.js";
+
+import { BaseBuilder } from "./basebuilder.js";
+
+import {
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "./types.js";
+import { PM } from "../PM/index.js";
+import { ITTestResourceRequest } from "./index.js";
+
+export abstract class ClassBuilder<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> 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
+  ) {
+    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,
+      testResourceRequirement,
+      testSpecification
+      // puppetMaster
+    );
+  }
+}

package/src/lib/core.ts

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