eslint-plugin-test-governance 0.3.0 → 0.4.0

package/dist/utils/analyze.js

@@ -1,19 +1,27 @@
-const PLAYWRIGHT_MODULES = new Set(['@playwright/test', 'playwright/test']);
-/** Other test runners. A name imported from one of these is never Playwright's `test`. */
-const OTHER_FRAMEWORKS = new Set(['vitest', '@jest/globals', 'node:test', 'bun:test', 'mocha', 'ava', 'tap', 'uvu']);
-/** `@playwright/test` and the component-testing packages such as `@playwright/experimental-ct-react`. */
-function isPlaywrightModule(source) {
-    return PLAYWRIGHT_MODULES.has(source) || source.startsWith('@playwright/experimental-ct-');
-}
-const TEST_MODIFIERS = new Set(['only', 'skip', 'fixme', 'fail', 'slow']);
-const DESCRIBE_MODIFIERS = new Set(['only', 'skip', 'fixme', 'serial', 'parallel']);
-const RUNTIME_MODIFIERS = new Set(['skip', 'fixme', 'fail', 'slow']);
-const SKIPPING_MODIFIERS = new Set(['skip', 'fixme']);
+import { isOtherRunner, RUNTIME_MODIFIERS } from "./frameworks.js";
+const TEST = { kind: 'test', modifiers: [] };
+/** Modifiers that keep a test from running. */
+const SKIPPING_MODIFIERS = new Set(['skip', 'fixme', 'todo']);
+/** What a step's `TestStepInfo` can do at runtime: `step.skip()`. */
+const STEP_INFO_METHODS = new Set(['skip']);
 const MARKER_LINE_RE = /^\s*\*?\s*([A-Za-z][\w-]*)\s*:(.*)$/;
 const TAG_RE = /(?<![\w@])@[\w-]+/g;
 export function isStateMarker(marker) {
     return marker.state !== undefined;
 }
