@sarj/eslint-plugin 2.13.0 → 2.14.0

package/README.md

@@ -12,10 +12,41 @@ import sarj from "@sarj/eslint-plugin";
 export default [...sarj.configs.recommended];
 ```
 
-44 rules. Each rule's source under `src/rules/` carries its own `@fileoverview` rationale plus `meta.docs.description` + `meta.messages` — read the file for the full reasoning, including the false positives it deliberately does not fire on.
+45 rules. Each rule's source under `src/rules/` carries its own `@fileoverview` rationale plus `meta.docs.description` + `meta.messages` — read the file for the full reasoning, including the false positives it deliberately does not fire on.
 
 Presets: `recommended` (warn-first), `strict` (every rule at error), `style-guide` (formatting/naming subset).
 
+## New in 2.14.0 — `no-tautological-expect`
+
+The TS half of SARJ057. An `expect(...)` whose operands are all literals has
+already decided its outcome before the test runs — `expect(true).toBe(true)`
+passes if you delete the module under test.
+
+Python has caught the assertion-*free* test since 0.15.0 (`SARJ043
+zero-assertion-test`) and had no TypeScript counterpart, which is exactly how
+`expect(true).toBe(true); // placeholder` survived in an internal suite named for
+the behaviour it was supposed to check: the file *has* an assertion, so nothing
+was looking at it.
+
+| Rule | What it catches | Preset |
+|---|---|---|
+| `no-tautological-expect` | `expect(<literal>).toBe/toEqual/toStrictEqual(<textually identical literal>)`, and `expect(<literal>).toBeDefined()/toBeTruthy()/toBeNull()/…` — a zero-argument matcher on a literal receiver. | warn / error |
+
+**The narrowness is the rule.** The obvious generalisation — "flag a comparison
+of a thing with itself" — measures ~95% false positives:
+`expect(hash([o])).toEqual(hash([o]))` is a *determinism* test,
+`expect(memo(x)).toBe(memo(x))` a *memoization* test, `expect(a).toEqual(a)` on a
+value with custom equality a *reflexivity* test. All three can genuinely fail. So
+an identifier, member-expression or call operand is never enough: both sides must
+be literals, and textually identical ones. A modified chain (`.not`, `.resolves`,
+`.rejects`), a spread, an interpolated template literal, and two *different*
+literals are all left alone.
+
+Measured before shipping: **3 hits across 5,819 `.ts`/`.tsx` files** (1,003 of
+them test files, where the rule is active) — six internal repos plus `got`,
+`hono`, `swr` and `trpc`. 3 true positives, **0 false positives**; every hit is
+an abandoned placeholder.
+
 ## New in 2.13.0 — the anti-comment-verbosity family
 
 From a 37,918-comment, nine-repo measurement study. All three are

package/dist/index.cjs

@@ -7160,6 +7160,107 @@ var trailing_value_narration_default = import_utils49.ESLintUtils.RuleCreator(
   }
 });
 
+// src/rules/no-tautological-expect.ts
+var import_utils50 = require("@typescript-eslint/utils");
+var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
+  "toBeDefined",
+  "toBeUndefined",
+  "toBeNull",
+  "toBeTruthy",
+  "toBeFalsy",
+  "toBeNaN"
+]);
+var OPERAND_PREVIEW_CHARS = 40;
+var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
+function isLiteral(node) {
+  switch (node.type) {
+    case import_utils50.AST_NODE_TYPES.Literal:
+      return true;
+    case import_utils50.AST_NODE_TYPES.TemplateLiteral:
+      return node.expressions.length === 0;
+    case import_utils50.AST_NODE_TYPES.UnaryExpression:
+      return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
+    case import_utils50.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.every((element) => element !== null && isLiteral(element));
+    case import_utils50.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.every(
+        (property) => property.type === import_utils50.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+      );
+    default:
+      return false;
+  }
+}
+function expectOperand(callee) {
+  const receiver = callee.object;
+  if (receiver.type !== import_utils50.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils50.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+    return null;
+  }
+  return receiver.arguments[0] ?? null;
+}
+var no_tautological_expect_default = import_utils50.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-tautological-expect",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow an assertion whose operands are all literals; its outcome is fixed before the code runs, so it can never fail."
+    },
+    schema: [],
+    messages: {
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` compares a literal with an identical literal \u2014 it passes even if the code under test is deleted. Assert on a value the code produced, or delete the test.",
+      tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` asserts on a literal, so its outcome is fixed before the code runs. Assert on a value the code produced, or delete the test."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isTestFile(context.filename)) {
+      return {};
+    }
+    const preview2 = (node) => {
+      const text = context.sourceCode.getText(node).replaceAll(/\s+/gu, " ");
+      return text.length > OPERAND_PREVIEW_CHARS ? `${text.slice(0, OPERAND_PREVIEW_CHARS)}\u2026` : text;
+    };
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.computed) {
+          return;
+        }
+        if (callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        const matcher = callee.property.name;
+        const operand = expectOperand(callee);
+        if (operand === null || !isLiteral(operand)) {
+          return;
+        }
+        if (ZERO_ARG_MATCHERS.has(matcher) && node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "tautologicalMatcher",
+            data: { operand: preview2(operand), matcher }
+          });
+          return;
+        }
+        const expected = node.arguments[0];
+        if (!EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === void 0 || !isLiteral(expected)) {
+          return;
+        }
+        if (context.sourceCode.getText(operand) !== context.sourceCode.getText(expected)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "tautologicalComparison",
+          data: { operand: preview2(operand), matcher }
+        });
+      }
+    };
+  }
+});
+
 // src/index.ts
 var rules = {
   "enforce-file-structure": enforce_file_structure_default,
@@ -7205,12 +7306,13 @@ var rules = {
   "prefer-module-level-constant": prefer_module_level_constant_default,
   "jsdoc-restates-signature": jsdoc_restates_signature_default,
   "no-restated-comment": no_restated_comment_default,
-  "trailing-value-narration": trailing_value_narration_default
+  "trailing-value-narration": trailing_value_narration_default,
+  "no-tautological-expect": no_tautological_expect_default
 };
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.13.0"
+    version: "2.14.0"
   },
   rules,
   configs: {
@@ -7277,7 +7379,15 @@ var plugin = {
         // wrong deletion is silent information loss.
         "@sarj/no-restated-comment": "warn",
         "@sarj/jsdoc-restates-signature": "warn",
-        "@sarj/trailing-value-narration": "warn"
+        "@sarj/trailing-value-narration": "warn",
+        // The TS half of SARJ057 (2026-07). Python has caught the
+        // assertion-FREE test since 0.15.0 (SARJ043) and had no TS
+        // counterpart, which is how `expect(true).toBe(true); // placeholder`
+        // survived in internal-automations: the file HAS an assertion.
+        // Measured across 5,819 .ts/.tsx files (1,003 of them test files) in
+        // six internal repos plus got / hono / swr / trpc: 3 hits, 3 true
+        // positives, 0 false positives.
+        "@sarj/no-tautological-expect": "warn"
       }
     },
     strict: {
@@ -7345,7 +7455,9 @@ var plugin = {
         // for the measured hit counts and false-positive rates.
         "@sarj/no-restated-comment": "error",
         "@sarj/jsdoc-restates-signature": "error",
-        "@sarj/trailing-value-narration": "error"
+        "@sarj/trailing-value-narration": "error",
+        // TS half of SARJ057 — see the `recommended` block for the measurement.
+        "@sarj/no-tautological-expect": "error"
       }
     }
   }