@cjser/eslint-node-test 0.2.0-cjser.2

package/rules/no-incorrect-deep-equal.js

@@ -0,0 +1,113 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'no-deep-equal-with-primitive';
+
+const DEEP_EQUAL_METHODS = new Map([
+	['deepEqual', 'equal'],
+	['deepStrictEqual', 'strictEqual'],
+	['notDeepEqual', 'notEqual'],
+	['notDeepStrictEqual', 'notStrictEqual'],
+]);
+
+/**
+Check if a node represents a primitive value.
+Covers: literals, `undefined`/`NaN`/`Infinity` identifiers, template literals (always a string,
+regardless of interpolation), `void` expressions, and negated numeric/Infinity/NaN literals.
+*/
+function isPrimitive(node) {
+	node = unwrapTypeScriptExpression(node);
+	return (
+		(node.type === 'Literal' && !node.regex)
+		|| (node.type === 'Identifier' && ['undefined', 'NaN', 'Infinity'].includes(node.name))
+		|| node.type === 'TemplateLiteral'
+		|| (node.type === 'UnaryExpression' && node.operator === 'void')
+		|| (
+			node.type === 'UnaryExpression'
+			&& node.operator === '-'
+			&& (
+				(node.argument.type === 'Literal' && !node.argument.regex)
+				|| (node.argument.type === 'Identifier' && (node.argument.name === 'Infinity' || node.argument.name === 'NaN'))
+			)
+		)
+	);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports, {trackHooks: true});
+
+	context.on('CallExpression', node => {
+		tracker.update(node);
+
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		const {method} = assertion;
+		const replacement = DEEP_EQUAL_METHODS.get(method);
+		if (!replacement) {
+			return;
+		}
+
+		const [actual, expected] = node.arguments;
+		if (!actual || !expected) {
+			return;
+		}
+
+		if (!isPrimitive(actual) && !isPrimitive(expected)) {
+			return;
+		}
+
+		const {callee} = node;
+		const problem = {
+			node,
+			messageId: MESSAGE_ID,
+			data: {method},
+		};
+
+		// Autofix only the member forms (`assert.deepEqual`, `t.assert.deepEqual`). A bare named
+		// import (`deepEqual`) cannot be rewritten to `equal` without also importing it, so leave
+		// it reported but unfixed.
+		if (callee.type === 'MemberExpression') {
+			problem.fix = fixer => fixer.replaceText(callee.property, replacement);
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `deepEqual`/`deepStrictEqual` (and their `notDeep*` variants) when comparing with primitives.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema: [],
+		messages: {
+			[MESSAGE_ID]: 'Avoid using `{{method}}` with a primitive. Use the non-deep equality equivalent instead.',
+		},
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-incorrect-strict-equal.js

@@ -0,0 +1,99 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'no-incorrect-strict-equal';
+
+// Strict/loose equality methods and their deep equivalents.
+const STRICT_TO_DEEP = new Map([
+	['equal', 'deepEqual'],
+	['strictEqual', 'deepStrictEqual'],
+	['notEqual', 'notDeepEqual'],
+	['notStrictEqual', 'notDeepStrictEqual'],
+]);
+
+/**
+Check if a node is an object or array literal. These are freshly allocated, so a strict/loose
+equality comparison against them is decided purely by reference identity, never by structure.
+*/
+function isObjectOrArrayLiteral(node) {
+	const unwrapped = unwrapTypeScriptExpression(node);
+	return unwrapped.type === 'ObjectExpression' || unwrapped.type === 'ArrayExpression';
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports, {trackHooks: true});
+
+	context.on('CallExpression', node => {
+		tracker.update(node);
+
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		const replacement = STRICT_TO_DEEP.get(assertion.method);
+		if (!replacement) {
+			return;
+		}
+
+		const [actual, expected] = node.arguments;
+		if (!actual || !expected) {
+			return;
+		}
+
+		if (!isObjectOrArrayLiteral(actual) && !isObjectOrArrayLiteral(expected)) {
+			return;
+		}
+
+		const {callee} = node;
+		const problem = {
+			node,
+			messageId: MESSAGE_ID,
+			data: {method: assertion.method, replacement},
+		};
+
+		// Autofix only the member forms (`assert.strictEqual`, `t.assert.strictEqual`). A bare named
+		// import (`strictEqual`) cannot be rewritten to `deepStrictEqual` without also importing it,
+		// so leave it reported but unfixed.
+		if (callee.type === 'MemberExpression') {
+			problem.fix = fixer => fixer.replaceText(callee.property, replacement);
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `strictEqual`/`equal` (and their `not*` variants) when comparing with an object or array literal.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema: [],
+		messages: {
+			[MESSAGE_ID]: 'Avoid using `{{method}}` with an object or array literal, which compares by reference rather than structure. Use `{{replacement}}` instead.',
+		},
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-loop-static-title.js

@@ -0,0 +1,93 @@
+import {resolveImports, parseTestCall, getStaticString} from './utils/node-test.js';
+import {isLoop, isFunction} from './ast/index.js';
+
+const MESSAGE_ID = 'no-loop-static-title';
+
+const messages = {
+	[MESSAGE_ID]: 'This title is static but generated in a loop, so every iteration registers the same title. Include the loop variable so each title is unique.',
+};
+
+// Array methods whose callback is commonly used to generate one test per element.
+const ITERATION_METHODS = new Set(['map', 'forEach', 'flatMap']);
+
+/** Whether `callExpression` is an iteration method call (`xs.map(fn)`) whose callback is `callback`. */
+function isIterationCall(callExpression, callback) {
+	const {callee} = callExpression;
+	return (
+		callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.property.type === 'Identifier'
+		&& ITERATION_METHODS.has(callee.property.name)
+		&& callExpression.arguments.includes(callback)
+	);
+}
+
+/*
+Whether the test/suite call repeats across a loop without an intervening test/suite scope.
+Walking up from the call: a loop means it repeats; the first enclosing function that is an
+iteration callback (`xs.map(…)`) also means it repeats; any other function is a scope boundary
+(a `describe`/test callback or helper) under which the static title is no longer a duplicate.
+*/
+function isInRepeatingScope(node) {
+	let current = node.parent;
+	while (current) {
+		if (isLoop(current)) {
+			return true;
+		}
+
+		if (isFunction(current)) {
+			return current.parent?.type === 'CallExpression' && isIterationCall(current.parent, current);
+		}
+
+		current = current.parent;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (parsed?.kind !== 'test' && parsed?.kind !== 'suite') {
+			return;
+		}
+
+		// A static title resolves to a constant string; a title that interpolates the loop variable
+		// does not, so it is correctly left alone.
+		if (getStaticString(node.arguments[0], context) === undefined) {
+			return;
+		}
+
+		if (!isInRepeatingScope(node)) {
+			return;
+		}
+
+		return {
+			node: node.arguments[0],
+			messageId: MESSAGE_ID,
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow a static test or suite title inside a loop.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-misused-concurrency.js

@@ -0,0 +1,85 @@
+import {
+	resolveImports,
+	parseTestCall,
+	createContextTracker,
+	getSubtestReceiver,
+	getTestOptions,
+	findOptionsProperty,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-misused-concurrency';
+
+const messages = {
+	[MESSAGE_ID]: 'The `concurrency` option has no effect on a test without subtests. It only controls how a suite or a test\'s subtests run concurrently.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports);
+
+	// One frame per test/subtest. A frame with a `concurrency` option but no subtests is misused.
+	const frames = [];
+
+	context.on('CallExpression', node => {
+		const isSubtest = tracker.isSubtestCall(node);
+
+		// Attribute this subtest to the frame that owns its receiver context, before it pushes its own.
+		if (isSubtest) {
+			const receiver = getSubtestReceiver(node).name;
+			const ownerFrame = frames.findLast(frame => frame.contextName === receiver);
+			if (ownerFrame) {
+				ownerFrame.hasSubtest = true;
+			}
+		}
+
+		const isTest = parseTestCall(node, imports)?.kind === 'test';
+		tracker.update(node);
+
+		if (isTest || isSubtest) {
+			frames.push({
+				node,
+				contextName: tracker.current(),
+				concurrencyProperty: findOptionsProperty(getTestOptions(node), 'concurrency'),
+				hasSubtest: false,
+			});
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+
+		if (frames.at(-1)?.node !== node) {
+			return;
+		}
+
+		const frame = frames.pop();
+		if (frame.concurrencyProperty && !frame.hasSubtest) {
+			return {
+				node: frame.concurrencyProperty,
+				messageId: MESSAGE_ID,
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow the `concurrency` option on a test without subtests.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-mock-timers-destructured-import.js

@@ -0,0 +1,150 @@
+import {resolveImports} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-mock-timers-destructured-import';
+
+const messages = {
+	[MESSAGE_ID]: '`{{name}}` is imported directly, so `mock.timers` cannot intercept it. Call the global `{{name}}` instead.',
+};
+
+const TIMER_MODULES = new Set(['node:timers', 'timers']);
+
+// Imported timer function -> the `mock.timers` API name that mocks it.
+const FUNCTION_TO_API = new Map([
+	['setTimeout', 'setTimeout'],
+	['clearTimeout', 'setTimeout'],
+	['setInterval', 'setInterval'],
+	['clearInterval', 'setInterval'],
+	['setImmediate', 'setImmediate'],
+	['clearImmediate', 'setImmediate'],
+]);
+
+/*
+The enabled timer APIs, or `null` when `enable()` was called without an `apis` list (all APIs).
+*/
+function getEnabledApis(callExpression) {
+	const [argument] = callExpression.arguments;
+	if (argument?.type !== 'ObjectExpression') {
+		return null;
+	}
+
+	const apisProperty = argument.properties.find(property =>
+		property.type === 'Property'
+		&& !property.computed
+		&& (
+			(property.key.type === 'Identifier' && property.key.name === 'apis')
+			|| (property.key.type === 'Literal' && property.key.value === 'apis')
+		));
+
+	if (apisProperty?.value.type !== 'ArrayExpression') {
+		return null;
+	}
+
+	return apisProperty.value.elements
+		.filter(element => element?.type === 'Literal' && typeof element.value === 'string')
+		.map(element => element.value);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	// Named timer-function imports from `node:timers`.
+	const timerImports = [];
+	for (const node of sourceCode.ast.body) {
+		if (node.type !== 'ImportDeclaration' || !TIMER_MODULES.has(node.source.value)) {
+			continue;
+		}
+
+		for (const specifier of node.specifiers) {
+			if (
+				specifier.type === 'ImportSpecifier'
+				&& specifier.imported.type === 'Identifier'
+				&& FUNCTION_TO_API.has(specifier.imported.name)
+			) {
+				timerImports.push(specifier);
+			}
+		}
+	}
+
+	if (timerImports.length === 0) {
+		return;
+	}
+
+	const {mockLocals} = imports;
+
+	// `mock.timers` (global) or `t.mock.timers` (context).
+	const isMockTimers = node =>
+		node.type === 'MemberExpression'
+		&& !node.computed
+		&& node.property.type === 'Identifier'
+		&& node.property.name === 'timers'
+		&& (
+			// `mock.timers` (global, named/renamed import).
+			(node.object.type === 'Identifier' && mockLocals.has(node.object.name))
+			// `t.mock.timers` (context) or `namespace.mock.timers`.
+			|| (
+				node.object.type === 'MemberExpression'
+				&& !node.object.computed
+				&& node.object.property.type === 'Identifier'
+				&& node.object.property.name === 'mock'
+			)
+		);
+
+	const enabledApis = new Set();
+	let isAllEnabled = false;
+
+	context.on('CallExpression', node => {
+		const {callee} = node;
+		if (
+			callee.type === 'MemberExpression'
+			&& !callee.computed
+			&& callee.property.type === 'Identifier'
+			&& callee.property.name === 'enable'
+			&& isMockTimers(callee.object)
+		) {
+			const apis = getEnabledApis(node);
+			if (apis === null) {
+				isAllEnabled = true;
+			} else {
+				for (const api of apis) {
+					enabledApis.add(api);
+				}
+			}
+		}
+	});
+
+	context.onExit('Program', () => {
+		if (!isAllEnabled && enabledApis.size === 0) {
+			return;
+		}
+
+		return timerImports
+			.filter(specifier => isAllEnabled || enabledApis.has(FUNCTION_TO_API.get(specifier.imported.name)))
+			.map(specifier => ({
+				node: specifier,
+				messageId: MESSAGE_ID,
+				data: {name: specifier.imported.name},
+			}));
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow destructured timer imports when using `mock.timers`.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-nested-tests.js

@@ -0,0 +1,71 @@
+import {resolveImports, parseTestCall, getTestCallback} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-nested-tests/error';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not define a test or suite inside a test body. Use `t.test()` for subtests instead.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	// Stack of callback function nodes of the `test`/`it` calls we are currently inside.
+	// Suites (`describe`/`suite`) legitimately contain tests and nested suites, so they
+	// do not open a scope here — only a test/it body does.
+	const testCallbackStack = [];
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed) {
+			return;
+		}
+
+		// A test or suite defined inside a test body should be a subtest (`t.test()`).
+		if ((parsed.kind === 'test' || parsed.kind === 'suite') && testCallbackStack.length > 0) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+			};
+		}
+
+		if (parsed.kind === 'test') {
+			const callback = getTestCallback(node);
+			if (callback) {
+				testCallbackStack.push(callback);
+			}
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed || parsed.kind !== 'test') {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		if (callback && testCallbackStack.at(-1) === callback) {
+			testCallbackStack.pop();
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow tests and suites nested inside a test body.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-only-test.js

@@ -0,0 +1,11 @@
+import createTestModifierRule from './shared/test-modifier-rule.js';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = createTestModifierRule({
+	modifier: 'only',
+	description: 'Disallow the `.only` test modifier.',
+	errorMessage: 'Do not use the `.only` test modifier as it prevents the other tests from running.',
+	recommended: 'unopinionated',
+});
+
+export default config;