@sarj/eslint-plugin 16.19.1 → 16.19.2

package/dist/index.cjs

@@ -52,7 +52,7 @@ module.exports = __toCommonJS(src_exports);
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.19.1",
+  version: "16.19.2",
   packageManager: "npm@12.2.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -14349,13 +14349,14 @@ var no_duplicate_test_case_default = createRule({
 // src/rules/no-tautological-expect.ts
 var import_utils80 = require("@typescript-eslint/utils");
 var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
-  summary: "Disallow supported assertions known to pass from literals or immutable scalar setup.",
-  rationale: "An assertion determined entirely by literals does not observe the code under test and can keep passing after that code is removed.",
+  summary: "Disallow supported assertions fixed by literal setup or immutable self identity.",
+  rationale: "An assertion fixed by literal setup or one immutable binding's identity cannot distinguish a wrong result from the intended behavior.",
   remediation: "Assert on a value produced by the behavior under test against an independently specified expectation, or remove only the redundant assertion while preserving coverage.",
   category: "testing",
   limitations: [
     "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases, static string messages on imported Vitest/Playwright expect calls, and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
-    "Scalar const bindings and aliases resolve through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded.",
+    "The literal proof resolves scalar const bindings and aliases through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded from that proof.",
+    "Positive toBe assertions on the same initialized, unreassigned local identifier const binding also have fixed identity, including runtime results. Different bindings, imported live values, property/getter accesses and deep-equality reflexivity remain excluded from this identity proof.",
     "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid.",
     "Direct framework expect.extend registrations exclude replaced built-in matchers; opaque registrations exclude all supported matchers, and nonempty custom equality testers exclude deep equality. Direct synchronous expect callbacks observed by a throwing matcher retain their assertion contracts. Cross-file or indirect matcher customization is not inferred."
   ],
@@ -14477,6 +14478,26 @@ var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
       focusPath: "src/assertion.test.ts",
       expectedCount: 0,
       public: true
+    },
+    {
+      id: "self-identity-oracle",
+      scenarioId: "immutable-identity",
+      title: "A returned value's identity with itself cannot reject a wrong result",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result).toBe(result);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "independent-result-oracle",
+      scenarioId: "immutable-identity",
+      title: "An independent expected state can reject a wrong result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result.status).toBe('ready');" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
     }
   ]
 };
@@ -14628,6 +14649,15 @@ function collectCustomization(node, source, customized) {
     customized.add(name ?? "*");
   }
 }
