tamperward 2.24.1 → 2.24.3

package/dist/cli/index.js

@@ -3713,8 +3713,101 @@ var init_lint_suppression = __esm({
   }
 });
 
+// src/detectors/runner-chain.ts
+function readRunnerChain(root, props) {
+  let runner = root;
+  const modifiers = [];
+  let table = null;
+  let skipMarker = null;
+  let skipIndex = -1;
+  for (let i = 0; i < props.length; i++) {
+    const p = props[i];
+    if (table) return null;
+    if (RUNNER_NAMES.has(p) && modifiers.length === 0) {
+      runner = p;
+      continue;
+    }
+    if (CHAIN_MODIFIERS.has(p)) {
+      modifiers.push(p);
+      const marker = skipMarkerOf(p);
+      if (marker && !skipMarker) {
+        skipMarker = marker;
+        skipIndex = i;
+      }
+      continue;
+    }
+    const t = tableOf(p);
+    if (t) {
+      table = t;
+      continue;
+    }
+    return null;
+  }
+  return { runner, modifiers, table, skipMarker, skipIndex };
+}
+function readCallee(expr) {
+  const props = [];
+  let cur = expr;
+  while (ts.isPropertyAccessExpression(cur) || ts.isElementAccessExpression(cur)) {
+    if (ts.isPropertyAccessExpression(cur)) {
+      props.unshift(cur.name.text);
+    } else {
+      const arg = cur.argumentExpression;
+      if (!ts.isStringLiteralLike(arg)) return null;
+      props.unshift(arg.text);
+    }
+    cur = cur.expression;
+  }
+  if (!ts.isIdentifier(cur)) return null;
+  return readRunnerChain(cur.text, props);
+}
+function readTableCallee(expr) {
+  const head = ts.isCallExpression(expr) ? expr.expression : ts.isTaggedTemplateExpression(expr) ? expr.tag : null;
+  if (!head) return null;
+  const chain = readCallee(head);
+  return chain?.table ? chain : null;
+}
+var RUNNER_NAMES, CHAIN_MODIFIERS, skipMarkerOf, tableOf;
+var init_runner_chain = __esm({
+  "src/detectors/runner-chain.ts"() {
+    "use strict";
+    init_ts_lazy();
+    RUNNER_NAMES = /* @__PURE__ */ new Set(["it", "test", "describe", "suite"]);
+    CHAIN_MODIFIERS = /* @__PURE__ */ new Set([
+      "concurrent",
+      "sequential",
+      "shuffle",
+      "serial",
+      "parallel",
+      "skip",
+      "only",
+      "todo",
+      "fails",
+      "failing"
+    ]);
+    skipMarkerOf = (name) => name === "skip" || name === "only" || name === "todo" ? name : null;
+    tableOf = (name) => name === "each" || name === "for" ? name : null;
+  }
+});
+
 // src/detectors/test-skip.ts
 import { posix as posix2 } from "node:path";
