testeranto 0.166.0 → 0.171.0

package/testeranto/bundles/node/allTests/{chunk-4ONUZRZ4.mjs → chunk-3EUGBAOM.mjs}

@@ -4,7 +4,7 @@ import {
   BaseSuite,
   BaseThen,
   BaseWhen
-} from "./chunk-FFBRDUBH.mjs";
+} from "./chunk-E75CSRER.mjs";
 
 // src/lib/BaseSuite.test/mock.ts
 var MockGiven = class extends BaseGiven {

package/testeranto/bundles/node/allTests/{chunk-FFBRDUBH.mjs → chunk-E75CSRER.mjs}

@@ -15,146 +15,243 @@ var baseProxy = function(pm, mappings) {
     }
   });
 };
-var butThenProxy = (pm, filepath) => baseProxy(pm, [
-  [
-    "screencast",
-    (opts, p) => [
-      {
-        ...opts,
-        path: `${filepath}/butThen/${opts.path}`
-      },
-      p
-    ]
-  ],
-  ["createWriteStream", (fp) => [`${filepath}/butThen/${fp}`]],
-  [
-    "writeFileSync",
-    (fp, contents) => [`${filepath}/butThen/${fp}`, contents]
-  ],
-  [
-    "customScreenShot",
-    (opts, p) => [
-      {
-        ...opts,
-        path: `${filepath}/butThen/${opts.path}`
-      },
-      p
+var butThenProxy = (pm, filepath) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts, p) => {
+        const path = `${filepath}/butThen/${opts.path}`;
+        console.log(`[Proxy] Captured artifact path for butThen:`, path);
+        if (pm.currentStep?.addArtifact) {
+          pm.currentStep.addArtifact(path);
+        } else {
+          console.warn("No currentStep or addArtifact method found");
+        }
+        return [
+          {
+            ...opts,
+            path
+          },
+          p
+        ];
+      }
+    ],
+    ["createWriteStream", (fp) => {
+      const path = `${filepath}/butThen/${fp}`;
+      console.log(`[Proxy] Captured artifact path for butThen:`, path);
+      if (pm.currentStep?.addArtifact) {
+        pm.currentStep.addArtifact(path);
+      } else {
+        console.warn("No currentStep or addArtifact method found");
+      }
+      return [path];
+    }],
+    [
+      "writeFileSync",
+      (fp, contents) => {
+        const path = `${filepath}/butThen/${fp}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [path, contents];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path = `${filepath}/butThen/${opts.path}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts,
+            path
+          },
+          p
+        ];
+      }
     ]
-  ]
-]);
+  ]);
+};
 var andWhenProxy = (pm, filepath) => baseProxy(pm, [
   [
     "screencast",
-    (opts, p) => [
-      {
-        ...opts,
-        path: `${filepath}/andWhen/${opts.path}`
-      },
-      p
-    ]
+    (opts, p) => {
+      const path = `${filepath}/andWhen/${opts.path}`;
+      pm.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ],
-  ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
-  ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
+  ["createWriteStream", (fp) => {
+    const path = `${filepath}/andWhen/${fp}`;
+    pm.currentStep?.artifacts?.push(path);
+    return [path];
+  }],
+  ["writeFileSync", (fp, contents) => {
+    const path = `${filepath}/andWhen/${fp}`;
+    pm.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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ]
 ]);
 var afterEachProxy = (pm, suite, given) => 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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ],
-  ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
+  ["createWriteStream", (fp) => {
+    const path = `suite-${suite}/afterEach/${fp}`;
+    pm.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.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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ]
 ]);
 var beforeEachProxy = (pm, suite) => baseProxy(pm, [
   [
     "screencast",
-    (opts, p) => [
-      {
-        ...opts,
-        path: `suite-${suite}/beforeEach/${opts.path}`
-      },
-      p
-    ]
+    (opts, p) => {
+      const path = `suite-${suite}/beforeEach/${opts.path}`;
+      pm.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.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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ],
-  ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]]
+  ["createWriteStream", (fp) => {
+    const path = `suite-${suite}/beforeEach/${fp}`;
+    pm.currentStep?.artifacts?.push(path);
+    return [path];
+  }]
 ]);
 var beforeAllProxy = (pm, suite) => baseProxy(pm, [
   [
     "writeFileSync",
-    (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents]
+    (fp, contents) => {
+      const path = `suite-${suite}/beforeAll/${fp}`;
+      pm.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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ],
-  ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]]
+  ["createWriteStream", (fp) => {
+    const path = `suite-${suite}/beforeAll/${fp}`;
+    pm.currentStep?.artifacts?.push(path);
+    return [path];
+  }]
 ]);
 var afterAllProxy = (pm, suite) => baseProxy(pm, [
-  ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
+  ["createWriteStream", (fp) => {
+    const path = `suite-${suite}/afterAll/${fp}`;
+    pm.currentStep?.artifacts?.push(path);
+    return [path];
+  }],
   [
     "writeFileSync",
-    (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents]
+    (fp, contents) => {
+      const path = `suite-${suite}/afterAll/${fp}`;
+      pm.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.currentStep?.artifacts?.push(path);
+      return [
+        {
+          ...opts,
+          path
+        },
+        p
+      ];
+    }
   ]
 ]);
 
