testeranto 0.166.0 → 0.171.0

package/src/lib/abstractBase.ts

@@ -26,6 +26,11 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
   initialValues: any;
   key: string;
   failed: boolean;
+  artifacts: string[] = [];
+  protected addArtifact(path: string) {
+    console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
+    this.artifacts.push(path);
+  }
 
   constructor(
     name: string,
@@ -54,13 +59,14 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
       whens: this.whens.map((w) => {
         if (w && w.toObj) return w.toObj();
 
-        console.error("w is not as expected!", w);
+        console.error("w is not as expected!", w.toString());
         return {};
       }),
       thens: this.thens.map((t) => t.toObj()),
       error: this.error ? [this.error, this.error.stack] : null,
       failed: this.failed,
       features: this.features,
+      artifacts: this.artifacts,
     };
   }
 
@@ -103,22 +109,25 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
       artifactory(`given-${key}/${fPath}`, value);
 
     this.uberCatcher((e) => {
-      console.error(e);
+      console.error(e.toString());
       this.error = e.error;
       tLog(e.stack);
     });
 
     try {
+      const proxiedPm = beforeEachProxy(pm, suiteNdx.toString());
+      console.log(`[Given] Setting currentStep for beforeEach:`, this.name);
+      (proxiedPm as any).currentStep = this;
       this.store = await this.givenThat(
         subject,
         testResourceConfiguration,
         givenArtifactory,
         this.givenCB,
         this.initialValues,
-        beforeEachProxy(pm, suiteNdx.toString())
+        proxiedPm
       );
     } catch (e) {
-      console.error("failure 4 ", e);
+      console.error("Given failure: ", e.toString());
       this.error = e;
       throw e;
     }
@@ -163,7 +172,7 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
           afterEachProxy(pm, suiteNdx.toString(), key)
         );
       } catch (e) {
-        console.error("afterEach failed!", e);
+        console.error("afterEach failed!", e.toString());
         this.failed = e;
         throw e;
 
@@ -178,6 +187,7 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
   public name: string;
   whenCB: (x: I["iselection"]) => I["then"];
   error: Error;
+  artifacts: string[] = [];
 
   constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]) {
     this.name = name;
@@ -193,10 +203,19 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
 
   toObj() {
     console.log("toObj error", this.error);
-    return {
-      name: this.name,
-      error: this.error && this.error.name + this.error.stack,
-    };
+
+    if (this.error) {
+      return {
+        name: this.name,
+        error: this.error && this.error.name + this.error.stack,
+        artifacts: this.artifacts,
+      };
+    } else {
+      return {
+        name: this.name,
+        artifacts: this.artifacts,
+      };
+    }
   }
 
   async test(
@@ -208,19 +227,26 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
   ) {
     try {
       tLog(" When:", this.name);
-      console.debug("[DEBUG] Executing When step:", this.name);
+      console.debug("[DEBUG] Executing When step:", this.name.toString());
 
+      const proxiedPm = andWhenProxy(pm, filepath);
+      console.log(`[When] Setting currentStep for andWhen:`, this.name);
+      (proxiedPm as any).currentStep = this;
       const result = await this.andWhen(
         store,
         this.whenCB,
         testResourceConfiguration,
-        andWhenProxy(pm, filepath)
+        proxiedPm
       );
 
-      console.debug("[DEBUG] When step completed:", this.name);
+      console.debug("[DEBUG] When step completed:", this.name.toString());
       return result;
     } catch (e: Error) {
-      console.error("[ERROR] When step failed:", this.name, e);
+      console.error(
+        "[ERROR] When step failed:",
+        this.name.toString(),
+        e.toString()
+      );
       this.error = e;
       throw e;
     }
@@ -231,6 +257,7 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
   public name: string;
   thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
   error: boolean;
+  artifacts: string[] = [];
 
   constructor(
     name: string,
@@ -245,6 +272,7 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
     return {
       name: this.name,
       error: this.error,
+      artifacts: this.artifacts,
     };
   }
 
@@ -263,11 +291,14 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
     pm: IPM,
     filepath: string
   ): Promise<I["then"] | undefined> {
+    const proxiedPm = butThenProxy(pm, filepath);
+    console.log(`[Then] Setting currentStep for butThen:`, this.name);
+    (proxiedPm as any).currentStep = this;
     return this.butThen(
       store,
       async (s: I["iselection"]) => {
         if (typeof this.thenCB === "function") {
-          return await this.thenCB(s);
+          return await this.thenCB(s, proxiedPm);
         } else {
           return this.thenCB;
         }

package/src/lib/baseBuilder.test/baseBuilder.test.adapter.ts

@@ -13,7 +13,7 @@ export const testAdapter: ITestAdapter<I> = {
       initialValues,
     });
     const result = initializer();
-    console.log("Initialization result:", result);
+    console.log("Initialization result:", result.toString());
     return result;
   },
   andWhen: async (store, whenCB, testResource, utils) => {

package/src/lib/baseBuilder.test/baseBuilder.test.mock.ts

@@ -73,7 +73,7 @@ export class MockBaseBuilder<
       failed: false,
       fails: 0,
       artifacts: [],
-      logPromise: Promise.resolve(),
+      // logPromise: Promise.resolve(),
       features: [],
     });
   }