+function pyMarkAliases(source) {
+  const out3 = /* @__PURE__ */ new Set();
+  for (const m of source.matchAll(PY_MARK_ALIAS)) out3.add(m[1]);
+  return out3;
+}
+function pyAliasDecoratorHits(c) {
+  const added = addedLines(c);
+  const aliases = pyMarkAliases(c.after ?? added.map((l) => l.content).join("\n"));
+  if (aliases.size === 0) return [];
+  const hits = [];
+  for (const l of added) {
+    const m = PY_DECORATOR.exec(l.content);
+    if (m && aliases.has(m[1])) hits.push({ line: l.newLine ?? void 0, evidence: l.content.trim() });
+  }
+  return hits;
+}
 function matchesOutsideString(p, content, lang) {
   if (p.comment) return p.re.test(content);
   const re = p.re.global ? p.re : new RegExp(p.re.source, p.re.flags + "g");
@@ -3870,12 +3963,14 @@ function staticPropertyName(expr, ctx, strings) {
 }
 function runnerChain(expr, ctx, binder, strings) {
   const props = [];
+  const propNodes = [];
   const causes = [];
   let cur = expr;
   let terminalNode = expr;
   while (ts.isPropertyAccessExpression(cur) || ts.isElementAccessExpression(cur)) {
     if (ts.isPropertyAccessExpression(cur)) {
       props.unshift(cur.name.text);
+      propNodes.unshift(cur.name);
       if (props.length === 1) terminalNode = cur.name;
       cur = cur.expression;
       continue;
@@ -3884,6 +3979,7 @@ function runnerChain(expr, ctx, binder, strings) {
     const property = staticPropertyName(cur.argumentExpression, ctx, strings);
     if (!property) return null;
     props.unshift(property.name);
+    propNodes.unshift(cur.argumentExpression);
     causes.push(...property.causes);
     if (props.length === 1) terminalNode = cur.argumentExpression;
     cur = cur.expression;
@@ -3900,17 +3996,21 @@ function runnerChain(expr, ctx, binder, strings) {
     }
   } else {
     namespace = requiredModule(cur);
+    if (namespace == null && readTableCallee(cur)) return null;
     verdict2 = namespace == null ? UNKNOWN : NON_RUNNER;
   }
   let root = ts.isIdentifier(cur) ? cur.text : "";
   if (namespace != null && props.length > 0) {
     verdict2 = withCause(binder.memberOf(namespace, props[0]), cur);
-    if (verdict2.kind === "runner") root = props.shift() ?? root;
+    if (verdict2.kind === "runner") {
+      root = props.shift() ?? root;
+      propNodes.shift();
+    }
   }
   if (verdict2.kind === "unknown") return "unknown";
   if (verdict2.kind === "non-runner") return null;
   causes.push(...verdict2.causes);
-  return { root, props, terminalNode, causes };
+  return { root, props, propNodes, terminalNode, causes };
 }
 function optionDisables(value) {
   return !(value.kind === ts.SyntaxKind.FalseKeyword || ts.isNumericLiteral(value) && Number(value.text) === 0);
@@ -3949,8 +4049,9 @@ function semanticSkipHits(ctx, binder) {
         const last = lineOf(callee.getEnd());
         for (let line = first; line <= last; line++) unowned.add(line);
       } else if (chain) {
-        const { props, terminalNode, causes } = chain;
+        const { root, props, propNodes, terminalNode, causes } = chain;
         const terminal = props.at(-1);
+        const shape = readRunnerChain(root, props);
         const push = (target, extraCauses, why) => {
           hits.push({
             semanticKey: `${callKey}\0${why}`,
@@ -3960,13 +4061,13 @@ function semanticSkipHits(ctx, binder) {
             evidence: callText
           });
         };
-        if (terminal && (terminal === "skip" || terminal === "only" || terminal === "todo") && props.slice(0, -1).every((p) => JS_CHAIN_MODIFIERS.has(p) || JS_RUNNERS.has(p))) {
-          push(terminalNode, [], "a .skip/.only/.todo marker");
+        if (shape?.skipMarker) {
+          push(propNodes[shape.skipIndex] ?? terminalNode, [], "a .skip/.only/.todo marker");
         } else if (terminal && ["skipIf", "runIf"].includes(terminal) && props.length === 1) {
           push(terminalNode, [], "a .skipIf()/.runIf() condition (the test runs only when the condition allows)");
         } else if (terminal && ["fails", "failing"].includes(terminal) && props.length === 1) {
           push(terminalNode, [], "a .fails/.failing marker (the test now passes by failing)");
-        } else if (terminal === "each" && props.length === 1 && node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0]) && node.arguments[0].elements.length === 0) {
+        } else if (shape?.table === "each" && node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0]) && node.arguments[0].elements.length === 0) {
           push(terminalNode, [], "an empty .each table (no case ever runs)");
         }
         if (props.length === 0) {
@@ -4046,11 +4147,12 @@ function astSkipHits(c, resolvers) {
   }
   return { hits, authoritative: true, unowned: analysis.unowned };
 }
-var RULE4, acc, JS_RUNNER, JS_MOD, PATTERNS2, JS_RUNNERS, JS_CHAIN_MODIFIERS, JS_DEFAULT_RUNNER_MODULES, JS_TEST_MODULES, RUNNER2, NON_RUNNER, UNKNOWN, withCause, MODULE_EXTENSIONS, RunnerResolver, ModuleBinder, NO_AST, testSkip;
+var RULE4, acc, JS_RUNNER, JS_MOD, GO_SKIP_PATTERNS, PY_MARK, PY_CONFTEST_PATTERNS, PY_MARK_ALIAS, PY_DECORATOR, PATTERNS2, JS_RUNNERS, JS_DEFAULT_RUNNER_MODULES, JS_TEST_MODULES, RUNNER2, NON_RUNNER, UNKNOWN, withCause, MODULE_EXTENSIONS, RunnerResolver, ModuleBinder, NO_AST, testSkip;
 var init_test_skip = __esm({
   "src/detectors/test-skip.ts"() {
     "use strict";
     init_ts_lazy();
+    init_runner_chain();
     init_select();
     init_policy();
     init_repo();
@@ -4060,6 +4162,21 @@ var init_test_skip = __esm({
     acc = (names) => `(?:\\s*\\.\\s*(?:${names})(?![\\w$])|\\s*\\[\\s*['"\`](?:${names})['"\`]\\s*\\])`;
     JS_RUNNER = "\\b(?:it|test|describe|suite)";
     JS_MOD = "concurrent|sequential|shuffle|serial|parallel";
+    GO_SKIP_PATTERNS = [
+      { re: /\b\w+\.Skip(?:f|Now)?\(/, why: "a runtime t.Skip()/Skipf()/SkipNow() call" },
+      { re: /\bT\(\)\.Skip(?:f|Now)?\(/, why: "a runtime T().Skip()/Skipf()/SkipNow() call (testify suite)" }
+    ];
+    PY_MARK = "(?:\\w+\\.)?mark\\.(?:skip|skipif|xfail)\\b";
+    PY_CONFTEST_PATTERNS = [
+      { re: /\bdef\s+pytest_collection_modifyitems\s*\(/, why: "a pytest_collection_modifyitems hook (collected tests are filtered or marked before they run)" },
+      { re: /\bdef\s+pytest_pycollect_makeitem\s*\(/, why: "a pytest_pycollect_makeitem hook (what counts as a test is decided here)" },
+      { re: /\bdef\s+pytest_runtest_makereport\s*\(/, why: "a pytest_runtest_makereport hook (the test report can be rewritten)" },
+      { re: new RegExp("\\.add_marker\\(\\s*" + PY_MARK), why: "an add_marker(mark.skip/skipif/xfail) call (the test is skipped programmatically)" },
+      { re: new RegExp("^\\s*\\w+\\s*=\\s*" + PY_MARK), why: "a skip/skipif/xfail marker bound to a name (an aliased decorator)" },
+      { re: /\b\w+\.outcome\s*=\s*['"](?:passed|skipped)['"]/, why: "a report outcome rewritten to passed/skipped" }
+    ];
+    PY_MARK_ALIAS = new RegExp("^\\s*(\\w+)\\s*=\\s*" + PY_MARK, "gm");
+    PY_DECORATOR = /^\s*@(\w+)\s*(?:\(|$)/;
     PATTERNS2 = {
       js: [
         // The skip/only/todo family on a runner, by dot-or-bracket access, with one optional
@@ -4103,10 +4220,13 @@ var init_test_skip = __esm({
         { re: /@(?:unittest\.)?(?:skip|skipIf|skipUnless|expectedFailure)\b/, why: "a unittest skip/expectedFailure decorator" },
         { re: /\bself\.skipTest\(/, why: "a runtime self.skipTest() call" },
         { re: /\braise\s+(?:unittest\.)?SkipTest\b/, why: "a raised SkipTest" },
-        { re: /\b__test__\s*=\s*False\b/, why: "__test__ = False hides the test from collection" }
+        { re: /\b__test__\s*=\s*False\b/, why: "__test__ = False hides the test from collection" },
+        ...PY_CONFTEST_PATTERNS
+        // #441
       ],
       go: [
-        { re: /\b[tb]\.Skip(?:f|Now)?\(/, why: "a runtime t.Skip()/Skipf()/SkipNow() call" },
+        ...GO_SKIP_PATTERNS,
+        // #441: any receiver, and testify's T()
         { re: /\bif\s+testing\.Short\(\)/, why: "a testing.Short() guard (the body is skipped under -short)" },
         { re: /^\s*\/\/\s*(?:go:build|\+build)\s+ignore\b/, why: "a build-ignore constraint (the file is excluded from the test run)", comment: true }
       ],
@@ -4138,7 +4258,6 @@ var init_test_skip = __esm({
       ]
     };
     JS_RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe", "suite"]);
-    JS_CHAIN_MODIFIERS = /* @__PURE__ */ new Set(["concurrent", "sequential", "shuffle", "serial", "parallel"]);
     JS_DEFAULT_RUNNER_MODULES = /* @__PURE__ */ new Set(["node:test", "node:test/promises", "@playwright/test"]);
     JS_TEST_MODULES = /* @__PURE__ */ new Set([
       "vitest",
@@ -4440,6 +4559,20 @@ var init_test_skip = __esm({
               );
             }
           }
+          if (lang === "py") {
+            for (const hit of pyAliasDecoratorHits(c)) {
+              if (hit.line != null) astHitLines.add(hit.line);
+              out3.push(
+                makeFinding(RULE4, policy, {
+                  file: c.path,
+                  line: hit.line,
+                  message: "Test skipped or narrowed: a decorator aliasing a pytest skip/skipif/xfail marker.",
+                  evidence: hit.evidence,
+                  remediation: "Make the test pass rather than skipping it. If it is genuinely obsolete, a human must sign off."
+                })
+              );
+            }
+          }
           for (const l of addedLines(c)) {
             if (l.newLine != null && astHitLines.has(l.newLine)) continue;
             const comment = isCommentLine(l.content.trim(), lang);
@@ -7830,6 +7963,8 @@ function calleeName(expr) {
   if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) {
     return expr.expression.text;
   }
+  const chain = readCallee(expr);
+  if (chain && !chain.table) return chain.runner;
   return null;
 }
 function loopRows(iterable) {
@@ -8050,7 +8185,7 @@ function pytestPrecedenceFindings(changes, policy, ctx) {
     })
   );
 }
-var RULE9, JVM_TEST, TEST_DEFS, TABLE_METHOD, isEachOf, isDescribeEach, OTHER_RUNNER_DIR, WHOLE_SUITE_SCRIPT, SLICE_SCRIPT, SED_INPLACE, testDeletion;
+var RULE9, JVM_TEST, TEST_DEFS, isTableOf, isEachOf, isDescribeEach, OTHER_RUNNER_DIR, WHOLE_SUITE_SCRIPT, SLICE_SCRIPT, SED_INPLACE, testDeletion;
 var init_test_deletion = __esm({
   "src/detectors/test-deletion.ts"() {
     "use strict";
@@ -8063,6 +8198,7 @@ var init_test_deletion = __esm({
     init_suite_config();
     init_invocation();
     init_narrow();
+    init_runner_chain();
     RULE9 = "test-deletion";
     JVM_TEST = /^\s*(?:@\w+(?:\([^)]*\))?\s+)*@(?:Test|ParameterizedTest|RepeatedTest|TestFactory|TestTemplate)\b/;
     TEST_DEFS = {
@@ -8075,9 +8211,12 @@ var init_test_deletion = __esm({
       php: /^\s*(?:(?:public\s+)?function\s+test\w*\s*\(|#\[Test\]|\*\s*@test\b)/,
       cs: /^\s*\[(?:Fact|Theory|Test|TestMethod|TestCase|DataTestMethod)\b/
     };
-    TABLE_METHOD = /^(?:each|for)$/;
-    isEachOf = (expr) => ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && TABLE_METHOD.test(expr.name.text);
-    isDescribeEach = (expr) => ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "describe" && TABLE_METHOD.test(expr.name.text);
+    isTableOf = (expr, runners) => {
+      const chain = readCallee(expr);
+      return chain != null && chain.table != null && runners.includes(chain.runner);
+    };
+    isEachOf = (expr) => isTableOf(expr, ["it", "test"]);
+    isDescribeEach = (expr) => isTableOf(expr, ["describe"]);
     OTHER_RUNNER_DIR = /(?:^|\/)(?:e2e|cypress|playwright|fixtures|__fixtures__|__mocks__)\//;
     WHOLE_SUITE_SCRIPT = /^(?:test|test:ci|check|pretest)$/;
     SLICE_SCRIPT = /^test:(?:unit|integration)$/;
@@ -8587,7 +8726,11 @@ function expectAssertion(node, sf) {
   };
 }
 function simpleCallName(node) {
-  return ts.isIdentifier(node.expression) ? node.expression.text : null;
+  if (ts.isIdentifier(node.expression)) return node.expression.text;
+  const chain = readCallee(node.expression) ?? readTableCallee(node.expression);
+  if (!chain) return null;
+  if (chain.table && !ts.isCallExpression(node.expression) && !ts.isTaggedTemplateExpression(node.expression)) return null;
+  return chain.runner;
 }
 function callbackFor(node) {
   const cb = node.arguments[1];
@@ -8707,6 +8850,7 @@ var init_assertion_weakening = __esm({
     init_policy();
     init_finding();
     init_files();
+    init_runner_chain();
     RULE13 = "assertion-weakening";
     TEST_CALLS = /* @__PURE__ */ new Set(["it", "test"]);
     SUITE_CALLS = /* @__PURE__ */ new Set(["describe", "suite", "context"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.24.1",
+  "version": "2.24.3",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",