@qaguardian/playwright-score 2.2.0 → 2.3.0

package/dist/rules/ast-util.js

@@ -0,0 +1,140 @@
+export const FN_TYPES = new Set(['FunctionExpression', 'ArrowFunctionExpression', 'FunctionDeclaration']);
+/** Walk a subtree. `visit` returns false to skip that node's children. Never descends into nested functions unless `intoFunctions`. */
+export function walk(node, visit, intoFunctions = false) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walk(item, visit, intoFunctions);
+        return;
+    }
+    const rec = node;
+    if (typeof rec.type !== 'string')
+        return;
+    if (visit(node) === false)
+        return;
+    for (const key of Object.keys(rec)) {
+        if (key === 'parent')
+            continue;
+        const v = rec[key];
+        if (!v || typeof v !== 'object')
+            continue;
+        const child = v;
+        if (!intoFunctions && !Array.isArray(v) && child.type && FN_TYPES.has(child.type))
+            continue;
+        walk(v, visit, intoFunctions);
+    }
+}
+export function unwrap(node) {
+    let n = node ?? undefined;
+    while (n &&
+        (n.type === 'AwaitExpression' ||
+            n.type === 'TSNonNullExpression' ||
+            n.type === 'ChainExpression' ||
+            n.type === 'TSAsExpression' ||
+            n.type === 'ParenthesizedExpression')) {
+        n = (n.type === 'AwaitExpression' ? n.argument : (n.argument ?? n.expression)) ?? undefined;
+    }
+    return n;
+}
+export function memberName(callee) {
+    if (!callee || callee.type !== 'MemberExpression' || callee.computed)
+        return undefined;
+    return callee.property?.type === 'Identifier' ? callee.property.name : undefined;
+}
+/** `expect(...)`, `expect.soft(...)`, `expect.poll(...)`. */
+export function isExpectCall(node) {
+    if (!node || node.type !== 'CallExpression')
+        return false;
+    const c = node.callee;
+    if (c?.type === 'Identifier' && c.name === 'expect')
+        return true;
+    return (c?.type === 'MemberExpression' &&
+        !c.computed &&
+        c.object?.type === 'Identifier' &&
+        c.object.name === 'expect' &&
+        (c.property?.name === 'soft' || c.property?.name === 'poll'));
+}
+/** If `call` is `expect(x).[not.]matcher(...)`, describe it. */
+export function parseMatcherCall(call) {
+    if (call.type !== 'CallExpression')
+        return undefined;
+    const matcher = memberName(call.callee);
+    if (!matcher)
+        return undefined;
+    const modifiers = [];
+    let obj = call.callee?.object;
+    while (obj && obj.type === 'MemberExpression' && !obj.computed && obj.property?.type === 'Identifier') {
+        modifiers.push(obj.property.name ?? '');
+        obj = obj.object;
+    }
+    if (!obj || !isExpectCall(obj))
+        return undefined;
+    if (!modifiers.every((m) => m === 'not' || m === 'resolves' || m === 'rejects'))
+        return undefined;
+    return { expectCall: obj, matcher, modifiers, call };
+}
+/** Scope-resolved `const x = <init>` initialiser for an identifier, if any. */
+export function resolveConstInit(context, id) {
+    if (id.type !== 'Identifier' || !id.name)
+        return undefined;
+    let scope = context.sourceCode.getScope(id);
+    while (scope) {
+        const v = scope.set.get(id.name);
+        if (v) {
+            const def = v.defs[0];
+            if (!def || def.type !== 'Variable')
+                return undefined;
+            if (def.parent?.type === 'VariableDeclaration' && def.parent.kind !== 'const')
+                return undefined;
+            return def.node.id?.type === 'Identifier' ? (def.node.init ?? undefined) : undefined;
+        }
+        scope = scope.upper;
+    }
+    return undefined;
+}
+const CHAIN_OK = new Set(['first', 'last', 'nth', 'filter', 'locator', 'and', 'or', 'frameLocator', 'contentFrame']);
+/** Syntactic Locator: `page.locator(..)`, `x.getBy*(..)`, those chained with first/last/nth/filter/..., or a const initialised from one. */
+export function isLocatorExpr(context, node, depth = 0) {
+    const n = unwrap(node);
+    if (!n || depth > 3)
+        return false;
+    if (n.type === 'Identifier') {
+        const init = resolveConstInit(context, n);
+        return init ? isLocatorExpr(context, init, depth + 1) : false;
+    }
+    if (n.type !== 'CallExpression')
+        return false;
+    const name = memberName(n.callee);
+    if (!name)
+        return false;
+    if (name === 'locator' || name.startsWith('getBy'))
+        return true;
+    if (CHAIN_OK.has(name))
+        return isLocatorExpr(context, n.callee?.object, depth + 1);
+    return false;
+}
+/** Receiver is plausibly a Playwright Page/Locator/Frame (syntactic). */
+export function isPlaywrightReceiver(context, node, depth = 0) {
+    const n = unwrap(node);
+    if (!n || depth > 3)
+        return false;
+    if (isLocatorExpr(context, n))
+        return true;
+    if (n.type === 'Identifier') {
+        return n.name === 'page' || n.name === 'frame' || /[a-z]Locator$/.test(n.name ?? '') || /^(locator|page)$/i.test(n.name ?? '');
+    }
+    if (n.type === 'MemberExpression' && !n.computed) {
+        return n.property?.name === 'page' && n.object?.type === 'ThisExpression';
+    }
+    return false;
+}
+export function nearestFunction(node) {
+    let p = node.parent;
+    while (p) {
+        if (FN_TYPES.has(p.type))
+            return p;
+        p = p.parent;
+    }
+    return undefined;
+}

