@qaguardian/playwright-score 2.1.1 → 2.3.0

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;

package/dist/rules/no-self-fulfilling-fallback.js

@@ -0,0 +1,221 @@
+import { FN_TYPES, isExpectCall, memberName, resolveConstInit, unwrap, walk } from './ast-util.js';
+const CHECKS = new Set([
+    'isVisible', 'isHidden', 'isEnabled', 'isDisabled', 'isChecked', 'isEditable', 'count',
+    'textContent', 'innerText', 'inputValue', 'getAttribute', 'allTextContents', 'allInnerTexts',
+]);
+const NEGATIVE_STATE_CHECKS = new Set(['isHidden', 'isDisabled']);
+// Only actions that SUPPLY content count. A click-only fallback is the
+// "make sure the menu/toggle is open, then assert" setup idiom (checked on
+// rill, mattermost: all click-only hits were setup, not self-fulfilment;
+// `press('Escape')` in an else branch was setup too, so press is excluded).
+const ACTIONS = new Set(['fill', 'type', 'pressSequentially', 'selectOption', 'setInputFiles']);
+export const noSelfFulfillingFallback = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow fallbacks that perform the expected state themselves before asserting it' },
+        messages: {
+            fallback: 'Self-fulfilling fallback: when the app does not produce this state, the test performs the actions itself and then asserts the result. The assertion can no longer detect the app failing to do it. Assert first and fail, or remove the fallback.',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: { testAliasNames: { items: { type: 'string' }, type: 'array' } },
+                type: 'object',
+            },
+        ],
+    },
+    create(context) {
+        const aliases = context.options[0]?.testAliasNames ?? [];
+        const testNames = new Set(['test', ...aliases]);
+        const text = (n) => context.sourceCode.getText(n).replace(/\s+/g, '');
+        function isTestCallback(fn) {
+            const call = fn.parent;
+            if (!call || call.type !== 'CallExpression' || !(call.arguments ?? []).includes(fn))
+                return false;
+            let c = call.callee;
+            if (c?.type === 'MemberExpression')
+                c = c.object?.type === 'MemberExpression' ? c.object.object : c.object;
+            return c?.type === 'Identifier' && !!c.name && testNames.has(c.name);
+        }
+        function inTest(n) {
+            for (let p = n.parent; p; p = p.parent)
+                if (FN_TYPES.has(p.type) && isTestCallback(p))
+                    return true;
+            return false;
+        }
+        /** Does the expression contain a state check (resolving one level of const)? */
+        function hasCheck(e, depth = 0) {
+            let found = false;
+            walk(e, (n) => {
+                if (found)
+                    return false;
+                if (n.type === 'CallExpression' && CHECKS.has(memberName(n.callee) ?? ''))
+                    found = true;
+                else if (n.type === 'MemberExpression' && !n.computed && n.property?.name === 'length')
+                    found = true;
+                else if (n.type === 'Identifier' && depth < 2) {
+                    const init = resolveConstInit(context, n);
+                    if (init && hasCheck(init, depth + 1))
+                        found = true;
+                }
+                return undefined;
+            });
+            return found;
+        }
+        function isZeroish(n) {
+            return !!n && n.type === 'Literal' && (n.value === 0 || n.value === '' || n.value === false);
+        }
+        /** The test expression is true when the app did NOT produce the state. */
+        function negated(e, depth = 0) {
+            const n = unwrap(e);
+            if (!n || depth > 3)
+                return false;
+            if (n.type === 'UnaryExpression' && n.operator === '!')
+                return hasCheck(n.argument ?? undefined);
+            if (n.type === 'LogicalExpression')
+                return negated(n.left, depth + 1) || negated(n.right, depth + 1);
+            if (n.type === 'BinaryExpression') {
+                const op = n.operator;
+                const l = unwrap(n.left);
+                const r = unwrap(n.right);
+                if ((op === '===' || op === '==') && hasCheck(l) && isZeroish(r))
+                    return true;
+                if ((op === '<' && hasCheck(l) && r?.type === 'Literal' && r.value === 1))
+                    return true;
+                if ((op === '!==' || op === '!=') && hasCheck(l) && r?.type === 'Literal' && typeof r.value === 'string')
+                    return true;
+                return false;
+            }
+            if (n.type === 'CallExpression')
+                return NEGATIVE_STATE_CHECKS.has(memberName(n.callee) ?? '');
+            if (n.type === 'Identifier' && depth < 2) {
+                const init = resolveConstInit(context, n);
+                // `const hidden = await x.isHidden(); if (hidden)`
+                return init ? negated(init, depth + 1) : false;
+            }
+            return false;
+        }
+        function positive(e) {
+            return hasCheck(e) && !negated(e);
+        }
+        /** Receiver texts of member calls and expect() subjects in a subtree. */
+        function keys(root, depth = 0) {
+            const out = new Set();
+            walk(root, (n) => {
+                if (n.type === 'CallExpression') {
+                    if (isExpectCall(n)) {
+                        const a = unwrap((n.arguments ?? [])[0]);
+                        if (a)
+                            addKey(out, a, depth);
+                    }
+                    else if (n.callee?.type === 'MemberExpression') {
+                        addKey(out, n.callee.object, depth);
+                    }
+                }
+            });
+            return out;
+        }
+        function addKey(out, n, depth) {
+            const u = unwrap(n);
+            if (!u)
+                return;
+            const t = text(u);
+            if (t === 'page' || t === 'this.page' || t === 'expect' || t === 'test' || t.length < 3)
+                return;
+            out.add(t);
+            if (u.type === 'Identifier' && depth < 2) {
+                const init = resolveConstInit(context, u);
+                if (init)
+                    for (const k of keys(init, depth + 1))
+                        out.add(k);
+                if (init)
+                    addKey(out, init, depth + 1);
+            }
+        }
+        function overlap(a, b) {
+            for (const x of a)
+                for (const y of b)
+                    if (x === y)
+                        return true;
+            return false;
+        }
+        function hasAction(branch) {
+            let has = false;
+            const targets = new Set();
+            walk(branch, (n) => {
+                if (n.type === 'CallExpression' && ACTIONS.has(memberName(n.callee) ?? '')) {
+                    has = true;
+                    addKey(targets, n.callee?.object, 0);
+                }
+            });
+            return { has, targets };
+        }
+        function expectsAfter(siblings, from) {
+            const found = [];
+            for (const s of siblings.slice(from + 1)) {
+                walk(s, (n) => {
+                    if (isExpectCall(n))
+                        found.push(n);
+                });
+            }
+            return found;
+        }
+        function evaluate(stmt, siblings, idx) {
+            let fallback;
+            let condKeys = new Set();
+            if (stmt.type === 'IfStatement') {
+                const test = stmt.test;
+                if (negated(test))
+                    fallback = stmt.consequent;
+                else if (positive(test) && stmt.alternate)
+                    fallback = stmt.alternate;
+                if (!fallback)
+                    return;
+                condKeys = keys(test);
+                // keys() only sees member-call receivers/expect subjects; a const-derived test needs its init too.
+                walk(test, (n) => {
+                    if (n.type === 'Identifier') {
+                        const init = resolveConstInit(context, n);
+                        if (init)
+                            for (const k of keys(init))
+                                condKeys.add(k);
+                    }
+                });
+            }
+            else if (stmt.type === 'TryStatement' && stmt.handler) {
+                let guarded = false;
+                walk(stmt.block, (n) => {
+                    if (isExpectCall(n) || (n.type === 'CallExpression' && CHECKS.has(memberName(n.callee) ?? '')))
+                        guarded = true;
+                });
+                if (!guarded)
+                    return;
+                fallback = stmt.handler.body;
+                condKeys = keys(stmt.block);
+            }
+            else
+                return;
+            const act = hasAction(fallback);
+            if (!act.has)
+                return;
+            const expects = expectsAfter(siblings, idx);
+            if (expects.length === 0)
+                return;
+            const later = new Set();
+            for (const e of expects)
+                for (const k of keys(e))
+                    later.add(k);
+            if (overlap(condKeys, later) || overlap(act.targets, later)) {
+                context.report({ node: stmt, messageId: 'fallback' });
+            }
+        }
+        function onBlock(raw) {
+            const block = raw;
+            if (!inTest(block))
+                return;
+            const body = (Array.isArray(block.body) ? block.body : []);
+            body.forEach((s, i) => evaluate(s, body, i));
+        }
+        return { BlockStatement: onBlock };
+    },
+};

