eslint-plugin-test-governance 0.6.2 → 0.8.0

package/dist/utils/analyze.js

@@ -138,6 +138,9 @@ function collectTestNames(program, framework, configured) {
                     else if (spec.type === 'ImportDefaultSpecifier') {
                         if (framework.defaultExport)
                             roots.set(local, framework.defaultExport);
+                        // `import test from 'node:test'` also has `test.describe`.
+                        if (framework.moduleIsDefault)
+                            modules.add(local);
                     }
                     else {
                         const root = framework.exports.get(importedName(spec));
@@ -167,10 +170,14 @@ function collectTestNames(program, framework, configured) {
                 else if (isOtherFramework(init))
                     setOther(name);
                 else {
-                    // `const pw = require('@playwright/test')`, used as `pw.test`.
+                    // `const pw = require('@playwright/test')`, used as `pw.test`, or `const test = require('node:test')`,
+                    // which is `test` itself.
                     const source = requireSource(init);
-                    if (source !== undefined && framework.ownsModule(source))
+                    if (source !== undefined && framework.ownsModule(source)) {
                         modules.add(name);
+                        if (framework.moduleIsDefault && framework.defaultExport)
+                            roots.set(name, framework.defaultExport);
+                    }
                 }
             }
             else if (declarator.id.type === 'ObjectPattern') {
@@ -443,10 +450,10 @@ function readTexts(sourceCode, node, out, via, path = []) {
 /**
  * The details or options object of a declaration, the second argument in
  * `test('title', { tag: '@smoke' }, fn)` or Vitest's `test('title', { skip: true }, fn)`, also when it
- * is a constant declared in this file.
+ * is a constant declared in this file. With `optionsFirst`, the first: node:test's `test({ skip: true }, fn)`.
  */
-function detailsOf(sourceCode, call) {
-    const details = call.arguments.at(1);
+function detailsOf(sourceCode, call, optionsFirst) {
+    const details = call.arguments.at(optionsFirst ? 0 : 1);
     if (details === undefined || isFunction(details))
         return { entries: [] };
     const target = unwrap(details);
@@ -455,7 +462,9 @@ function detailsOf(sourceCode, call) {
     if (object?.type !== 'ObjectExpression') {
         // A name that can't be read is the details object only when a body comes after it:
         // `test.skip('places an order', placeOrder)` has a body defined elsewhere and no details.
-        return call.arguments.slice(2).some(isFunction) ? { entries: [], unread: details } : { entries: [] };
+        return call.arguments.slice(optionsFirst ? 1 : 2).some(isFunction)
+            ? { entries: [], unread: details }
+            : { entries: [] };
     }
     const entries = object.properties.flatMap((prop) => {
         if (prop.type !== 'Property' || prop.computed)
@@ -492,31 +501,88 @@ function collectTags(sourceCode, call, hasTitle, framework, details) {
         unread.push(details.unread);
     return { tags, dynamic: title.unread.size > 0, unread, opaqueDetails: details.unread !== undefined };
 }
+/** Whether `node` is an object written out or held in a constant declared in this file. */
+function isObject(sourceCode, node) {
+    const target = unwrap(node);
+    const value = target.type === 'ObjectExpression' ? target : constantValue(sourceCode, target);
+    return value !== undefined && unwrap(value).type === 'ObjectExpression';
+}
+/**
+ * Whether a declaration leaves out its title: a describe with only a body, or in node:test any test or
+ * describe that starts with its body or its options.
+ */
+function leavesOutTitle(sourceCode, framework, args) {
+    const [first] = args;
+    return isFunction(first) || (framework.optionalTitle && isObject(sourceCode, first));
+}
+/** Whether a title is text, written out or held in a constant declared in this file. */
+function isTextTitle(sourceCode, node) {
+    const title = unwrap(node);
+    const value = constantValue(sourceCode, title);
+    return isStaticText(title) || (value !== undefined && isStaticText(unwrap(value)));
+}
 /**
  * Whether a call declares a test or describe block: a title and a body, as in `test('title', fn)`,
  * `test('title', details, fn)` or `test.skip(title, payWithCard)` with the body defined elsewhere, a
- * describe with only a body, or a `todo` with only a title, and in Vitest a `skip` with only a title.
+ * describe with only a body, or a `todo` with only a title, in Vitest, Mocha and node:test a `skip` with
+ * only a title, in Mocha a test with only a title written out, which it runs as pending, and in node:test
+ * a test or describe with no title.
  * Only Playwright has a runtime `test.skip(isMobile, 'why')`; there a title, written out or held in a
  * constant, or a body written in place tells the two apart.
  */
 function isDeclaration(sourceCode, framework, kind, args, members) {
     const first = args.at(0);
     if (isFunction(first))
-        return kind === 'describe';
+        return kind === 'describe' || framework.optionalTitle;
     if (first === undefined)
         return false;
-    if (args.length === 1)
-        return members.includes('todo') || (framework.skipWithoutBody && members.includes('skip'));
+    // node:test's `test({ skip: true }, fn)`, or `test({ name, fn })` with everything in the options.
+    if (framework.optionalTitle && isObject(sourceCode, first))
+        return true;
+    if (args.length === 1) {
+        if (members.includes('todo') || (framework.skipWithoutBody && members.includes('skip')))
+            return true;
+        return framework.todoWithoutBody && kind === 'test' && isTextTitle(sourceCode, first);
+    }
     if (!framework.playwright)
         return true;
-    const title = unwrap(first);
-    const value = constantValue(sourceCode, title);
-    return isStaticText(title) || (value !== undefined && isStaticText(unwrap(value))) || args.slice(1).some(isFunction);
+    return isTextTitle(sourceCode, first) || args.slice(1).some(isFunction);
+}
+/** The function whose `this` a call sees: the nearest one around it that isn't an arrow function. */
+function thisFunction(node) {
+    let current = node.parent;
+    while (current && (current.type === 'ArrowFunctionExpression' || !FUNCTIONS.has(current.type))) {
+        current = current.parent;
+    }
+    return current;
 }
 /** The value of a `true` or `false` literal; undefined for anything else. */
 function booleanOf(node) {
     return node?.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined;
 }
+/**
+ * Whether a node:test option applies: Node counts any value but `false` and `undefined`, so a reason such
+ * as `{ skip: 'flaky' }`, `''`, `0`, `null`, and an `expectFailure` pattern or matcher always do. Undefined
+ * for a value only known when the test runs, such as `{ skip: isWindows }`.
+ */
+function optionApplies(node) {
+    const value = unwrap(node);
+    if (value.type === 'Identifier' && value.name === 'undefined')
+        return false;
+    if (value.type === 'Literal')
+        return value.value !== false;
+    return OPTION_VALUES.has(value.type) ? true : undefined;
+}
+/** Values that are never `false` or `undefined`. */
+const OPTION_VALUES = new Set([
+    'TemplateLiteral',
+    'ObjectExpression',
+    'ArrayExpression',
+    'ArrowFunctionExpression',
+    'FunctionExpression',
+    'ClassExpression',
+    'NewExpression',
+]);
 /**
  * Whether a runtime call always applies: it has no condition, or `true`, or with `notes` only a note, as
  * Vitest's `context.skip('Broker sandbox is down')`, and nothing around it makes it conditional.
@@ -540,8 +606,8 @@ function isEarlyExit(statement) {
 }
 /**
  * Whether the call only runs on some paths of its function: under an `if`, a `switch` case, a ternary,
- * the right side of `&&`, `||` or `??`, in a `catch` block, or after an early exit such as
- * `if (ready) return;`. `if (!enabled) test.skip()` is the same as `test.skip(!enabled)`, and
+ * the right side of `&&`, `||` or `??`, in a `catch` block, after other code in a `try` block that has a
+ * `catch`, or after an early exit such as `if (ready) return;`. `if (!enabled) test.skip()` is the same as `test.skip(!enabled)`, and
  * `catch { test.skip(true, 'service is down') }` only skips when the service is down.
  */
 function isGuarded(call) {
@@ -559,6 +625,10 @@ function isGuarded(call) {
             const index = node.body.indexOf(child);
             if (node.body.slice(0, index).some(isEarlyExit))
                 return true;
+            // `try { await stat(target); test.skip(); } catch {}`: an error before the skip jumps to the catch.
+            const owner = node.parent;
+            if (index > 0 && owner.type === 'TryStatement' && owner.block === node && owner.handler)
+                return true;
         }
     }
     return false;
@@ -603,8 +673,10 @@ function runAnalysis(sourceCode, options) {
         const { root, path, args } = 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]);
+        // `pw.test.skip`, or node:test's `test.describe`, whose module is also its `test`.
+        const member = testNames.modules.has(root.name) ? framework.exports.get(path[0]) : undefined;
+        if (member !== undefined || base === undefined) {
+            base = member;
             rest = path.slice(1);
         }
         return base !== undefined && !isLocalVariable(sourceCode, root) ? { root: base, path: rest, args } : undefined;
@@ -617,6 +689,8 @@ function runAnalysis(sourceCode, options) {
     const keys = sourceCode.visitorKeys;
     /** States an options object can put a test in, such as `skip` for Vitest's `{ skip: true }`. */
     const optionModifiers = new Set(framework.optionEffects.values());
+    /** Bodies of Mocha tests and hooks written as a `function`, where `this.skip()` skips at runtime. */
+    const thisBodies = new Set();
     /**
      * `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`.
@@ -716,12 +790,32 @@ function runAnalysis(sourceCode, options) {
         // `{ skip: true }` always skips, `{ skip: isMobile }` only sometimes, `{ skip: false }` never.
         for (const [key, value] of details) {
             const modifier = framework.optionEffects.get(key);
-            const literal = booleanOf(value);
-            if (modifier && literal !== false)
-                add(modifier, literal === true);
+            const always = framework.anyOptionValue ? optionApplies(value) : booleanOf(value);
+            if (modifier && always !== false)
+                add(modifier, always === true);
         }
+        const first = framework.exclusiveStates.findIndex((state) => modifiers.get(state) === true);
+        if (first !== -1)
+            for (const state of framework.exclusiveStates.slice(first + 1))
+                modifiers.delete(state);
         return modifiers;
     };
+    /**
+     * The modifiers of a declaration, with `todo` for a Mocha test that has only a title, which Mocha runs as
+     * pending: someone has yet to write it. A skipped one, as `it.skip('title')`, stays a skip.
+     */
+    const declarationModifiers = (kind, args, modifiers) => {
+        if (framework.todoWithoutBody && kind === 'test' && args.length === 1 && !modifiers.has('skip')) {
+            modifiers.set('todo', true);
+        }
+        return modifiers;
+    };
+    /** Keeps the body of a test or hook written as a `function`, whose `this` can skip it, as in Mocha. */
+    const addThisBody = (args) => {
+        const body = args.findLast(isFunction);
+        if (body?.type === 'FunctionExpression')
+            thisBodies.add(body);
+    };
     /** 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);
@@ -765,26 +859,61 @@ function runAnalysis(sourceCode, options) {
         if (yes.kind !== no.kind || !declares(yes, args) || !declares(no, args))
             return undefined;
         usesTest = true;
-        const details = detailsOf(sourceCode, call);
-        const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
-        const [ifYes, ifNo] = [yes, no].map(({ members, args: conditions }) => modifiersOf(members, details.entries, conditions));
+        const { details, tagInfo } = headOf(call);
+        const [ifYes, ifNo] = [yes, no].map(({ members, args: conditions }) => declarationModifiers(yes.kind, args, modifiersOf(members, details.entries, conditions)));
+        if (yes.kind === 'test')
+            addThisBody(args);
         const modifiers = new Map();
         for (const modifier of new Set([...ifYes.keys(), ...ifNo.keys()])) {
             modifiers.set(modifier, ifYes.get(modifier) === true && ifNo.get(modifier) === true);
         }
-        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos: bodyInfos(args, yes.members) };
+        const infos = yes.kind === 'test' ? bodyInfos(args, yes.members) : [];
+        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos };
+    };
+    /** The details and tags of a declaration; node:test lets it leave out its title. */
+    const headOf = (call) => {
+        const args = call.arguments;
+        const untitled = leavesOutTitle(sourceCode, framework, args);
+        const details = detailsOf(sourceCode, call, untitled && !isFunction(args[0]));
+        return { details, tagInfo: collectTags(sourceCode, call, !untitled, framework, details) };
+    };
+    const declare = (call, { kind, members, args: conditions }, infos) => {
+        const args = call.arguments;
+        const { details, tagInfo } = headOf(call);
+        const modifiers = declarationModifiers(kind, args, modifiersOf(members, details.entries, conditions));
+        if (kind === 'test')
+            addThisBody(args);
+        return { subject: makeSubject(kind, call, modifiers, tagInfo), infos };
+    };
+    /** node:test's `t.test('title', fn)`: a subtest declared through the context of the test around it. */
+    const subtestOf = (call) => {
+        const { callee } = call;
+        if (!framework.subtests || callee.type !== 'MemberExpression' || memberName(callee) !== 'test')
+            return undefined;
+        const { object } = callee;
+        if (object.type !== 'Identifier' || !infos.findLast((info) => info.name === object.name)?.methods)
+            return undefined;
+        const declaration = { kind: 'test', members: [], args: new Map() };
+        return declares(declaration, call.arguments)
+            ? declare(call, declaration, bodyInfos(call.arguments, []))
+            : undefined;
     };
     const visitCall = (call) => {
         const callee = target(chainOf(call.callee, framework.factories));
         if (callee === undefined)
-            return pickedDeclaration(call) ?? { subject: runtimeCall(call) };
+            return subtestOf(call) ?? pickedDeclaration(call) ?? { subject: runtimeCall(call) };
         usesTest = true;
         const args = call.arguments;
         const { path } = callee;
         const declaration = declarationOf(callee);
-        // Vitest's `beforeEach((context) => context.skip())` skips the tests it runs before.
-        if (declaration === undefined)
+        // Vitest's `beforeEach((context) => context.skip())` and Mocha's `before(function () { this.skip(); })`
+        // skip the tests they run for.
+        if (declaration === undefined) {
+            if (callee.root.noContext)
+                return { infos: [] };
+            addThisBody(args);
             return { infos: bodyInfos(args, path) };
+        }
         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.
@@ -796,24 +925,21 @@ function runAnalysis(sourceCode, options) {
                 return { subject, infos: infoNames(param, STEP_INFO_METHODS, subject) };
             }
         }
-        const bodyInfo = bodyInfos(args, path);
         const { kind, members } = declaration;
-        if (declares(declaration, args)) {
-            // A declaration always has a first argument: its title, or the body of a describe without one.
-            const details = detailsOf(sourceCode, call);
-            const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
-            return {
-                subject: makeSubject(kind, call, modifiersOf(members, details.entries, callee.args), tagInfo),
-                infos: bodyInfo,
-            };
-        }
+        // A describe's body gets no test context: node:test passes one that can't skip.
+        const bodyInfo = kind === 'describe' ? [] : bodyInfos(args, path);
+        if (declares(declaration, args))
+            return declare(call, declaration, bodyInfo);
         // test.skip(), test.fixme(), test.fail() and test.slow() in a test, a describe or a hook.
         if (framework.playwright && members.length === 1 && RUNTIME_MODIFIERS.has(members[0])) {
             return { subject: runtimeSubject(call, members[0]), infos: bodyInfo };
         }
         return { infos: bodyInfo };
     };
-    /** `testInfo.skip()`, `step.skip()`, `test.info().skip()`, and Vitest's `context.skip()` or `skip()`. */
+    /**
+     * `testInfo.skip()`, `step.skip()`, `test.info().skip()`, Vitest's `context.skip()` or `skip()`,
+     * Mocha's `this.skip()`, and node:test's `t.skip()` and `t.todo()`.
+     */
     const runtimeCall = (call) => {
         const { callee } = call;
         // The innermost parameter with a name is the one the call uses.
@@ -825,14 +951,21 @@ function runAnalysis(sourceCode, options) {
         if (callee.type !== 'MemberExpression')
             return undefined;
         const name = memberName(callee);
-        if (name === undefined || !RUNTIME_MODIFIERS.has(name))
+        if (name === undefined)
             return undefined;
         const { object } = callee;
+        // Mocha's `this.skip()` or node:test's `this.todo()`, in a test or hook whose `function` gives it the
+        // test's `this`.
+        if (object.type === 'ThisExpression') {
+            const owner = framework.thisMethods.has(name) ? thisFunction(call) : undefined;
+            return owner !== undefined && thisBodies.has(owner) ? runtimeSubject(call, name) : undefined;
+        }
         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' &&
+        const isTestInfo = RUNTIME_MODIFIERS.has(name) &&
+            object.type === 'CallExpression' &&
             target(chainOf(object.callee, framework.factories))?.path.join('.') === 'info';
         return isTestInfo ? runtimeSubject(call, name) : undefined;
     };
@@ -960,9 +1093,10 @@ export function headLoc(subject) {
     const { node } = subject;
     if (subject.kind === 'runtime')
         return node.loc;
-    // A describe can have a body and no title. A todo test has only a title.
+    // A describe, or in node:test any declaration, can start with its body or options and have no title. A
+    // todo test has only a title.
     const [first] = node.arguments;
-    const title = isFunction(first) ? undefined : first;
+    const title = isFunction(first) || first.type === 'ObjectExpression' ? undefined : first;
     return { start: node.callee.loc.start, end: (title ?? node.callee).loc.end };
 }
 export function describeSubject(subject) {

package/dist/utils/constants.d.ts

@@ -8,7 +8,7 @@ export type BuiltinStateName = (typeof BUILTIN_STATE_NAMES)[number];
 export declare const TAG_STATE_NAMES: readonly ["new", "quarantined"];
 export type TagStateName = (typeof TAG_STATE_NAMES)[number];
 /** The test frameworks the rules understand. */
-export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest"];
+export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test"];
 export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];
 export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "numeric", "pattern"];
 /** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */

package/dist/utils/constants.js

@@ -6,7 +6,15 @@ export const BUILTIN_STATE_NAMES = ['skip', 'fixme', 'fail', 'slow', 'todo', 'ne
 /** The built-in states a tag puts a test in, so the only ones whose tag can be renamed. */
 export const TAG_STATE_NAMES = ['new', 'quarantined'];
 /** The test frameworks the rules understand. */
-export const FRAMEWORK_NAMES = ['playwright', 'jest', 'vitest'];
+export const FRAMEWORK_NAMES = [
+    'playwright',
+    'jest',
+    'vitest',
+    'mocha',
+    'cypress',
+    'webdriverio',
+    'node-test',
+];
 export const TICKET_PRESETS = [
     'any',
     'jira',

package/dist/utils/frameworks.d.ts

@@ -8,6 +8,8 @@ export type Modifier = 'skip' | 'fixme' | 'fail' | 'slow' | 'todo';
 export interface Root {
     kind: 'test' | 'describe' | 'hook';
     modifiers: readonly string[];
+    /** Set for a hook whose body gets no test context, as node:test's `before` in a describe. */
+    noContext?: true;
 }
 /**
  * The state a member puts a test in. A member called with a condition, like Vitest's `skipIf(...)`, puts it
@@ -27,6 +29,11 @@ export interface Framework {
     exports: ReadonlyMap<string, Root>;
     /** What a default import from the framework's module is. */
     defaultExport?: Root;
+    /**
+     * Whether the module itself is its default export with the other functions as members, as
+     * `require('node:test')`, which is `test` and has `test.describe`.
+     */
+    moduleIsDefault: boolean;
     /** Test functions that exist without an import, besides `testFunctions`. */
     globals: ReadonlyMap<string, Root>;
     /** The default `testFunctions`. */
@@ -43,6 +50,21 @@ export interface Framework {
     effects: ReadonlyMap<string, Effect>;
     /** Keys of an options object that put a test in a state, as in Vitest's `{ skip: true }`. */
     optionEffects: ReadonlyMap<string, Modifier>;
+    /**
+     * Whether an option counts whatever its value, unless it is `false` or `undefined`, as node:test's
+     * `{ skip: 'reason' }`. Otherwise only `true` always counts and other values are conditions.
+     */
+    anyOptionValue: boolean;
+    /**
+     * States a test is in only one of: the first that always applies, as node:test reports a skipped todo
+     * test as skipped only. A state that applies only sometimes leaves the later ones for the other runs.
+     */
+    exclusiveStates: readonly Modifier[];
+    /**
+     * Whether the title can be left out, as node:test's `test(fn)` and `test({ skip: true }, fn)`, and an
+     * options object then comes first.
+     */
+    optionalTitle: boolean;
     /** The key of the details or options object that holds tags. */
     tagKey?: string;
     /** Whether that key holds names without their `@`, as Vitest's `tags: ['flaky']`, which stand for `@flaky`. */
@@ -55,6 +77,8 @@ export interface Framework {
         param: number;
         methods: ReadonlySet<string>;
     };
+    /** Whether that parameter declares subtests with `t.test(...)`, as in node:test. */
+    subtests: boolean;
     /** Whether `skip` with only a title declares a skipped test or describe, as Vitest's `test.skip('title')`. */
     skipWithoutBody: boolean;
     /**
@@ -62,6 +86,13 @@ export interface Framework {
      * `context.skip('why')`. In Playwright the first argument is always a condition.
      */
     skipNotes: boolean;
+    /**
+     * The methods a test or hook written as a `function` can change its state with at runtime through `this`,
+     * as Mocha's `this.skip()`. Empty when `this` can't.
+     */
+    thisMethods: ReadonlySet<string>;
+    /** Whether a test with only a title written out is a todo, as Mocha's pending `it('title')`. */
+    todoWithoutBody: boolean;
     /** Built-in states a test can be put in with this framework. */
     states: ReadonlySet<BuiltinStateName>;
     /** Playwright's own API on `test`: `test.describe`, `test.step`, `test.info()` and runtime `test.skip()`. */

package/dist/utils/frameworks.js

@@ -16,6 +16,7 @@ const playwright = {
     ownsModule: isPlaywrightModule,
     exports: new Map([['test', TEST]]),
     defaultExport: TEST,
+    moduleIsDefault: false,
     globals: new Map(),
     testFunctions: ['test'],
     testMembers: new Set(['only', 'skip', 'fixme', 'fail']),
@@ -27,11 +28,17 @@ const playwright = {
         ['fail', 'fail'],
     ]),
     optionEffects: new Map(),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     tagKey: 'tag',
     plainTags: false,
     info: { param: 1, methods: RUNTIME_MODIFIERS },
+    subtests: false,
     skipWithoutBody: false,
     skipNotes: false,
+    thisMethods: new Set(),
+    todoWithoutBody: false,
     states: new Set(['skip', 'fixme', 'fail', 'slow', 'new', 'quarantined']),
     playwright: true,
 };
@@ -49,6 +56,7 @@ const jest = {
     name: 'jest',
     ownsModule: (source) => source === '@jest/globals',
     exports: JEST_FUNCTIONS,
+    moduleIsDefault: false,
     globals: new Map([...JEST_FUNCTIONS].filter(([name]) => name !== 'test' && name !== 'it')),
     testFunctions: ['test', 'it'],
     testMembers: new Set(['only', 'skip', 'todo', 'failing', 'concurrent', 'each()']),
@@ -60,9 +68,15 @@ const jest = {
         ['failing', 'fail'],
     ]),
     optionEffects: new Map(),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     plainTags: false,
+    subtests: false,
     skipWithoutBody: false,
     skipNotes: false,
+    thisMethods: new Set(),
+    todoWithoutBody: false,
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
 };
@@ -77,6 +91,7 @@ const vitest = {
         ['suite', DESCRIBE],
         ['beforeEach', HOOK],
     ]),
+    moduleIsDefault: false,
     globals: new Map([
         ['describe', DESCRIBE],
         ['suite', DESCRIBE],
@@ -98,15 +113,127 @@ const vitest = {
         ['todo', 'todo'],
         ['fails', 'fail'],
     ]),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     tagKey: 'tags',
     plainTags: true,
     info: { param: 0, methods: new Set(['skip']) },
+    subtests: false,
     skipWithoutBody: true,
     skipNotes: true,
+    thisMethods: new Set(),
+    todoWithoutBody: false,
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
 };
-export const FRAMEWORKS = { playwright, jest, vitest };
+const SKIPPED_TEST = { kind: 'test', modifiers: ['skip'] };
+const SKIPPED_DESCRIBE = { kind: 'describe', modifiers: ['skip'] };
+/** What the `mocha` module exports, the BDD and TDD names alike. `context` and `specify` are only globals. */
+const MOCHA_EXPORTS = new Map([
+    ['it', TEST],
+    ['test', TEST],
+    ['xit', SKIPPED_TEST],
+    ['describe', DESCRIBE],
+    ['suite', DESCRIBE],
+    ['xdescribe', SKIPPED_DESCRIBE],
+    ...['before', 'beforeEach', 'after', 'afterEach', 'suiteSetup', 'setup', 'suiteTeardown', 'teardown'].map((name) => [name, HOOK]),
+]);
+/** Mocha, and Cypress and WebdriverIO, which run their tests on Mocha. */
+const mocha = {
+    ownsModule: (source) => source === 'mocha',
+    exports: MOCHA_EXPORTS,
+    moduleIsDefault: false,
+    globals: new Map([
+        ...[...MOCHA_EXPORTS].filter(([name]) => name !== 'it' && name !== 'test'),
+        ['context', DESCRIBE],
+        ['xcontext', SKIPPED_DESCRIBE],
+        ['xspecify', SKIPPED_TEST],
+    ]),
+    testFunctions: ['it', 'specify', 'test'],
+    testMembers: new Set(['only', 'skip']),
+    describeMembers: new Set(['only', 'skip']),
+    factories: new Set(),
+    effects: effects([['skip', 'skip']]),
+    // Cypress's `{ browser: '!webkit' }` runs the test only in some browsers.
+    optionEffects: new Map([['browser', 'skip']]),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
+    // @cypress/grep's `{ tags: '@smoke' }`, written with the `@`.
+    tagKey: 'tags',
+    plainTags: false,
+    subtests: false,
+    skipWithoutBody: true,
+    skipNotes: false,
+    thisMethods: new Set(['skip']),
+    todoWithoutBody: true,
+    states: new Set(['skip', 'todo', 'new', 'quarantined']),
+    playwright: false,
+};
+const NODE_TEST_MEMBERS = new Set(['only', 'skip', 'todo', 'expectFailure']);
+/** What a test's context can do to it, as `t.skip()`, or as `this.skip()` in a `function`. */
+const NODE_TEST_CONTEXT = new Set(['skip', 'todo']);
+/**
+ * Node's built-in runner. `test` and `it` are one function, as are `describe` and `suite`, and the state
+ * members are exported by name too. Only `beforeEach` and `afterEach` get the test's context, as a test
+ * does: as their first parameter, and as `this` when written as a `function`. `before`, `after` and the
+ * describe itself get the suite's, which can't skip.
+ */
+const nodeTest = {
+    name: 'node-test',
+    ownsModule: (source) => source === 'node:test',
+    exports: new Map([
+        ['test', TEST],
+        ['it', TEST],
+        ['describe', DESCRIBE],
+        ['suite', DESCRIBE],
+        ...[...NODE_TEST_MEMBERS].map((member) => [member, { kind: 'test', modifiers: [member] }]),
+        ['before', { kind: 'hook', modifiers: [], noContext: true }],
+        ['after', { kind: 'hook', modifiers: [], noContext: true }],
+        ['beforeEach', HOOK],
+        ['afterEach', HOOK],
+    ]),
+    defaultExport: TEST,
+    moduleIsDefault: true,
+    globals: new Map(),
+    testFunctions: ['test', 'it'],
+    testMembers: NODE_TEST_MEMBERS,
+    describeMembers: NODE_TEST_MEMBERS,
+    factories: new Set(),
+    effects: effects([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['expectFailure', 'fail'],
+    ]),
+    optionEffects: new Map([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['expectFailure', 'fail'],
+    ]),
+    anyOptionValue: true,
+    exclusiveStates: ['skip', 'todo', 'fail'],
+    optionalTitle: true,
+    plainTags: false,
+    info: { param: 0, methods: NODE_TEST_CONTEXT },
+    subtests: true,
+    skipWithoutBody: true,
+    // `t.skip('why')` takes a message, not a condition.
+    skipNotes: true,
+    thisMethods: NODE_TEST_CONTEXT,
+    todoWithoutBody: false,
+    states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
+    playwright: false,
+};
+export const FRAMEWORKS = {
+    playwright,
+    jest,
+    vitest,
+    mocha: { name: 'mocha', ...mocha },
+    cypress: { name: 'cypress', ...mocha },
+    webdriverio: { name: 'webdriverio', ...mocha },
+    'node-test': nodeTest,
+};
 /** Whether `source` belongs to a test runner other than `framework`, so its names are never tests here. */
 export function isOtherRunner(framework, source) {
     return (isPlaywrightModule(source) || OTHER_RUNNERS.has(source)) && !framework.ownsModule(source);