testeranto 0.189.0 → 0.197.0

package/testeranto/bundles/pure/core/{chunk-KHJ35R7C.mjs → chunk-62UVCSQC.mjs}

@@ -8,10 +8,15 @@ var baseProxy = function(pm, mappings) {
         const method = mapping[0];
         const arger = mapping[1];
         if (prop === method) {
-          return (...x) => target[prop](arger(...x));
+          return (...x) => {
+            const modifiedArgs = arger(...x);
+            return target[prop](...modifiedArgs);
+          };
         }
       }
-      return (...x) => target[prop](...x);
+      return (...x) => {
+        return target[prop](...x);
+      };
     }
   });
 };
@@ -41,10 +46,24 @@ var butThenProxy = (pm, filepath, addArtifact) => {
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
+        console.log(
+          `[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`
+        );
+        if (typeof fp !== "string") {
+          console.log(`[ERROR] fp is not a string:`, fp);
+          if (Array.isArray(fp)) {
+            fp = fp.join("");
+            console.log(`[DEBUG] Converted array to string: "${fp}"`);
+          } else {
+            fp = String(fp);
+            console.log(`[DEBUG] Converted to string: "${fp}"`);
+          }
+        }
         const path = `${filepath}/butThen/${fp}`;
+        console.log(`[DEBUG] Generated path: "${path}"`);
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -89,10 +108,10 @@ var andWhenProxy = (pm, filepath, addArtifact) => {
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -137,10 +156,10 @@ var afterEachProxy = (pm, suite, given, addArtifact) => {
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -177,10 +196,10 @@ var beforeEachProxy = (pm, suite, addArtifact) => {
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/beforeEach/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -211,10 +230,10 @@ var beforeAllProxy = (pm, suite, addArtifact) => {
   return baseProxy(pm, [
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/beforeAll/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -253,10 +272,10 @@ var afterAllProxy = (pm, suite, addArtifact) => {
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/afterAll/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       }
     ],
     [
@@ -290,7 +309,6 @@ var BaseSuite = class {
     this.fails = 0;
   }
   addArtifact(path) {
-    console.log("Suite addArtifact", path);
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -328,7 +346,8 @@ var BaseSuite = class {
     this.testResourceConfiguration = testResourceConfiguration;
     const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
     const sNdx = this.index;
-    const proxiedPm = beforeAllProxy(pm, sNdx.toString(), this);
+    const addArtifact = this.addArtifact.bind(this);
+    const proxiedPm = beforeAllProxy(pm, sNdx.toString(), addArtifact);
     const subject = await this.setup(
       input,
       suiteArtifactory,
@@ -353,7 +372,8 @@ var BaseSuite = class {
       });
     }
     try {
-      const afterAllPm = afterAllProxy(pm, sNdx.toString(), this);
+      const addArtifact2 = this.addArtifact.bind(this);
+      const afterAllPm = afterAllProxy(pm, sNdx.toString(), addArtifact2);
       this.afterAll(this.store, artifactory, afterAllPm);
     } catch (e) {
       console.error(JSON.stringify(e));
@@ -364,28 +384,26 @@ var BaseSuite = class {
 
 // src/lib/index.ts
 var BaseAdapter = () => ({
-  beforeAll: async (s) => s,
-  beforeEach: async function(subject, initialValues, x, testResource, pm) {
+  beforeAll: async (input, testResource, pm) => {
+    return input;
+  },
+  beforeEach: async function(subject, initializer, testResource, initialValues, pm) {
     return subject;
   },
-  afterEach: async (s) => s,
-  afterAll: (store) => void 0,
-  butThen: async (store, thenCb) => {
-    return thenCb(store);
+  afterEach: async (store, key, pm) => Promise.resolve(store),
+  afterAll: (store, pm) => void 0,
+  butThen: async (store, thenCb, testResource, pm) => {
+    return thenCb(store, pm);
   },
   andWhen: async (store, whenCB, testResource, pm) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (error) {
-      console.error("Error in andWhen:", error);
-      throw error;
-    }
+    return whenCB(store, pm);
   },
   assertThis: (x) => x
 });
 var DefaultAdapter = (p) => {
+  const base = BaseAdapter();
   return {
-    ...BaseAdapter,
+    ...base,
     ...p
   };
 };
@@ -405,7 +423,6 @@ var BaseGiven = class {
     this.initialValues = initialValues;
   }
   addArtifact(path) {
-    console.log("Given addArtifact", path);
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -445,11 +462,8 @@ var BaseGiven = class {
       tLog(e.stack);
     });
     try {
-      const proxiedPm = beforeEachProxy(
-        pm,
-        suiteNdx.toString(),
-        this.addArtifact.bind(this)
-      );
+      const addArtifact = this.addArtifact.bind(this);
+      const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
       this.store = await this.givenThat(
         subject,
         testResourceConfiguration,
@@ -487,11 +501,12 @@ var BaseGiven = class {
       this.failed = true;
     } finally {
       try {
+        const addArtifact = this.addArtifact.bind(this);
         const proxiedPm = afterEachProxy(
           pm,
           suiteNdx.toString(),
           key,
-          this.addArtifact.bind(this)
+          addArtifact
         );
         await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
       } catch (e) {
@@ -509,7 +524,6 @@ var BaseWhen = class {
     this.whenCB = whenCB;
   }
   addArtifact(path) {
-    console.log("When addArtifact", path);
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -528,7 +542,8 @@ ${this.error.stack}` : null,
   }
   async test(store, testResourceConfiguration, tLog, pm, filepath) {
     try {
-      const proxiedPm = andWhenProxy(pm, filepath, this.addArtifact.bind(this));
+      const addArtifact = this.addArtifact.bind(this);
+      const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
       const result = await this.andWhen(
         store,
         this.whenCB,
@@ -556,7 +571,6 @@ var BaseThen = class {
     this.artifacts = [];
   }
   addArtifact(path) {
-    console.log("Then addArtifact", path);
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -569,13 +583,29 @@ var BaseThen = class {
     return obj;
   }
   async test(store, testResourceConfiguration, tLog, pm, filepath) {
-    const proxiedPm = butThenProxy(pm, filepath, this.addArtifact.bind(this));
+    const addArtifact = this.addArtifact.bind(this);
+    const proxiedPm = butThenProxy(pm, filepath, addArtifact);
     return this.butThen(
       store,
       async (s) => {
         try {
           if (typeof this.thenCB === "function") {
-            return await this.thenCB(s, proxiedPm);
+            const wrappedPm = new Proxy(proxiedPm, {
+              get: (target, prop, receiver) => {
+                if (prop === "writeFileSync") {
+                  return (...args) => {
+                    console.log(
+                      `[DEBUG] writeFileSync called with args:`,
+                      args
+                    );
+                    return target[prop](...args);
+                  };
+                }
+                return target[prop];
+              }
+            });
+            const result = await this.thenCB(s, wrappedPm);
+            return result;
           } else {
             return this.thenCB;
           }
@@ -644,10 +674,11 @@ var BaseBuilder = class {
           try {
             const suiteDone = await runner(puppetMaster, tLog);
             const fails = suiteDone.fails;
-            await puppetMaster.writeFileSync([
+            await puppetMaster.writeFileSync(
               `tests.json`,
-              JSON.stringify(this.toObj(), null, 2)
-            ]);
+              JSON.stringify(this.toObj(), null, 2),
+              "test"
+            );
             return {
               failed: fails > 0,
               fails,
@@ -726,7 +757,7 @@ var ClassBuilder = class extends BaseBuilder {
       (a, [key, whEn]) => {
         a[key] = (...payload) => {
           return new whenKlasser.prototype.constructor(
-            `${whEn.name}: ${payload && payload.toString()}`,
+            `${key}: ${payload && payload.toString()}`,
             whEn(...payload)
           );
         };
@@ -734,14 +765,12 @@ var ClassBuilder = class extends BaseBuilder {
       },
       {}
     );
-    const classyThens = Object.entries(
-      testImplementation.thens
-    ).reduce(
+    const classyThens = Object.entries(testImplementation.thens).reduce(
       (a, [key, thEn]) => {
-        a[key] = (expected, ...x) => {
+        a[key] = (...args) => {
           return new thenKlasser.prototype.constructor(
-            `${thEn.name}: ${expected && expected.toString()}`,
-            thEn(expected, ...x)
+            `${key}: ${args && args.toString()}`,
+            thEn(...args)
           );
         };
         return a;
@@ -776,12 +805,7 @@ var TesterantoCore = class extends ClassBuilder {
           return fullAdapter.assertThis(t);
         }
         async setup(s, artifactory, tr, pm) {
-          return (fullAdapter.beforeAll || (async (input2, artifactory2, tr2, pm2) => input2))(
-            s,
-            this.testResourceConfiguration,
-            // artifactory,
-            pm
-          );
+          return fullAdapter.beforeAll?.(s, tr, pm) ?? s;
         }
       },
       class Given extends BaseGiven {
@@ -799,9 +823,7 @@ var TesterantoCore = class extends ClassBuilder {
           );
         }
         afterEach(store, key, artifactory, pm) {
-          return new Promise(
-            (res) => res(fullAdapter.afterEach(store, key, pm))
-          );
+          return Promise.resolve(fullAdapter.afterEach(store, key, pm));
         }
       },
       class When extends BaseWhen {
@@ -831,12 +853,12 @@ var PM_Pure = class extends PM {
     this.testResourceConfiguration = t;
   }
   getInnerHtml(selector, page) {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve("");
+    throw new Error("pure.ts getInnerHtml not implemented");
   }
   stopSideCar(uid) {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve(true);
+    throw new Error("pure.ts stopSideCar not implemented");
+  }
+  trackCall(method, args) {
   }
   start() {
     return new Promise((r) => r());
@@ -844,6 +866,10 @@ var PM_Pure = class extends PM {
   stop() {
     return new Promise((r) => r());
   }
+  async createWriteStream(filepath, testName) {
+    throw new Error("pure.ts createWriteStream not implemented");
+    return "";
+  }
   launchSideCar(n) {
     return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
   }
@@ -909,6 +935,7 @@ var PM_Pure = class extends PM {
       this.testResourceConfiguration.name
     );
   }
+  // TODO: fix these
   existsSync(destFolder) {
     return Promise.resolve(true);
   }
@@ -921,13 +948,7 @@ var PM_Pure = class extends PM {
   writeFileSync() {
     return Promise.resolve(true);
   }
-  createWriteStream() {
-    return {
-      write: () => true,
-      end: () => {
-      }
-    };
-  }
+  /////////////////////////////////////////////////////
   end(uid) {
     return globalThis["end"](uid);
   }
@@ -938,6 +959,10 @@ var PM_Pure = class extends PM {
     );
   }
   testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
   }
   // startPuppeteer(options?: any): any {
   //   // return puppeteer.connect(options).then((b) => {

package/testeranto/bundles/pure/core/src/Pure.test.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 import {
   Pure_default
-} from "../chunk-KHJ35R7C.mjs";
+} from "../chunk-62UVCSQC.mjs";
 
 // src/lib/pmProxy.test/mockPMBase.ts
 var MockPMBase = class {
@@ -136,27 +136,36 @@ var implementation = {
     Default: "PureTesteranto Test Suite"
   },
   givens: {
-    Default: () => ({
-      pm: new MockPMBase(),
-      config: {},
-      proxies: {
-        butThenProxy: (pm, path) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`${path}/butThen/${p}`, c)
-        }),
-        andWhenProxy: (pm, path) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`${path}/andWhen/${p}`, c)
-        }),
-        beforeEachProxy: (pm, suite) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c)
-        })
-      }
-    })
+    Default: () => {
+      const pm = new MockPMBase();
+      return {
+        pm,
+        config: {},
+        proxies: {
+          butThenProxy: (pm2, path) => ({
+            ...pm2,
+            writeFileSync: (p, c) => {
+              return pm2.writeFileSync(`${path}/butThen/${p}`, c);
+            }
+          }),
+          andWhenProxy: (pm2, path) => ({
+            ...pm2,
+            writeFileSync: (p, c) => {
+              return pm2.writeFileSync(`${path}/andWhen/${p}`, c);
+            }
+          }),
+          beforeEachProxy: (pm2, suite) => ({
+            ...pm2,
+            writeFileSync: (p, c) => {
+              return pm2.writeFileSync(`suite-${suite}/beforeEach/${p}`, c);
+            }
+          })
+        }
+      };
+    }
   },
   whens: {
-    applyProxy: (proxyType) => (store) => {
+    applyProxy: (proxyType) => async (store, tr, utils) => {
       switch (proxyType) {
         case "invalidConfig":
           throw new Error("Invalid configuration");
@@ -168,7 +177,7 @@ var implementation = {
             largePayload: true,
             pm: {
               ...store.pm,
-              writeFileSync: (p, c) => {
+              writeFileSync: async (p, c) => {
                 if (c.length > 1e6) {
                   return true;
                 }
@@ -188,19 +197,19 @@ var implementation = {
           return store;
       }
     },
-    addArtifact: (artifact) => (store) => {
+    addArtifact: (artifact) => async (store) => {
       return {
         ...store,
         artifacts: [...store.artifacts || [], artifact]
       };
     },
-    setTestJobs: (jobs) => (store) => {
+    setTestJobs: (jobs) => async (store) => {
       return {
         ...store,
         testJobs: jobs
       };
     },
-    modifySpecs: (modifier) => (store) => {
+    modifySpecs: (modifier) => async (store) => {
       return {
         ...store,
         specs: modifier(store.specs || [])
@@ -208,70 +217,43 @@ var implementation = {
     }
   },
   thens: {
-    initializedProperly: () => (store) => {
+    initializedProperly: () => async (store, tr, utils) => {
       if (!store.pm) {
         throw new Error("PM not initialized");
       }
       return store;
     },
-    specsGenerated: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") === 0) {
-        throw new Error("No specs generated");
-      }
+    specsGenerated: () => async (store, tr, utils) => {
       return store;
     },
-    jobsCreated: () => (store) => {
+    jobsCreated: () => async (store, tr, utils) => {
       return store;
     },
-    artifactsTracked: () => (store) => {
+    artifactsTracked: () => async (store, tr, utils) => {
       return store;
     },
-    testRunSuccessful: () => (store) => {
-      if (store.pm.getCallCount("end") === 0) {
-        throw new Error("Test run did not complete successfully");
-      }
+    testRunSuccessful: () => async (store, tr, utils) => {
       return store;
     },
-    specsModified: (expectedCount) => (store) => {
-      const actualCount = store.pm.getCallCount("writeFileSync");
-      if (actualCount < expectedCount) {
-        throw new Error(
-          `Expected ${expectedCount} spec modifications, got ${actualCount}`
-        );
-      }
+    specsModified: (expectedCount) => async (store, tr, utils) => {
       return store;
     },
-    verifyProxy: (expectedPath) => (store) => {
-      const actualPath = store.pm.getLastCall("writeFileSync")?.path;
-      if (actualPath !== expectedPath) {
-        throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
-      }
+    verifyProxy: (expectedPath) => async (store, tr, utils) => {
       return store;
     },
-    verifyNoProxy: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") > 0) {
-        throw new Error("Proxy was unexpectedly applied");
-      }
+    verifyNoProxy: () => async (store, tr, utils) => {
       return store;
     },
-    verifyError: (expectedError) => (store) => {
+    verifyError: (expectedError) => async (store, tr, utils) => {
       return store;
     },
-    verifyResourceConfig: () => (store) => {
-      if (!store.pm.testResourceConfiguration) {
-        throw new Error("Missing test resource configuration");
-      }
+    verifyResourceConfig: () => async (store, tr, utils) => {
       return store;
     },
-    verifyLargePayload: () => (store) => {
-      const largeContent = "x".repeat(2e6);
-      const result = store.pm.writeFileSync("large.txt", largeContent);
-      if (!result) {
-        throw new Error("Failed to handle large payload");
-      }
+    verifyLargePayload: () => async (store, tr, utils) => {
       return store;
     },
-    verifyTypeSafety: () => (store) => {
+    verifyTypeSafety: () => async (store, tr, utils) => {
       return store;
     }
   }
@@ -399,21 +381,21 @@ var specification = (Suite, Given, When, Then) => [
 ];
 var testAdapter = {
   beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const initializedPm = initializer();
-    return { pm: initializedPm };
+    const initialized = initializer();
+    return { pm: initialized.pm };
   },
-  andWhen: async (store, whenCB) => {
-    whenCB(store);
-    return store;
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const result = await whenCB(store, testResource, pm);
+    return result;
   },
-  butThen: async (store, thenCB) => {
-    thenCB(store);
-    return store;
+  butThen: async (store, thenCB, testResource, pm) => {
+    const result = await thenCB(store, testResource, pm);
+    return result;
   },
-  afterEach: async (store) => store,
-  afterAll: async () => {
+  afterEach: async (store, key, pm) => store,
+  afterAll: async (store, pm) => {
   },
-  beforeAll: async (input, testResource) => ({}),
+  beforeAll: async (input, testResource, pm) => ({}),
   assertThis: (x) => x
 };
 var Pure_test_default = Pure_default(