testeranto 0.197.0 → 0.198.0

package/dist/types/src/lib/classBuilder.test/classBuilder.test.d.ts

@@ -1,3 +0,0 @@
-import { I, O, M } from "./classBuilder.test.types";
-declare const _default: Promise<import("../core").default<I, O, M>>;
-export default _default;

package/dist/types/src/lib/classBuilder.test/classBuilder.test.implementation.d.ts

@@ -1,3 +0,0 @@
-import { ITestImplementation } from "../../CoreTypes";
-import { I, O, M } from "./classBuilder.test.types";
-export declare const implementation: ITestImplementation<I, O, M>;

package/dist/types/src/lib/classBuilder.test/classBuilder.test.specification.d.ts

@@ -1,3 +0,0 @@
-import { ITestSpecification } from "../../CoreTypes";
-import { I, O } from "./classBuilder.test.types";
-export declare const specification: ITestSpecification<I, O>;

package/dist/types/src/lib/classBuilder.test/mock.d.ts

@@ -1,14 +0,0 @@
-import { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification } from "../../CoreTypes";
-import { ClassBuilder } from "../classBuilder";
-import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser } from "../types";
-import { ITTestResourceRequest } from "..";
-/**
- * Concrete testable implementation of ClassBuilder for testing
- */
-export default class TestClassBuilderMock<I extends Ibdd_in_any, O extends Ibdd_out_any, M = unknown> extends ClassBuilder<I, O, M> {
-    testJobs: any[];
-    specs: any[];
-    artifacts: any[];
-    summary: Record<string, any>;
-    constructor(testImplementation: ITestImplementation<I, O, M>, testSpecification: ITestSpecification<I, O>, input: I["iinput"], suiteKlasser: ISuiteKlasser<I, O>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, testResourceRequirement: ITTestResourceRequest);
-}

package/dist/types/src/lib/core.d.ts

@@ -1,12 +0,0 @@
-import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestAdapter, ITestSpecification } from "../CoreTypes";
-import { IFinalResults, ITTestResourceRequest } from "./index.js";
-import { ClassBuilder } from "./classBuilder.js";
-export default abstract class TesterantoCore<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends ClassBuilder<I, O, M> {
-    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
-        suites: Record<string, any>;
-        givens: Record<string, any>;
-        whens: Record<string, any>;
-        thens: Record<string, any>;
-    }, testResourceRequirement: ITTestResourceRequest | undefined, testAdapter: Partial<ITestAdapter<I>>, uberCatcher: (cb: () => void) => void);
-    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
-}

package/dist/types/src/lib/core.test/core.test.d.ts

@@ -1,3 +0,0 @@
-import { I, M } from "./core.test.types";
-declare const _default: Promise<number | import("../core").default<I, any, M>>;
-export default _default;

package/dist/types/src/lib/core.test/core.test.types.d.ts

