testeranto 0.203.0 → 0.206.0

package/src/lib/BaseSuite.ts

@@ -34,7 +34,11 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
 
   addArtifact(path: string) {
     if (typeof path !== "string") {
-      throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
+          path
+        )}`
+      );
     }
     const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
     this.artifacts.push(normalizedPath);
@@ -61,10 +65,10 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
           return array.indexOf(value) === index;
         });
       // Convert all features to strings
-      const stringFeatures = features.map(feature => {
-        if (typeof feature === 'string') {
+      const stringFeatures = features.map((feature) => {
+        if (typeof feature === "string") {
           return feature;
-        } else if (feature && typeof feature === 'object') {
+        } else if (feature && typeof feature === "object") {
           return feature.name || JSON.stringify(feature);
         } else {
           return String(feature);
@@ -81,17 +85,19 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
     const givens = Object.keys(this.givens).map((k) => {
       const givenObj = this.givens[k].toObj();
       // Ensure given features are strings
-      if (givenObj.features) {
-        givenObj.features = givenObj.features.map(feature => {
-          if (typeof feature === 'string') {
-            return feature;
-          } else if (feature && typeof feature === 'object') {
-            return feature.name || JSON.stringify(feature);
-          } else {
-            return String(feature);
-          }
-        });
-      }
+      // if (givenObj.features) {
+      //   givenObj.features = givenObj.features.map(feature => {
+
+      //     return feature;
+      //     // if (typeof feature === 'string') {
+      //     //   return feature;
+      //     // } else if (feature && typeof feature === 'object') {
+      //     //   return feature.name || JSON.stringify(feature);
+      //     // } else {
+      //     //   return String(feature);
+      //     // }
+      //   });
+      // }
       return givenObj;
     });
 
@@ -101,7 +107,9 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
       fails: this.fails,
       failed: this.failed,
       features: this.features(),
-      artifacts: this.artifacts ? this.artifacts.filter(art => typeof art === 'string') : [],
+      artifacts: this.artifacts
+        ? this.artifacts.filter((art) => typeof art === "string")
+        : [],
     };
   }
 

package/src/lib/BaseThen.ts

@@ -14,6 +14,7 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
   thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
   error: boolean;
   artifacts: string[] = [];
+  status: boolean | undefined;
 
   constructor(
     name: string,
@@ -42,6 +43,7 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
       name: this.name,
       error: this.error,
       artifacts: this.artifacts,
+      status: this.status,
     };
     return obj;
   }
@@ -63,9 +65,9 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
     // Ensure addArtifact is properly bound to 'this'
     const addArtifact = this.addArtifact.bind(this);
     const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-    
+
     try {
-      return await this.butThen(
+      const x = await this.butThen(
         store,
         async (s: I["iselection"]) => {
           try {
@@ -85,10 +87,11 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
         testResourceConfiguration,
         proxiedPm
       );
+      this.status = true;
+      return x;
     } catch (e) {
-      // Record the error and mark this then step as failed
+      this.status = false;
       this.error = true;
-      // Re-throw to propagate to the test runner
       throw e;
     }
   }

package/src/lib/BaseWhen.ts

@@ -14,6 +14,7 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
   whenCB: (x: I["iselection"]) => I["then"];
   error: Error;
   artifacts: string[] = [];
+  status: boolean | undefined;
 
   addArtifact(path: string) {
     if (typeof path !== "string") {
@@ -42,15 +43,12 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
   toObj() {
     const obj = {
       name: this.name,
+      status: this.status,
       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;
   }
 
@@ -66,22 +64,16 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
       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
       );
-
+      this.status = true;
       return result;
     } catch (e: any) {
-      console.error(
-        "[ERROR] When step failed:",
-        this.name.toString(),
-        e.toString()
-      );
+      this.status = false;
       this.error = e;
       throw e;
     }

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.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>;
@@ -225,26 +224,8 @@ export default abstract class Tiposkripto<
       this.Then()
     );
 
-    // Debug: log the structure of the first suite to see if whens are properly set up
-    // if (this.specs.length > 0 && this.specs[0]) {
-    //   const firstSuite = this.specs[0] as any;
-    //   if (firstSuite.givens) {
-    //     Object.entries(firstSuite.givens).forEach(([givenKey, given]) => {
-    //       console.log(`[DEBUG] Given "${givenKey}":`, {
-    //         name: given.name,
-    //         whens: given.whens ? given.whens.map((w) => w?.name) : [],
-    //         thens: given.thens ? given.thens.map((t) => t?.name) : [],
-    //       });
-    //     });
-    //   }
-    // }
-
-    // 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>) =>
@@ -294,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),