@ripplo/testing 0.0.3 → 0.0.5

package/dist/index.js

@@ -61,7 +61,11 @@ function createRipplo(rawConfig) {
     },
     precondition(name) {
       if (preconditionNames.has(name)) {
-        throw new Error(`Duplicate precondition name: "${name}"`);
+        preconditions.splice(
+          0,
+          preconditions.length,
+          ...preconditions.filter((p) => p.name !== name)
+        );
       }
       preconditionNames.add(name);
       return buildPrecondition(name, preconditions);
@@ -69,7 +73,7 @@ function createRipplo(rawConfig) {
     test(id) {
       validateTestId(id);
       if (testNames.has(id)) {
-        throw new Error(`Duplicate test id: "${id}"`);
+        tests.splice(0, tests.length, ...tests.filter((t) => t.id !== id));
       }
       testNames.add(id);
       return buildTestName(id, tests);
@@ -446,6 +450,181 @@ function looksLikeDynamicData(value) {
 function isAssertionNode(node) {
   return node.type.startsWith("assert");
 }
+var EFFECT_ASSERTION_TYPES = /* @__PURE__ */ new Set([
+  "assertText",
+  "assertValue",
+  "assertCount",
+  "assertUrl",
+  "assertNotVisible",
+  "assertChecked",
+  "assertNotChecked",
+  "assertAttribute",
+  "assertDisabled",
+  "assertEnabled"
+]);
+function isEffectAssertion(node) {
+  return EFFECT_ASSERTION_TYPES.has(node.type);
+}
+function noAssertions(nodes, test, report) {
+  if (!test.implemented || nodes.length === 0) {
+    return;
+  }
+  if (!nodes.some((n) => isAssertionNode(n))) {
+    report({
+      message: "Test has zero assertion steps \u2014 cannot verify expectedOutcome. Add assert.* steps.",
+      rule: "no-assertions",
+      step: void 0
+    });
+  }
+}
+function lowAssertionRatio(nodes, test, report) {
+  if (!test.implemented || nodes.length <= 3) {
+    return;
+  }
+  const assertions = nodes.filter((n) => isAssertionNode(n)).length;
+  if (assertions === 0) {
+    return;
+  }
+  const ratio = assertions / nodes.length;
+  if (ratio < 0.15) {
+    const pct = Math.round(ratio * 100);
+    report({
+      message: `Only ${String(assertions)}/${String(nodes.length)} steps are assertions (${String(pct)}%) \u2014 add more verification between actions`,
+      rule: "low-assertion-ratio",
+      step: void 0
+    });
+  }
+}
+function locatorSignature(node) {
+  if (!("locator" in node) || node.locator == null) {
+    return void 0;
+  }
+  const loc = node.locator;
+  if (loc.by === "role") {
+    return `role:${loc.role}:${loc.name ?? ""}`;
+  }
+  return `testId:${loc.value}`;
+}
+function tautologicalPostClickAssert(nodes, _test, report) {
+  nodes.forEach((node, index) => {
+    if (node.type !== "click") {
+      return;
+    }
+    const sig = locatorSignature(node);
+    if (sig == null) {
+      return;
+    }
+    const window = nodes.slice(index + 1, index + 4);
+    const matchesSameAssertVisible = window.find(
+      (n) => n.type === "assertVisible" && locatorSignature(n) === sig
+    );
+    if (matchesSameAssertVisible == null) {
+      return;
+    }
+    const hasOtherEffect = window.some(
+      (n) => isEffectAssertion(n) || isAssertionNode(n) && locatorSignature(n) !== sig
+    );
+    if (hasOtherEffect) {
+      return;
+    }
+    report({
+      message: `click "${node.label ?? node.id}" is followed only by assert.visible on the same locator \u2014 verifies nothing about the click's effect`,
+      rule: "tautological-post-click-assert",
+      step: node.label ?? node.id
+    });
+  });
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "is",
+  "a",
+  "an",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "for",
+  "that",
+  "this",
+  "with",
+  "be",
+  "are",
+  "was",
+  "were",
+  "it",
+  "its",
+  "as",
+  "by",
+  "from",
+  "after",
+  "before",
+  "should",
+  "will",
+  "can",
+  "still",
+  "but",
+  "not",
+  "no",
+  "so",
+  "if",
+  "then",
+  "than",
+  "user",
+  "users",
+  "page",
+  "view",
+  "shows",
+  "show",
+  "see",
+  "click",
+  "clicks",
+  "clicked",
+  "clickable",
+  "visible",
+  "appears",
+  "appear",
+  "displayed",
+  "stays",
+  "remains"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+}
+function nodeKeywords(node) {
+  const fromLabel = node.label == null ? [] : tokenize(node.label);
+  if (!("locator" in node) || node.locator == null) {
+    return fromLabel;
+  }
+  const loc = node.locator;
+  const locName = loc.by === "role" ? loc.name ?? "" : loc.value;
+  return [...fromLabel, ...tokenize(locName)];
+}
+function expectedOutcomeKeywordCoverage(nodes, test, report) {
+  if (!test.implemented || nodes.length === 0) {
+    return;
+  }
+  const outcomeTokens = new Set(tokenize(test.expectedOutcome));
+  if (outcomeTokens.size === 0) {
+    return;
+  }
+  const assertions = nodes.filter((n) => isAssertionNode(n));
+  if (assertions.length === 0) {
+    return;
+  }
+  const covered = assertions.some(
+    (node) => nodeKeywords(node).some((tok) => outcomeTokens.has(tok))
+  );
+  if (!covered) {
+    report({
+      message: `No assertion references any keyword from expectedOutcome (${[...outcomeTokens].join(", ")}) \u2014 the outcome may not actually be verified`,
+      rule: "expected-outcome-keyword-coverage",
+      step: void 0
+    });
+  }
+}
 var RULES = [
   exactTextMatch,
   noHardcodedData,
@@ -454,7 +633,11 @@ var RULES = [
   noDuplicateLabels,
   assertAfterAction,
   assertMatchesOutcome,
-  noEmptySteps
+  noEmptySteps,
+  noAssertions,
+  lowAssertionRatio,
+  tautologicalPostClickAssert,
+  expectedOutcomeKeywordCoverage
 ];
 export {
   buildSetCookieHeader,

package/dist/nextjs.js

@@ -23,10 +23,9 @@ function createNextHandler({ enabled, ripplo }) {
     if ("error" in verified) {
       return verified.error;
     }
-    if (action === "execute-batch") {
-      return handleExecuteBatch({ body: verified.body, engine, req });
-    }
-    return handleTeardown({ body: verified.body, engine });
+    return runGuarded(
+      () => action === "execute-batch" ? handleExecuteBatch({ body: verified.body, engine, req }) : handleTeardown({ body: verified.body, engine })
+    );
   };
 }
 async function handleExecuteBatch({
@@ -85,6 +84,20 @@ async function verifyAndReadBody(req, webhookSecret) {
   }
   return { body };
 }
+async function runGuarded(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return jsonResponse(
+      {
+        error: error instanceof Error ? error.message : "Unknown error",
+        stack: error instanceof Error ? error.stack : void 0,
+        success: false
+      },
+      500
+    );
+  }
+}
 function lastPathSegment(url) {
   const pathname = new URL(url).pathname;
   const segments = pathname.split("/").filter((s) => s.length > 0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "dist"
@@ -55,16 +55,16 @@
   },
   "dependencies": {
     "standardwebhooks": "^1.0.0",
-    "zod": "^4.3.6"
+    "zod": "catalog:"
   },
   "devDependencies": {
     "@types/express": "^5.0.2",
-    "@types/node": "^22.15.3",
-    "eslint": "^9.39.1",
+    "@types/node": "catalog:",
+    "eslint": "catalog:",
     "express": "^5.1.0",
     "fastify": "^5.3.3",
     "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
+    "typescript": "catalog:",
     "vitest": "^4.1.4",
     "@ripplo/eslint-config": "0.0.0",
     "@ripplo/spec": "^0.0.0"