testeranto 0.200.1 → 0.203.0

package/src/lib/Tiposkripto.ts

@@ -50,6 +50,7 @@ export default abstract class Tiposkripto<
   testResourceRequirement: ITTestResourceRequest;
   artifacts: Promise<unknown>[] = [];
   testJobs: ITestJob[];
+  private totalTests: number;
   testSpecification: ITestSpecification<I, O>;
   suitesOverrides: Record<keyof IExtenstions, any>;
   givenOverides: Record<keyof IExtenstions, any>;
@@ -110,13 +111,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;
 
@@ -146,10 +159,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
           );
@@ -162,11 +175,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;
       },
@@ -176,7 +191,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,
@@ -186,6 +201,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;
       },
@@ -208,6 +225,25 @@ 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 =
@@ -269,6 +305,8 @@ export default abstract class Tiposkripto<
               fails,
               artifacts: this.artifacts || [],
               features: suiteDone.features(),
+              tests: 0, // Keep existing field
+              runTimeTests: this.totalTests, // Add the total number of tests
             };
           } catch (e) {
             console.error(e.stack);
@@ -277,6 +315,8 @@ export default abstract class Tiposkripto<
               fails: -1,
               artifacts: this.artifacts || [],
               features: [],
+              tests: 0, // Keep existing field
+              runTimeTests: -1, // Set to -1 on hard error
             };
           }
         },
@@ -322,4 +362,21 @@ export default abstract class Tiposkripto<
   getTestJobs(): ITestJob[] {
     return this.testJobs;
   }
+
+  private calculateTotalTests(): number {
+    let total = 0;
+    for (const suite of this.specs) {
+      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) {
+          const givens = (suite as any).givens;
+          if (givens && typeof givens === "object") {
+            total += Object.keys(givens).length;
+          }
+        }
+      }
+    }
+    return total;
+  }
 }

package/src/lib/index.ts

@@ -131,6 +131,11 @@ export type IRunnables = {
   webEntryPointSidecars: Record<string, string>;
   pureEntryPoints: Record<string, string>;
   pureEntryPointSidecars: Record<string, string>;
+
+  pythonEntryPoints: Record<string, string>;
+  pythonEntryPointSidecars: Record<string, string>;
+  golangEntryPoints: Record<string, string>;
+  golangEntryPointSidecars: Record<string, string>;
 };
 
 export type IFinalResults = {
@@ -138,5 +143,7 @@ export type IFinalResults = {
   failed: boolean;
   fails: number;
   artifacts: Promise<unknown>[];
+  tests: number;
+  runTimeTests: number;
   // logPromise: Promise<unknown>;
 };

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

@@ -2,6 +2,8 @@ import { ITestSpecification } from "../../CoreTypes";
 
 import { I, O } from "./types";
 
+console.log("wtf");
+
 export const specification: ITestSpecification<I, O> = (
   Suite,
   Given,
@@ -21,175 +23,175 @@ export const specification: ITestSpecification<I, O> = (
       ],
       "writeFileSync test"
     ),
-    createWriteStreamProxyTest: Given.SomeBaseString(
-      ["butThenProxy should rewrite createWriteStream paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "createWriteStream",
-          "test/path/butThen/stream.txt"
-        ),
-      ],
-      "createWriteStream test"
-    ),
-    screencastProxyTest: Given.SomeBaseString(
-      ["butThenProxy should rewrite screencast paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "screencast",
-          "test/path/butThen/screen.png"
-        ),
-      ],
-      "screencast test"
-    ),
-    customScreenShotProxyTest: Given.SomeBaseString(
-      ["butThenProxy should rewrite customScreenShot paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "customScreenShot",
-          "test/path/butThen/shot.png"
-        ),
-      ],
-      "customScreenShot test"
-    ),
+    // createWriteStreamProxyTest: Given.SomeBaseString(
+    //   ["butThenProxy should rewrite createWriteStream paths"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "createWriteStream",
+    //       "test/path/butThen/stream.txt"
+    //     ),
+    //   ],
+    //   "createWriteStream test"
+    // ),
+    // screencastProxyTest: Given.SomeBaseString(
+    //   ["butThenProxy should rewrite screencast paths"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "screencast",
+    //       "test/path/butThen/screen.png"
+    //     ),
+    //   ],
+    //   "screencast test"
+    // ),
+    // customScreenShotProxyTest: Given.SomeBaseString(
+    //   ["butThenProxy should rewrite customScreenShot paths"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "customScreenShot",
+    //       "test/path/butThen/shot.png"
+    //     ),
+    //   ],
+    //   "customScreenShot test"
+    // ),
 