@@ -1,46 +0,0 @@
-import { Ibdd_in, Ibdd_out, ITestAdapter } from "../../CoreTypes";
-import { MockCore } from "./MockCore";
-import { ITTestResourceRequest } from "..";
-export type I = Ibdd_in<{}, // iinput
-MockCore<any, any, any>, // isubject
-MockCore<any, any, any>, // istore
-MockCore<any, any, any>, // iselection
-() => MockCore<any, any, any>, // given
-(store: any) => any, // when
-(store: any) => any>;
-export type O = Ibdd_out<{
-    Default: [string];
-    ExtendedSuite: [description: string];
-}, {
-    Default: [];
-    WithCustomInput: [input: any];
-    WithResourceRequirements: [requirements: ITTestResourceRequest];
-    WithCustomAdapter: [adapter: Partial<ITestAdapter<any>>];
-}, {
-    addArtifact: [artifact: Promise<any>];
-    setTestJobs: [jobs: any[]];
-    modifySpecs: [modifier: (specs: any[]) => any[]];
-    triggerError: [message: string];
-}, {
-    initializedProperly: [];
-    specsGenerated: [];
-    jobsCreated: [];
-    artifactsTracked: [];
-    resourceRequirementsSet: [];
-    interfaceConfigured: [];
-    errorThrown: [expectedMessage: string];
-    testRunSuccessful: [];
-}, {
-    Default: [];
-}>;
-export type M = {
-    givens: {
-        [K in keyof O["givens"]]: (...args: O["givens"][K]) => MockCore<any, any, any>;
-    };
-    whens: {
-        [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
-    };
-    thens: {
-        [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
-    };
-};

package/src/lib/abstractBase.ts

@@ -1,351 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-// Do not add logging to this file as it is used by the pure runtime.
-
-import type { Ibdd_in_any } from "../CoreTypes";
-
-import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
-import { IPM } from "./types.js";
-import {
-  afterEachProxy,
-  andWhenProxy,
-  beforeEachProxy,
-  butThenProxy,
-} from "./pmProxy.js";
-
-export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
-
-export abstract class BaseGiven<I extends Ibdd_in_any> {
-  name: string;
-  features: string[];
-  whens: BaseWhen<I>[];
-  thens: BaseThen<I>[];
-  error: Error;
-  fail: any;
-  store: I["istore"];
-  recommendedFsPath: string;
-  givenCB: I["given"];
-  initialValues: any;
-  key: string;
-  failed: boolean;
-  artifacts: string[] = [];
-
-  addArtifact(path: string) {
-    const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-    this.artifacts.push(normalizedPath);
-  }
-
-  constructor(
-    name: string,
-    features: string[],
-    whens: BaseWhen<I>[],
-    thens: BaseThen<I>[],
-    givenCB: I["given"],
-    initialValues: any
-  ) {
-    this.name = name;
-    this.features = features;
-    this.whens = whens;
-    this.thens = thens;
-    this.givenCB = givenCB;
-    this.initialValues = initialValues;
-  }
-
-  beforeAll(store: I["istore"]) {
-    return store;
-  }
-
-  toObj() {
-    return {
-      key: this.key,
-      name: this.name,
-      whens: this.whens.map((w) => {
-        if (w && w.toObj) return w.toObj();
-
-        console.error("w is not as expected!", JSON.stringify(w));
-        return {};
-      }),
-      thens: this.thens.map((t) => t.toObj()),
-      error: this.error ? [this.error, this.error.stack] : null,
-      failed: this.failed,
-      features: this.features,
-      artifacts: this.artifacts,
-    };
-  }
-
-  abstract givenThat(
-    subject: I["isubject"],
-    testResourceConfiguration,
-    artifactory: ITestArtifactory,
-    givenCB: I["given"],
-    initialValues: any,
-    pm: IPM
-  ): Promise<I["istore"]>;
-
-  async afterEach(
-    store: I["istore"],
-    key: string,
-    artifactory: ITestArtifactory,
-    pm: IPM
-  ): Promise<unknown> {
-    return store;
-  }
-
-  abstract uberCatcher(e);
-
-  async give(
-    subject: I["isubject"],
-    key: string,
-    testResourceConfiguration: ITTestResourceConfiguration,
-    tester: (t: Awaited<I["then"]> | undefined) => boolean,
-    artifactory: ITestArtifactory,
-    tLog: ITLog,
-    pm: IPM,
-    suiteNdx: number
-  ) {
-    this.key = key;
-
-    tLog(`\n ${this.key}`);
-    tLog(`\n Given: ${this.name}`);
-
-    const givenArtifactory = (fPath: string, value: unknown) =>
-      artifactory(`given-${key}/${fPath}`, value);
-
-    this.uberCatcher((e) => {
-      console.error(e.toString());
-      this.error = e.error;
-      tLog(e.stack);
-    });
-
-    try {
-      // Ensure addArtifact is properly bound to 'this'
-      const addArtifact = this.addArtifact.bind(this);
-      const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
-      this.store = await this.givenThat(
-        subject,
-        testResourceConfiguration,
-        givenArtifactory,
-        this.givenCB,
-        this.initialValues,
-        proxiedPm
-      );
-    } catch (e) {
-      // console.error("Given failure: ", e.stack);
-      this.failed = true;
-      this.error = e.stack;
-      // throw e;
-    }
-
-    try {
-      // tLog(`\n Given this.store`, this.store);
-
-      for (const [whenNdx, whenStep] of this.whens.entries()) {
-        await whenStep.test(
-          this.store,
-          testResourceConfiguration,
-          tLog,
-          pm,
-          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
-        );
-      }
-
-      for (const [thenNdx, thenStep] of this.thens.entries()) {
-        const t = await thenStep.test(
-          this.store,
-          testResourceConfiguration,
-          tLog,
-          pm,
-          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
-        );
-        tester(t);
-      }
-    } catch (e) {
-      this.error = e.stack;
-      this.failed = true;
-      // tLog(e.stack);
-      // throw e;
-    } finally {
-      try {
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        const proxiedPm = afterEachProxy(
-          pm,
-          suiteNdx.toString(),
-          key,
-          addArtifact
-        );
-        // (proxiedPm as any).currentStep = this;
-        await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
-      } catch (e) {
-        this.failed = e;
-        throw e;
-        // this.error = e.message;
-      }
-    }
-
-    return this.store;
-  }
-}
-
-export abstract class BaseWhen<I extends Ibdd_in_any> {
-  public name: string;
-  whenCB: (x: I["iselection"]) => I["then"];
-  error: Error;
-  artifacts: string[] = [];
-
-  addArtifact(path: string) {
-    const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-    this.artifacts.push(normalizedPath);
-  }
-
-  constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]) {
-    this.name = name;
-    this.whenCB = whenCB;
-  }
-
-  abstract andWhen(
-    store: I["istore"],
-    whenCB: (x: I["iselection"]) => I["then"],
-    testResource,
-    pm: IPM
-  ): Promise<any>;
-
-  toObj() {
-    const obj = {
-      name: this.name,
-      error: this.error
-        ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
-        : null,
-      artifacts: this.artifacts || [],
-    };
-    console.log(
-      `[TOOBJ] Serializing ${this.constructor.name} with artifacts:`,
-      obj.artifacts
-    );
-    return obj;
-  }
-
-  async test(
-    store: I["istore"],
-    testResourceConfiguration,
-    tLog: ITLog,
-    pm: IPM,
-    filepath: string
-  ) {
-    try {
-      // tLog(" When:", this.name);
-      // Ensure addArtifact is properly bound to 'this'
-      const addArtifact = this.addArtifact.bind(this);
-      const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
-
-      // (proxiedPm as any).currentStep = this;
-      const result = await this.andWhen(
-        store,
-        this.whenCB,
-        testResourceConfiguration,
-        proxiedPm
-      );
-
-      return result;
-    } catch (e: any) {
-      console.error(
-        "[ERROR] When step failed:",
-        this.name.toString(),
-        e.toString()
-      );
-      this.error = e;
-      throw e;
-    }
-  }
-}
-
-export abstract class BaseThen<I extends Ibdd_in_any> {
-  public name: string;
-  thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
-  error: boolean;
-  artifacts: string[] = [];
-
-  constructor(
-    name: string,
-    thenCB: (val: I["iselection"]) => Promise<I["then"]>
-  ) {
-    this.name = name;
-    this.thenCB = thenCB;
-    this.error = false;
-    this.artifacts = [];
-  }
-
-  addArtifact(path: string) {
-    const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-    this.artifacts.push(normalizedPath);
-  }
-
-  toObj() {
-    const obj = {
-      name: this.name,
-      error: this.error,
-      artifacts: this.artifacts,
-    };
-    return obj;
-  }
-
-  abstract butThen(
-    store: I["istore"],
-    thenCB: (s: I["iselection"]) => Promise<I["isubject"]>,
-    testResourceConfiguration: ITTestResourceConfiguration,
-    pm: IPM,
-    ...args: any[]
-  ): Promise<I["iselection"]>;
-
-  async test(
-    store: I["istore"],
-    testResourceConfiguration,
-    tLog: ITLog,
-    pm: IPM,
-    filepath: string
-  ): Promise<I["then"] | undefined> {
-    // Ensure addArtifact is properly bound to 'this'
-    const addArtifact = this.addArtifact.bind(this);
-    const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-    return this.butThen(
-      store,
-      async (s: I["iselection"]) => {
-        try {
-          if (typeof this.thenCB === "function") {
-            // Add debug logging to see what's being passed to thenCB
-
-            // Check if the thenCB is spreading the arguments incorrectly
-            // Wrap the proxy to see what's happening when writeFileSync is called
-            const wrappedPm = new Proxy(proxiedPm, {
-              get: (target, prop, receiver) => {
-                if (prop === "writeFileSync") {
-                  return (...args) => {
-                    console.log(
-                      `[DEBUG] writeFileSync called with args:`,
-                      args
-                    );
-                    return target[prop](...args);
-                  };
-                }
-                return target[prop];
-              },
-            });
-            const result = await this.thenCB(s, wrappedPm);
-
-            return result;
-          } else {
-            return this.thenCB;
-          }
-        } catch (e) {
-          console.error(e.stack);
-        }
-      },
-      testResourceConfiguration,
-      proxiedPm
-    ).catch((e) => {
-      this.error = e.stack;
-      // throw e;
-    });
-  }
-}