package/dist/rules/no-shared-mutable-state.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+export declare const noSharedMutableState: Rule.RuleModule;
+/** Report-only companion: serial mode declares order dependence. */
+export declare const serialModeDependency: Rule.RuleModule;

package/dist/rules/no-shared-mutable-state.js

@@ -0,0 +1,186 @@
+import { TEST_ALIAS_SCHEMA, enclosingFunction, hookName, isDescribeCall, isInSerialScope, isSerialConfigureCall, isSerialDescribeCall, isTestDeclaration, propName, testNamesFromOptions, unwrap, } from './rule-util.js';
+/**
+ * `pwscore/no-shared-mutable-state` (QAG-287). A module-level or
+ * describe-level `let`/`var` (or a `const` bound to an object/array
+ * literal, `new Map()` or `new Set()`) that one `test(...)` body assigns or
+ * mutates and a DIFFERENT `test(...)` body reads without writing it
+ * itself. Run alone, in another order or on another worker, the reader sees
+ * the initial value, so the suite is order-dependent.
+ *
+ * Not matched: variables in serial mode (`test.describe.serial`, or
+ * `test.describe.configure({ mode: 'serial' })` at file level or in an
+ * enclosing describe); assignment only inside `beforeEach`/`beforeAll`/`afterEach`
+ * (setup); a variable that any `beforeEach` assigns (it is reset before each
+ * test); a reader that also writes the variable itself (its own setup);
+ * variables declared inside a test.
+ * Mutation = assignment, `++`/`--`, member assignment (`v.x = 1`), or a
+ * call of `push/pop/shift/unshift/splice/set/add/delete/clear/sort/reverse`.
+ *
+ * Companion `pwscore/serial-mode-dependency` is report-only information:
+ * `test.describe.configure({ mode: 'serial' })` and `test.describe.serial()`
+ * declare that tests depend on order; not an error on its own.
+ */
+const MUTATORS = new Set(['push', 'pop', 'shift', 'unshift', 'splice', 'set', 'add', 'delete', 'clear', 'sort', 'reverse']);
+export const noSharedMutableState = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow state written in one test and read in another' },
+        messages: {
+            shared: '`{{name}}` is written in test "{{writer}}" and read in this test. Tests that share state depend on run order and break under retries or parallel workers. Create the state inside each test (or a fixture/beforeEach).',
+        },
+        schema: TEST_ALIAS_SCHEMA,
+    },
+    create(context) {
+        const testNames = testNamesFromOptions(context.options);
+        /** The test(...) call (and its title) whose callback contains `node`, if any. */
+        const owningTest = (node) => {
+            let fn = enclosingFunction(node);
+            while (fn) {
+                const call = fn.parent;
+                if (call?.type === 'CallExpression' && call.arguments.includes(fn)) {
+                    if (isTestDeclaration(call, testNames))
+                        return call;
+                    if (hookName(call, testNames))
+                        return undefined;
+                }
+                fn = enclosingFunction(fn);
+            }
+            return undefined;
+        };
+        const owningHook = (node) => {
+            let fn = enclosingFunction(node);
+            while (fn) {
+                const call = fn.parent;
+                if (call?.type === 'CallExpression' && call.arguments.includes(fn)) {
+                    const h = hookName(call, testNames);
+                    if (h)
+                        return h;
+                    if (isTestDeclaration(call, testNames))
+                        return undefined;
+                }
+                fn = enclosingFunction(fn);
+            }
+            return undefined;
+        };
+        /** Declared directly at module level or directly in a describe callback. */
+        const isSharedScope = (decl) => {
+            const fn = enclosingFunction(decl);
+            if (!fn)
+                return true;
+            const call = fn.parent;
+            return call?.type === 'CallExpression' && call.arguments.includes(fn) && isDescribeCall(call, testNames);
+        };
+        const isMutableInit = (kind, init) => {
+            if (kind !== 'const')
+                return true;
+            const i = unwrap(init);
+            return (!!i &&
+                (i.type === 'ObjectExpression' ||
+                    i.type === 'ArrayExpression' ||
+                    (i.type === 'NewExpression' && i.callee?.type === 'Identifier' && (i.callee.name === 'Map' || i.callee.name === 'Set'))));
+        };
+        const titleOf = (call) => {
+            const t = call.arguments?.[0];
+            return t?.type === 'Literal' && typeof t.value === 'string' ? t.value : 'another test';
+        };
+        /** Is this reference a write/mutation of the variable? */
+        const isMutation = (id, ref) => {
+            if (ref.isWrite())
+                return true;
+            let child = id;
+            let parent = id.parent;
+            while (parent?.type === 'MemberExpression' && parent.object === child) {
+                const gp = parent.parent;
+                if (gp?.type === 'AssignmentExpression' && gp.left === parent)
+                    return true;
+                if (gp?.type === 'UpdateExpression')
+                    return true;
+                if (gp?.type === 'CallExpression' && gp.callee === parent) {
+                    const name = propName(parent);
+                    if (name && MUTATORS.has(name) && parent.object === id)
+                        return true;
+                }
+                child = parent;
+                parent = gp;
+            }
+            return false;
+        };
+        return {
+            VariableDeclaration(node) {
+                if (!isSharedScope(node))
+                    return;
+                for (const decl of node.declarations) {
+                    if (decl.id?.type !== 'Identifier' || !isMutableInit(node.kind, decl.init))
+                        continue;
+                    const [variable] = context.sourceCode.getDeclaredVariables(decl);
+                    if (!variable)
+                        continue;
+                    // Serial mode is Playwright's documented way to share state in order.
+                    if (isInSerialScope(decl, testNames))
+                        continue;
+                    const writes = new Map(); // test call -> write node
+                    const reads = new Map(); // test call -> first read identifier
+                    let hookReset = false;
+                    for (const ref of variable.references) {
+                        const id = ref.identifier;
+                        if (id === decl.id)
+                            continue;
+                        const test = owningTest(id);
+                        const mutation = isMutation(id, ref);
+                        if (!test) {
+                            if (mutation && owningHook(id) === 'beforeEach')
+                                hookReset = true;
+                            continue;
+                        }
+                        if (mutation) {
+                            if (!writes.has(test))
+                                writes.set(test, id);
+                        }
+                        else if (ref.isRead() && !reads.has(test)) {
+                            reads.set(test, id);
+                        }
+                    }
+                    if (hookReset || writes.size === 0)
+                        continue;
+                    for (const [test, id] of reads) {
+                        if (writes.has(test))
+                            continue;
+                        // Serial mode orders the tests that share state: skip a writer/reader
+                        // pair only when BOTH sit in a serial scope.
+                        const readerSerial = isInSerialScope(test, testNames);
+                        const writer = [...writes.keys()].find((w) => !(readerSerial && isInSerialScope(w, testNames)));
+                        if (!writer)
+                            continue;
+                        context.report({
+                            node: id,
+                            messageId: 'shared',
+                            data: { name: decl.id.name, writer: titleOf(writer) },
+                        });
+                        break; // one finding per variable
+                    }
+                }
+            },
+        };
+    },
+};
+/** Report-only companion: serial mode declares order dependence. */
+export const serialModeDependency = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Report serial-mode describe blocks (tests depend on order)' },
+        messages: {
+            serial: 'Serial mode: the tests in this scope depend on running in order, so one failure skips the rest and retries rerun the whole group. Information only.',
+        },
+        schema: TEST_ALIAS_SCHEMA,
+    },
+    create(context) {
+        const testNames = testNamesFromOptions(context.options);
+        return {
+            CallExpression(node) {
+                if (isSerialDescribeCall(node, testNames) || isSerialConfigureCall(node, testNames)) {
+                    context.report({ node: node, messageId: 'serial' });
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-swallowed-assertion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An assertion whose failure is caught and discarded cannot fail the test.
+ *
+ * Matches:
+ *  1. `try { ... expect(x).matcher() ... } catch { ... }` where the catch
+ *     body does not throw, call expect / test.fail / a fail-ish helper,
+ *     return a value, or assign/mutate outer state (any of which may carry
+ *     the failure to a later assertion). Skipped inside loops (retry idiom).
+ *  2. `await expect(x).matcher().catch(<fn that does not throw>)` as a
+ *     statement (result discarded).
+ */
+import type { Rule } from 'eslint';
+export declare const noSwallowedAssertion: Rule.RuleModule;