testeranto 0.202.0 → 0.205.0

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

@@ -31,11 +31,10 @@ export class MockTiposkripto<
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
     testImplementation: ITestImplementation<I, O, M>,
-    testResourceRequirement: ITTestResourceRequest = { ports: [] },
+    testResourceRequirement: ITTestResourceRequest = { ports: 0 },
     testAdapter: Partial<ITestAdapter<I>>,
     uberCatcher: (cb: () => void) => void = (cb) => cb()
   ) {
-    // Call super first
     super(
       input,
       testSpecification,
@@ -44,103 +43,101 @@ export class MockTiposkripto<
       testAdapter,
       uberCatcher
     );
-    
+
     this.testImplementation = testImplementation;
-    // Add debug logging for features
-    console.log('MockTiposkripto constructor called with input:', JSON.stringify(input));
-    // Validate required implementation methods
-    const requiredMethods = ["suites", "givens", "whens", "thens"];
-    requiredMethods.forEach((method) => {
-      if (!testImplementation[method]) {
-        throw new Error(`Missing required implementation method: ${method}`);
-      }
-    });
-    
-    // Store the test adapter
+
     this.testAdapter = testAdapter;
-    
+
     // Store implementation methods as overrides
     this.suitesOverrides = testImplementation.suites as any;
     this.givenOverides = testImplementation.givens as any;
     this.whenOverides = testImplementation.whens as any;
     this.thenOverides = testImplementation.thens as any;
-    
+
     // Calculate total number of tests (sum of all Givens across all Suites)
     // For testing purposes, we'll use the number of Givens in the implementation
     // Each Given corresponds to one test
     let totalTests = Object.keys(testImplementation.givens).length;
-    
+
     // Override with specific values for test cases
-    if (input && typeof input === 'object') {
+    if (input && typeof input === "object") {
       const inputObj = input as Record<string, unknown>;
-      if ('testCount' in inputObj) {
+      if ("testCount" in inputObj) {
         totalTests = Number(inputObj.testCount);
       }
     }
-    
+
     // Extract features from the test specification
     try {
       this.features = this.extractFeaturesFromSpecification(testSpecification);
     } catch (error) {
-      console.error('Failed to extract features, using fallback:', error);
+      console.error("Failed to extract features, using fallback:", error);
       // Fallback to basic features
       this.features = [
-        'Tiposkripto should initialize with default values',
-        'Custom input test',
-        'Resource requirements test',
-        'Should generate specs from test specification',
-        'Should create test jobs from specs',
-        'Should track artifacts',
-        'Should properly configure all overrides',
-        'Interface configuration test',
-        'Custom implementation test',
-        'Custom specification test',
-        'Should allow modifying specs',
-        'Should allow modifying jobs',
-        'Should properly handle errors',
-        'Should complete a full test run successfully',
-        'Should correctly count the number of tests',
-        'Should set runTimeTests to -1 on hard errors',
-        'Given a config that has 1 suite containing 5 GivenWhenThens',
-        'Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens'
+        "Tiposkripto should initialize with default values",
+        "Custom input test",
+        "Resource requirements test",
+        "Should generate specs from test specification",
+        "Should create test jobs from specs",
+        "Should track artifacts",
+        "Should properly configure all overrides",
+        "Interface configuration test",
+        "Custom implementation test",
+        "Custom specification test",
+        "Should allow modifying specs",
+        "Should allow modifying jobs",
+        "Should properly handle errors",
+        "Should complete a full test run successfully",
+        "Should correctly count the number of tests",
+        "Should set runTimeTests to -1 on hard errors",
+        "Given a config that has 1 suite containing 5 GivenWhenThens",
+        "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
       ];
     }
   }
 
-  private extractFeaturesFromSpecification(specification: ITestSpecification<I, O>): string[] {
+  private extractFeaturesFromSpecification(
+    specification: ITestSpecification<I, O>
+  ): string[] {
     try {
       // Create proper mock functions that match the expected signatures
       // The Suite function should take name, tests, and features
-      const mockSuite = (name: string, tests: Record<string, any>, features: any[]) => ({ 
-        name, 
+      const mockSuite = (
+        name: string,
+        tests: Record<string, any>,
+        features: any[]
+      ) => ({
+        name,
         tests,
-        features 
+        features,
       });
-      
+
       // The Given function should take features, whens, thens
       const mockGiven = (features: string[], whens: any[], thens: any[]) => {
         return {
-          features: Array.isArray(features) ? features.filter(f => typeof f === 'string') : [],
+          features: Array.isArray(features)
+            ? features.filter((f) => typeof f === "string")
+            : [],
           whens,
-          thens
+          thens,
         };
       };
-      
+
       // Create mock When and Then objects that have all the methods from the implementation
       // We need to dynamically create objects with all the method names from this.testImplementation.whens and this.testImplementation.thens
       const mockWhen: any = {};
       const mockThen: any = {};
-      
+
       // Add all when methods
       if (this.testImplementation.whens) {
-        Object.keys(this.testImplementation.whens).forEach(key => {
+        Object.keys(this.testImplementation.whens).forEach((key) => {
           mockWhen[key] = (...args: any[]) => ({ name: key, args });
         });
       }
-      
+
       // Add all then methods
       if (this.testImplementation.thens) {
-        Object.keys(this.testImplementation.thens).forEach(key => {
+        Object.keys(this.testImplementation.thens).forEach((key) => {
           mockThen[key] = (...args: any[]) => ({ name: key, args });
         });
       }
@@ -156,13 +153,13 @@ export class MockTiposkripto<
       // Extract all features from all tests in all suites
       const features: string[] = [];
       for (const suite of suites) {
-        if (suite && suite.tests && typeof suite.tests === 'object') {
+        if (suite && suite.tests && typeof suite.tests === "object") {
           for (const testKey of Object.keys(suite.tests)) {
             const test = suite.tests[testKey];
             if (test && test.features && Array.isArray(test.features)) {
               // Ensure all features are strings
               for (const feature of test.features) {
-                if (typeof feature === 'string') {
+                if (typeof feature === "string") {
                   features.push(feature);
                 }
               }
@@ -170,13 +167,12 @@ export class MockTiposkripto<
           }
         }
       }
-      
+
       // Remove duplicates
       const uniqueFeatures = [...new Set(features)];
-      console.log('Extracted features:', JSON.stringify(uniqueFeatures));
       return uniqueFeatures;
     } catch (error) {
-      console.error('Error extracting features from specification:', error);
+      console.error("Error extracting features from specification:", error);
       return [];
     }
   }
@@ -189,21 +185,21 @@ export class MockTiposkripto<
       if (!this.testAdapter) {
         throw new Error("Test adapter not configured");
       }
-      
+
       // Ensure features are always strings
-      const stringFeatures = this.features.filter(f => typeof f === 'string');
-      
+      const stringFeatures = this.features.filter((f) => typeof f === "string");
+
       // Calculate totalTests based on input
       let totalTests = Object.keys((this as any).givenOverides).length;
       const input = (this as any).input;
-      
+
       // Override with specific values for test cases
-      if (input && typeof input === 'object') {
-        if ('testCount' in input) {
+      if (input && typeof input === "object") {
+        if ("testCount" in input) {
           totalTests = (input as any).testCount;
         }
       }
-      
+
       // Simulate running tests
       return {
         failed: false,

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

@@ -1,8 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { PassThrough } from "stream";
 
-import { ITestImplementation, ITestSpecification, ITestAdapter } from "../../CoreTypes";
+import {
+  ITestImplementation,
+  ITestSpecification,
+  ITestAdapter,
+} from "../../CoreTypes";
 import { MockTiposkripto } from "./MockTiposkripto";
 
 import { I, O, M } from "./Tiposkripto.types";
@@ -23,7 +26,7 @@ export const implementation: ITestImplementation<I, O, M> = {
         {}, // input
         specification, // Use the current specification
         implementation, // Use the current implementation
-        { ports: [] }, // Default resource requirements
+        { ports: 0 }, // Default resource requirements
         testAdapter, // Default adapter
         (cb) => cb() // Default uberCatcher
       );
@@ -39,12 +42,14 @@ export const implementation: ITestImplementation<I, O, M> = {
         input,
         specification,
         implementation,
-        { ports: [] },
+        { ports: 0 },
         testAdapter,
         (cb) => cb()
       );
     },
-    WithResourceRequirements: (requirements: ITTestResourceRequest = { ports: 0 }) => {
+    WithResourceRequirements: (
+      requirements: ITTestResourceRequest = { ports: 0 }
+    ) => {
       return new MockTiposkripto(
         {},
         specification,
@@ -54,22 +59,26 @@ export const implementation: ITestImplementation<I, O, M> = {
         (cb) => cb()
       );
     },
-    WithCustomImplementation: (impl: ITestImplementation<any, any> = implementation) => {
+    WithCustomImplementation: (
+      impl: ITestImplementation<any, any> = implementation
+    ) => {
       return new MockTiposkripto(
         {},
         specification,
         impl,
-        { ports: [] },
+        { ports: 0 },
         testAdapter,
         (cb) => cb()
       );
     },
-    WithCustomSpecification: (spec: ITestSpecification<any, any> = specification) => {
+    WithCustomSpecification: (
+      spec: ITestSpecification<any, any> = specification
+    ) => {
       return new MockTiposkripto(
         {},
         spec,
         implementation,
-        { ports: [] },
+        { ports: 0 },
         testAdapter,
         (cb) => cb()
       );
@@ -79,7 +88,7 @@ export const implementation: ITestImplementation<I, O, M> = {
         {},
         specification,
         implementation,
-        { ports: [] },
+        { ports: 0 },
         { ...testAdapter, ...customAdapter },
         (cb) => cb()
       );
@@ -193,16 +202,16 @@ export const implementation: ITestImplementation<I, O, M> = {
       }
       // Check if the test adapter has the required methods
       const requiredMethods = [
-        'beforeAll',
-        'beforeEach',
-        'andWhen',
-        'butThen',
-        'afterEach',
-        'afterAll',
-        'assertThis'
+        "beforeAll",
+        "beforeEach",
+        "andWhen",
+        "butThen",
+        "afterEach",
+        "afterAll",
+        "assertThis",
       ];
       for (const method of requiredMethods) {
-        if (typeof builder.testAdapter[method] !== 'function') {
+        if (typeof builder.testAdapter[method] !== "function") {
           throw new Error(`Test adapter missing required method: ${method}`);
         }
       }
@@ -232,7 +241,9 @@ export const implementation: ITestImplementation<I, O, M> = {
       const result = await builder.receiveTestResourceConfig("");
       // The total number of tests should be greater than 0
       if (result.runTimeTests <= 0) {
-        throw new Error(`Expected runTimeTests > 0, got ${result.runTimeTests}`);
+        throw new Error(
+          `Expected runTimeTests > 0, got ${result.runTimeTests}`
+        );
       }
       return builder;
     },
@@ -245,7 +256,9 @@ export const implementation: ITestImplementation<I, O, M> = {
     runTimeTestsCountIs: (expectedCount: number) => async (builder: any) => {
       const result = await builder.receiveTestResourceConfig("");
       if (result.runTimeTests !== expectedCount) {
-        throw new Error(`Expected runTimeTests to be ${expectedCount}, got ${result.runTimeTests}`);
+        throw new Error(
+          `Expected runTimeTests to be ${expectedCount}, got ${result.runTimeTests}`
+        );
       }
       return builder;
     },

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

@@ -1,7 +1,6 @@
 import { ITestSpecification } from "../../CoreTypes";
 
 import { I, O } from "./Tiposkripto.types";
-import { implementation } from "./Tiposkripto.implementation";
 import { ITestJob } from "..";
 
 export const specification: ITestSpecification<I, O> = (
@@ -73,14 +72,12 @@ export const specification: ITestSpecification<I, O> = (
       customImplementation: Given.WithCustomImplementation(
         ["Custom implementation test"],
         [],
-        [Then.specsGenerated(), Then.jobsCreated()],
-        implementation
+        [Then.specsGenerated(), Then.jobsCreated()]
       ),
       customSpecification: Given.WithCustomSpecification(
         ["Custom specification test"],
         [],
-        [Then.specsGenerated(), Then.jobsCreated()],
-        specification
+        [Then.specsGenerated(), Then.jobsCreated()]
       ),
 
       // Dynamic modification tests
@@ -120,7 +117,7 @@ export const specification: ITestSpecification<I, O> = (
         [When.triggerError("test error")],
         [Then.runTimeTestsSetToNegativeOne()]
       ),
-      
+
       // Specific test cases for runTimeTests behavior
       runTimeTestsSingleSuiteFiveTests: Given.WithCustomInput(
         ["Given a config that has 1 suite containing 5 GivenWhenThens"],
@@ -135,13 +132,17 @@ export const specification: ITestSpecification<I, O> = (
         { testCount: 5 }
       ),
       runTimeTestsTwoSuitesThreeTestsEach: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"],
+        [
+          "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+        ],
         [],
         [Then.runTimeTestsCountIs(6)],
         { testCount: 6 }
       ),
       runTimeTestsTwoSuitesThreeTestsEachError: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"],
+        [
+          "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+        ],
         [When.triggerError("hard error")],
         [Then.runTimeTestsIsNegativeOne()],
         { testCount: 6 }

package/src/lib/Tiposkripto.ts

@@ -39,7 +39,6 @@ export default abstract class Tiposkripto<
   O extends Ibdd_out_any = Ibdd_out_any,
   M = unknown
 > {
-  // Add the receiveTestResourceConfig method from TesterantoCore
   abstract receiveTestResourceConfig(
     partialTestResource: string
   ): Promise<IFinalResults>;
@@ -111,13 +110,25 @@ export default abstract class Tiposkripto<
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
         a[key] = (
-          name: string,
+          // name: string,
           features: string[],
           whens: BaseWhen<I>[],
           thens: BaseThen<I>[],
           gcb: I["given"],
           initialValues: any
         ) => {
+          // Debug the parameters being passed - check if features contains when-like objects
+          // console.log(`[Tiposkripto] Creating Given ${key} with:`);
+          // console.log(`  name: ${name}`);
+          // console.log(`  features:`, features);
+          // console.log(`  whens:`, whens);
+          // console.log(`  thens:`, thens);
+
+          // Ensure parameters are arrays and create copies to avoid reference issues
+          const safeFeatures = Array.isArray(features) ? [...features] : [];
+          const safeWhens = Array.isArray(whens) ? [...whens] : [];
+          const safeThens = Array.isArray(thens) ? [...thens] : [];
+
           return new (class extends BaseGiven<I> {
             uberCatcher = uberCatcher;
 
@@ -147,10 +158,10 @@ export default abstract class Tiposkripto<
               return Promise.resolve(fullAdapter.afterEach(store, key, pm));
             }
           })(
-            name,
-            features,
-            whens,
-            thens,
+            // name,
+            safeFeatures,
+            safeWhens,
+            safeThens,
             testImplementation.givens[key],
             initialValues
           );
@@ -163,11 +174,13 @@ export default abstract class Tiposkripto<
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]: [string, (...x: any[]) => any]) => {
         a[key] = (...payload: any[]) => {
-          return new (class extends BaseWhen<I> {
+          const whenInstance = new (class extends BaseWhen<I> {
             async andWhen(store, whenCB, testResource, pm) {
               return await fullAdapter.andWhen(store, whenCB, testResource, pm);
             }
           })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+          // console.log(`[Tiposkripto] Created When ${key}:`, whenInstance.name);
+          return whenInstance;
         };
         return a;
       },
@@ -177,7 +190,7 @@ export default abstract class Tiposkripto<
     const classyThens = Object.entries(testImplementation.thens).reduce(
       (a, [key, thEn]: [string, (...x: any[]) => any]) => {
         a[key] = (...args: any[]) => {
-          return new (class extends BaseThen<I> {
+          const thenInstance = new (class extends BaseThen<I> {
             async butThen(
               store: any,
               thenCB,
@@ -187,6 +200,8 @@ export default abstract class Tiposkripto<
               return await fullAdapter.butThen(store, thenCB, testResource, pm);
             }
           })(`${key}: ${args && args.toString()}`, thEn(...args));
+          // console.log(`[Tiposkripto] Created Then ${key}:`, thenInstance.name);
+          return thenInstance;
         };
         return a;
       },
@@ -209,12 +224,8 @@ export default abstract class Tiposkripto<
       this.Then()
     );
 
-    // Calculate total number of tests (sum of all Givens across all Suites)
-    // Each suite should have a 'givens' property that's a record of test names to BaseGiven instances
     this.totalTests = this.calculateTotalTests();
-    console.log(`Total tests calculated: ${this.totalTests}`);
 
-    // Create test jobs
     this.testJobs = this.specs.map((suite: BaseSuite<I, O>) => {
       const suiteRunner =
         (suite: BaseSuite<I, O>) =>
@@ -264,6 +275,7 @@ export default abstract class Tiposkripto<
           try {
             const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
             const fails = suiteDone.fails;
+            // Always use PM.writeFileSync to write tests.json, not direct filesystem access
             await puppetMaster.writeFileSync(
               `tests.json`,
               JSON.stringify(this.toObj(), null, 2),
@@ -336,12 +348,12 @@ export default abstract class Tiposkripto<
   private calculateTotalTests(): number {
     let total = 0;
     for (const suite of this.specs) {
-      if (suite && typeof suite === 'object') {
+      if (suite && typeof suite === "object") {
         // Access the givens property which should be a record of test names to BaseGiven instances
         // The givens property is typically on the suite instance
-        if ('givens' in suite) {
+        if ("givens" in suite) {
           const givens = (suite as any).givens;
-          if (givens && typeof givens === 'object') {
+          if (givens && typeof givens === "object") {
             total += Object.keys(givens).length;
           }
         }