testeranto 0.197.0 → 0.198.0

package/src/lib/classBuilder.ts

@@ -1,120 +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 { NonEmptyObject } from "type-fest";
-
-import type {
-  Ibdd_in_any,
-  Ibdd_out_any,
-  ITestImplementation,
-  ITestSpecification,
-} from "../CoreTypes";
-
-import { BaseBuilder } from "./basebuilder.js";
-import {
-  ISuiteKlasser,
-  IGivenKlasser,
-  IWhenKlasser,
-  IThenKlasser,
-} from "./types.js";
-import { ITTestResourceRequest } from "./index.js";
-
-type IExtenstions = Record<string, unknown>;
-
-export abstract class ClassBuilder<
-  I extends Ibdd_in_any = Ibdd_in_any,
-  O extends Ibdd_out_any = Ibdd_out_any,
-  M = unknown
-> extends BaseBuilder<
-  I,
-  O,
-  IExtenstions,
-  IExtenstions,
-  IExtenstions,
-  IExtenstions
-> {
-  constructor(
-    testImplementation: ITestImplementation<I, O, M> & {
-      suites: Record<string, NonEmptyObject<object>>;
-      givens: Record<string, any>;
-      whens: Record<string, any>;
-      thens: Record<string, any>;
-    },
-    testSpecification: ITestSpecification<I, O>,
-    input: I["iinput"],
-    suiteKlasser: ISuiteKlasser<I, O>,
-    givenKlasser: IGivenKlasser<I>,
-    whenKlasser: IWhenKlasser<I>,
-    thenKlasser: IThenKlasser<I>,
-    testResourceRequirement: ITTestResourceRequest
-  ) {
-    const classySuites = Object.entries(testImplementation.suites).reduce(
-      (a, [key], index) => {
-        a[key] = (somestring, givens) => {
-          return new suiteKlasser.prototype.constructor(
-            somestring,
-            index,
-            givens
-          );
-        };
-        return a;
-      },
-      {}
-    );
-
-    const classyGivens = Object.entries(testImplementation.givens).reduce(
-      (a, [key, g]) => {
-        a[key] = (features, whens, thens, ...initialValues) => {
-          return new givenKlasser.prototype.constructor(
-            key,
-            features,
-            whens,
-            thens,
-            testImplementation.givens[key],
-            initialValues
-          );
-        };
-        return a;
-      },
-      {}
-    );
-
-    const classyWhens = Object.entries(testImplementation.whens).reduce(
-      (a, [key, whEn]: [string, (...x: any[]) => any]) => {
-        a[key] = (...payload: any[]) => {
-          return new whenKlasser.prototype.constructor(
-            `${key}: ${payload && payload.toString()}`,
-            whEn(...payload)
-          );
-        };
-        return a;
-      },
-      {}
-    );
-
-    const classyThens = Object.entries(testImplementation.thens).reduce(
-      (a, [key, thEn]: [string, (...x: any[]) => any]) => {
-        a[key] = (...args: any[]) => {
-          return new thenKlasser.prototype.constructor(
-            `${key}: ${args && args.toString()}`,
-            thEn(...args)
-          );
-        };
-        return a;
-      },
-      {}
-    );
-
-    super(
-      input,
-      classySuites,
-      classyGivens,
-      classyWhens,
-      classyThens,
-      testResourceRequirement,
-      testSpecification
-    );
-  }
-}

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