package/dist/rules/base-plugin.d.ts

@@ -3,16 +3,30 @@
  * style — always active.
  */
 import type { Rule } from 'eslint';
+/**
+ * Rule crashes are contained: an exception thrown while a rule builds its
+ * listeners or runs one on some unusual syntax must not abort the run for
+ * the whole suite. The rule simply reports nothing for that node. Crashes are
+ * recorded so tests can assert there are none.
+ */
+export declare const ruleCrashes: Array<{
+    rule: string;
+    error: unknown;
+}>;
+/** Clear the crash log; scorePaths calls this at the start of every run. */
+export declare function resetRuleCrashes(): void;
+/** Crashes of the current run, one entry per rule, in first-crash order. */
+export declare function summarizeRuleCrashes(): Array<{
+    rule: string;
+    count: number;
+}>;
+export declare function contain(name: string, rule: Rule.RuleModule): Rule.RuleModule;
 export declare const basePlugin: {
     meta: {
         name: string;
         version: string;
     };
     rules: {
-        'no-skipped-test-declaration': Rule.RuleModule;
-        'no-timer-sleep': Rule.RuleModule;
-        'no-coordinate-click': Rule.RuleModule;
-        'no-trivial-assertion': Rule.RuleModule;
-        'no-soft-assertion-only-test': Rule.RuleModule;
+        [k: string]: Rule.RuleModule;
     };
 };

package/dist/rules/base-plugin.js

