eslint-node-test 0.0.1

package/rules/no-export.js

@@ -0,0 +1,79 @@
+import {resolveImports} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-export';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not export from a test file.',
+};
+
+// `module.exports` / `exports.foo` / `module.exports.foo` assignment targets.
+function isCommonJsExport(node) {
+	if (node.type !== 'MemberExpression' || node.computed) {
+		return false;
+	}
+
+	const {object} = node;
+
+	// `exports.foo = …`
+	if (object.type === 'Identifier' && object.name === 'exports') {
+		return true;
+	}
+
+	// `module.exports = …` and `module.exports.foo = …`
+	if (object.type === 'Identifier' && object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
+		return true;
+	}
+
+	return (
+		object.type === 'MemberExpression'
+		&& !object.computed
+		&& object.object.type === 'Identifier'
+		&& object.object.name === 'module'
+		&& object.property.type === 'Identifier'
+		&& object.property.name === 'exports'
+	);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const report = node => ({node, messageId: MESSAGE_ID});
+
+	context.on('ExportNamedDeclaration', node => {
+		// `export {}` exports nothing — it is only a marker to make a file a module. Leave it alone.
+		if (!node.declaration && !node.source && node.specifiers.length === 0) {
+			return;
+		}
+
+		return report(node);
+	});
+	context.on('ExportDefaultDeclaration', report);
+	context.on('ExportAllDeclaration', report);
+
+	context.on('AssignmentExpression', node => {
+		if (isCommonJsExport(node.left)) {
+			return {node, messageId: MESSAGE_ID};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow exports from test files.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-identical-assertion-arguments.js

@@ -0,0 +1,71 @@
+import {resolveImports, parseAssertionCall} from './utils/node-test.js';
+import {isSameReference} from './utils/index.js';
+
+const MESSAGE_ID_ALWAYS_PASSES = 'no-identical-assertion-arguments/always-passes';
+const MESSAGE_ID_ALWAYS_FAILS = 'no-identical-assertion-arguments/always-fails';
+
+const messages = {
+	[MESSAGE_ID_ALWAYS_PASSES]: 'Both arguments are the same, so this assertion always passes.',
+	[MESSAGE_ID_ALWAYS_FAILS]: 'Both arguments are the same, so this assertion always fails.',
+};
+
+// Two-operand `node:assert` comparisons. The negated ones always fail on identical operands.
+const POSITIVE_METHODS = new Set(['equal', 'strictEqual', 'deepEqual', 'deepStrictEqual']);
+const NEGATED_METHODS = new Set(['notEqual', 'notStrictEqual', 'notDeepEqual', 'notDeepStrictEqual']);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	// Activate on a `node:assert` import, or in a test file where `t.assert.*` may be used.
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion) {
+			return;
+		}
+
+		const isNegated = NEGATED_METHODS.has(assertion.method);
+		if (!isNegated && !POSITIVE_METHODS.has(assertion.method)) {
+			return;
+		}
+
+		const [first, second] = node.arguments;
+		if (
+			!first
+			|| !second
+			|| first.type === 'SpreadElement'
+			|| second.type === 'SpreadElement'
+		) {
+			return;
+		}
+
+		if (!isSameReference(first, second)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: isNegated ? MESSAGE_ID_ALWAYS_FAILS : MESSAGE_ID_ALWAYS_PASSES,
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow comparing a value to itself in an assertion.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-identical-title.js

@@ -0,0 +1,101 @@
+import {
+	resolveImports,
+	parseTestCall,
+	getTestTitle,
+	getStaticString,
+	getTestCallback,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-identical-title/duplicate';
+
+const messages = {
+	[MESSAGE_ID]: 'Test title is already used by another test in the same scope.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	/*
+	Stack of title sets, one per scope level.
+	The bottom of the stack (index 0) is the module top-level.
+	Each describe/suite callback body pushes a new set on entry and pops it on exit.
+	*/
+	const scopeStack = [new Set()];
+
+	/*
+	Map from a suite callback function node to the call expression that created it,
+	so we can push/pop the scope when entering/exiting the callback body.
+	*/
+	const suiteCallbackNodes = new WeakSet();
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed || parsed.kind === 'hook') {
+			return;
+		}
+
+		// Track suite callbacks for scope push/pop.
+		if (parsed.kind === 'suite') {
+			const callback = getTestCallback(node);
+			if (callback) {
+				suiteCallbackNodes.add(callback);
+			}
+		}
+
+		const titleNode = getTestTitle(node, context);
+		if (!titleNode) {
+			return;
+		}
+
+		const titleValue = getStaticString(titleNode, context);
+		if (titleValue === undefined) {
+			return;
+		}
+
+		const currentScope = scopeStack.at(-1);
+		if (currentScope.has(titleValue)) {
+			return {
+				node: titleNode,
+				messageId: MESSAGE_ID,
+			};
+		}
+
+		currentScope.add(titleValue);
+	});
+
+	// Push/pop a scope around each suite callback body.
+	const functionTypes = ['FunctionExpression', 'ArrowFunctionExpression'];
+
+	context.on(functionTypes, node => {
+		if (suiteCallbackNodes.has(node)) {
+			scopeStack.push(new Set());
+		}
+	});
+
+	context.onExit(functionTypes, node => {
+		if (suiteCallbackNodes.has(node)) {
+			scopeStack.pop();
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow identical test titles within the same scope.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

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

@@ -0,0 +1,100 @@
+import {resolveImports, parseAssertionCall} 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' && (node.name === 'undefined' || node.name === 'NaN' || node.name === 'Infinity'))
+		|| 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;
+	}
+
+	context.on('CallExpression', node => {
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion) {
+			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;
+	});
+};
+
+/** @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 strict equality equivalent instead.',
+		},
+		languages: ['js/js'],
+	},
+};
+
+export default config;

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

@@ -0,0 +1,86 @@
+import {resolveImports, parseAssertionCall} 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;
+	}
+
+	context.on('CallExpression', node => {
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion) {
+			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;
+	});
+};
+
+/** @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;