@ripplo/testing 0.0.3 → 0.0.4

package/dist/index.js

@@ -446,6 +446,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 +629,11 @@ var RULES = [
   noDuplicateLabels,
   assertAfterAction,
   assertMatchesOutcome,
-  noEmptySteps
+  noEmptySteps,
+  noAssertions,
+  lowAssertionRatio,
+  tautologicalPostClickAssert,
+  expectedOutcomeKeywordCoverage
 ];
 export {
   buildSetCookieHeader,

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.4",
   "type": "module",
   "files": [
     "dist"
@@ -66,8 +66,8 @@
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.4",
-    "@ripplo/eslint-config": "0.0.0",
-    "@ripplo/spec": "^0.0.0"
+    "@ripplo/spec": "^0.0.0",
+    "@ripplo/eslint-config": "0.0.0"
   },
   "peerDependencies": {
     "dotenv": "^16.0.0 || ^17.0.0",