@@ -1,3 +1,12 @@
+import { noUnawaitedAction } from './no-unawaited-action.js';
+import { noBrittleSelector } from './no-brittle-selector.js';
+import { noSharedMutableState, serialModeDependency } from './no-shared-mutable-state.js';
+import { noExcessiveTimeout } from './no-excessive-timeout.js';
+import { noFixmeTest } from './no-fixme-test.js';
+import { noSwallowedAssertion } from './no-swallowed-assertion.js';
+import { noWeakAssertion } from './no-weak-assertion.js';
+import { noUnawaitedExpectValue } from './no-unawaited-expect-value.js';
+import { noSelfFulfillingFallback } from './no-self-fulfilling-fallback.js';
 /**
  * `testNames` is `'test'` plus any `test.extend(...)`-derived fixture
  * aliases detected by test-aliases.ts (see eslint-runner.ts, which feeds
@@ -925,13 +934,72 @@ const noSoftAssertionOnlyTest = {
         };
     },
 };
+const rawRules = {
+    'no-skipped-test-declaration': noSkippedTestDeclaration,
+    'no-timer-sleep': noTimerSleep,
+    'no-coordinate-click': noCoordinateClick,
+    'no-trivial-assertion': noTrivialAssertion,
+    'no-soft-assertion-only-test': noSoftAssertionOnlyTest,
+    'no-unawaited-action': noUnawaitedAction,
+    'no-brittle-selector': noBrittleSelector,
+    'no-shared-mutable-state': noSharedMutableState,
+    'serial-mode-dependency': serialModeDependency,
+    'no-excessive-timeout': noExcessiveTimeout,
+    'no-fixme-test': noFixmeTest,
+    'no-swallowed-assertion': noSwallowedAssertion,
+    'no-weak-assertion': noWeakAssertion,
+    'no-unawaited-expect-value': noUnawaitedExpectValue,
+    'no-self-fulfilling-fallback': noSelfFulfillingFallback,
+};
+/**
+ * Rule crashes are contained: an exception thrown while a rule builds its
+ * listeners or runs one on some unusual syntax must not abort the run for
+ * the whole suite. The rule simply reports nothing for that node. Crashes are
+ * recorded so tests can assert there are none.
+ */
+export const ruleCrashes = [];
+/** Clear the crash log; scorePaths calls this at the start of every run. */
+export function resetRuleCrashes() {
+    ruleCrashes.length = 0;
+}
+/** Crashes of the current run, one entry per rule, in first-crash order. */
+export function summarizeRuleCrashes() {
+    const counts = new Map();
+    for (const c of ruleCrashes)
+        counts.set(c.rule, (counts.get(c.rule) ?? 0) + 1);
+    return [...counts].map(([rule, count]) => ({ rule, count }));
+}
+export function contain(name, rule) {
+    return {
+        ...rule,
+        create(context) {
+            let listeners;
+            try {
+                listeners = rule.create(context);
+            }
+            catch (error) {
+                ruleCrashes.push({ rule: name, error });
+                return {};
+            }
+            const safe = {};
+            for (const [key, fn] of Object.entries(listeners)) {
+                if (typeof fn !== 'function')
+                    continue;
+                safe[key] = (...args) => {
+                    try {
+                        return fn(...args);
+                    }
+                    catch (error) {
+                        ruleCrashes.push({ rule: name, error });
+                        return undefined;
+                    }
+                };
+            }
+            return safe;
+        },
+    };
+}
 export const basePlugin = {
     meta: { name: 'pwscore-base', version: '0.1.0' },
-    rules: {
-        'no-skipped-test-declaration': noSkippedTestDeclaration,
-        'no-timer-sleep': noTimerSleep,
-        'no-coordinate-click': noCoordinateClick,
-        'no-trivial-assertion': noTrivialAssertion,
-        'no-soft-assertion-only-test': noSoftAssertionOnlyTest,
-    },
+    rules: Object.fromEntries(Object.entries(rawRules).map(([name, rule]) => [name, contain(name, rule)])),
 };

package/dist/rules/no-brittle-selector.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+export declare function brittleReason(sel: string): string | undefined;
+export declare const noBrittleSelector: Rule.RuleModule;

package/dist/rules/no-brittle-selector.js

