testeranto 0.49.10 → 0.62.0

package/src/lib/abstractBase.ts

@@ -0,0 +1,459 @@
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { IBaseTest, IUtils } from "../Types";
+
+export type IGivens<
+  ITestShape extends IBaseTest
+> = Record<
+  string,
+  BaseGiven<
+    ITestShape
+  >
+>;
+
+export abstract class BaseSuite<
+  ITestShape extends IBaseTest
+> {
+  name: string;
+  givens: IGivens<
+    ITestShape
+  >;
+  checks: BaseCheck<
+    ITestShape
+  >[];
+  store: ITestShape['istore'];
+  fails: BaseGiven<
+    ITestShape
+  >[];
+  testResourceConfiguration: ITTestResourceConfiguration;
+  index: number;
+
+  constructor(
+    name: string,
+    index: number,
+    givens: IGivens<
+      ITestShape
+    > = {},
+    checks: BaseCheck<
+      ITestShape
+    >[] = []
+  ) {
+    this.name = name;
+    this.index = index;
+    this.givens = givens;
+    this.checks = checks;
+    this.fails = [];
+  }
+
+  public toObj() {
+    return {
+      name: this.name,
+      givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+      fails: this.fails,
+    };
+  }
+
+  setup(
+    s: ITestShape['iinput'],
+    artifactory: ITestArtifactory,
+    tr: ITTestResourceConfiguration,
+    utils: IUtils
+  ): Promise<ITestShape['isubject']> {
+    return new Promise((res) => res(s as unknown as ITestShape['isubject']));
+  }
+
+  assertThat(t: ITestShape['then']): unknown {
+    // console.log("base assertThat")
+    return t;
+  }
+
+  async run(
+    input: ITestShape['iinput'],
+    testResourceConfiguration: ITTestResourceConfiguration,
+    artifactory: (
+      fPath: string,
+      value: unknown
+    ) => void,
+    tLog: (...string) => void,
+    utils: IUtils
+  ): Promise<
+    BaseSuite<
+      ITestShape
+    >
+  > {
+    this.testResourceConfiguration = testResourceConfiguration;
+    tLog("test resources: ", testResourceConfiguration);
+
+    const suiteArtifactory = (fPath: string, value: unknown) =>
+      artifactory(`suite-${this.index}-${this.name}/${fPath}`, value)
+    const subject = await this.setup(
+      input,
+      suiteArtifactory,
+      testResourceConfiguration,
+      utils
+    );
+
+    tLog("\nSuite:", this.index, this.name);
+    for (const k of Object.keys(this.givens)) {
+      const giver = this.givens[k];
+      try {
+        this.store = await giver.give(
+          subject,
+          k,
+          testResourceConfiguration,
+          this.assertThat,
+          suiteArtifactory,
+          tLog,
+          utils
+        );
+      } catch (e) {
+        console.error(e);
+        this.fails.push(giver);
+        return this;
+      }
+    }
+    for (const [ndx, thater] of this.checks.entries()) {
+      await thater.check(
+        subject,
+        thater.name,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        utils
+      );
+    }
+
+    // @TODO fix me
+    for (const k of Object.keys(this.givens)) {
+      const giver = this.givens[k];
+      giver.afterAll(this.store, artifactory, utils);
+    }
+    ////////////////
+
+    return this;
+  }
+}
+
+export abstract class BaseGiven<
+  ITestShape extends IBaseTest
+> {
+  name: string;
+  features: string[];
+  whens: BaseWhen<
+    ITestShape
+  >[];
+  thens: BaseThen<
+    ITestShape
+  >[];
+  error: Error;
+  store: ITestShape['istore'];
+  recommendedFsPath: string;
+  givenCB: ITestShape['given'];
+  initialValues: any;
+
+  constructor(
+    name: string,
+    features: string[],
+    whens: BaseWhen<
+      ITestShape
+    >[],
+    thens: BaseThen<
+      ITestShape
+    >[],
+    givenCB: ITestShape['given'],
+    initialValues: any
+  ) {
+    this.name = name;
+    this.features = features;
+    this.whens = whens;
+    this.thens = thens;
+    this.givenCB = givenCB;
+    this.initialValues = initialValues;
+  }
+
+  beforeAll(
+    store: ITestShape['istore'],
+    artifactory: ITestArtifactory,
+
+  ) {
+    return store;
+  }
+
+  afterAll(
+    store: ITestShape['istore'],
+    artifactory: ITestArtifactory,
+    utils: IUtils
+  ) {
+    return store;
+  }
+
+  toObj() {
+    return {
+      name: this.name,
+      whens: this.whens.map((w) => w.toObj()),
+      thens: this.thens.map((t) => t.toObj()),
+      error: this.error ? [this.error, this.error.stack] : null,
+      features: this.features,
+    };
+  }
+
+  abstract givenThat(
+    subject: ITestShape['isubject'],
+    testResourceConfiguration,
+    artifactory: ITestArtifactory,
+    givenCB: ITestShape['given']
+  ): Promise<ITestShape['istore']>;
+
+  async afterEach(
+    store: ITestShape['istore'],
+    key: string,
+    artifactory: ITestArtifactory
+  ): Promise<unknown> {
+    return store;
+  }
+
+  async give(
+    subject: ITestShape['isubject'],
+    key: string,
+    testResourceConfiguration,
+    tester,
+    artifactory: ITestArtifactory,
+    tLog: ITLog,
+    utils: IUtils
+  ) {
+    tLog(`\n Given: ${this.name}`);
+
+    const givenArtifactory = (fPath: string, value: unknown) =>
+      artifactory(`given-${key}/${fPath}`, value)
+    try {
+      this.store = await this.givenThat(
+        subject,
+        testResourceConfiguration,
+        givenArtifactory,
+        this.givenCB
+      );
+
+      // tLog(`\n Given this.store`, this.store);
+      for (const whenStep of this.whens) {
+        await whenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          utils
+        );
+      }
+      for (const thenStep of this.thens) {
+        const t = await thenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          utils
+        );
+        tester(t);
+      }
+    } catch (e) {
+      this.error = e;
+      tLog(e);
+      tLog("\u0007"); // bell
+      // throw e;
+    } finally {
+      try {
+        await this.afterEach(this.store, key, givenArtifactory);
+      } catch (e) {
+        console.error("afterEach failed! no error will be recorded!", e);
+      }
+    }
+    return this.store;
+  }
+}
+
+export abstract class BaseWhen<
+  ITestShape extends IBaseTest
+> {
+  public name: string;
+  whenCB: (x: ITestShape['iselection']) => ITestShape['then'];
+  error: boolean;
+
+  constructor(
+    name: string,
+    whenCB: (xyz: ITestShape['iselection']) => ITestShape['then']) {
+    this.name = name;
+    this.whenCB = whenCB;
+  }
+
+  abstract andWhen(
+    store: ITestShape['istore'],
+    whenCB: (x: ITestShape['iselection']) => ITestShape['then'],
+    testResource
+  );
+
+  toObj() {
+    return {
+      name: this.name,
+      error: this.error,
+    };
+  }
+
+  async test(
+    store: ITestShape['istore'],
+    testResourceConfiguration,
+    tLog: ITLog,
+    utils: IUtils
+  ) {
+    tLog(" When:", this.name);
+    try {
+      return await this.andWhen(
+        store,
+        this.whenCB,
+        testResourceConfiguration
+      );
+    } catch (e) {
+      this.error = true;
+      throw e;
+    }
+  }
+}
+
+export abstract class BaseThen<
+  ITestShape extends IBaseTest
+> {
+  public name: string;
+  thenCB: (storeState: ITestShape['iselection']) => ITestShape['then'];
+  error: boolean;
+
+  constructor(name: string, thenCB: (val: ITestShape['iselection']) => ITestShape['then']) {
+    this.name = name;
+    this.thenCB = thenCB;
+  }
+
+  toObj() {
+    return {
+      name: this.name,
+      error: this.error,
+    };
+  }
+
+  abstract butThen(
+    store: ITestShape['istore'],
+    thenCB,
+    testResourceConfiguration?
+  ): Promise<ITestShape['iselection']>;
+
+  async test(
+    store: ITestShape['istore'],
+    testResourceConfiguration,
+    tLog: ITLog,
+    utils: IUtils
+  ): Promise<ITestShape['then'] | undefined> {
+    tLog(" Then:", this.name);
+    try {
+      const x = (await this.butThen(
+        store,
+        this.thenCB,
+        testResourceConfiguration
+      ));
+      return x;
+    } catch (e) {
+      console.log("test failed", e);
+      this.error = true;
+      throw e;
+    }
+  }
+}
+
+export abstract class BaseCheck<
+  ITestShape extends IBaseTest
+> {
+  name: string;
+  features: string[];
+  checkCB: (whens, thens) => any;
+  whens: {
+    [K in keyof ITestShape["whens"]]: (
+      p,
+      tc
+    ) => BaseWhen<
+      ITestShape
+    >;
+  };
+  thens: {
+    [K in keyof ITestShape["thens"]]: (
+      p,
+      tc
+    ) => BaseThen<
+      ITestShape
+    >;
+  };
+
+  constructor(
+    name: string,
+    features: string[],
+    checkCB: (whens, thens) => any,
+    whens,
+    thens
+  ) {
+    this.name = name;
+    this.features = features;
+    this.checkCB = checkCB;
+    this.whens = whens;
+    this.thens = thens;
+  }
+
+  abstract checkThat(
+    subject: ITestShape['isubject'],
+    testResourceConfiguration,
+    artifactory: ITestArtifactory
+  ): Promise<ITestShape['istore']>;
+
+  async afterEach(
+    store: ITestShape['istore'],
+    key: string,
+    cb?
+  ): Promise<unknown> {
+    return;
+  }
+
+  async check(
+    subject: ITestShape['isubject'],
+    key: string,
+    testResourceConfiguration,
+    tester,
+    artifactory: ITestArtifactory,
+    tLog: ITLog,
+    utils: IUtils
+  ) {
+    tLog(`\n Check: ${this.name}`);
+    const store = await this.checkThat(
+      subject,
+      testResourceConfiguration,
+      artifactory
+    );
+    await this.checkCB(
+      Object.entries(this.whens).reduce((a, [key, when]) => {
+        a[key] = async (payload) => {
+          return await when(payload, testResourceConfiguration).test(
+            store,
+            testResourceConfiguration,
+            tLog,
+            utils
+          );
+        };
+        return a;
+      }, {}),
+      Object.entries(this.thens).reduce((a, [key, then]) => {
+        a[key] = async (payload) => {
+          const t = await then(payload, testResourceConfiguration).test(
+            store,
+            testResourceConfiguration,
+            tLog,
+            utils
+          );
+          tester(t);
+        };
+        return a;
+      }, {})
+    );
+
+    await this.afterEach(store, key);
+    return;
+  }
+}

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