testeranto 0.189.0 → 0.198.0

package/src/lib/BaseThen.ts

@@ -0,0 +1,108 @@
+/* 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 { ITLog, ITTestResourceConfiguration } from ".";
+import { IPM } from "./types.js";
+import { butThenProxy } from "./pmProxy.js";
+
+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
+  ): 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;
+    });
+  }
+}
+/**
+ * Represents a collection of Then assertions keyed by their names.
+ * Thens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - Assertions might need to be reused or composed dynamically
+ * - Custom assertion libraries could benefit from named assertion collections
+ * - Advanced validation patterns require named Then conditions
+ */
+export type IThens<I extends Ibdd_in_any> = Record<string, BaseThen<I>>;

package/src/lib/BaseWhen.ts

@@ -0,0 +1,91 @@
+/* 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 { ITLog } from ".";
+import { IPM } from "./types.js";
+import { andWhenProxy } from "./pmProxy.js";
+
+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;
+    }
+  }
+}
+/**
+ * Represents a collection of When actions keyed by their names.
+ * Whens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - When actions might need to be reused across multiple Given conditions
+ * - Dynamic composition of test steps is required
+ * - Advanced test patterns need to reference When actions by name
+ */
+export type IWhens<I extends Ibdd_in_any> = Record<string, BaseWhen<I>>;

package/src/lib/{core.test/MockCore.ts → Tiposkripto.test/MockTiposkripto.ts}

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import TesterantoCore from "../core";
+import Tiposkripto from "../Tiposkripto";
 
 import {
   Ibdd_in_any,
@@ -12,13 +12,13 @@ import {
 import { ITTestResourceRequest, IFinalResults } from "..";
 
 /**
- * Concrete implementation of Testeranto for testing purposes
+ * Concrete implementation of Tiposkripto for testing purposes
  */
-export class MockCore<
+export class MockTiposkripto<
   I extends Ibdd_in_any,
   O extends Ibdd_out_any,
   M = unknown
-> extends TesterantoCore<I, O, M> {
+> extends Tiposkripto<I, O, M> {
   public specs: any[] = [];
   public testJobs: any[] = [];
   public artifacts: any[] = [];
@@ -41,8 +41,6 @@ export class MockCore<
       }
     });
 
-    // this.testResourceRequirement = testResourceRequirement;
-    // this.testAdapter = testAdapter;
     super(
       input,
       testSpecification,
@@ -60,7 +58,6 @@ export class MockCore<
       failed: false,
       fails: 0,
       artifacts: [],
-      // logPromise: Promise.resolve(),
       features: [],
     };
   }

package/src/lib/{core.test/core.test.adapter.ts → Tiposkripto.test/Tiposkripto.adapter.ts}