+function hasConstSelfIdentity(actual, expected, source) {
+  actual = unwrapExpression(actual);
+  expected = unwrapExpression(expected);
+  if (actual.type !== import_utils80.AST_NODE_TYPES.Identifier || expected.type !== import_utils80.AST_NODE_TYPES.Identifier) return false;
+  const variable = import_utils80.ASTUtils.findVariable(source.getScope(actual), actual.name);
+  if (variable?.defs.length !== 1 || import_utils80.ASTUtils.findVariable(source.getScope(expected), expected.name) !== variable) return false;
+  const definition = variable.defs[0];
+  return definition?.node.type === import_utils80.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils80.AST_NODE_TYPES.Identifier && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.init.range[1] <= Math.min(actual.range[0], expected.range[0]) && !variable.references.some((reference) => reference.isWrite() && !reference.init);
+}
 var no_tautological_expect_default = createRule({
   name: "no-tautological-expect",
   documentation: NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION,
@@ -14638,7 +14668,7 @@ var no_tautological_expect_default = createRule({
     },
     schema: [],
     messages: {
-      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by literal setup and does not observe behavior. Assert on a produced value or remove only the redundant assertion, preserving other coverage.",
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by {{reason}} and does not observe behavior. Assert against an independent expectation or remove only the redundant assertion, preserving the action and other coverage.",
       tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` is statically known to pass. Assert on a produced value or remove only the redundant assertion, preserving other coverage."
     }
   },
@@ -14659,10 +14689,19 @@ var no_tautological_expect_default = createRule({
         const matcher = import_utils80.ASTUtils.getPropertyName(callee);
         if (matcher === null || !ZERO_ARG_MATCHERS.has(matcher) && !EQUALITY_MATCHERS.has(matcher) || customized.has("*") || customized.has(matcher)) return;
         const assertion = expectOperand(callee, context.sourceCode);
-        if (assertion === null) return;
+        if (assertion === null || isExceptionContract(node, context.sourceCode)) return;
         const writtenOperand = assertion.operand;
+        const writtenExpected = node.arguments[0];
+        if (!assertion.negated && matcher === "toBe" && node.arguments.length === 1 && writtenExpected !== void 0 && hasConstSelfIdentity(writtenOperand, writtenExpected, context.sourceCode)) {
+          context.report({
+            node,
+            messageId: "tautologicalComparison",
+            data: { operand: preview2(writtenOperand), matcher, reason: "the same immutable binding" }
+          });
+          return;
+        }
         const operand = resolveLiteral(writtenOperand, context.sourceCode);
-        if (operand === null || isExceptionContract(node, context.sourceCode)) {
+        if (operand === null) {
           return;
         }
         const writtenMatcher = `${assertion.negated ? "not." : ""}${matcher}`;
@@ -14674,7 +14713,6 @@ var no_tautological_expect_default = createRule({
           });
           return;
         }
-        const writtenExpected = node.arguments[0];
         const expected = writtenExpected === void 0 ? null : resolveLiteral(writtenExpected, context.sourceCode);
         if (assertion.negated || !EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === null) {
           return;
@@ -14688,7 +14726,7 @@ var no_tautological_expect_default = createRule({
         context.report({
           node,
           messageId: "tautologicalComparison",
-          data: { operand: preview2(writtenOperand), matcher }
+          data: { operand: preview2(writtenOperand), matcher, reason: "literal setup" }
         });
       }
     };

package/dist/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.19.1",
+  version: "16.19.2",
   packageManager: "npm@12.2.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -14330,13 +14330,14 @@ var no_duplicate_test_case_default = createRule({
 // src/rules/no-tautological-expect.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES65, ASTUtils as ASTUtils40 } from "@typescript-eslint/utils";
 var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
-  summary: "Disallow supported assertions known to pass from literals or immutable scalar setup.",
-  rationale: "An assertion determined entirely by literals does not observe the code under test and can keep passing after that code is removed.",
+  summary: "Disallow supported assertions fixed by literal setup or immutable self identity.",
+  rationale: "An assertion fixed by literal setup or one immutable binding's identity cannot distinguish a wrong result from the intended behavior.",
   remediation: "Assert on a value produced by the behavior under test against an independently specified expectation, or remove only the redundant assertion while preserving coverage.",
   category: "testing",
   limitations: [
     "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases, static string messages on imported Vitest/Playwright expect calls, and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
-    "Scalar const bindings and aliases resolve through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded.",
+    "The literal proof resolves scalar const bindings and aliases through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded from that proof.",
+    "Positive toBe assertions on the same initialized, unreassigned local identifier const binding also have fixed identity, including runtime results. Different bindings, imported live values, property/getter accesses and deep-equality reflexivity remain excluded from this identity proof.",
     "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid.",
     "Direct framework expect.extend registrations exclude replaced built-in matchers; opaque registrations exclude all supported matchers, and nonempty custom equality testers exclude deep equality. Direct synchronous expect callbacks observed by a throwing matcher retain their assertion contracts. Cross-file or indirect matcher customization is not inferred."
   ],
@@ -14458,6 +14459,26 @@ var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
       focusPath: "src/assertion.test.ts",
       expectedCount: 0,
       public: true
+    },
+    {
+      id: "self-identity-oracle",
+      scenarioId: "immutable-identity",
+      title: "A returned value's identity with itself cannot reject a wrong result",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result).toBe(result);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "independent-result-oracle",
+      scenarioId: "immutable-identity",
+      title: "An independent expected state can reject a wrong result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result.status).toBe('ready');" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
     }
   ]
 };
@@ -14609,6 +14630,15 @@ function collectCustomization(node, source, customized) {
     customized.add(name ?? "*");
   }
 }
+function hasConstSelfIdentity(actual, expected, source) {
+  actual = unwrapExpression(actual);
+  expected = unwrapExpression(expected);
+  if (actual.type !== AST_NODE_TYPES65.Identifier || expected.type !== AST_NODE_TYPES65.Identifier) return false;
+  const variable = ASTUtils40.findVariable(source.getScope(actual), actual.name);
+  if (variable?.defs.length !== 1 || ASTUtils40.findVariable(source.getScope(expected), expected.name) !== variable) return false;
+  const definition = variable.defs[0];
+  return definition?.node.type === AST_NODE_TYPES65.VariableDeclarator && definition.node.id.type === AST_NODE_TYPES65.Identifier && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.init.range[1] <= Math.min(actual.range[0], expected.range[0]) && !variable.references.some((reference) => reference.isWrite() && !reference.init);
+}
 var no_tautological_expect_default = createRule({
   name: "no-tautological-expect",
   documentation: NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION,
@@ -14619,7 +14649,7 @@ var no_tautological_expect_default = createRule({
     },
     schema: [],
     messages: {
-      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by literal setup and does not observe behavior. Assert on a produced value or remove only the redundant assertion, preserving other coverage.",
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by {{reason}} and does not observe behavior. Assert against an independent expectation or remove only the redundant assertion, preserving the action and other coverage.",
       tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` is statically known to pass. Assert on a produced value or remove only the redundant assertion, preserving other coverage."
     }
   },
@@ -14640,10 +14670,19 @@ var no_tautological_expect_default = createRule({
         const matcher = ASTUtils40.getPropertyName(callee);
         if (matcher === null || !ZERO_ARG_MATCHERS.has(matcher) && !EQUALITY_MATCHERS.has(matcher) || customized.has("*") || customized.has(matcher)) return;
         const assertion = expectOperand(callee, context.sourceCode);
-        if (assertion === null) return;
+        if (assertion === null || isExceptionContract(node, context.sourceCode)) return;
         const writtenOperand = assertion.operand;
+        const writtenExpected = node.arguments[0];
+        if (!assertion.negated && matcher === "toBe" && node.arguments.length === 1 && writtenExpected !== void 0 && hasConstSelfIdentity(writtenOperand, writtenExpected, context.sourceCode)) {
+          context.report({
+            node,
+            messageId: "tautologicalComparison",
+            data: { operand: preview2(writtenOperand), matcher, reason: "the same immutable binding" }
+          });
+          return;
+        }
         const operand = resolveLiteral(writtenOperand, context.sourceCode);
-        if (operand === null || isExceptionContract(node, context.sourceCode)) {
+        if (operand === null) {
           return;
         }
         const writtenMatcher = `${assertion.negated ? "not." : ""}${matcher}`;
@@ -14655,7 +14694,6 @@ var no_tautological_expect_default = createRule({
           });
           return;
         }
-        const writtenExpected = node.arguments[0];
         const expected = writtenExpected === void 0 ? null : resolveLiteral(writtenExpected, context.sourceCode);
         if (assertion.negated || !EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === null) {
           return;
@@ -14669,7 +14707,7 @@ var no_tautological_expect_default = createRule({
         context.report({
           node,
           messageId: "tautologicalComparison",
-          data: { operand: preview2(writtenOperand), matcher }
+          data: { operand: preview2(writtenOperand), matcher, reason: "literal setup" }
         });
       }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "16.19.1",
+  "version": "16.19.2",
   "packageManager": "npm@12.2.0",
   "description": "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",