package/src/lib/basebuilder.ts

@@ -103,10 +103,10 @@ export abstract class BaseBuilder<
         receiveTestResourceConfig: async function (
           puppetMaster: IPM
         ): Promise<IFinalResults> {
-          const logFilePath = "logs.txt";
-          const access: number = await puppetMaster.createWriteStream(
-            logFilePath
-          );
+          // const logFilePath = "logs.txt";
+          // const access: number = await puppetMaster.createWriteStream(
+          //   logFilePath
+          // );
 
           // deprecated?
           const tLog = async (...l: string[]) => {
@@ -115,10 +115,10 @@ export abstract class BaseBuilder<
 
           const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
 
-          const logPromise = new Promise(async (res) => {
-            await puppetMaster.end(access);
-            res(true);
-          });
+          // const logPromise = new Promise(async (res) => {
+          //   await puppetMaster.end(access);
+          //   res(true);
+          // });
 
           const fails = suiteDone.fails;
 
@@ -133,7 +133,7 @@ export abstract class BaseBuilder<
             failed: fails > 0,
             fails,
             artifacts: this.artifacts || [],
-            logPromise,
+            // logPromise,
             features: suiteDone.features(),
           };
         },

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

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import TesterantoCore from "../core";
 
 import {
@@ -31,34 +33,39 @@ export class MockCore<
     testAdapter: Partial<ITestAdapter<I>>,
     uberCatcher: (cb: () => void) => void = (cb) => cb()
   ) {
-    console.log('[DEBUG] MockCore constructor starting...');
-    
+    console.log("[DEBUG] MockCore constructor starting...");
+
     if (!testImplementation) {
-      throw new Error('testImplementation is required');
+      throw new Error("testImplementation is required");
     }
     if (!testSpecification) {
-      console.warn('[WARN] testSpecification is null/undefined - tests may fail');
+      console.warn(
+        "[WARN] testSpecification is null/undefined - tests may fail"
+      );
     }
-    
-    console.log('[DEBUG] MockCore constructor called with:');
-    console.log('- input:', JSON.stringify(input, null, 2));
-    console.log('- testSpecification keys:', Object.keys(testSpecification));
-    console.log('- testImplementation keys:', Object.keys(testImplementation));
-    console.log('- testResourceRequirement:', JSON.stringify(testResourceRequirement));
-    console.log('- testAdapter keys:', Object.keys(testAdapter));
-    
+
+    console.log("[DEBUG] MockCore constructor called with:");
+    console.log("- input:", JSON.stringify(input, null, 2));
+    console.log("- testSpecification keys:", Object.keys(testSpecification));
+    console.log("- testImplementation keys:", Object.keys(testImplementation));
+    console.log(
+      "- testResourceRequirement:",
+      JSON.stringify(testResourceRequirement)
+    );
+    console.log("- testAdapter keys:", Object.keys(testAdapter));
+
     // Validate required implementation methods
-    const requiredMethods = ['suites', 'givens', 'whens', 'thens'];
-    requiredMethods.forEach(method => {
+    const requiredMethods = ["suites", "givens", "whens", "thens"];
+    requiredMethods.forEach((method) => {
       if (!testImplementation[method]) {
         throw new Error(`Missing required implementation method: ${method}`);
       }
     });
 
-    console.log('[DEBUG] Validation passed, calling super...');
-    
-    this.testResourceRequirement = testResourceRequirement;
-    this.testAdapter = testAdapter;
+    console.log("[DEBUG] Validation passed, calling super...");
+
+    // this.testResourceRequirement = testResourceRequirement;
+    // this.testAdapter = testAdapter;
     super(
       input,
       testSpecification,
@@ -76,7 +83,7 @@ export class MockCore<
       failed: false,
       fails: 0,
       artifacts: [],
-      logPromise: Promise.resolve(),
+      // logPromise: Promise.resolve(),
       features: [],
     };
   }

package/src/lib/index.ts

@@ -131,5 +131,5 @@ export type IFinalResults = {
   failed: boolean;
   fails: number;
   artifacts: Promise<unknown>[];
-  logPromise: Promise<unknown>;
+  // logPromise: Promise<unknown>;
 };

package/src/lib/pmProxy.ts

@@ -38,64 +38,107 @@ const baseProxy: IProxyBase = function (
   });
 };
 