@@ -199,17 +296,9 @@ var BaseBuilder = class {
         },
         runner,
         receiveTestResourceConfig: async function(puppetMaster) {
-          const logFilePath = "logs.txt";
-          const access = await puppetMaster.createWriteStream(
-            logFilePath
-          );
           const tLog = async (...l) => {
           };
           const suiteDone = await runner(puppetMaster, tLog);
-          const logPromise = new Promise(async (res) => {
-            await puppetMaster.end(access);
-            res(true);
-          });
           const fails = suiteDone.fails;
           await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
           await puppetMaster.writeFileSync(
@@ -220,7 +309,7 @@ var BaseBuilder = class {
             failed: fails > 0,
             fails,
             artifacts: this.artifacts || [],
-            logPromise,
+            // logPromise,
             features: suiteDone.features()
           };
         }
@@ -327,20 +416,25 @@ var BaseSuite = class {
     if (!suiteName) {
       throw new Error("BaseSuite requires a non-empty name");
     }
-    console.log("[DEBUG] BaseSuite constructor - name:", suiteName, "index:", index);
+    console.log(
+      "[DEBUG] BaseSuite constructor - name:",
+      suiteName,
+      "index:",
+      index
+    );
     this.name = suiteName;
     this.index = index;
     this.givens = givens;
     this.fails = 0;
     console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
-    console.log("[DEBUG] BaseSuite givens:", Object.keys(givens));
+    console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
   }
   features() {
     try {
       const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
         return array.indexOf(value) === index;
       });
-      console.debug("[DEBUG] Features extracted:", features);
+      console.debug("[DEBUG] Features extracted:", features.toString());
       return features || [];
     } catch (e) {
       console.error("[ERROR] Failed to extract features:", e);
@@ -391,7 +485,6 @@ var BaseSuite = class {
       ).catch((e) => {
         this.failed = true;
         this.fails = this.fails + 1;
-        console.error("Given error 1:", e);
         throw e;
       });
     }
@@ -442,6 +535,7 @@ var defaultTestResourceRequirement = {
 // src/lib/abstractBase.ts
 var BaseGiven = class {
   constructor(name, features, whens, thens, givenCB, initialValues) {
+    this.artifacts = [];
     this.name = name;
     this.features = features;
     this.whens = whens;
@@ -449,6 +543,10 @@ var BaseGiven = class {
     this.givenCB = givenCB;
     this.initialValues = initialValues;
   }
+  addArtifact(path) {
+    console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
+    this.artifacts.push(path);
+  }
   beforeAll(store) {
     return store;
   }
@@ -459,13 +557,14 @@ var BaseGiven = class {
       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
+      features: this.features,
+      artifacts: this.artifacts
     };
   }
   async afterEach(store, key, artifactory, pm) {
@@ -479,21 +578,24 @@ var BaseGiven = class {
  Given: ${this.name}`);
     const givenArtifactory = (fPath, value) => 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.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;
     }
@@ -530,7 +632,7 @@ var BaseGiven = class {
           afterEachProxy(pm, suiteNdx.toString(), key)
         );
       } catch (e) {
-        console.error("afterEach failed!", e);
+        console.error("afterEach failed!", e.toString());
         this.failed = e;
         throw e;
       }
@@ -540,30 +642,46 @@ var BaseGiven = class {
 };
 var BaseWhen = class {
   constructor(name, whenCB) {
+    this.artifacts = [];
     this.name = name;
     this.whenCB = whenCB;
   }
   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(store, testResourceConfiguration, tLog, pm, filepath) {
     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.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) {
-      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;
     }
@@ -571,6 +689,7 @@ var BaseWhen = class {
 };
 var BaseThen = class {
   constructor(name, thenCB) {
+    this.artifacts = [];
     this.name = name;
     this.thenCB = thenCB;
     this.error = false;
@@ -578,15 +697,19 @@ var BaseThen = class {
   toObj() {
     return {
       name: this.name,
-      error: this.error
+      error: this.error,
+      artifacts: this.artifacts
     };
   }
   async test(store, testResourceConfiguration, tLog, pm, filepath) {
+    const proxiedPm = butThenProxy(pm, filepath);
+    console.log(`[Then] Setting currentStep for butThen:`, this.name);
+    proxiedPm.currentStep = this;
     return this.butThen(
       store,
       async (s) => {
         if (typeof this.thenCB === "function") {
-          return await this.thenCB(s);
+          return await this.thenCB(s, proxiedPm);
         } else {
           return this.thenCB;
         }

package/testeranto/bundles/node/allTests/{chunk-NQEP7SN4.mjs → chunk-M6DO7VMB.mjs}

@@ -3,7 +3,7 @@ import {
   PM,
   TesterantoCore,
   defaultTestResourceRequirement
-} from "./chunk-FFBRDUBH.mjs";
+} from "./chunk-E75CSRER.mjs";
 
 // src/PM/node.ts
 import net from "net";