package/src/lib/baseBuilder.test/baseBuilder.test.adapter.ts

@@ -1,29 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { ITestAdapter } from "../../CoreTypes";
-import { I } from "./baseBuilder.test.types";
-import { ITTestResourceConfiguration } from "..";
-import { IPM } from "../types";
-
-export const testAdapter: ITestAdapter<I> = {
-  beforeAll: async (input, testResource, pm) => {
-    return input;
-  },
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const result = initializer()();
-    return result;
-  },
-  andWhen: async (store, whenCB, testResource, utils) => {
-    const result = whenCB(store, utils);
-    return result;
-  },
-  butThen: async (store, thenCB, testResource, pm) => {
-    const result = thenCB(store, pm);
-    return result;
-  },
-  afterEach: async (store, key, pm) => {
-    return store;
-  },
-  afterAll: (store, pm) => {},
-  assertThis: (x: any) => x,
-};

package/src/lib/baseBuilder.test/baseBuilder.test.implementation.ts

@@ -1,139 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ITestImplementation } from "../../CoreTypes";
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-
-import { I, O } from "./baseBuilder.test.types";
-import { ITestJob, ITTestResourceRequest } from "..";
-import { BaseBuilder } from "../basebuilder";
-import { IPM } from "../types";
-
-// Define our test subject type
-type TestSubject = MockBaseBuilder<any, any, any, any, any, any>;
-
-export const implementation: ITestImplementation<I, O, {}> = {
-  suites: {
-    Default: "BaseBuilder test suite",
-  },
-
-  givens: {
-    "the default BaseBuilder": () => () => {
-      return new MockBaseBuilder(
-        {}, // input
-        {}, // suitesOverrides
-        {}, // givenOverrides
-        {}, // whenOverrides
-        {}, // thenOverrides
-        { ports: 0 }, // testResourceRequirement
-        () => [] // testSpecification
-      );
-    },
-    "a BaseBuilder with TestInput": (input: any) => () => {
-      return new MockBaseBuilder(
-        input,
-        {},
-        {},
-        {},
-        {},
-        { ports: [] },
-        () => []
-      );
-    },
-    "a BaseBuilder with Test Resource Requirements": (
-      requirements: ITTestResourceRequest
-    ) => () => {
-      return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
-    },
-  },
-
-  whens: {
-    addArtifact: (artifact: Promise<any>) => (builder: TestSubject, utils: IPM) => {
-      builder.artifacts.push(artifact);
-      return builder;
-    },
-    setTestJobs: (jobs: ITestJob[]) => (builder: TestSubject, utils: IPM) => {
-      builder.testJobs = jobs;
-      return builder;
-    },
-  },
-
-  thens: {
-    "it is initialized": () => (builder: TestSubject, utils: IPM) => {
-      utils.writeFileSync("hello.txt", "world");
-
-      if (!(builder instanceof BaseBuilder)) {
-        console.error("Builder instance:", builder);
-        throw new Error(
-          `Builder was not properly initialized - expected BaseBuilder instance but got ${builder?.constructor?.name}`
-        );
-      }
-
-      // Verify required properties exist
-      [
-        "artifacts",
-        "testJobs",
-        "specs",
-        "suitesOverrides",
-        "givenOverides",
-        "whenOverides",
-        "thenOverides",
-      ].forEach((prop) => {
-        if (!(prop in builder)) {
-          throw new Error(`Builder missing required property: ${prop}`);
-        }
-      });
-
-      return builder;
-    },
-    "it generates TestSpecifications": () => (builder: TestSubject, utils: IPM) => {
-      if (!Array.isArray(builder.specs)) {
-        throw new Error("Specs were not generated");
-      }
-      return builder;
-    },
-    "it creates jobs": () => (builder: TestSubject, utils: IPM) => {
-      if (!Array.isArray(builder.testJobs)) {
-        throw new Error("Test jobs were not created");
-      }
-      return builder;
-    },
-    "it tracks artifacts": () => (builder: TestSubject, utils: IPM) => {
-      if (!Array.isArray(builder.artifacts)) {
-        throw new Error("Artifacts array not initialized");
-      }
-      // Verify we can write artifacts
-      utils.writeFileSync("artifact_test.txt", "test");
-      return builder;
-    },
-    resourceRequirementsSet: () => (builder: TestSubject, utils: IPM) => {
-      if (!builder.testResourceRequirement) {
-        throw new Error("Resource requirements not set");
-      }
-      return builder;
-    },
-    suitesOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
-      if (!builder.suitesOverrides) {
-        throw new Error("Suites overrides not configured");
-      }
-      return builder;
-    },
-    givensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
-      if (!builder.givenOverides) {
-        throw new Error("Givens overrides not configured");
-      }
-      return builder;
-    },
-    whensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
-      if (!builder.whenOverides) {
-        throw new Error("Whens overrides not configured");
-      }
-      return builder;
-    },
-    thensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
-      if (!builder.thenOverides) {
-        throw new Error("Thens overrides not configured");
-      }
-      return builder;
-    },
-  },
-};