-    // Edge cases
-    emptyPathTest: Given.SomeBaseString(
-      ["butThenProxy should handle empty paths"],
-      [],
-      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
-      "empty path test"
-    ),
-    nestedPathTest: Given.SomeBaseString(
-      ["butThenProxy should handle nested paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/nested/folder/test.txt"
-        ),
-      ],
-      "nested path test"
-    ),
-    specialCharsTest: Given.SomeBaseString(
-      ["butThenProxy should handle special characters in paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/file with spaces.txt"
-        ),
-      ],
-      "special chars test"
-    ),
-    testsJsonTest: Given.SomeBaseString(
-      ["butThenProxy should handle tests.json correctly"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/tests.json"
-        ),
-      ],
-      "tests.json test"
-    ),
+    // // Edge cases
+    // emptyPathTest: Given.SomeBaseString(
+    //   ["butThenProxy should handle empty paths"],
+    //   [],
+    //   [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
+    //   "empty path test"
+    // ),
+    // nestedPathTest: Given.SomeBaseString(
+    //   ["butThenProxy should handle nested paths"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "writeFileSync",
+    //       "test/path/butThen/nested/folder/test.txt"
+    //     ),
+    //   ],
+    //   "nested path test"
+    // ),
+    // specialCharsTest: Given.SomeBaseString(
+    //   ["butThenProxy should handle special characters in paths"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "writeFileSync",
+    //       "test/path/butThen/file with spaces.txt"
+    //     ),
+    //   ],
+    //   "special chars test"
+    // ),
+    // testsJsonTest: Given.SomeBaseString(
+    //   ["butThenProxy should handle tests.json correctly"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "writeFileSync",
+    //       "test/path/butThen/tests.json"
+    //     ),
+    //   ],
+    //   "tests.json test"
+    // ),
   }),
 
-  Suite.Default("Proxy Type Coverage", {
-    // Test all proxy types
-    butThenProxyTest: Given.SomeBaseString(
-      ["butThenProxy should work correctly"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/test.txt"
-        ),
-      ],
-      "butThenProxy test"
-    ),
-    andWhenProxyTest: Given.SomeBaseString(
-      ["andWhenProxy should work correctly"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/andWhen/test.txt"
-        ),
-      ],
-      "andWhenProxy test"
-    ),
-    beforeEachProxyTest: Given.SomeBaseString(
-      ["beforeEachProxy should work correctly"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "suite-1/beforeEach/test.txt"
-        ),
-      ],
-      "beforeEachProxy test"
-    ),
-    afterEachProxyTest: Given.SomeBaseString(
-      ["afterEachProxy should work correctly"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "suite-1/given-1/afterEach/test.txt"
-        ),
-      ],
-      "afterEachProxy test"
-    ),
-  }),
+  // Suite.Default("Proxy Type Coverage", {
+  //   // Test all proxy types
+  //   butThenProxyTest: Given.SomeBaseString(
+  //     ["butThenProxy should work correctly"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "test/path/butThen/test.txt"
+  //       ),
+  //     ],
+  //     "butThenProxy test"
+  //   ),
+  //   andWhenProxyTest: Given.SomeBaseString(
+  //     ["andWhenProxy should work correctly"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "test/path/andWhen/test.txt"
+  //       ),
+  //     ],
+  //     "andWhenProxy test"
+  //   ),
+  //   beforeEachProxyTest: Given.SomeBaseString(
+  //     ["beforeEachProxy should work correctly"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "suite-1/beforeEach/test.txt"
+  //       ),
+  //     ],
+  //     "beforeEachProxy test"
+  //   ),
+  //   afterEachProxyTest: Given.SomeBaseString(
+  //     ["afterEachProxy should work correctly"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "suite-1/given-1/afterEach/test.txt"
+  //       ),
+  //     ],
+  //     "afterEachProxy test"
+  //   ),
+  // }),
 