@@ -0,0 +1,150 @@
+import { isPwReceiver, propName, staticString, unwrap } from './rule-util.js';
+/**
+ * `pwscore/no-brittle-selector` (QAG-287). Selector strings that encode
+ * page structure instead of what the user sees. Matches, on the first
+ * argument of `.locator(...)`, `.frameLocator(...)` and the legacy
+ * selector-taking page methods (`page.click('..')`, `page.$('..')`, ...)
+ * when it is a fully static string:
+ *  - XPath: `xpath=...`, or a string starting with `//` or `(//`
+ *  - `:nth-child(` / `:nth-of-type(`
+ *  - a CSS chain with 4 or more combinators (`>`, `+`, `~`, descendant
+ *    space) outside brackets/parentheses/quotes
+ *  - generated class names: `.css-1a2b3c`, `.sc-bdfBwQ`, `.jss123`,
+ *    `.MuiBox-root-12`, `.makeStyles-root-12`
+ * and `.nth(n)` / `.first()` / `.last()` applied directly to a raw
+ * `.locator('<string>')` (a `data-testid`/`role=`/`text=` selector string
+ * is exempt: it names something stable).
+ *
+ * Reported as warning but report-only (evidence, not score): the locators
+ * dimension already counts every raw `.locator()`/legacy selector call in
+ * its native/raw ratio; scoring these as well would charge the same call
+ * twice. The finding says why the raw call is fragile.
+ */
+const SELECTOR_METHODS = new Set(['locator', 'frameLocator']);
+const LEGACY = new Set([
+    'click', 'dblclick', 'fill', 'type', 'press', 'check', 'uncheck', 'hover', 'focus',
+    'selectOption', 'textContent', 'innerText', 'innerHTML', 'getAttribute', 'inputValue',
+    'isVisible', 'isChecked', 'isEnabled', 'isDisabled', 'isHidden', 'waitForSelector', '$', '$$',
+    'setInputFiles', 'dispatchEvent', 'tap',
+]);
+function countCombinators(css) {
+    let depthParen = 0;
+    let depthBracket = 0;
+    let quote = '';
+    let count = 0;
+    let pendingSpace = false;
+    let sawCompound = false;
+    for (let i = 0; i < css.length; i++) {
+        const ch = css[i];
+        if (quote) {
+            if (ch === '\\')
+                i++;
+            else if (ch === quote)
+                quote = '';
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            sawCompound = true;
+            continue;
+        }
+        if (ch === '(') {
+            depthParen++;
+            continue;
+        }
+        if (ch === ')') {
+            depthParen = Math.max(0, depthParen - 1);
+            continue;
+        }
+        if (ch === '[') {
+            depthBracket++;
+            continue;
+        }
+        if (ch === ']') {
+            depthBracket = Math.max(0, depthBracket - 1);
+            continue;
+        }
+        if (depthParen || depthBracket)
+            continue;
+        if (ch === ',')
+            return 0; // selector list: do not guess
+        if (ch === '>' || ch === '+' || ch === '~') {
+            if (sawCompound)
+                count++;
+            sawCompound = false;
+            pendingSpace = false;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (sawCompound)
+                pendingSpace = true;
+            continue;
+        }
+        if (pendingSpace) {
+            count++;
+            pendingSpace = false;
+        }
+        sawCompound = true;
+    }
+    return count;
+}
+export function brittleReason(sel) {
+    const s = sel.trim();
+    if (/^xpath=/i.test(s) || s.startsWith('//') || s.startsWith('(//'))
+        return 'an XPath selector';
+    if (/:nth-(child|of-type|last-child|last-of-type)\(/.test(s))
+        return 'a positional :nth-child/:nth-of-type selector';
+    if (/\.css-(?=[a-z0-9]*\d)[a-z0-9]{5,}\b/.test(s) || /\.sc-(?=[A-Za-z0-9]*[A-Z0-9])[A-Za-z0-9]{5,}/.test(s) ||
+        /\.jss\d+/.test(s) || /\.Mui[A-Za-z]+-[A-Za-z]+-\d+/.test(s) || /\.makeStyles-[A-Za-z]+-\d+/.test(s)) {
+        return 'a generated class name that changes between builds';
+    }
+    // Only plain CSS gets the combinator count (not text=/role=/>> chains).
+    if (!/^[a-z-]+=/i.test(s) || /^css=/i.test(s)) {
+        const css = s.replace(/^css=/i, '');
+        if (!css.includes('>>') && countCombinators(css) >= 4)
+            return 'a long CSS chain (4+ combinators) tied to the page structure';
+    }
+    return undefined;
+}
+export const noBrittleSelector = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow selectors that encode page structure' },
+        messages: {
+            brittle: 'Brittle selector: {{reason}}. It breaks when markup is reorganised; prefer getByRole/getByLabel/getByTestId.',
+            positional: '`.{{method}}()` on a raw `.locator(...)` picks an element by its position, which changes with the data or layout. Narrow the locator instead (role, label, test id, filter).',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = unwrap(node.callee);
+                if (callee?.type !== 'MemberExpression')
+                    return;
+                const name = propName(callee);
+                if (!name)
+                    return;
+                if (SELECTOR_METHODS.has(name) || (LEGACY.has(name) && isPwReceiver(context, callee.object))) {
+                    const sel = staticString(node.arguments?.[0]);
+                    if (sel !== undefined) {
+                        const reason = brittleReason(sel);
+                        if (reason)
+                            context.report({ node: node, messageId: 'brittle', data: { reason } });
+                    }
+                }
+                if (name === 'first' || name === 'last' || name === 'nth') {
+                    const inner = unwrap(callee.object);
+                    if (inner?.type === 'CallExpression' && inner.callee?.type === 'MemberExpression' && propName(inner.callee) === 'locator') {
+                        const sel = staticString(inner.arguments?.[0]);
+                        if (sel === undefined)
+                            return;
+                        if (/data-(testid|test-id|test|cy|qa|pw)|^role=|^text=|^internal:|^id=|^testid=/i.test(sel.trim()))
+                            return;
+                        context.report({ node: node, messageId: 'positional', data: { method: name } });
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-excessive-timeout.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const noExcessiveTimeout: Rule.RuleModule;

package/dist/rules/no-excessive-timeout.js

@@ -0,0 +1,87 @@
+import { TEST_ALIAS_SCHEMA, enclosingFunction, evalNumber, hookName, isDescribeCall, isTestDeclaration, propName, testNamesFromOptions, unwrap, } from './rule-util.js';
+/**
+ * `pwscore/no-excessive-timeout` (QAG-287). A timeout so long that a real
+ * failure takes minutes to show and a slow app is silently tolerated.
+ * Matches (literals and simple arithmetic such as `2 * 60 * 1000`, numeric
+ * separators included):
+ *  - `{ timeout: N }` with N > 60_000 passed to an action, wait or
+ *    matcher call: `x.click/fill/goto/waitFor*(...)`, `expect(..).toXxx(..)`,
+ *    `expect.poll(..)`
+ *  - `test.setTimeout(N)` / `testInfo.setTimeout(N)` with N >= 300_000
+ *  - `test.slow()` with no arguments written directly at file or describe
+ *    level (a conditional `test.slow(cond, why)` or one inside a test is fine)
+ * Not matched: config-file timeouts, non-literal values, `timeout: 0`.
+ */
+const WAIT_METHODS = new Set([
+    'goto', 'reload', 'goBack', 'goForward', 'click', 'dblclick', 'fill', 'clear', 'press',
+    'pressSequentially', 'type', 'check', 'uncheck', 'setChecked', 'selectOption', 'hover',
+    'focus', 'tap', 'dragTo', 'dragAndDrop', 'setInputFiles', 'waitFor', 'poll', 'toPass',
+]);
+export const noExcessiveTimeout = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow very long literal timeouts' },
+        messages: {
+            long: 'A {{seconds}}s timeout means a failure takes that long to report and slowness is hidden. Fix the wait condition or the app instead of stretching the limit.',
+            longTest: '`setTimeout({{seconds}}s)` gives one test an extreme budget; split the test or fix the slow step.',
+            slow: 'Unconditional `test.slow()` triples every timeout in scope, hiding slowness. Apply it to the specific slow test with a reason, or fix the slowness.',
+        },
+        schema: TEST_ALIAS_SCHEMA,
+    },
+    create(context) {
+        const testNames = testNamesFromOptions(context.options);
+        const owners = new Set([...testNames, 'testInfo']);
+        return {
+            CallExpression(node) {
+                const callee = unwrap(node.callee);
+                const isExpectRoot = callee?.type === 'Identifier' && callee.name === 'expect';
+                if (callee?.type !== 'MemberExpression' && !isExpectRoot)
+                    return;
+                const name = callee.type === 'MemberExpression' ? propName(callee) : undefined;
+                // test.setTimeout(N) / testInfo.setTimeout(N)
+                if (name === 'setTimeout' && callee.object?.type === 'Identifier' && owners.has(callee.object.name)) {
+                    const ms = evalNumber(node.arguments?.[0]);
+                    if (ms !== undefined && ms >= 300_000) {
+                        context.report({ node: node, messageId: 'longTest', data: { seconds: String(ms / 1000) } });
+                    }
+                    return;
+                }
+                // test.slow() at file/describe level
+                if (name === 'slow' && callee.object?.type === 'Identifier' && testNames.has(callee.object.name) && node.arguments.length === 0) {
+                    const stmt = node.parent;
+                    if (stmt?.type !== 'ExpressionStatement')
+                        return;
+                    const fn = enclosingFunction(node);
+                    if (!fn) {
+                        context.report({ node: node, messageId: 'slow' });
+                        return;
+                    }
+                    const call = fn.parent;
+                    if (call?.type === 'CallExpression' && isDescribeCall(call, testNames) && !hookName(call, testNames) && !isTestDeclaration(call, testNames)) {
+                        context.report({ node: node, messageId: 'slow' });
+                    }
+                    return;
+                }
+                // { timeout: N } on an action / wait / matcher
+                if (!name || !(WAIT_METHODS.has(name) || /^waitFor[A-Z]/.test(name) || /^to[A-Z]/.test(name)))
+                    return;
+                for (const arg of node.arguments ?? []) {
+                    const obj = unwrap(arg);
+                    if (obj?.type !== 'ObjectExpression')
+                        continue;
+                    for (const prop of obj.properties) {
+                        if (prop.type !== 'Property' || prop.computed)
+                            continue;
+                        const key = prop.key?.name ?? prop.key?.value;
+                        if (key !== 'timeout')
+                            continue;
+                        const ms = evalNumber(prop.value);
+                        if (ms !== undefined && ms > 60_000) {
+                            context.report({ node: prop, messageId: 'long', data: { seconds: String(ms / 1000) } });
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-fixme-test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `test.fixme(...)` is the "known broken, do not run" marker. Same split as
+ * pwscore/no-skipped-test-declaration:
+ *
+ *  - FLAGGED: declaration `test.fixme('t', fn)` / `test.describe.fixme(...)`
+ *    (last argument is a function, 2+ arguments), and the unconditional
+ *    in-body forms `test.fixme()` (no arguments) and `test.fixme(true, ...)`.
+ *  - CLEAN: conditional `test.fixme(browserName === 'webkit', 'why')`
+ *    (any first argument that is not the literal `true`).
+ *
+ * `test` includes `test.extend()` aliases (testAliasNames option).
+ */
+import type { Rule } from 'eslint';
+export declare const noFixmeTest: Rule.RuleModule;

package/dist/rules/no-fixme-test.js

@@ -0,0 +1,53 @@
+import { FN_TYPES, memberName } from './ast-util.js';
+function isFixmeCallee(callee, names) {
+    if (memberName(callee) !== 'fixme')
+        return false;
+    const obj = callee?.object;
+    if (obj?.type === 'Identifier' && obj.name && names.has(obj.name))
+        return true;
+    return (obj?.type === 'MemberExpression' &&
+        !obj.computed &&
+        obj.property?.name === 'describe' &&
+        obj.object?.type === 'Identifier' &&
+        !!obj.object.name &&
+        names.has(obj.object.name));
+}
+export const noFixmeTest = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow unconditional test.fixme(): a test marked broken never runs' },
+        messages: {
+            declaration: 'Unexpected test.fixme() declaration: this test never runs. Fix it or delete it.',
+            unconditional: 'Unconditional test.fixme() inside a test: everything after it never runs. Use test.fixme(condition, reason) or fix the test.',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: { testAliasNames: { items: { type: 'string' }, type: 'array' } },
+                type: 'object',
+            },
+        ],
+    },
+    create(context) {
+        const aliases = context.options[0]?.testAliasNames ?? [];
+        const names = new Set(['test', ...aliases]);
+        return {
+            CallExpression(raw) {
+                const node = raw;
+                if (!isFixmeCallee(node.callee, names))
+                    return;
+                const args = node.arguments ?? [];
+                const last = args[args.length - 1];
+                if (args.length >= 2 && last && FN_TYPES.has(last.type)) {
+                    context.report({ node: raw, messageId: 'declaration' });
+                    return;
+                }
+                if (node.callee?.object?.type !== 'Identifier')
+                    return; // describe.fixme() in-body form is not a thing
+                if (args.length === 0 || (args[0].type === 'Literal' && args[0].value === true)) {
+                    context.report({ node: raw, messageId: 'unconditional' });
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-self-fulfilling-fallback.d.ts

@@ -0,0 +1,29 @@
+/**
+ * "If the app did not do it, the test does it itself, then asserts."
+ *
+ * Inside a test callback, for a statement S in a block that is
+ *  - `if (<negated state check>) { ...actions... }`, or the `else` branch of
+ *    `if (<state check>) {...} else { ...actions... }`, or
+ *  - `try { ...expect/state check... } catch { ...actions... }`
+ * ALL of the following must hold:
+ *  (a) the fallback branch (not descending into nested functions) calls a
+ *      content-supplying Playwright action: fill, type,
+ *      pressSequentially, selectOption, setInputFiles (click-only fallbacks
+ *      are the common "ensure the menu/toggle is open" setup idiom and are
+ *      not flagged);
+ *  (b) a later statement in the same block contains an expect(...);
+ *  (c) the later expect's text shares a locator/selector expression with the
+ *      state check (or try block), or with the action targets. "Locator
+ *      expression" = the receiver text of a member call, e.g.
+ *      `page.getByRole('textbox')` or the variable `input`; the bare `page`
+ *      never counts.
+ *
+ * A "state check" is a call to isVisible/isHidden/isEnabled/isChecked/count/
+ * textContent/innerText/inputValue/getAttribute (or a const boolean derived
+ * from one). "Negated" means: `!check`, `check === false`, `count() === 0`,
+ * `count() < 1`, `.length === 0`, `text !== '...'`, `isHidden()`/
+ * `isDisabled()`, or `||`/`&&` containing one. Positive-branch conditional
+ * actions (dismiss a banner if visible) are never flagged.
+ */
+import type { Rule } from 'eslint';
+export declare const noSelfFulfillingFallback: Rule.RuleModule;