@@ -1,155 +0,0 @@
-import { ITestImplementation } from "../../CoreTypes";
-import { MockCore } from "./MockCore";
-import { I, O, M } from "./core.test.types";
-import { ITTestResourceRequest } from "..";
-import { ITestAdapter } from "../../CoreTypes";
-
-export const implementation: ITestImplementation<I, O, M> = {
-  suites: {
-    Default: "Testeranto test suite",
-    ExtendedSuite: "Extended Testeranto test suite",
-  },
-
-  givens: {
-    Default: () => {
-      const input = { debug: true };
-      const resourceReq = { ports: [3000] };
-
-      try {
-        const instance = new MockCore(
-          input,
-          specification,
-          implementation,
-          resourceReq,
-          testAdapter,
-          (cb) => cb()
-        );
-        return instance;
-      } catch (e) {
-        console.error("[ERROR] Failed to create MockCore:", e);
-        throw e;
-      }
-    },
-    WithCustomInput: (input: any) => {
-      return new MockCore(
-        input,
-        specification,
-        implementation,
-        { ports: [] },
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithResourceRequirements: (requirements: ITTestResourceRequest) => {
-      return new MockCore(
-        {},
-        specification,
-        implementation,
-        requirements,
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithCustomAdapter: (customAdapter: Partial<ITestAdapter<any>>) => {
-      return new MockCore(
-        {},
-        specification,
-        implementation,
-        { ports: [] },
-        { ...testAdapter, ...customAdapter },
-        (cb) => cb()
-      );
-    },
-  },
-
-  whens: {
-    addArtifact: (artifact: Promise<any>) => (builder) => {
-      builder.artifacts.push(artifact);
-      return builder;
-    },
-    setTestJobs: (jobs: any[]) => (builder) => {
-      builder.testJobs = jobs;
-      return builder;
-    },
-    modifySpecs: (modifier: (specs: any[]) => any[]) => (builder) => {
-      console.log("Modifying specs - current count:", builder.specs?.length);
-      const newSpecs = modifier(builder.specs || []);
-      console.log("Modifying specs - new count:", newSpecs.length);
-      builder.specs = newSpecs;
-      return builder;
-    },
-    triggerError: (message: string) => (builder) => {
-      throw new Error(message);
-    },
-  },
-
-  thens: {
-    initializedProperly: () => (builder) => {
-      if (!builder) {
-        throw new Error("Builder is undefined");
-      }
-      if (!(builder instanceof MockCore)) {
-        throw new Error(
-          `Builder is not MockCore (got ${builder.constructor.name})`
-        );
-      }
-      if (!builder.testResourceRequirement) {
-        throw new Error("testResourceRequirement not set");
-      }
-      if (!builder.testAdapter) {
-        throw new Error("testAdapter not set");
-      }
-      return builder;
-    },
-    specsGenerated: () => (builder) => {
-      if (!Array.isArray(builder.specs)) {
-        throw new Error("Specs were not generated");
-      }
-      return builder;
-    },
-    jobsCreated: () => (builder) => {
-      if (!Array.isArray(builder.testJobs)) {
-        throw new Error("Test jobs were not created");
-      }
-      return builder;
-    },
-    artifactsTracked: () => (builder) => {
-      if (!Array.isArray(builder.artifacts)) {
-        throw new Error("Artifacts array not initialized");
-      }
-      return builder;
-    },
-    resourceRequirementsSet: () => (builder) => {
-      if (!builder.testResourceRequirement) {
-        throw new Error("Resource requirements not set");
-      }
-      return builder;
-    },
-    interfaceConfigured: () => (builder) => {
-      if (!builder.testAdapter) {
-        throw new Error("Test adapter not configured");
-      }
-      return builder;
-    },
-    errorThrown: (expectedMessage: string) => (builder) => {
-      // Handled by test runner
-      return builder;
-    },
-    testRunSuccessful: () => async (builder) => {
-      try {
-        await builder.receiveTestResourceConfig("");
-        return builder;
-      } catch (e) {
-        throw new Error(`Test run failed: ${e.message}`);
-      }
-    },
-    specsModified: (expectedCount: number) => (builder) => {
-      if (!builder.specs || builder.specs.length !== expectedCount) {
-        throw new Error(
-          `Expected ${expectedCount} specs, got ${builder.specs?.length}`
-        );
-      }
-      return builder;
-    },
-  },
-};

package/src/lib/core.test/core.test.specification.ts

@@ -1,113 +0,0 @@
-import { ITestSpecification } from "../../CoreTypes";
-import { I, O } from "./core.test.types";
-
-export const specification: ITestSpecification<I, O> = (
-  Suite,
-  Given,
-  When,
-  Then
-) => {
-  const summary = {
-    suites: {
-      'Testeranto Core Functionality': {
-        features: {},
-        artifacts: []
-      },
-      'Testeranto Advanced Features': {
-        features: {},
-        artifacts: []
-      }
-    },
-    features: {},
-    artifacts: []
-  };
-
-  return [
-    Suite.Default(
-      "Testeranto Core Functionality",
-      summary.suites['Testeranto Core Functionality'],
-      {
-        // Initialization tests
-        defaultInitialization: Given.Default(
-          ["Should initialize with default values"],
-          [],
-          [
-            Then.initializedProperly(),
-            Then.specsGenerated(),
-            Then.jobsCreated(),
-            Then.artifactsTracked()
-          ]
-        ),
-        customInputInitialization: Given.WithCustomInput(
-          { test: "input" },
-          [],
-          [Then.initializedProperly()]
-        ),
-
-        // Configuration tests
-        resourceConfig: Given.WithResourceRequirements(
-          { ports: [3000, 3001] },
-          [],
-          [Then.resourceRequirementsSet()]
-        ),
-        interfaceConfig: Given.WithCustomAdapter(
-          {
-            assertThis: (x) => !!x,
-            beforeEach: async (s, i) => i(),
-          },
-          [],
-          [Then.interfaceConfigured()]
-        ),
-
-        // Core operations
-        specGeneration: Given.Default(
-          ["Should generate test specs"],
-          [],
-          [Then.specsGenerated()]
-        ),
-        jobCreation: Given.Default(
-          ["Should create test jobs"],
-          [],
-          [Then.jobsCreated()]
-        ),
-        artifactHandling: Given.Default(
-          ["Should track artifacts"],
-          [When.addArtifact(Promise.resolve("test"))],
-          [Then.artifactsTracked()]
-        ),
-      },
-      []
-    ),
-
-    Suite.ExtendedSuite("Testeranto Advanced Features", summary.suites['Testeranto Advanced Features'], {
-      // Error handling
-      errorPropagation: Given.Default(
-        ["Should propagate errors properly"],
-        [When.triggerError("test error")],
-        [Then.errorThrown("test error")]
-      ),
-
-      // Dynamic behavior
-      specModification: Given.Default(
-        ["Should allow spec modification"],
-        [When.modifySpecs((specs) => [...specs, { name: "extra" }])],
-        [Then.specsModified(1)]
-      ),
-
-      // Full lifecycle
-      testExecution: Given.Default(
-        ["Should execute full test lifecycle"],
-        [],
-        [Then.testRunSuccessful()]
-      ),
-
-      // Custom implementations
-      // Removed customImpl test since WithCustomImplementation isn't defined
-      dynamicSpecs: Given.Default(
-        ["Should handle dynamic spec changes"],
-        [When.modifySpecs((specs) => specs)],
-        [Then.specsGenerated()]
-      ),
-    }),
-  ];
-};

package/src/lib/core.test/core.test.ts

@@ -1,72 +0,0 @@
-import Testeranto from "../../Pure";
-import { specification } from "./core.test.specification";
-import { implementation } from "./core.test.implementation";
-import { testAdapter } from "./core.test.adapter";
-import { I, O, M } from "./core.test.types";
-import { MockCore } from "./MockCore";
-
-export default Testeranto<I, O, M>(
-  MockCore.prototype,
-  specification,
-  implementation,
-  testAdapter
-);
-
-// console.log("[DEBUG] Starting core.test.ts");
-// console.log("[DEBUG] MockCore:", MockCore?.name);
-// console.log("[DEBUG] specification:", specification?.name);
-// console.log("[DEBUG] implementation keys:", Object.keys(implementation));
-// console.log("[DEBUG] testAdapter keys:", Object.keys(testAdapter));
-
-// console.log("[DEBUG] Starting test runner with:");
-// console.log("- Specification:", specification?.name);
-// console.log("- Implementation keys:", Object.keys(implementation));
-// console.log("- Test adapter keys:", Object.keys(testAdapter));
-
-// console.log("[DEBUG] Creating test runner instance...");
-// try {
-//   const testRunner = new Testeranto<I, O, M>(
-//     MockCore.prototype,
-//     specification,
-//     implementation,
-//     { ports: [3000, 3001] },
-//     testAdapter
-//   );
-
-//   console.log("[DEBUG] Starting test execution...");
-//   const runTests = async () => {
-//     try {
-//       const result = await testRunner.receiveTestResourceConfig(
-//         JSON.stringify({
-//           name: "core.test",
-//           fs: "/tmp/core.test",
-//           ports: [3000, 3001],
-//         })
-//       );
-
-//       console.log("[DEBUG] Test run completed with:");
-//       console.log("- Status:", result.failed ? "FAILED" : "PASSED");
-//       console.log("- Failures:", result.fails);
-//       console.log("- Features tested:", result.features?.length);
-//       console.log("- Artifacts:", result.artifacts?.length);
-
-//       if (result.failed) {
-//         throw new Error(`Tests failed with ${result.fails} failures`);
-//       }
-//       return result;
-//     } catch (e) {
-//       console.error("[ERROR] Test runner failed:", e.message);
-//       console.error("- Full error:", e);
-//       process.exit(1);
-//     }
-//   };
-
-//   // Run tests immediately when imported
-//   runTests().catch(e => {
-//     console.error("[ERROR] Test runner failed:", e);
-//     process.exit(1);
-//   });
-// } catch (e) {
-//   console.error("[ERROR] Failed to initialize test runner:", e);
-//   process.exit(1);
-// }

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

@@ -1,68 +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 // then
->;
-
-export type O = Ibdd_out<
-  // Suites
-  {
-    Default: [string];
-    ExtendedSuite: [description: string];
-  },
-  // Givens
-  {
-    Default: [];
-    WithCustomInput: [input: any];
-    WithResourceRequirements: [requirements: ITTestResourceRequest];
-    WithCustomAdapter: [adapter: Partial<ITestAdapter<any>>];
-  },
-  // Whens
-  {
-    addArtifact: [artifact: Promise<any>];
-    setTestJobs: [jobs: any[]];
-    modifySpecs: [modifier: (specs: any[]) => any[]];
-    triggerError: [message: string];
-  },
-  // Thens
-  {
-    initializedProperly: [];
-    specsGenerated: [];
-    jobsCreated: [];
-    artifactsTracked: [];
-    resourceRequirementsSet: [];
-    interfaceConfigured: [];
-    errorThrown: [expectedMessage: string];
-    testRunSuccessful: [];
-  },
-  // Checks
-  {
-    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/core.ts

@@ -1,125 +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,
-  Ibdd_out_any,
-  ITestImplementation,
-  ITestAdapter,
-  ITestSpecification,
-} from "../CoreTypes";
-
-import {
-  DefaultAdapter,
-  IFinalResults,
-  ITTestResourceConfiguration,
-  ITTestResourceRequest,
-  ITestArtifactory,
-  defaultTestResourceRequirement,
-} from "./index.js";
-import { BaseGiven, BaseWhen, BaseThen } from "./abstractBase.js";
-import { ClassBuilder } from "./classBuilder.js";
-import { IPM } from "./types";
-import { BaseSuite } from "./BaseSuite.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 = defaultTestResourceRequirement,
-    testAdapter: Partial<ITestAdapter<I>>,
-    uberCatcher: (cb: () => void) => void
-  ) {
-    const fullAdapter = DefaultAdapter<I>(testAdapter);
-
-    super(
-      testImplementation,
-      testSpecification,
-      input,
-
-      class extends BaseSuite<I, O> {
-        afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM) {
-          return fullAdapter.afterAll(store, pm);
-        }
-
-        assertThat(t: Awaited<I["then"]>): boolean {
-          return fullAdapter.assertThis(t);
-        }
-
-        async setup(
-          s: I["iinput"],
-          artifactory: ITestArtifactory,
-          tr: ITTestResourceConfiguration,
-          pm: IPM
-        ): Promise<I["isubject"]> {
-          return fullAdapter.beforeAll?.(s, tr, pm) ?? (s as unknown as Promise<I["isubject"]>);
-        }
-      } as any,
-
-      class Given extends BaseGiven<I> {
-        uberCatcher = uberCatcher;
-
-        async givenThat(
-          subject,
-          testResource,
-          artifactory,
-          initializer,
-          initialValues,
-          pm
-        ) {
-          return fullAdapter.beforeEach(
-            subject,
-            initializer,
-            testResource,
-            initialValues,
-            pm
-          );
-        }
-
-        afterEach(
-          store: I["istore"],
-          key: string,
-          artifactory,
-          pm
-        ): Promise<unknown> {
-          return Promise.resolve(fullAdapter.afterEach(store, key, pm));
-        }
-      } as any,
-
-      class When extends BaseWhen<I> {
-        async andWhen(store, whenCB, testResource, pm) {
-          return await fullAdapter.andWhen(store, whenCB, testResource, pm);
-        }
-      } as any,
-
-      class Then extends BaseThen<I> {
-        async butThen(
-          store: any,
-          thenCB,
-          testResource: any,
-          pm: IPM
-        ): Promise<I["iselection"]> {
-          return await fullAdapter.butThen(store, thenCB, testResource, pm);
-        }
-      } as any,
-
-      testResourceRequirement
-    );
-  }
-
-  abstract receiveTestResourceConfig(
-    partialTestResource: string
-  ): Promise<IFinalResults>;
-}