-  Suite.Default("Content Preservation", {
-    // Verify content is preserved
-    contentPreservationTest: Given.SomeBaseString(
-      ["Proxies should preserve file content"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/test.txt"
-        ),
-        Then.verifyContent("test content"),
-      ],
-      "content preservation test"
-    ),
-    objectContentTest: Given.SomeBaseString(
-      ["Proxies should preserve object content"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "screencast",
-          "test/path/butThen/screen.png"
-        ),
-        Then.verifyContent({ quality: 80, fullPage: true }),
-      ],
-      "object content test"
-    ),
-  }),
+  // Suite.Default("Content Preservation", {
+  //   // Verify content is preserved
+  //   contentPreservationTest: Given.SomeBaseString(
+  //     ["Proxies should preserve file content"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "test/path/butThen/test.txt"
+  //       ),
+  //       Then.verifyContent("test content"),
+  //     ],
+  //     "content preservation test"
+  //   ),
+  //   objectContentTest: Given.SomeBaseString(
+  //     ["Proxies should preserve object content"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "screencast",
+  //         "test/path/butThen/screen.png"
+  //       ),
+  //       Then.verifyContent({ quality: 80, fullPage: true }),
+  //     ],
+  //     "object content test"
+  //   ),
+  // }),
 
-  Suite.Default("Error Cases", {
-    invalidPathTest: Given.SomeBaseString(
-      ["Proxies should handle invalid paths"],
-      [],
-      [
-        Then.theButTheProxyReturns(
-          "writeFileSync",
-          "test/path/butThen/../invalid.txt"
-        ),
-      ],
-      "invalid path test"
-    ),
-    undefinedInputTest: Given.SomeBaseString(
-      ["Proxies should handle undefined inputs"],
-      [],
-      [Then.theButTheProxyReturns("writeFileSync", undefined)],
-      "undefined input test"
-    ),
-  }),
+  // Suite.Default("Error Cases", {
+  //   invalidPathTest: Given.SomeBaseString(
+  //     ["Proxies should handle invalid paths"],
+  //     [],
+  //     [
+  //       Then.theButTheProxyReturns(
+  //         "writeFileSync",
+  //         "test/path/butThen/../invalid.txt"
+  //       ),
+  //     ],
+  //     "invalid path test"
+  //   ),
+  //   undefinedInputTest: Given.SomeBaseString(
+  //     ["Proxies should handle undefined inputs"],
+  //     [],
+  //     [Then.theButTheProxyReturns("writeFileSync", undefined)],
+  //     "undefined input test"
+  //   ),
+  // }),
 ];

package/src/lib/pmProxy.ts

@@ -90,6 +90,25 @@ export const butThenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
+        // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] createWriteStream fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // // Ensure fp is always a string
+        // if (typeof fp !== "string") {
+        //   console.error(
+        //     `[PROXY ERROR] createWriteStream fp is not a string:`,
+        //     fp
+        //   );
+        //   // Don't convert, just throw to find the source
+        //   throw new Error(
+        //     `createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/butThen/${fp}`;
         addArtifact(path);
         return [path];
@@ -98,25 +117,17 @@ export const butThenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
-        console.log(
-          `[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`
-        );
-        // Check if fp is being treated as individual characters
-        if (typeof fp !== "string") {
-          console.log(`[ERROR] fp is not a string:`, fp);
-          // If fp is not a string, try to handle it
-          if (Array.isArray(fp)) {
-            // If it's an array, join it back into a string
-            fp = fp.join("");
-            console.log(`[DEBUG] Converted array to string: "${fp}"`);
-          } else {
-            // For other cases, convert to string
-            fp = String(fp);
-            console.log(`[DEBUG] Converted to string: "${fp}"`);
-          }
-        }
+        // Add debug logging to see what fp is
+        // console.log(`[DEBUG] writeFileSync fp type: ${typeof fp}, value:`, fp);
+
+        // Ensure fp is always a string
+        // if (typeof fp !== "string") {
+        //   console.error(`[PROXY ERROR] writeFileSync fp is not a string:`, fp);
+        //   // Don't convert, just throw to find the source
+        //   throw new Error(`writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(fp)}`);
+        // }
         const path = `${filepath}/butThen/${fp}`;
-        console.log(`[DEBUG] Generated path: "${path}"`);
+        // console.log(`[DEBUG] Adding artifact: "${path}"`);
         addArtifact(path);
         return [path, contents, testName];
       },
@@ -162,6 +173,19 @@ export const andWhenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
+        // // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] andWhen createWriteStream fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // if (typeof fp !== "string") {
+        //   throw new Error(
+        //     `andWhen createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path];
@@ -171,6 +195,19 @@ export const andWhenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
+        // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] andWhen writeFileSync fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // if (typeof fp !== "string") {
+        //   throw new Error(
+        //     `andWhen writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path, contents, testName];