testeranto 0.202.0 → 0.203.0

package/testeranto/bundles/pure/core/{chunk-XYOCRDEQ.mjs → chunk-6HR24P27.mjs}

@@ -47,7 +47,21 @@ var butThenProxy = (pm, filepath, addArtifact) => {
     [
       "writeFileSync",
       (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, testName];
       }
@@ -295,9 +309,6 @@ var BaseSuite = class {
     this.fails = 0;
   }
   addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
-    }
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -306,44 +317,20 @@ var BaseSuite = class {
       const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
         return array.indexOf(value) === index;
       });
-      const stringFeatures = features.map((feature) => {
-        if (typeof feature === "string") {
-          return feature;
-        } else if (feature && typeof feature === "object") {
-          return feature.name || JSON.stringify(feature);
-        } else {
-          return String(feature);
-        }
-      });
-      return stringFeatures || [];
+      return features || [];
     } catch (e) {
       console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
       return [];
     }
   }
   toObj() {
-    const givens = Object.keys(this.givens).map((k) => {
-      const givenObj = this.givens[k].toObj();
-      if (givenObj.features) {
-        givenObj.features = givenObj.features.map((feature) => {
-          if (typeof feature === "string") {
-            return feature;
-          } else if (feature && typeof feature === "object") {
-            return feature.name || JSON.stringify(feature);
-          } else {
-            return String(feature);
-          }
-        });
-      }
-      return givenObj;
-    });
+    const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
     return {
       name: this.name,
       givens,
       fails: this.fails,
       failed: this.failed,
-      features: this.features(),
-      artifacts: this.artifacts ? this.artifacts.filter((art) => typeof art === "string") : []
+      features: this.features()
     };
   }
   setup(s, artifactory, tr, pm) {
@@ -369,29 +356,20 @@ var BaseSuite = class {
     );
     for (const [gKey, g] of Object.entries(this.givens)) {
       const giver = this.givens[gKey];
-      try {
-        this.store = await giver.give(
-          subject,
-          gKey,
-          testResourceConfiguration,
-          this.assertThat,
-          suiteArtifactory,
-          tLog,
-          pm,
-          sNdx
-        );
-        this.fails += giver.fails || 0;
-      } catch (e) {
+      this.store = await giver.give(
+        subject,
+        gKey,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        pm,
+        sNdx
+      ).catch((e) => {
         this.failed = true;
-        this.fails += 1;
-        if (giver.fails) {
-          this.fails += giver.fails;
-        }
-        console.error(`Error in given ${gKey}:`, e);
-      }
-    }
-    if (this.fails > 0) {
-      this.failed = true;
+        this.fails = this.fails + 1;
+        throw e;
+      });
     }
     try {
       const addArtifact2 = this.addArtifact.bind(this);
@@ -435,33 +413,16 @@ var defaultTestResourceRequirement = {
 
 // src/lib/BaseGiven.ts
 var BaseGiven = class {
-  constructor(features, whens, thens, givenCB, initialValues) {
+  constructor(name, features, whens, thens, givenCB, initialValues) {
     this.artifacts = [];
-    this.features = (Array.isArray(features) ? features : []).map((feature) => {
-      if (typeof feature === "string")
-        return feature;
-      if (feature && typeof feature === "object") {
-        console.error(
-          `[ERROR] Found object in features array: ${feature.name || JSON.stringify(feature)}`
-        );
-        return "";
-      }
-      return String(feature);
-    }).filter((f) => f !== null && f !== void 0 && f !== "");
-    this.whens = Array.isArray(whens) ? whens : [];
-    this.thens = Array.isArray(thens) ? thens : [];
+    this.name = name;
+    this.features = features || [];
+    this.whens = whens || [];
+    this.thens = thens || [];
     this.givenCB = givenCB;
     this.initialValues = initialValues;
-    this.fails = 0;
   }
   addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
-          path
-        )}`
-      );
-    }
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -471,18 +432,18 @@ var BaseGiven = class {
   toObj() {
     return {
       key: this.key,
-      // name: this.name,
+      name: this.name,
       whens: (this.whens || []).map((w) => {
         if (w && w.toObj)
           return w.toObj();
-        console.error("When step is not as expected!", JSON.stringify(w));
+        console.error("w is not as expected!", JSON.stringify(w));
         return {};
       }),
       thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
       error: this.error ? [this.error, this.error.stack] : null,
       failed: this.failed,
       features: this.features || [],
-      artifacts: this.artifacts
+      artifacts: this.artifacts || []
     };
   }
   async afterEach(store, key, artifactory, pm) {
@@ -490,7 +451,6 @@ var BaseGiven = class {
   }
   async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
     this.key = key;
-    this.fails = 0;
     tLog(`
  ${this.key}`);
     tLog(`
@@ -514,55 +474,27 @@ var BaseGiven = class {
       );
     } catch (e) {
       this.failed = true;
-      this.fails++;
       this.error = e.stack;
     }
     try {
-      const whens = this.whens || [];
-      if (whens.length > 0) {
-        for (const [whenNdx, whenStep] of whens.entries()) {
-          if (whenStep && whenStep.name && whenStep.name.startsWith("result:")) {
-            this.thens.push(whenStep);
-            continue;
-          }
-          if (whenStep && typeof whenStep.test === "function") {
-            try {
-              this.store = await whenStep.test(
-                this.store,
-                testResourceConfiguration,
-                tLog,
-                pm,
-                `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
-              );
-            } catch (e) {
-              this.failed = true;
-              this.fails++;
-              throw e;
-            }
-          } else {
-            this.failed = true;
-            this.fails++;
-            throw new Error(`When step ${whenNdx} does not have a test method`);
-          }
-        }
-      } else {
-        console.log(`[BaseGiven.give] No when steps to process`);
+      for (const [whenNdx, whenStep] of this.whens.entries()) {
+        await whenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+        );
       }
       for (const [thenNdx, thenStep] of this.thens.entries()) {
-        try {
-          const t = await thenStep.test(
-            this.store,
-            testResourceConfiguration,
-            tLog,
-            pm,
-            `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
-          );
-          tester(t);
-        } catch (e) {
-          this.failed = true;
-          this.fails++;
-          throw e;
-        }
+        const t = await thenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
+        );
+        tester(t);
       }
     } catch (e) {
       this.error = e.stack;
@@ -578,8 +510,7 @@ var BaseGiven = class {
         );
         await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
       } catch (e) {
-        this.failed = true;
-        this.fails++;
+        this.failed = e;
         throw e;
       }
     }
@@ -595,13 +526,6 @@ var BaseWhen = class {
     this.whenCB = whenCB;
   }
   addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
-          path
-        )}`
-      );
-    }
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -610,7 +534,7 @@ var BaseWhen = class {
       name: this.name,
       error: this.error ? `${this.error.name}: ${this.error.message}
 ${this.error.stack}` : null,
-      artifacts: this.artifacts
+      artifacts: this.artifacts || []
     };
     console.log(
       `[TOOBJ] Serializing ${this.constructor.name} with artifacts:`,
@@ -651,13 +575,6 @@ var BaseThen = class {
     this.artifacts = [];
   }
   addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
-          path
-        )}`
-      );
-    }
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
@@ -672,29 +589,39 @@ var BaseThen = class {
   async test(store, testResourceConfiguration, tLog, pm, filepath) {
     const addArtifact = this.addArtifact.bind(this);
     const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-    try {
-      return await this.butThen(
-        store,
-        async (s) => {
-          try {
-            if (typeof this.thenCB === "function") {
-              const result = await this.thenCB(s, proxiedPm);
-              return result;
-            } else {
-              return this.thenCB;
-            }
-          } catch (e) {
-            this.error = true;
-            throw e;
+    return this.butThen(
+      store,
+      async (s) => {
+        try {
+          if (typeof this.thenCB === "function") {
+            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;
           }
-        },
-        testResourceConfiguration,
-        proxiedPm
-      );
-    } catch (e) {
-      this.error = true;
-      throw e;
-    }
+        } catch (e) {
+          console.error(e.stack);
+        }
+      },
+      testResourceConfiguration,
+      proxiedPm
+    ).catch((e) => {
+      this.error = e.stack;
+    });
   }
 };
 
@@ -724,10 +651,7 @@ var Tiposkripto = class {
     );
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
-        a[key] = (features, whens, thens, gcb, initialValues) => {
-          const safeFeatures = Array.isArray(features) ? [...features] : [];
-          const safeWhens = Array.isArray(whens) ? [...whens] : [];
-          const safeThens = Array.isArray(thens) ? [...thens] : [];
+        a[key] = (name, features, whens, thens, gcb, initialValues) => {
           return new class extends BaseGiven {
             constructor() {
               super(...arguments);
@@ -746,10 +670,10 @@ var Tiposkripto = class {
               return Promise.resolve(fullAdapter.afterEach(store, key2, pm));
             }
           }(
-            // name,
-            safeFeatures,
-            safeWhens,
-            safeThens,
+            name,
+            features,
+            whens,
+            thens,
             testImplementation.givens[key],
             initialValues
           );
@@ -761,12 +685,11 @@ var Tiposkripto = class {
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]) => {
         a[key] = (...payload) => {
-          const whenInstance = new class extends BaseWhen {
+          return new class extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
               return await fullAdapter.andWhen(store, whenCB, testResource, pm);
             }
           }(`${key}: ${payload && payload.toString()}`, whEn(...payload));
-          return whenInstance;
         };
         return a;
       },
@@ -775,12 +698,11 @@ var Tiposkripto = class {
     const classyThens = Object.entries(testImplementation.thens).reduce(
       (a, [key, thEn]) => {
         a[key] = (...args) => {
-          const thenInstance = new class extends BaseThen {
+          return new class extends BaseThen {
             async butThen(store, thenCB, testResource, pm) {
               return await fullAdapter.butThen(store, thenCB, testResource, pm);
             }
           }(`${key}: ${args && args.toString()}`, thEn(...args));
-          return thenInstance;
         };
         return a;
       },
@@ -799,6 +721,7 @@ var Tiposkripto = class {
       this.Then()
     );
     this.totalTests = this.calculateTotalTests();
+    console.log(`Total tests calculated: ${this.totalTests}`);
     this.testJobs = this.specs.map((suite) => {
       const suiteRunner = (suite2) => async (puppetMaster, tLog) => {
         try {

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-XYOCRDEQ.mjs";
+} from "../chunk-6HR24P27.mjs";
 
 // src/lib/pmProxy.test/mockPMBase.ts
 var MockPMBase = class {

package/testeranto/bundles/pure/core/src/lib/BaseSuite.test/pure.test.mjs

@@ -5,7 +5,7 @@ import {
   BaseThen,
   BaseWhen,
   Pure_default
-} from "../../../chunk-XYOCRDEQ.mjs";
+} from "../../../chunk-6HR24P27.mjs";
 
 // src/lib/BaseSuite.test/mock.ts
 var MockGiven = class extends BaseGiven {
@@ -85,29 +85,29 @@ var specification = (Suite, Given, When, Then) => [
       ["BaseSuite should initialize with correct name and index"],
       [],
       [Then.SuiteNameMatches("testSuite"), Then.SuiteIndexMatches(0)]
-    ),
-    // Test execution flow
-    execution: Given.Default(
-      ["BaseSuite should execute all phases successfully"],
-      [When.RunSuite()],
-      [Then.StoreValid()]
-    ),
-    // Test multiple features
-    multipleFeatures: Given.Default(
-      ["BaseSuite should handle multiple features"],
-      [When.AddFeature("additionalFeature")],
-      [
-        Then.FeaturesIncludes("testFeature"),
-        Then.FeaturesIncludes("additionalFeature"),
-        Then.FeatureCountMatches(2)
-      ]
-    ),
-    // Test error handling
-    errorHandling: Given.Default(
-      ["BaseSuite should handle errors gracefully"],
-      [When.RunSuiteWithError()],
-      [Then.ErrorCountMatches(1), Then.FailedFlagSet()]
     )
+    // // Test execution flow
+    // execution: Given.Default(
+    //   ["BaseSuite should execute all phases successfully"],
+    //   [When.RunSuite()],
+    //   [Then.StoreValid()]
+    // ),
+    // // Test multiple features
+    // multipleFeatures: Given.Default(
+    //   ["BaseSuite should handle multiple features"],
+    //   [When.AddFeature("additionalFeature")],
+    //   [
+    //     Then.FeaturesIncludes("testFeature"),
+    //     Then.FeaturesIncludes("additionalFeature"),
+    //     Then.FeatureCountMatches(2),
+    //   ]
+    // ),
+    // // Test error handling
+    // errorHandling: Given.Default(
+    //   ["BaseSuite should handle errors gracefully"],
+    //   [When.RunSuiteWithError()],
+    //   [Then.ErrorCountMatches(1), Then.FailedFlagSet()]
+    // ),
   })
   // Suite.Default("Comprehensive Integration", {
   //   fullStackTest: Given.Default(
@@ -143,27 +143,6 @@ var implementation = {
     }
   },
   whens: {
-    // Add TestWhen which is defined in O type
-    TestWhen: () => (suite) => {
-      return suite;
-    },
-    // Add RunSuite which is defined in O type
-    RunSuite: () => (suite) => {
-      return suite;
-    },
-    // Add AddFeature which is used in the specification
-    AddFeature: (feature) => (suite) => {
-      const firstGivenKey = Object.keys(suite.givens)[0];
-      if (firstGivenKey) {
-        suite.givens[firstGivenKey].features.push(feature);
-      }
-      return suite;
-    },
-    // Add RunSuiteWithError which is used in the specification
-    RunSuiteWithError: () => (suite) => {
-      return suite;
-    },
-    // Keep other whens
     addArtifact: (artifact) => (suite) => {
       suite.artifacts.push(artifact);
       return suite;
@@ -175,16 +154,70 @@ var implementation = {
     modifyJobs: (modifier) => (suite) => {
       suite.testJobs = modifier(suite.testJobs);
       return suite;
+    },
+    RunSuite: () => async (suite) => {
+      const mockConfig = {
+        name: "test",
+        fs: "/tmp",
+        ports: [3e3],
+        environment: {},
+        timeout: 5e3,
+        retries: 3
+      };
+      const mockArtifactory = (key, value) => {
+      };
+      const mockTLog = (...args) => {
+      };
+      const mockPM = {
+        server: null,
+        testResourceConfiguration: mockConfig,
+        start: async () => {
+        },
+        stop: async () => {
+        },
+        testArtiFactoryfileWriter: () => {
+        },
+        $: () => {
+        },
+        click: () => {
+        },
+        closePage: () => {
+        },
+        createWriteStream: async () => ""
+      };
+      return await suite.run(
+        null,
+        mockConfig,
+        mockArtifactory,
+        mockTLog,
+        mockPM
+      );
+    },
+    RunSuiteWithError: () => async (suite) => {
+      try {
+        await suite.run(
+          null,
+          {},
+          // Invalid config
+          () => {
+          },
+          () => {
+          },
+          {}
+        );
+      } catch (e) {
+      }
+      return suite;
+    },
+    AddFeature: (feature) => (suite) => {
+      const firstGivenKey = Object.keys(suite.givens)[0];
+      if (firstGivenKey) {
+        suite.givens[firstGivenKey].features.push(feature);
+      }
+      return suite;
     }
   },
   thens: {
-    // Add StoreValid which is used in the specification
-    StoreValid: () => (ssel, utils) => async (s) => {
-      if (!s.testSelection) {
-        throw new Error("Store is not valid");
-      }
-      return Promise.resolve(new BaseSuite("temp", 0, {}));
-    },
     SuiteNameMatches: (expectedName) => (ssel, utils) => async (s) => {
       return Promise.resolve(new BaseSuite("temp", 0, {}));
     },
@@ -194,20 +227,35 @@ var implementation = {
     FeaturesIncludes: (feature) => (ssel, utils) => async (s) => {
       return Promise.resolve(new BaseSuite("temp", 0, {}));
     },
-    // Add FeatureCountMatches which is used in the specification
-    FeatureCountMatches: (expectedCount) => (ssel, utils) => async (s) => {
-      return Promise.resolve(new BaseSuite("temp", 0, {}));
+    FeatureCountMatches: (expectedCount) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
     },
-    // Add ErrorCountMatches which is used in the specification
-    ErrorCountMatches: (expectedCount) => (ssel, utils) => async (s) => {
-      return Promise.resolve(new BaseSuite("temp", 0, {}));
+    NoErrorsOccurred: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
     },
-    // Add FailedFlagSet which is used in the specification
-    FailedFlagSet: () => (ssel, utils) => async (s) => {
-      return Promise.resolve(new BaseSuite("temp", 0, {}));
+    ErrorCountMatches: (expectedCount) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
     },
-    TestThen: () => (ssel, utils) => async (s) => {
-      return Promise.resolve(new BaseSuite("temp", 0, {}));
+    FailedFlagSet: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    AllTestsCompleted: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    CleanExit: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    specsModified: (expectedCount) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    jobsModified: (expectedCount) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    artifactsTracked: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    testRunSuccessful: () => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
     }
   }
 };