+/** The names a parameter gives to runtime info: `testInfo`, or `skip` in `({ skip }) => ...`. */
+function infoNames(param, methods, step) {
+    if (param?.type === 'Identifier')
+        return [{ name: param.name, methods, step }];
+    if (param?.type !== 'ObjectPattern')
+        return [];
+    return param.properties.flatMap((prop) => {
+        if (prop.type !== 'Property' || prop.value.type !== 'Identifier')
+            return [];
+        const method = propertyName(prop);
+        return method !== undefined && methods.has(method) ? [{ name: prop.value.name, method, step }] : [];
+    });
+}
 function memberName(node) {
     if (!node.computed && node.property.type === 'Identifier')
         return node.property.name;
@@ -21,15 +29,35 @@ function memberName(node) {
         return node.property.value;
     return undefined;
 }
-function chainOf(node) {
+/**
+ * The name a callee starts from and the members after it: `['describe', 'skip']` for
+ * `test.describe.skip`. A member called to build the function, as `each` in `test.each(table)` or
+ * ``test.each`...` ``, is written with parentheses: `['skip', 'each()']` for `test.skip.each(table)`.
+ */
+function chainOf(node, factories) {
     const path = [];
     let current = node;
-    while (current.type === 'MemberExpression') {
-        const name = memberName(current);
-        if (name === undefined)
+    for (;;) {
+        if (current.type === 'MemberExpression') {
+            const name = memberName(current);
+            if (name === undefined)
+                return undefined;
+            path.unshift(name);
+            current = current.object;
+            continue;
+        }
+        const factory = current.type === 'CallExpression'
+            ? current.callee
+            : current.type === 'TaggedTemplateExpression'
+                ? current.tag
+                : undefined;
+        if (factory?.type !== 'MemberExpression')
+            break;
+        const name = memberName(factory);
+        if (name === undefined || !factories.has(name))
             return undefined;
-        path.unshift(name);
-        current = current.object;
+        path.unshift(`${name}()`);
+        current = factory.object;
     }
     return current.type === 'Identifier' ? { root: current, path } : undefined;
 }
@@ -45,38 +73,75 @@ function unwrap(node) {
 function isFunction(node) {
     return node?.type === 'ArrowFunctionExpression' || node?.type === 'FunctionExpression';
 }
-/** Collects the top-level names that refer to Playwright's `test`. */
-function collectTestNames(program, configured) {
-    const names = new Set(configured);
+/** Collects the top-level names that refer to the framework's test functions or to its module. */
+function collectTestNames(program, framework, configured) {
+    const roots = new Map(framework.globals);
+    for (const name of configured)
+        roots.set(name, TEST);
+    const modules = new Set();
     const mergeTests = new Set();
-    const isTestExpression = (node) => {
+    /** Names bound to another test runner, such as `ava` in `import ava from 'ava'`. */
+    const others = new Set();
+    /** The member name of `pw.test` or `pw.mergeTests` on a framework module. */
+    const moduleMember = (node) => node.type === 'MemberExpression' && node.object.type === 'Identifier' && modules.has(node.object.name)
+        ? memberName(node)
+        : undefined;
+    /** The test function an expression is, such as `base.extend({...})` or `mergeTests(a, b)`. */
+    const resolve = (node) => {
         const target = unwrap(node);
         if (target.type === 'Identifier')
-            return names.has(target.name);
+            return roots.get(target.name);
+        const member = moduleMember(target);
+        if (member !== undefined)
+            return framework.exports.get(member);
         if (target.type !== 'CallExpression')
-            return false;
-        // mergeTests(dbTest, a11yTest)
+            return undefined;
+        // mergeTests(dbTest, a11yTest) or pw.mergeTests(dbTest, a11yTest)
         if (target.callee.type === 'Identifier')
-            return mergeTests.has(target.callee.name);
+            return mergeTests.has(target.callee.name) ? TEST : undefined;
         if (target.callee.type !== 'MemberExpression')
-            return false;
-        return memberName(target.callee) === 'extend' && isTestExpression(target.callee.object);
+            return undefined;
+        if (moduleMember(target.callee) === 'mergeTests')
+            return TEST;
+        return memberName(target.callee) === 'extend' ? resolve(target.callee.object) : undefined;
+    };
+    // require('node:test'), ava, ava.serial or `ava as TestFn<Context>`
+    const isOtherFramework = (node) => {
+        const target = unwrap(node);
+        const source = requireSource(target);
+        if (source !== undefined)
+            return isOtherRunner(framework, source);
+        if (target.type === 'Identifier')
+            return others.has(target.name);
+        return target.type === 'MemberExpression' && isOtherFramework(target.object);
+    };
+    const setOther = (name) => {
+        roots.delete(name);
+        others.add(name);
     };
     for (const statement of program.body) {
         if (statement.type === 'ImportDeclaration') {
             const source = statement.source.value;
-            if (OTHER_FRAMEWORKS.has(source)) {
+            if (isOtherRunner(framework, source)) {
                 for (const spec of statement.specifiers)
-                    names.delete(spec.local.name);
+                    setOther(spec.local.name);
             }
-            else if (isPlaywrightModule(source)) {
+            else if (framework.ownsModule(source)) {
                 for (const spec of statement.specifiers) {
-                    if (spec.type === 'ImportDefaultSpecifier')
-                        names.add(spec.local.name);
-                    else if (spec.type === 'ImportSpecifier' && importedName(spec) === 'test')
-                        names.add(spec.local.name);
-                    else if (spec.type === 'ImportSpecifier' && importedName(spec) === 'mergeTests')
-                        mergeTests.add(spec.local.name);
+                    const local = spec.local.name;
+                    if (spec.type === 'ImportNamespaceSpecifier')
+                        modules.add(local);
+                    else if (spec.type === 'ImportDefaultSpecifier') {
+                        if (framework.defaultExport)
+                            roots.set(local, framework.defaultExport);
+                    }
+                    else {
+                        const root = framework.exports.get(importedName(spec));
+                        if (root)
+                            roots.set(local, root);
+                        else if (importedName(spec) === 'mergeTests')
+                            mergeTests.add(local);
+                    }
                 }
             }
             continue;
@@ -88,25 +153,47 @@ function collectTestNames(program, configured) {
             const init = declarator.init && unwrap(declarator.init);
             if (!init)
                 continue;
-            if (declarator.id.type === 'Identifier' && init.type === 'CallExpression' && isTestExpression(init)) {
-                names.add(declarator.id.name);
+            if (declarator.id.type === 'Identifier') {
+                const name = declarator.id.name;
+                // `const t = base.extend({...})`, `const t = mergeTests(a, b)` or a plain alias, `const t = base`.
+                const root = resolve(init);
+                if (root)
+                    roots.set(name, root);
+                // `const test = require('node:test')` is another runner's `test`, like an import from it.
+                else if (isOtherFramework(init))
+                    setOther(name);
+                else {
+                    // `const pw = require('@playwright/test')`, used as `pw.test`.
+                    const source = requireSource(init);
+                    if (source !== undefined && framework.ownsModule(source))
+                        modules.add(name);
+                }
             }
             else if (declarator.id.type === 'ObjectPattern') {
                 const source = requireSource(init);
                 if (source === undefined)
                     continue;
                 for (const prop of declarator.id.properties) {
-                    if (prop.type !== 'Property' || prop.key.type !== 'Identifier' || prop.value.type !== 'Identifier')
+                    if (prop.type !== 'Property' || prop.value.type !== 'Identifier')
                         continue;
-                    if (OTHER_FRAMEWORKS.has(source))
-                        names.delete(prop.value.name);
-                    else if (isPlaywrightModule(source) && prop.key.name === 'test')
-                        names.add(prop.value.name);
+                    if (isOtherRunner(framework, source))
+                        setOther(prop.value.name);
+                    else if (framework.ownsModule(source)) {
+                        const root = framework.exports.get(propertyName(prop) ?? '');
+                        if (root)
+                            roots.set(prop.value.name, root);
+                    }
                 }
             }
         }
     }
-    return names;
+    return { roots, modules };
+}
+/** The name a property key spells out: `test` in `{ test }`, `{ 'test': t }` or `{ ['test']: t }`. */
+function propertyName(prop) {
+    if (prop.key.type === 'Literal')
+        return typeof prop.key.value === 'string' ? prop.key.value : undefined;
+    return prop.computed ? undefined : prop.key.name;
 }
 function importedName(spec) {
     return spec.imported.type === 'Identifier' ? spec.imported.name : spec.imported.value;
@@ -127,7 +214,9 @@ function isLocalVariable(sourceCode, id) {
         const variable = scope.set.get(id.name);
         if (!variable)
             continue;
-        if (scope.type === 'module' || scope.type === 'global')
+        // A top-level scope: the global scope, a module's scope, or in CommonJS the function scope that
+        // wraps the module.
+        if (scope.block.type === 'Program')
             return false;
         return variable.defs.some((def) => def.type === 'Variable');
     }
@@ -172,8 +261,11 @@ export function parseTickets(text, offset, matcher) {
         const token = /^[^\s,]+/.exec(text.slice(index))?.[0];
         if (!token)
             break;
-        // Punctuation right after a ticket (`WEB-1:` or `WEB-1.`) is not part of it.
+        // Punctuation right after a ticket (`TRADE-1:` or `TRADE-1.`) is not part of it.
         const ticket = token.replace(/[.:;]+$/, '');
+        // Punctuation alone, as in `// SKIP: .`, is no ticket at all.
+        if (ticket === '')
+            break;
         tickets.push({ text: ticket, result: matcher.check(ticket) });
         index += ticket.length;
         lastEnd = index;
@@ -183,19 +275,29 @@ export function parseTickets(text, offset, matcher) {
         index += separator.length;
     }
     const rest = text.slice(lastEnd).trimEnd();
-    // A sentence-ending `WEB-1.` has nothing after the ticket; `WEB-1: flaky` has a note.
+    // A sentence-ending `TRADE-1.` has nothing after the ticket; `TRADE-1: flaky` has a note.
     if (tickets.length === 0 || /^[.:;]*$/.test(rest.trim()))
         return { tickets };
     return { tickets, extra: { text: rest.trim(), range: [offset + lastEnd, offset + lastEnd + rest.length] } };
 }
+const LINE_BREAK_RE = /\r\n|[\r\n\u2028\u2029]/g;
+/** The lines of a comment and where each starts in the source, split at every line break JavaScript has. */
+export function commentLines(comment) {
+    const lines = [];
+    // `//` and `/*` are both two characters, so the comment's value starts two characters in.
+    const valueStart = comment.range[0] + 2;
+    let lineStart = 0;
+    for (const lineBreak of comment.value.matchAll(LINE_BREAK_RE)) {
+        lines.push({ text: comment.value.slice(lineStart, lineBreak.index), start: valueStart + lineStart });
+        lineStart = lineBreak.index + lineBreak[0].length;
+    }
+    lines.push({ text: comment.value.slice(lineStart), start: valueStart + lineStart });
+    return lines;
+}
 function parseMarkers(comment, states) {
     const markers = [];
-    // `//` and `/*` are both two characters, so the comment's value starts two characters in.
-    let lineStart = comment.range[0] + 2;
-    for (const line of comment.value.split(/\n/)) {
-        const match = MARKER_LINE_RE.exec(line.replace(/\r$/, ''));
-        const start = lineStart;
-        lineStart += line.length + 1;
+    for (const { text, start } of commentLines(comment)) {
+        const match = MARKER_LINE_RE.exec(text);
         if (!match)
             continue;
         const [, keyword, rest] = match;
@@ -211,44 +313,77 @@ function parseMarkers(comment, states) {
     }
     return markers;
 }
-function scanTags(node, out) {
-    const texts = node.type === 'Literal'
-        ? [String(node.value)]
-        : // `cooked` is only null in tagged templates, which are never titles.
+function scanTags(source, node, out) {
+    // Each piece of text with where it starts in the source, after its opening quote, backtick or `}`.
+    const parts = node.type === 'Literal'
+        ? [{ text: String(node.value), start: node.range[0] + 1 }]
+        : node.quasis.map((quasi) => ({
+            // `cooked` is only null in tagged templates, which are never titles.
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
-            node.quasis.map((quasi) => quasi.value.cooked);
-    for (const text of texts) {
-        for (const match of text.matchAll(TAG_RE))
-            out.push({ tag: match[0], node });
+            text: quasi.value.cooked,
+            start: quasi.range[0] + 1,
+        }));
+    for (const { text, start } of parts) {
+        for (const match of text.matchAll(TAG_RE)) {
+            const end = match.index + match[0].length;
+            const written = source.slice(start, start + end) === text.slice(0, end);
+            out.push({ tag: match[0], node, ...(written && { range: [start + match.index, start + end] }) });
+        }
     }
 }
 function isStaticText(node) {
     return (node.type === 'Literal' && typeof node.value === 'string') || node.type === 'TemplateLiteral';
 }
-function collectTags(call, hasTitle) {
+/**
+ * The plain-keyed properties of a test's details or options object, the second argument in
+ * `test('title', { tag: '@smoke' }, fn)` or Vitest's `test('title', { skip: true }, fn)`.
+ */
+function detailsOf(call) {
+    const details = call.arguments.at(1);
+    if (details?.type !== 'ObjectExpression')
+        return [];
+    return details.properties.flatMap((prop) => {
+        if (prop.type !== 'Property' || prop.computed)
+            return [];
+        const key = prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value);
+        return [[key, prop.value]];
+    });
+}
+function collectTags(source, call, hasTitle, tagKey) {
     const tags = [];
     if (!hasTitle)
         return { tags, dynamic: false };
-    const [title, details] = call.arguments;
+    const [title] = call.arguments;
     const dynamic = !isStaticText(title);
     if (!dynamic)
-        scanTags(title, tags);
-    if (call.arguments.length >= 3 && details.type === 'ObjectExpression') {
-        for (const prop of details.properties) {
-            if (prop.type !== 'Property' || prop.computed)
-                continue;
-            const key = prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value);
-            if (key !== 'tag')
-                continue;
-            const values = prop.value.type === 'ArrayExpression' ? prop.value.elements : [prop.value];
-            for (const value of values) {
-                if (value && isStaticText(value))
-                    scanTags(value, tags);
-            }
+        scanTags(source, title, tags);
+    for (const [key, value] of detailsOf(call)) {
+        if (key !== tagKey)
+            continue;
+        const values = value.type === 'ArrayExpression' ? value.elements : [value];
+        for (const item of values) {
+            if (item && isStaticText(item))
+                scanTags(source, item, tags);
         }
     }
     return { tags, dynamic };
 }
+/**
+ * Whether a call declares a test or describe block: a title and a body, as in `test('title', fn)` or
+ * `test('title', details, fn)`, a static title with a body defined elsewhere, as in
+ * `test.skip('pays', payWithCard)`, a describe with only a body, or a `todo` with only a title. A string
+ * title tells `test.skip('pays', payWithCard)` apart from a runtime `test.skip(isMobile, 'why')`.
+ */
+function isDeclaration(kind, args, todo) {
+    const first = args.at(0);
+    if (isFunction(first))
+        return kind === 'describe';
+    if (first === undefined)
+        return false;
+    if (args.length === 1)
+        return todo;
+    return isStaticText(first) || args.slice(1).some(isFunction);
+}
 function isUnconditional(call) {
     const first = call.arguments.at(0);
     return (first === undefined || (first.type === 'Literal' && first.value === true)) && !isGuarded(call);
@@ -290,6 +425,18 @@ function isGuarded(call) {
     }
     return false;
 }
+/** Keys that point back up the tree or at comments rather than at child nodes. */
+const NON_CHILD_KEYS = new Set(['parent', 'leadingComments', 'trailingComments']);
+/**
+ * The keys of a node type that the parser gave no visitor keys for, read from the node itself, as
+ * ESLint's own traverser does. Without this, tests inside such a node would go unchecked.
+ */
+function ownKeys(node) {
+    return Object.keys(node).filter((key) => !NON_CHILD_KEYS.has(key) && !key.startsWith('_'));
+}
+function isNode(value) {
+    return typeof value?.type === 'string';
+}
 const cache = new WeakMap();
 export function analyze(sourceCode, options) {
     let byOptions = cache.get(sourceCode);
@@ -305,19 +452,39 @@ export function analyze(sourceCode, options) {
     return analysis;
 }
 function runAnalysis(sourceCode, options) {
-    const { states } = options;
-    const testNames = collectTestNames(sourceCode.ast, options.testFunctions);
-    let usesTest = sourceCode.ast.body.some((statement) => statement.type === 'ImportDeclaration' && isPlaywrightModule(statement.source.value));
+    const { states, framework } = options;
+    const testNames = collectTestNames(sourceCode.ast, framework, options.testFunctions);
+    /**
+     * The test function a callee starts from and the members after it, such as `test` and
+     * `['describe', 'skip']` for `test.describe.skip` or `pw.test.describe.skip`. Undefined when the callee
+     * isn't one of the framework's test functions.
+     */
+    const target = (chain) => {
+        if (chain === undefined)
+            return undefined;
+        const { root, path } = chain;
+        let base = testNames.roots.get(root.name);
+        let rest = path;
+        if (base === undefined && testNames.modules.has(root.name)) {
+            base = framework.exports.get(path[0]);
+            rest = path.slice(1);
+        }
+        return base !== undefined && !isLocalVariable(sourceCode, root) ? { root: base, path: rest } : undefined;
+    };
+    let usesTest = sourceCode.ast.body.some((statement) => statement.type === 'ImportDeclaration' && framework.ownsModule(statement.source.value));
     const subjects = [];
     const claimed = new Set();
     const stack = [];
-    const testInfoNames = [];
+    const infos = [];
     const keys = sourceCode.visitorKeys;
-    const makeSubject = (kind, call, modifiers, tagInfo, required = true) => {
-        const parent = stack.at(-1);
+    /**
+     * `modifiers` maps each state modifier the call has to whether it always applies; a conditional one,
+     * like `test.skip(isMobile)` or Vitest's `skipIf(...)`, needs a ticket only with `requireTicketForConditional`.
+     */
+    const makeSubject = (kind, call, modifiers, tagInfo, parent = stack.at(-1)) => {
         const anchor = anchorOf(call);
         const block = commentBlock(sourceCode, anchor, options.allowBlankLine);
-        // `rows.forEach((row) =>\n  // SKIP: WEB-1\n  test.skip(...))`: the marker sits above the call itself.
+        // `symbols.forEach((symbol) =>\n  // SKIP: TRADE-1\n  test.skip(...))`: the marker sits above the call itself.
         if (call.parent.type === 'ArrowFunctionExpression' && call.parent.body === call) {
             block.push(...commentBlock(sourceCode, call, options.allowBlankLine));
         }
@@ -326,9 +493,14 @@ function runAnalysis(sourceCode, options) {
         const ownTags = new Set(tagInfo.tags.map((t) => t.tag));
         const sources = [];
         for (const state of states) {
-            const matches = state.modifier !== undefined ? modifiers.includes(state.modifier) : ownTags.has(state.tag);
-            if (matches)
-                sources.push({ state, required });
+            if (state.modifier === undefined) {
+                if (ownTags.has(state.tag))
+                    sources.push({ state, required: true });
+                continue;
+            }
+            const always = modifiers.get(state.modifier);
+            if (always !== undefined)
+                sources.push({ state, required: always || options.requireTicketForConditional });
         }
         const inherited = new Set();
         const inheritedTags = new Set();
@@ -337,12 +509,15 @@ function runAnalysis(sourceCode, options) {
                 inherited.add(name);
             for (const source of parent.states)
                 inherited.add(source.state.name);
+        }
+        // Tags belong to tests: a step in a `@new` test is not itself new.
+        if (parent && (kind === 'test' || kind === 'describe')) {
             for (const tag of parent.inheritedTags)
                 inheritedTags.add(tag);
             for (const tag of parent.tags)
                 inheritedTags.add(tag.tag);
         }
-        const ownSkip = modifiers.some((m) => SKIPPING_MODIFIERS.has(m));
+        const ownSkip = [...modifiers].some(([modifier, always]) => always && SKIPPING_MODIFIERS.has(modifier));
         const subject = {
             kind,
             node: call,
@@ -361,55 +536,102 @@ function runAnalysis(sourceCode, options) {
         subjects.push(subject);
         return subject;
     };
+    /** The state modifiers of a declaration, from its members and, in Vitest, its options object. */
+    const modifiersOf = (members, call) => {
+        const modifiers = new Map();
+        const add = (modifier, always) => {
+            if (!modifiers.get(modifier))
+                modifiers.set(modifier, always);
+        };
+        for (const member of members) {
+            const effect = framework.effects.get(member);
+            if (effect)
+                add(effect.modifier, !effect.conditional);
+        }
+        // `{ skip: true }` always skips, `{ skip: isMobile }` only sometimes, `{ skip: false }` never.
+        for (const [key, value] of detailsOf(call)) {
+            const modifier = framework.optionEffects.get(key);
+            const literal = value.type === 'Literal' ? value.value : undefined;
+            if (modifier && literal !== false)
+                add(modifier, literal === true);
+        }
+        return modifiers;
+    };
+    /** What a body can change the test's state with: Playwright's `testInfo` or Vitest's test context. */
+    const bodyInfos = (args, path) => {
+        const body = args.findLast(isFunction);
+        // `test.each(table)` passes the row to the body, and `test.for(cases)` passes it before the context.
+        if (!framework.info || !body || path.includes('each()'))
+            return [];
+        const param = body.params.at(framework.info.param + (path.includes('for()') ? 1 : 0));
+        return infoNames(param, framework.info.methods);
+    };
     const visitCall = (call) => {
-        const chain = chainOf(call.callee);
+        const callee = target(chainOf(call.callee, framework.factories));
+        if (callee === undefined)
+            return { subject: runtimeCall(call) };
+        usesTest = true;
         const args = call.arguments;
-        const last = args.at(-1);
-        let testInfo;
-        if (chain && testNames.has(chain.root.name) && !isLocalVariable(sourceCode, chain.root)) {
-            usesTest = true;
-            const { path } = chain;
-            if (isFunction(last)) {
-                const param = last.params.at(1);
-                if (param?.type === 'Identifier')
-                    testInfo = param.name;
-            }
-            const isDeclaration = args.length >= 2 && isFunction(last) && !isFunction(args[0]);
-            if (path.every((p) => TEST_MODIFIERS.has(p)) && isDeclaration) {
-                return { subject: makeSubject('test', call, path, collectTags(call, true)), testInfo };
-            }
-            if (path[0] === 'describe' && path.slice(1).every((p) => DESCRIBE_MODIFIERS.has(p)) && isFunction(last)) {
-                const tagInfo = collectTags(call, args.length >= 2);
-                return { subject: makeSubject('describe', call, path.slice(1), tagInfo), testInfo };
+        const { root } = callee;
+        let { path } = callee;
+        if (framework.playwright) {
+            // `test.step('fills the order', async (step) => {...})` or `test.step.skip(...)`. The step's body
+            // gets a `TestStepInfo` that can skip the step at runtime.
+            const step = path.join('.');
+            if ((step === 'step' || step === 'step.skip') && args.length >= 2) {
+                const subject = makeSubject('step', call, modifiersOf(path.slice(1), call), { tags: [], dynamic: false });
+                const body = args[1];
+                const param = isFunction(body) ? body.params.at(0) : undefined;
+                return { subject, infos: infoNames(param, STEP_INFO_METHODS, subject) };
             }
-            if (path.length === 1 && RUNTIME_MODIFIERS.has(path[0])) {
-                return { subject: runtimeSubject(call, path[0]), testInfo };
-            }
-            return { testInfo };
         }
-        // testInfo.skip() and test.info().skip()
-        if (call.callee.type === 'MemberExpression') {
-            const name = memberName(call.callee);
-            const object = call.callee.object;
-            if (name !== undefined && RUNTIME_MODIFIERS.has(name)) {
-                const isTestInfo = (object.type === 'Identifier' && testInfoNames.includes(object.name)) ||
-                    (object.type === 'CallExpression' &&
-                        (() => {
-                            const inner = chainOf(object.callee);
-                            return inner !== undefined && testNames.has(inner.root.name) && inner.path.join('.') === 'info';
-                        })());
-                if (isTestInfo)
-                    return { subject: runtimeSubject(call, name) };
-            }
+        const bodyInfo = bodyInfos(args, path);
+        let { kind } = root;
+        if (framework.playwright && path[0] === 'describe') {
+            kind = 'describe';
+            path = path.slice(1);
+        }
+        const members = [...root.modifiers, ...path];
+        const allowed = kind === 'test' ? framework.testMembers : framework.describeMembers;
+        if (members.every((m) => allowed.has(m)) && isDeclaration(kind, args, members.includes('todo'))) {
+            // A declaration always has a first argument: its title, or the body of a describe without one.
+            const tagInfo = collectTags(sourceCode.text, call, !isFunction(args[0]), framework.tagKey);
+            return { subject: makeSubject(kind, call, modifiersOf(members, call), tagInfo), infos: bodyInfo };
+        }
+        // test.skip(), test.fixme(), test.fail() and test.slow() in a test, a describe or a hook.
+        if (framework.playwright && path.length === 1 && RUNTIME_MODIFIERS.has(path[0])) {
+            return { subject: runtimeSubject(call, path[0]), infos: bodyInfo };
         }
-        return {};
+        return { infos: bodyInfo };
     };
-    const runtimeSubject = (call, modifier) => {
+    /** `testInfo.skip()`, `step.skip()`, `test.info().skip()`, and Vitest's `context.skip()` or `skip()`. */
+    const runtimeCall = (call) => {
+        const { callee } = call;
+        // The innermost parameter with a name is the one the call uses.
+        const innermost = (name) => infos.findLast((info) => info.name === name);
+        if (callee.type === 'Identifier') {
+            const info = innermost(callee.name);
+            return info?.method !== undefined ? runtimeSubject(call, info.method, info.step) : undefined;
+        }
+        if (callee.type !== 'MemberExpression')
+            return undefined;
+        const name = memberName(callee);
+        if (name === undefined || !RUNTIME_MODIFIERS.has(name))
+            return undefined;
+        const { object } = callee;
+        if (object.type === 'Identifier') {
+            const info = innermost(object.name);
+            return info?.methods?.has(name) ? runtimeSubject(call, name, info.step) : undefined;
+        }
+        const isTestInfo = object.type === 'CallExpression' &&
+            target(chainOf(object.callee, framework.factories))?.path.join('.') === 'info';
+        return isTestInfo ? runtimeSubject(call, name) : undefined;
+    };
+    /** `step` is set for `step.skip()`, which skips only its step; the other calls act on the whole test. */
+    const runtimeSubject = (call, modifier, step) => {
         if (!states.some((s) => s.modifier === modifier))
             return undefined;
-        const unconditional = isUnconditional(call);
-        const subject = makeSubject('runtime', call, [modifier], { tags: [], dynamic: false }, unconditional || options.requireTicketForConditional);
-        subject.skipped = unconditional && SKIPPING_MODIFIERS.has(modifier);
+        const subject = makeSubject('runtime', call, new Map([[modifier, isUnconditional(call)]]), { tags: [], dynamic: false }, step ?? stack.findLast((s) => s.kind !== 'step'));
         const parent = subject.parent;
         if (parent) {
             parent.runtimeStates.add(subject.states[0].state.name);
@@ -420,35 +642,27 @@ function runAnalysis(sourceCode, options) {
     };
     const walk = (node) => {
         let pushedSubject = false;
-        let pushedInfo = false;
+        let pushedInfos = 0;
         if (node.type === 'CallExpression') {
-            const { subject, testInfo } = visitCall(node);
-            if (subject && subject.kind !== 'runtime') {
-                stack.push(subject);
+            const visit = visitCall(node);
+            if (visit.subject && visit.subject.kind !== 'runtime') {
+                stack.push(visit.subject);
                 pushedSubject = true;
             }
-            if (testInfo !== undefined) {
-                testInfoNames.push(testInfo);
-                pushedInfo = true;
+            for (const info of visit.infos ?? []) {
+                infos.push(info);
+                pushedInfos++;
             }
         }
-        // Parsers provide visitor keys for every node type they produce; the fallback is only defensive.
-        /* v8 ignore next */
-        for (const key of keys[node.type] ?? []) {
+        for (const key of keys[node.type] ?? ownKeys(node)) {
             const child = node[key];
-            if (Array.isArray(child)) {
-                for (const item of child)
-                    if (item)
-                        walk(item);
-            }
-            else if (child && typeof child.type === 'string') {
-                walk(child);
-            }
+            for (const item of Array.isArray(child) ? child : [child])
+                if (isNode(item))
+                    walk(item);
         }
         if (pushedSubject)
             stack.pop();
-        if (pushedInfo)
-            testInfoNames.pop();
+        infos.splice(infos.length - pushedInfos, pushedInfos);
     };
     walk(sourceCode.ast);
     const detachedMarkers = sourceCode
@@ -485,7 +699,7 @@ export function evaluate(subject, state) {
     }
     const isValid = (m) => m.tickets.length > 0 && m.tickets.every((t) => t.result === 'ok');
     // A broken marker in the subject's own block is reported even when another marker is valid: in
-    // `// SKIP: WEB-1` + `// SKIP: nope`, the second line is still wrong. Broken markers further up
+    // `// SKIP: TRADE-1` + `// SKIP: nope`, the second line is still wrong. Broken markers further up
     // are reported for the test or describe they sit above.
     const brokenOwn = markers.find((m) => subject.markers.includes(m) && !isValid(m));
     if (!brokenOwn && markers.some(isValid))
@@ -512,7 +726,7 @@ export function isProse(marker) {
  * is also a work-comment keyword and it doesn't start with a valid ticket. `require-ticket-in-comments`
  * reports those; the marker rules leave them alone.
  */
-export function isWorkComment(marker, options) {
+function isWorkComment(marker, options) {
     return options.workCommentKeywords.has(marker.keyword.toUpperCase()) && marker.tickets.at(0)?.result !== 'ok';
 }
 /** Markers in the subject's own block for states that don't apply to it, leaving out work comments. */
@@ -523,21 +737,24 @@ export function strayMarkers(subject, options) {
 }
 /**
  * Where to report a problem with a test or describe: from the callee to the end of the title
- * (`test.skip('pays with PayPal'`), so editors underline the declaration rather than the whole body.
+ * (`test.skip('places a limit order'`), so editors underline the declaration rather than the whole body.
  * Runtime calls such as `test.skip()` are short, so they are reported whole.
  */
 export function headLoc(subject) {
     const { node } = subject;
     if (subject.kind === 'runtime')
         return node.loc;
-    const title = node.arguments.length > 1 ? node.arguments[0] : undefined;
+    // A describe can have a body and no title. A todo test has only a title.
+    const [first] = node.arguments;
+    const title = isFunction(first) ? undefined : first;
     return { start: node.callee.loc.start, end: (title ?? node.callee).loc.end };
 }
 export function describeSubject(subject) {
     if (subject.kind === 'describe')
         return 'This describe block';
+    if (subject.kind === 'step')
+        return 'This step';
     if (subject.kind === 'runtime')
         return `This ${subject.states[0].state.modifier} call`;
     return 'This test';
 }
-//# sourceMappingURL=analyze.js.map