-export const butThenProxy: IProxy = (pm: IPM, filepath: string) =>
-  baseProxy(pm, [
+export const butThenProxy: IProxy = (pm: IPM, filepath: string) => {
+  return baseProxy(pm, [
     [
       "screencast",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `${filepath}/butThen/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `${filepath}/butThen/${opts.path}`;
+        console.log(`[Proxy] Captured artifact path for butThen:`, path);
+        if ((pm as any).currentStep?.addArtifact) {
+          (pm as any).currentStep.addArtifact(path);
+        } else {
+          console.warn('No currentStep or addArtifact method found');
+        }
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
-    ["createWriteStream", (fp) => [`${filepath}/butThen/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `${filepath}/butThen/${fp}`;
+      console.log(`[Proxy] Captured artifact path for butThen:`, path);
+      if ((pm as any).currentStep?.addArtifact) {
+        (pm as any).currentStep.addArtifact(path);
+      } else {
+        console.warn('No currentStep or addArtifact method found');
+      }
+      return [path];
+    }],
 
     [
       "writeFileSync",
-      (fp, contents) => [`${filepath}/butThen/${fp}`, contents],
+      (fp, contents) => {
+        const path = `${filepath}/butThen/${fp}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [path, contents];
+      },
     ],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `${filepath}/butThen/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `${filepath}/butThen/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
   ]);
+};
 
 export const andWhenProxy: IProxy = (pm: IPM, filepath: string) =>
   baseProxy(pm, [
     [
       "screencast",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `${filepath}/andWhen/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `${filepath}/andWhen/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
-    ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `${filepath}/andWhen/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path];
+    }],
 
-    ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
+    ["writeFileSync", (fp, contents) => {
+      const path = `${filepath}/andWhen/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path, contents];
+    }],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `${filepath}/andWhen${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `${filepath}/andWhen/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
   ]);
 
@@ -107,33 +150,47 @@ export const afterEachProxy: IProxyAfterEach = (
   baseProxy(pm, [
     [
       "screencast",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/given-${given}/afterEach/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
-    ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `suite-${suite}/afterEach/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path];
+    }],
+    
     [
       "writeFileSync",
-      (fp, contents) => [
-        `suite-${suite}/given-${given}/afterEach/${fp}`,
-        contents,
-      ],
+      (fp, contents) => {
+        const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [path, contents];
+      },
     ],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/given-${given}/afterEach/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
   ]);
 
@@ -144,72 +201,112 @@ export const beforeEachProxy: IProxyBeforeEach = (
   baseProxy(pm, [
     [
       "screencast",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/beforeEach/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/beforeEach/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
     [
       "writeFileSync",
-      (fp, contents) => [`suite-${suite}/beforeEach/${fp}`, contents],
+      (fp, contents) => {
+        const path = `suite-${suite}/beforeEach/${fp}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [path, contents];
+      },
     ],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/beforeEach/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/beforeEach/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `suite-${suite}/beforeEach/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path];
+    }],
   ]);
 
 export const beforeAllProxy: IProxy = (pm: IPM, suite: string): IPM =>
   baseProxy(pm, [
     [
       "writeFileSync",
-      (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
+      (fp, contents) => {
+        const path = `suite-${suite}/beforeAll/${fp}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [path, contents];
+      },
     ],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/beforeAll/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/beforeAll/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
 
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `suite-${suite}/beforeAll/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path];
+    }],
   ]);
 
 export const afterAllProxy: IProxy = (pm: IPM, suite: string): IPM =>
   baseProxy(pm, [
-    ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
+    ["createWriteStream", (fp) => {
+      const path = `suite-${suite}/afterAll/${fp}`;
+      (pm as any).currentStep?.artifacts?.push(path);
+      return [path];
+    }],
 
     [
       "writeFileSync",
-      (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents],
+      (fp, contents) => {
+        const path = `suite-${suite}/afterAll/${fp}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [path, contents];
+      },
     ],
 
     [
       "customScreenShot",
-      (opts, p) => [
-        {
-          ...opts,
-          path: `suite-${suite}/afterAll/${opts.path}`,
-        },
-        p,
-      ],
+      (opts, p) => {
+        const path = `suite-${suite}/afterAll/${opts.path}`;
+        (pm as any).currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path,
+          },
+          p,
+        ];
+      },
     ],
   ]);