@@ -1,36 +1,37 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { ITestAdapter } from "../../CoreTypes";
-import { I } from "./core.test.types";
-import { MockCore } from "./MockCore";
+
+import { I } from "./Tiposkripto.types";
+import { MockTiposkripto } from "./MockTiposkripto";
 
 export const testAdapter: ITestAdapter<I> = {
+  beforeAll: async (input, testResource, pm) => input as any,
   beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
     try {
       const result = await initializer();
       if (!result) {
         throw new Error("Initializer returned undefined");
       }
-      if (!(result instanceof MockCore)) {
+      if (!(result instanceof MockTiposkripto)) {
         throw new Error(
-          `Initializer returned ${result?.constructor?.name}, expected MockCore`
+          `Initializer returned ${result?.constructor?.name}, expected MockTiposkripto`
         );
       }
-
       return result;
     } catch (e) {
       console.error("[ERROR] BeforeEach failed:", e);
       throw e;
     }
   },
-  andWhen: async (store, whenCB, testResource, pm) => {
-    return whenCB(store, pm);
+  andWhen: async (store, whenCB, testResource, utils) => {
+    return whenCB(store, utils);
   },
   butThen: async (store, thenCB, testResource, pm) => {
     return thenCB(store, pm);
   },
   afterEach: (store) => store,
-  afterAll: (store, pm) => {},
-  assertThis: (result) => !!result,
-  beforeAll: async (input, testResource, pm) => input as any,
+  afterAll: () => {},
+  assertThis: (x: any) => !!x,
 };

package/src/lib/{classBuilder.test/classBuilder.test.implementation.ts → Tiposkripto.test/Tiposkripto.implementation.ts}

@@ -2,92 +2,89 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { PassThrough } from "stream";
 
-import { ITestImplementation, ITestSpecification } from "../../CoreTypes";
-import mock from "./mock";
-import { TestClassBuilder } from "../classBuilder";
+import { ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
+import { MockTiposkripto } from "./MockTiposkripto";
 
-import { I, O, M } from "./classBuilder.test.types";
+import { I, O, M } from "./Tiposkripto.types";
 
 import { ITTestResourceRequest } from "..";
-import { specification } from "./classBuilder.test.specification";
-import { MockSuite } from "../BaseSuite.test/mock";
+import { specification } from "./Tiposkripto.specification";
+import { testAdapter } from "./Tiposkripto.adapter";
 
 export const implementation: ITestImplementation<I, O, M> = {
   suites: {
-    Default: "ClassBuilder test suite",
-    ExtendedSuite: "Extended ClassBuilder test suite",
+    Default: "Tiposkripto test suite",
+    ExtendedSuite: "Extended Tiposkripto test suite",
   },
-
   givens: {
     Default: () => {
       console.log("Creating default test builder instance");
-      const builder = new mock(
-        implementation, // Use the current implementation
-        specification, // Use the current specification
-        {}, // Default input
-        MockSuite,
-        class {}, // givenKlasser
-        class {}, // whenKlasser
-        class {}, // thenKlasser
-        { ports: [] } // Default resource requirements
-      );
+      // Use a function to defer the implementation reference
+      const createBuilder = (impl: ITestImplementation<any, any, any>) => {
+        return new MockTiposkripto(
+          {}, // input
+          specification, // Use the current specification
+          impl, // Use the passed implementation
+          { ports: [] }, // Default resource requirements
+          testAdapter, // Default adapter
+          (cb) => cb() // Default uberCatcher
+        );
+      };
+      const builder = createBuilder(implementation);
       console.log("Builder created:", builder);
       return builder;
     },
     WithCustomInput: (input: any) => {
-      return new mock(
-        implementation,
-        specification,
+      return new MockTiposkripto(
         input,
-        class {},
-        class {},
-        class {},
-        class {},
-        class {},
-        { ports: [] }
+        specification,
+        implementation,
+        { ports: [] },
+        testAdapter,
+        (cb) => cb()
       );
     },
     WithResourceRequirements: (requirements: ITTestResourceRequest) => {
-      return new mock(
-        implementation,
-        specification,
+      return new MockTiposkripto(
         {},
-        class {},
-        class {},
-        class {},
-        class {},
-        class {},
-        requirements
+        specification,
+        implementation,
+        requirements,
+        testAdapter,
+        (cb) => cb()
       );
     },
     WithCustomImplementation: (impl: ITestImplementation<any, any>) => {
-      return new mock(
-        impl,
-        specification,
+      return new MockTiposkripto(
         {},
-        class {},
-        class {},
-        class {},
-        class {},
-        class {},
-        { ports: [] }
+        specification,
+        impl,
+        { ports: [] },
+        testAdapter,
+        (cb) => cb()
       );
     },
     WithCustomSpecification: (spec: ITestSpecification<any, any>) => {
-      return new mock(
-        implementation,
+      return new MockTiposkripto(
+        {},
         spec,
+        implementation,
+        { ports: [] },
+        testAdapter,
+        (cb) => cb()
+      );
+    },
+    WithCustomAdapter: (customAdapter: Partial<ITestAdapter<any>>) => {
+      return new MockTiposkripto(
         {},
-        class {},
-        class {},
-        class {},
-        class {},
-        class {},
-        { ports: [] }
+        specification,
+        implementation,
+        { ports: [] },
+        { ...testAdapter, ...customAdapter },
+        (cb) => cb()
       );
     },
   },
-
   whens: {
     addArtifact: (artifact: Promise<any>) => (builder) => {
       builder.artifacts.push(artifact);
@@ -109,43 +106,43 @@ export const implementation: ITestImplementation<I, O, M> = {
       throw new Error(message);
     },
   },
-
   thens: {
-    initializedProperly: () => (builder: any) => {
-      console.log("Checking builder initialization:", {
-        builder,
-        isMock: builder instanceof mock,
-        constructor: builder?.constructor?.name,
-        props: Object.keys(builder)
-      });
-      
+    "it is initialized": () => (builder: any, utils: any) => {
+      utils.writeFileSync("hello.txt", "world");
+
       if (!builder) {
         throw new Error("Builder is undefined");
       }
-      if (!(builder instanceof mock)) {
+      if (!(builder instanceof MockTiposkripto)) {
         throw new Error(
-          `Builder was not properly initialized. Expected mock instance but got ${builder?.constructor?.name}`
+          `Builder was not properly initialized. Expected MockTiposkripto instance but got ${builder?.constructor?.name}`
         );
       }
-      
+
       // Verify required properties exist
-      const requiredProps = ['specs', 'testJobs', 'artifacts'];
+      const requiredProps = [
+        "specs",
+        "testJobs",
+        "artifacts",
+        "suitesOverrides",
+        "givenOverides",
+        "whenOverides",
+        "thenOverides",
+      ];
       for (const prop of requiredProps) {
         if (!(prop in builder)) {
           throw new Error(`Missing required property: ${prop}`);
         }
       }
-      
+
       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");
@@ -188,6 +185,12 @@ export const implementation: ITestImplementation<I, O, M> = {
       }
       return builder;
     },
+    interfaceConfigured: () => (builder) => {
+      if (!builder.testAdapter) {
+        throw new Error("Test adapter not configured");
+      }
+      return builder;
+    },
     specsModified: (expectedCount: number) => (builder) => {
       if (builder.specs.length <= expectedCount) {
         throw new Error(`Expected at least ${expectedCount} modified specs`);
@@ -206,13 +209,7 @@ export const implementation: ITestImplementation<I, O, M> = {
     },
     testRunSuccessful: () => async (builder) => {
       try {
-        await builder.testRun({
-          testResourceConfiguration: {
-            name: "test",
-            fs: "/tmp",
-            ports: [],
-          },
-        });
+        await builder.receiveTestResourceConfig("");
         return builder;
       } catch (e) {
         throw new Error(`Test run failed: ${e.message}`);

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

@@ -0,0 +1,109 @@
+import { ITestSpecification } from "../../CoreTypes";
+
+import { I, O } from "./Tiposkripto.types";
+import { implementation } from "./Tiposkripto.implementation";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then
+) => {
+  return [
+    Suite.Default("Tiposkripto Core Functionality", {
+      // Basic initialization tests
+      initialization: Given.Default(
+        ["Tiposkripto should initialize with default values"],
+        [],
+        [Then.initializedProperly()]
+      ),
+      customInput: Given.WithCustomInput(
+        { custom: "input" },
+        [],
+        [Then.initializedProperly()]
+      ),
+      resourceRequirements: Given.WithResourceRequirements(
+        { ports: [3000, 3001] },
+        [],
+        [Then.resourceRequirementsSet()]
+      ),
+
+      // Core functionality tests
+      specGeneration: Given.Default(
+        ["Should generate specs from test specification"],
+        [],
+        [Then.specsGenerated()]
+      ),
+      jobCreation: Given.Default(
+        ["Should create test jobs from specs"],
+        [],
+        [Then.jobsCreated()]
+      ),
+      artifactTracking: Given.Default(
+        ["Should track artifacts"],
+        [When.addArtifact(Promise.resolve("test"))],
+        [Then.artifactsTracked()]
+      ),
+
+      // Configuration tests
+      overridesConfiguration: Given.Default(
+        ["Should properly configure all overrides"],
+        [],
+        [
+          Then.suitesOverridesConfigured(),
+          Then.givensOverridesConfigured(),
+          Then.whensOverridesConfigured(),
+          Then.thensOverridesConfigured(),
+        ]
+      ),
+      interfaceConfiguration: Given.WithCustomAdapter(
+        {
+          assertThis: (x) => !!x,
+          beforeEach: async (s, i) => i(),
+        },
+        [],
+        [Then.interfaceConfigured()]
+      ),
+    }),
+
+    Suite.ExtendedSuite("Tiposkripto Advanced Features", {
+      // Custom implementations
+      customImplementation: Given.WithCustomImplementation(
+        implementation,
+        [],
+        [Then.specsGenerated(), Then.jobsCreated()]
+      ),
+      customSpecification: Given.WithCustomSpecification(
+        specification,
+        [],
+        [Then.specsGenerated(), Then.jobsCreated()]
+      ),
+
+      // Dynamic modification tests
+      specModification: Given.Default(
+        ["Should allow modifying specs"],
+        [When.modifySpecs((specs) => [...specs, "extra"])],
+        [Then.specsModified(1)]
+      ),
+      jobModification: Given.Default(
+        ["Should allow modifying jobs"],
+        [When.modifyJobs((jobs) => [...jobs, {} as ITestJob])],
+        [Then.jobsModified(1)]
+      ),
+
+      // Error handling
+      errorHandling: Given.Default(
+        ["Should properly handle errors"],
+        [When.triggerError("test error")],
+        [Then.errorThrown("test error")]
+      ),
+
+      // Full test run
+      fullTestRun: Given.Default(
+        ["Should complete a full test run successfully"],
+        [],
+        [Then.testRunSuccessful()]
+      ),
+    }),
+  ];
+};

package/src/lib/Tiposkripto.test/Tiposkripto.ts

@@ -0,0 +1,15 @@
+import Testeranto from "../../Node";
+
+import { testAdapter } from "./Tiposkripto.adapter";
+import { I, O, M } from "./Tiposkripto.types";
+import { MockTiposkripto } from "./MockTiposkripto";
+import { specification } from "./Tiposkripto.specification";
+import { implementation } from "./Tiposkripto.implementation";
+
+export default Testeranto<I, O, M>(
+  MockTiposkripto.prototype,
+  specification,
+  implementation,
+  testAdapter,
+  { ports: 1 }
+);