testeranto 0.167.0 → 0.172.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/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,
+        ];
+      },
     ],
   ]);

package/testeranto/App.css

@@ -4437,24 +4437,24 @@ fieldset:disabled .btn {
     border-top-right-radius: 0;
     border-bottom-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-img-top,
-  .card-group > .card:not(:last-child) .card-header {
+  .card-group > .card:not(:last-child) > .card-img-top,
+  .card-group > .card:not(:last-child) > .card-header {
     border-top-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-img-bottom,
-  .card-group > .card:not(:last-child) .card-footer {
+  .card-group > .card:not(:last-child) > .card-img-bottom,
+  .card-group > .card:not(:last-child) > .card-footer {
     border-bottom-right-radius: 0;
   }
   .card-group > .card:not(:first-child) {
     border-top-left-radius: 0;
     border-bottom-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-img-top,
-  .card-group > .card:not(:first-child) .card-header {
+  .card-group > .card:not(:first-child) > .card-img-top,
+  .card-group > .card:not(:first-child) > .card-header {
     border-top-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-img-bottom,
-  .card-group > .card:not(:first-child) .card-footer {
+  .card-group > .card:not(:first-child) > .card-img-bottom,
+  .card-group > .card:not(:first-child) > .card-footer {
     border-bottom-left-radius: 0;
   }
 }
@@ -6956,6 +6956,10 @@ fieldset:disabled .btn {
 .visually-hidden-focusable:not(:focus):not(:focus-within):not(caption) {
   position: absolute !important;
 }
+.visually-hidden *,
+.visually-hidden-focusable:not(:focus):not(:focus-within) * {
+  overflow: hidden !important;
+}
 .stretched-link::after {
   position: absolute;
   top: 0;
@@ -11663,7 +11667,7 @@ code {
   transition: transform 0.3s ease;
 }
 /*!
- * Bootstrap  v5.3.5 (https://getbootstrap.com/)
+ * Bootstrap  v5.3.7 (https://getbootstrap.com/)
  * Copyright 2011-2025 The Bootstrap Authors
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  */