testeranto.tiposkripto 0.2.22 → 0.3.2

package/README.md

@@ -1,3 +1,16 @@
 # tiposkripto
 
 ## the typescript implementation of testeranto
+
+## Supported Patterns
+
+1. **BDD (Behavior Driven Development)**: Given, When, Then (3 verbs) - fully implemented and production-ready
+2. **TDT (Table-Driven Testing)**: Value, Should, Expected (3 verbs) - core classes implemented, integration in progress
+3. **Describe-It Pattern (AAA/Arrange-Act-Assert)**: Describe, It (2 verbs) - core classes implemented, integration in progress
+
+## Status
+
+- BDD pattern is fully functional and production-ready (uses 3 verbs: Given, When, Then)
+- TDT pattern has core classes (BaseValue, BaseShould, BaseExpected) and specification helpers (createTDTSpecification, Confirm) available (uses 3 verbs)
+- Describe-It pattern (AAA) has core classes (BaseDescribe, BaseIt) and specification helpers (createDescribeItSpecification, DescribeIt) available (uses 2 verbs)
+- BDD is recommended for production use; TDT and Describe-It patterns are available for experimentation

package/dist/module/Node.js

@@ -179,113 +179,6 @@ var BaseSetup = class {
   }
 };
 
-// src/BaseAction.ts
-var BaseAction = class {
-  constructor(name, actionCB) {
-    this.error = null;
-    this.artifacts = [];
-    this.name = name;
-    this.actionCB = actionCB;
-  }
-  addArtifact(path2) {
-    if (typeof path2 !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path2}: ${JSON.stringify(
-          path2
-        )}`
-      );
-    }
-    const normalizedPath = path2.replace(/\\/g, "/");
-    this.artifacts.push(normalizedPath);
-  }
-  toObj() {
-    const obj = {
-      name: this.name,
-      status: this.status,
-      error: this.error ? `${this.error.name}: ${this.error.message}
-${this.error.stack}` : null,
-      artifacts: this.artifacts
-    };
-    return obj;
-  }
-  async test(store, testResourceConfiguration, artifactory) {
-    try {
-      const result = await this.performAction(
-        store,
-        this.actionCB,
-        testResourceConfiguration,
-        artifactory
-      );
-      this.status = true;
-      return result;
-    } catch (e) {
-      this.status = false;
-      this.error = e;
-      throw e;
-    }
-  }
-};
-
-// src/BaseCheck.ts
-var BaseCheck = class {
-  constructor(name, checkCB) {
-    this.artifacts = [];
-    this.name = name;
-    this.checkCB = checkCB;
-    this.error = false;
-    this.artifacts = [];
-  }
-  addArtifact(path2) {
-    if (typeof path2 !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path2}: ${JSON.stringify(
-          path2
-        )}`
-      );
-    }
-    const normalizedPath = path2.replace(/\\/g, "/");
-    this.artifacts.push(normalizedPath);
-  }
-  toObj() {
-    const obj = {
-      name: this.name,
-      error: this.error,
-      artifacts: this.artifacts,
-      status: this.status
-    };
-    return obj;
-  }
-  async test(store, testResourceConfiguration, filepath, artifactory) {
-    const addArtifact = this.addArtifact.bind(this);
-    try {
-      const x = await this.verifyCheck(
-        store,
-        async (s) => {
-          try {
-            if (typeof this.checkCB === "function") {
-              const result = await this.checkCB(s);
-              return result;
-            } else {
-              return this.checkCB;
-            }
-          } catch (e) {
-            this.error = true;
-            throw e;
-          }
-        },
-        testResourceConfiguration,
-        artifactory
-      );
-      this.status = true;
-      return x;
-    } catch (e) {
-      this.status = false;
-      this.error = true;
-      throw e;
-    }
-  }
-};
-
 // src/BaseGiven.ts
 var BaseGiven = class extends BaseSetup {
   constructor(features, whens, thens, givenCB, initialValues) {
@@ -554,6 +447,53 @@ var BaseGiven = class extends BaseSetup {
   }
 };
 
+// src/BaseAction.ts
+var BaseAction = class {
+  constructor(name, actionCB) {
+    this.error = null;
+    this.artifacts = [];
+    this.name = name;
+    this.actionCB = actionCB;
+  }
+  addArtifact(path2) {
+    if (typeof path2 !== "string") {
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path2}: ${JSON.stringify(
+          path2
+        )}`
+      );
+    }
+    const normalizedPath = path2.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      status: this.status,
+      error: this.error ? `${this.error.name}: ${this.error.message}
+${this.error.stack}` : null,
+      artifacts: this.artifacts
+    };
+    return obj;
+  }
+  async test(store, testResourceConfiguration, artifactory) {
+    try {
+      const result = await this.performAction(
+        store,
+        this.actionCB,
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return result;
+    } catch (e) {
+      this.status = false;
+      this.error = e;
+      throw e;
+    }
+  }
+};
+
 // src/BaseWhen.ts
 var BaseWhen = class extends BaseAction {
   constructor(name, whenCB) {
@@ -582,6 +522,66 @@ var BaseWhen = class extends BaseAction {
   }
 };
 
+// src/BaseCheck.ts
+var BaseCheck = class {
+  constructor(name, checkCB) {
+    this.artifacts = [];
+    this.name = name;
+    this.checkCB = checkCB;
+    this.error = false;
+    this.artifacts = [];
+  }
+  addArtifact(path2) {
+    if (typeof path2 !== "string") {
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path2}: ${JSON.stringify(
+          path2
+        )}`
+      );
+    }
+    const normalizedPath = path2.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      error: this.error,
+      artifacts: this.artifacts,
+      status: this.status
+    };
+    return obj;
+  }
+  async test(store, testResourceConfiguration, filepath, artifactory) {
+    const addArtifact = this.addArtifact.bind(this);
+    try {
+      const x = await this.verifyCheck(
+        store,
+        async (s) => {
+          try {
+            if (typeof this.checkCB === "function") {
+              const result = await this.checkCB(s);
+              return result;
+            } else {
+              return this.checkCB;
+            }
+          } catch (e) {
+            this.error = true;
+            throw e;
+          }
+        },
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return x;
+    } catch (e) {
+      this.status = false;
+      this.error = true;
+      throw e;
+    }
+  }
+};
+
 // src/BaseThen.ts
 var BaseThen = class extends BaseCheck {
   constructor(name, thenCB) {
@@ -900,7 +900,7 @@ var BaseTiposkripto = class {
     }
     const classySuites = Object.entries(testImplementation.suites).reduce(
       (a, [key], index) => {
-        a[key] = (somestring, givens) => {
+        a[key] = (somestring, setups) => {
           const capturedFullAdapter = fullAdapter;
           return new class extends BaseSuite {
             afterAll(store, artifactory) {
@@ -924,15 +924,16 @@ var BaseTiposkripto = class {
             async setup(s, artifactory, tr) {
               return capturedFullAdapter.prepareAll?.(s, tr, artifactory) ?? s;
             }
-          }(somestring, index, givens, instance);
+          }(somestring, index, setups, instance);
         };
         return a;
       },
       {}
     );
-    const classyGivens = Object.entries(testImplementation.givens).reduce(
-      (a, [key, g]) => {
-        a[key] = (features, whens, thens, gcb, initialValues) => {
+    const classyGivens = {};
+    if (testImplementation.givens) {
+      Object.entries(testImplementation.givens).forEach(([key, g]) => {
+        classyGivens[key] = (features, whens, thens, gcb, initialValues) => {
           const safeFeatures = Array.isArray(features) ? [...features] : [];
           const safeWhens = Array.isArray(whens) ? [...whens] : [];
           const safeThens = Array.isArray(thens) ? [...thens] : [];
@@ -967,16 +968,14 @@ var BaseTiposkripto = class {
           if (givenInstance.setParent) {
             givenInstance.setParent(instance);
           }
-          console.log(`[BaseTiposkripto] Set _parent for given instance`, givenInstance);
           return givenInstance;
         };
-        return a;
-      },
-      {}
-    );
-    const classyWhens = Object.entries(testImplementation.whens).reduce(
-      (a, [key, whEn]) => {
-        a[key] = (...payload) => {
+      });
+    }
+    const classyWhens = {};
+    if (testImplementation.whens) {
+      Object.entries(testImplementation.whens).forEach(([key, whEn]) => {
+        classyWhens[key] = (...payload) => {
           const capturedFullAdapter = fullAdapter;
           const whenInstance = new class extends BaseWhen {
             async andWhen(store, whenCB, testResource, artifactory) {
@@ -990,44 +989,113 @@ var BaseTiposkripto = class {
           }(`${key}: ${payload && payload.toString()}`, whEn(...payload));
           return whenInstance;
         };
-        return a;
-      },
-      {}
-    );
-    const classyThens = Object.entries(testImplementation.thens).reduce(
-      (a, [key, thEn]) => {
-        a[key] = (...args) => {
+      });
+    }
+    const classyThens = {};
+    if (testImplementation.thens) {
+      Object.entries(testImplementation.thens).forEach(([key, thEn]) => {
+        classyThens[key] = (...args) => {
           const capturedFullAdapter = fullAdapter;
           const thenInstance = new class extends BaseThen {
-            verifyCheck(store, checkCB, testResourceConfiguration2) {
-              throw new Error("Method not implemented.");
-            }
-            async butThen(store, thenCB, testResource, artifactory) {
-              return await capturedFullAdapter.verify(
+            verifyCheck(store, checkCB, testResourceConfiguration2, artifactory) {
+              return capturedFullAdapter.verify(
                 store,
-                thenCB,
-                testResource,
+                checkCB,
+                testResourceConfiguration2,
                 artifactory
               );
             }
           }(`${key}: ${args && args.toString()}`, thEn(...args));
           return thenInstance;
         };
-        return a;
-      },
-      {}
-    );
+      });
+    }
+    const classyConfirms = {};
+    if (testImplementation.confirms) {
+      Object.entries(testImplementation.confirms).forEach(([key, val]) => {
+        classyConfirms[key] = (features, tableRows, confirmCB, initialValues) => {
+          return new BaseValue(
+            features,
+            tableRows,
+            confirmCB,
+            initialValues
+          );
+        };
+      });
+    }
+    const classyValues = {};
+    if (testImplementation.values) {
+      Object.entries(testImplementation.values).forEach(([key, val]) => {
+        classyValues[key] = (features, tableRows, confirmCB, initialValues) => {
+          return new BaseValue(
+            features,
+            tableRows,
+            confirmCB,
+            initialValues
+          );
+        };
+      });
+    }
+    const classyShoulds = {};
+    if (testImplementation.shoulds) {
+      Object.entries(testImplementation.shoulds).forEach(([key, shouldCB]) => {
+        classyShoulds[key] = (...args) => {
+          return new BaseShould(`${key}: ${args && args.toString()}`, shouldCB(...args));
+        };
+      });
+    }
+    const classyExpecteds = {};
+    if (testImplementation.expecteds) {
+      Object.entries(testImplementation.expecteds).forEach(([key, expectedCB]) => {
+        classyExpecteds[key] = (...args) => {
+          return new BaseExpected(`${key}: ${args && args.toString()}`, expectedCB(...args));
+        };
+      });
+    }
+    const classyDescribes = {};
+    if (testImplementation.describes) {
+      Object.entries(testImplementation.describes).forEach(([key, desc]) => {
+        classyDescribes[key] = (features, its, describeCB, initialValues) => {
+          return new BaseDescribe(
+            features,
+            its,
+            describeCB,
+            initialValues
+          );
+        };
+      });
+    }
+    const classyIts = {};
+    if (testImplementation.its) {
+      Object.entries(testImplementation.its).forEach(([key, itCB]) => {
+        classyIts[key] = (...args) => {
+          return new BaseIt(`${key}: ${args && args.toString()}`, itCB(...args));
+        };
+      });
+    }
     this.suitesOverrides = classySuites;
     this.givenOverrides = classyGivens;
     this.whenOverrides = classyWhens;
     this.thenOverrides = classyThens;
+    this.valuesOverrides = classyValues;
+    this.shouldsOverrides = classyShoulds;
+    this.expectedsOverrides = classyExpecteds;
+    this.describesOverrides = classyDescribes;
+    this.itsOverrides = classyIts;
+    this.confirmsOverrides = classyConfirms;
     this.testResourceRequirement = testResourceRequirement;
     this.testSpecification = testSpecification;
     this.specs = testSpecification(
       this.Suites(),
       this.Given(),
       this.When(),
-      this.Then()
+      this.Then(),
+      this.Describe(),
+      this.It(),
+      this.Confirm(),
+      this.Value(),
+      this.Should(),
+      this.Expect()
     );
     this.totalTests = this.calculateTotalTests();
     this.testJobs = this.specs.map((suite) => {
@@ -1116,97 +1184,10 @@ var BaseTiposkripto = class {
         const fullPath = `${basePathClean}/${pathClean}`;
         console.log("[Artifactory] Full path:", fullPath);
         this.writeFileSync(fullPath, payload);
-      },
-      screenshot: (filename, payload) => {
-        let path2 = "";
-        const basePath = this.testResourceConfiguration?.fs || "testeranto";
-        console.log("[Artifactory Screenshot] Base path:", basePath);
-        console.log("[Artifactory Screenshot] Context:", context);
-        if (context.suiteIndex !== void 0) {
-          path2 += `suite-${context.suiteIndex}/`;
-        }
-        if (context.givenKey) {
-          path2 += `given-${context.givenKey}/`;
-        }
-        if (context.whenIndex !== void 0) {
-          path2 += `when-${context.whenIndex} `;
-        } else if (context.thenIndex !== void 0) {
-          path2 += `then-${context.thenIndex} `;
-        }
-        path2 += filename;
-        if (!path2.match(/\.[a-zA-Z0-9]+$/)) {
-          path2 += ".png";
-        }
-        const basePathClean = basePath.replace(/\/$/, "");
-        const pathClean = path2.replace(/^\//, "");
-        const fullPath = `${basePathClean}/${pathClean}`;
-        console.log("[Artifactory Screenshot] Full path:", fullPath);
-        if (typeof this.screenshot === "function") {
-          this.screenshot(fullPath, payload || "");
-        } else {
-          this.writeFileSync(fullPath, payload || "");
-        }
-      },
-      openScreencast: async (filename) => {
-        let path2 = "";
-        const basePath = this.testResourceConfiguration?.fs || "testeranto";
-        console.log("[Artifactory openScreencast] Base path:", basePath);
-        console.log("[Artifactory openScreencast] Context:", context);
-        if (context.suiteIndex !== void 0) {
-          path2 += `suite-${context.suiteIndex}/`;
-        }
-        if (context.givenKey) {
-          path2 += `given-${context.givenKey}/`;
-        }
-        if (context.whenIndex !== void 0) {
-          path2 += `when-${context.whenIndex} `;
-        } else if (context.thenIndex !== void 0) {
-          path2 += `then-${context.thenIndex} `;
-        }
-        path2 += filename;
-        if (!path2.match(/\.[a-zA-Z0-9]+$/)) {
-          path2 += ".webm";
-        }
-        const basePathClean = basePath.replace(/\/$/, "");
-        const pathClean = path2.replace(/^\//, "");
-        const fullPath = `${basePathClean}/${pathClean}`;
-        console.log("[Artifactory openScreencast] Full path:", fullPath);
-        if (typeof this.openScreencast === "function") {
-          await this.openScreencast(fullPath);
-        } else {
-          console.log("[Artifactory openScreencast] Method not available");
-        }
-      },
-      closeScreencast: async (filename) => {
-        let path2 = "";
-        const basePath = this.testResourceConfiguration?.fs || "testeranto";
-        console.log("[Artifactory closeScreencast] Base path:", basePath);
-        console.log("[Artifactory closeScreencast] Context:", context);
-        if (context.suiteIndex !== void 0) {
-          path2 += `suite-${context.suiteIndex}/`;
-        }
-        if (context.givenKey) {
-          path2 += `given-${context.givenKey}/`;
-        }
-        if (context.whenIndex !== void 0) {
-          path2 += `when-${context.whenIndex} `;
-        } else if (context.thenIndex !== void 0) {
-          path2 += `then-${context.thenIndex} `;
-        }
-        path2 += filename;
-        if (!path2.match(/\.[a-zA-Z0-9]+$/)) {
-          path2 += ".webm";
-        }
-        const basePathClean = basePath.replace(/\/$/, "");
-        const pathClean = path2.replace(/^\//, "");
-        const fullPath = `${basePathClean}/${pathClean}`;
-        console.log("[Artifactory closeScreencast] Full path:", fullPath);
-        if (typeof this.closeScreencast === "function") {
-          await this.closeScreencast(fullPath);
-        } else {
-          console.log("[Artifactory closeScreencast] Method not available");
-        }
       }
+      // screenshot, openScreencast, and closeScreencast are only applicable to web runtime
+      // They should be implemented in WebTiposkripto and will be added to the artifactory there
+      // For non-web runtimes, these methods will not be available
     };
   }
   async receiveTestResourceConfig(testResourceConfig) {
@@ -1238,6 +1219,24 @@ var BaseTiposkripto = class {
   Then() {
     return this.thenOverrides;
   }
+  Describe() {
+    return this.describesOverrides || {};
+  }
+  It() {
+    return this.itsOverrides || {};
+  }
+  Confirm() {
+    return this.confirmsOverrides || {};
+  }
+  Value() {
+    return this.valuesOverrides || {};
+  }
+  Should() {
+    return this.shouldsOverrides || {};
+  }
+  Expect() {
+    return this.expectedsOverrides || {};
+  }
   // Add a method to access test jobs which can be used by receiveTestResourceConfig
   getTestJobs() {
     return this.testJobs;
@@ -1280,6 +1279,8 @@ var NodeTiposkripto = class extends BaseTiposkripto {
     }
     fs.writeFileSync(filename, payload);
   }
+  // screenshot, openScreencast, and closeScreencast are not applicable to Node runtime
+  // These methods are only for web runtime to capture visual artifacts in browser environments
 };
 var tiposkripto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
   try {