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

package/rules/no-assert-throws-multiple-statements.js

@@ -0,0 +1,194 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	resolveImports,
+	parseAssertionCall,
+	parseTestCall,
+	getTestCallback,
+	getSubtestReceiver,
+} from './utils/node-test.js';
+import isFunction from './ast/is-function.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'no-assert-throws-multiple-statements';
+
+const messages = {
+	[MESSAGE_ID]: 'Keep the `{{method}}()` callback to one statement so unrelated setup errors cannot satisfy the assertion.',
+};
+
+const TARGET_METHODS = new Set(['throws', 'rejects']);
+
+function getCalleeRootIdentifier(node) {
+	let current = node;
+	while (current.type === 'MemberExpression' && !current.computed) {
+		current = current.object;
+	}
+
+	if (current.type === 'Identifier') {
+		return current;
+	}
+}
+
+function isImportBinding(identifier, sourceCode) {
+	const variable = findVariable(sourceCode.getScope(identifier), identifier);
+
+	return variable?.defs.some(({type}) => type === 'ImportBinding') === true;
+}
+
+function getImportedTestReceiver(callExpression, imports) {
+	const receiver = getCalleeRootIdentifier(callExpression.callee);
+	if (
+		receiver
+		&& (
+			receiver.name === imports.namespace
+			|| imports.locals.has(receiver.name)
+		)
+	) {
+		return receiver;
+	}
+}
+
+function isImportedTestCall(callExpression, imports, sourceCode) {
+	const receiver = getImportedTestReceiver(callExpression, imports);
+
+	return receiver !== undefined && isImportBinding(receiver, sourceCode);
+}
+
+function getImportedAssertReceiver(callExpression, imports) {
+	const {callee} = callExpression;
+	if (
+		callee.type === 'Identifier'
+		&& (
+			imports.assertNamed.has(callee.name)
+			|| imports.assertNamespace.has(callee.name)
+		)
+	) {
+		return callee;
+	}
+
+	if (
+		callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.object.type === 'Identifier'
+		&& (
+			imports.assertNamespace.has(callee.object.name)
+			|| imports.assertNamed.get(callee.object.name) === 'strict'
+		)
+	) {
+		return callee.object;
+	}
+
+	if (
+		callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.object.type === 'MemberExpression'
+		&& !callee.object.computed
+		&& callee.object.object.type === 'Identifier'
+		&& callee.object.property.type === 'Identifier'
+		&& callee.object.property.name === 'strict'
+		&& imports.assertNamespace.has(callee.object.object.name)
+	) {
+		return callee.object.object;
+	}
+}
+
+function getContextAssertReceiver(callee) {
+	if (
+		callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.object.type === 'MemberExpression'
+		&& !callee.object.computed
+		&& callee.object.object.type === 'Identifier'
+		&& callee.object.property.type === 'Identifier'
+		&& callee.object.property.name === 'assert'
+	) {
+		return callee.object.object;
+	}
+}
+
+function isKnownContextReceiver(receiver, contextParameters, sourceCode) {
+	const variable = findVariable(sourceCode.getScope(receiver), receiver);
+
+	return variable?.defs.some(({name}) => contextParameters.has(name)) === true;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const contextParameters = new WeakSet();
+
+	function rememberContextParameter(node) {
+		const parsed = parseTestCall(node, imports);
+		const subtestReceiver = getSubtestReceiver(node);
+		const isTest = parsed?.kind === 'test' && isImportedTestCall(node, imports, sourceCode);
+		const isSubtest = subtestReceiver && isKnownContextReceiver(subtestReceiver, contextParameters, sourceCode);
+		if (
+			!isTest
+			&& !isSubtest
+		) {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		const parameter = callback?.params[0];
+		if (parameter?.type === 'Identifier') {
+			contextParameters.add(parameter);
+		}
+	}
+
+	context.on('CallExpression', node => {
+		rememberContextParameter(node);
+
+		const parsed = parseAssertionCall(node, imports);
+		if (!parsed || !TARGET_METHODS.has(parsed.method)) {
+			return;
+		}
+
+		const importedAssertReceiver = getImportedAssertReceiver(node, imports);
+		if (importedAssertReceiver && !isImportBinding(importedAssertReceiver, sourceCode)) {
+			return;
+		}
+
+		const contextAssertReceiver = getContextAssertReceiver(node.callee);
+		if (contextAssertReceiver && !isKnownContextReceiver(contextAssertReceiver, contextParameters, sourceCode)) {
+			return;
+		}
+
+		const [firstArgument] = node.arguments;
+		if (!firstArgument || firstArgument.type === 'SpreadElement') {
+			return;
+		}
+
+		const callback = unwrapTypeScriptExpression(firstArgument);
+		if (!isFunction(callback) || callback.body.type !== 'BlockStatement' || callback.body.body.length <= 1) {
+			return;
+		}
+
+		return {
+			node: callback.body,
+			messageId: MESSAGE_ID,
+			data: {method: parsed.method},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow multiple statements in `assert.throws()`/`assert.rejects()` callbacks.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-assert-throws-string.js

@@ -0,0 +1,78 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+import {isStringExpression} from './ast/index.js';
+
+const MESSAGE_ID_ERROR = 'no-assert-throws-string/error';
+const MESSAGE_ID_SUGGESTION = 'no-assert-throws-string/suggestion';
+
+const messages = {
+	[MESSAGE_ID_ERROR]: 'The second argument to `{{method}}()` is the failure message, not an error matcher, so the thrown error is not validated.',
+	[MESSAGE_ID_SUGGESTION]: 'Match the error message with `{message: …}`.',
+};
+
+const THROWS_METHODS = new Set(['throws', 'rejects']);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports, {trackHooks: true});
+
+	context.on('CallExpression', node => {
+		tracker.update(node);
+
+		const parsed = parseAssertionCall(node, imports);
+		if (!parsed || !THROWS_METHODS.has(parsed.method) || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		const errorArgument = node.arguments[1];
+		if (!errorArgument || !isStringExpression(unwrapTypeScriptExpression(errorArgument))) {
+			return;
+		}
+
+		return {
+			node: errorArgument,
+			messageId: MESSAGE_ID_ERROR,
+			data: {method: parsed.method},
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix: fixer => fixer.replaceText(errorArgument, `{message: ${sourceCode.getText(errorArgument)}}`),
+				},
+			],
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow a string as the error matcher of `assert.throws()`/`assert.rejects()`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-async-describe.js

@@ -0,0 +1,50 @@
+import {resolveImports, parseTestCall, getTestCallback} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-async-describe';
+
+const messages = {
+	[MESSAGE_ID]: '`node:test` does not await a `{{name}}` callback, so any test registered after an `await` is silently dropped. Make the callback synchronous.',
+};
+
+/** @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 !== 'suite') {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		if (!callback?.async) {
+			return;
+		}
+
+		return {
+			node: callback,
+			messageId: MESSAGE_ID,
+			data: {name: parsed.name},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow `async` `describe` callbacks.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-async-fn-without-await.js

@@ -0,0 +1,74 @@
+import {resolveImports, parseTestCall, getTestCallback} from './utils/node-test.js';
+import containsSuspensionPoint from './utils/contains-suspension-point.js';
+
+const MESSAGE_ID = 'no-async-fn-without-await/error';
+const MESSAGE_ID_SUGGESTION = 'no-async-fn-without-await/suggestion';
+
+const messages = {
+	[MESSAGE_ID]: 'Async test/hook function has no `await` expression.',
+	[MESSAGE_ID_SUGGESTION]: 'Remove the `async` keyword.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		// Suites are handled by `no-async-describe`, which forbids an async `describe` callback
+		// outright (the runner never awaits it), so skip them here to avoid a duplicate report.
+		if (!parsed || parsed.kind === 'suite') {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		if (!callback?.async) {
+			return;
+		}
+
+		// Check if the async function body contains any suspension point at its own level.
+		// containsSuspensionPoint does not descend into nested functions.
+		if (containsSuspensionPoint(callback.body, sourceCode.visitorKeys)) {
+			return;
+		}
+
+		const asyncToken = sourceCode.getFirstToken(callback, token => token.value === 'async');
+
+		return {
+			node: asyncToken,
+			messageId: MESSAGE_ID,
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix(fixer) {
+						const nextToken = sourceCode.getTokenAfter(asyncToken);
+						return fixer.removeRange([sourceCode.getRange(asyncToken)[0], sourceCode.getRange(nextToken)[0]]);
+					},
+				},
+			],
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow async test/hook functions that have no `await` expression.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-callback-and-promise.js

@@ -0,0 +1,56 @@
+import {
+	resolveImports,
+	parseTestCall,
+	getTestCallback,
+	getEffectiveArity,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-callback-and-promise';
+
+const messages = {
+	[MESSAGE_ID]: 'A {{kind}} cannot use both a callback parameter and a Promise; this `async` function also declares a callback.',
+};
+
+/** @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);
+		// Suite (`describe`/`suite`) callbacks receive a `SuiteContext`, never a `done` callback.
+		if (parsed?.kind !== 'test' && parsed?.kind !== 'hook') {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		if (!callback?.async || getEffectiveArity(callback.params) < 2) {
+			return;
+		}
+
+		return {
+			node: callback.params[1],
+			messageId: MESSAGE_ID,
+			data: {kind: parsed.kind === 'hook' ? 'hook' : 'test'},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow a test or hook from using both a callback and a Promise.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-commented-tests.js

@@ -0,0 +1,64 @@
+import getComments from './utils/get-comments.js';
+
+const MESSAGE_ID = 'no-commented-tests/error';
+
+const messages = {
+	[MESSAGE_ID]: 'Use `.skip()` or remove the commented-out test instead of commenting it out.',
+};
+
+// Matches lines that look like commented-out test/hook calls from node:test.
+// Anchored at start-of-line (with optional leading whitespace and block comment asterisk).
+// Matches: test(, it(, describe(, suite(, before(, after(, beforeEach(, afterEach(
+// and dotted modifier variants like test.only(, it.skip(, describe.todo(, etc.
+// Only the real node:test modifiers are allowed in the chain, so unrelated method calls like
+// `it.each(` or `test.config(` are not misidentified as commented-out tests.
+const COMMENTED_TEST_PATTERN = /^\s*\*?\s*(?:test|it|describe|suite|before|after|beforeEach|afterEach)\s*(?:\.\s*(?:only|skip|todo)\s*)*\(/v;
+
+// Reports the first line of the comment that looks like a commented-out test.
+function reportFirstMatch(context, comment) {
+	const lines = comment.value.split('\n');
+	const commentStartLine = context.sourceCode.getLoc(comment).start.line;
+	for (const [index, line] of lines.entries()) {
+		if (COMMENTED_TEST_PATTERN.test(line)) {
+			context.report({
+				loc: {
+					line: commentStartLine + index,
+					column: 0,
+				},
+				messageId: MESSAGE_ID,
+			});
+			return;
+		}
+	}
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('Program:exit', () => {
+		for (const comment of getComments(context)) {
+			// Skip JSDoc-style block comments (/** ... */).
+			if (comment.type === 'Block' && context.sourceCode.getText(comment).startsWith('/**')) {
+				continue;
+			}
+
+			reportFirstMatch(context, comment);
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow commented-out tests.',
+			recommended: false,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-compound-assertion.js

@@ -0,0 +1,131 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'no-compound-assertion';
+
+const messages = {
+	[MESSAGE_ID]: 'Split this compound assertion into separate assertions so the failing operand is clear.',
+};
+
+function getConjunctionOperands(node) {
+	const unwrappedNode = unwrapTypeScriptExpression(node);
+
+	if (unwrappedNode.type !== 'LogicalExpression' || unwrappedNode.operator !== '&&') {
+		return [node];
+	}
+
+	return [
+		...getConjunctionOperands(unwrappedNode.left),
+		...getConjunctionOperands(unwrappedNode.right),
+	];
+}
+
+function getIndent(sourceCode, node) {
+	const prefix = sourceCode.lines[sourceCode.getLoc(node).start.line - 1].slice(0, sourceCode.getLoc(node).start.column);
+	return /^\s*$/.test(prefix) ? prefix : undefined;
+}
+
+function hasOnlyWhitespaceAfterStatement(sourceCode, node) {
+	const location = sourceCode.getLoc(node);
+	const suffix = sourceCode.lines[location.end.line - 1].slice(location.end.column);
+	return /^\s*$/.test(suffix);
+}
+
+function getOperandText(sourceCode, operand) {
+	const text = sourceCode.getText(operand);
+	return operand.type === 'SequenceExpression' ? `(${text})` : text;
+}
+
+function buildFix({node, operands, sourceCode}) {
+	return fixer => {
+		if (
+			node.arguments.length !== 1
+			|| node.parent.type !== 'ExpressionStatement'
+			|| !['Program', 'BlockStatement'].includes(node.parent.parent.type)
+			|| sourceCode.getCommentsInside(node.parent).length > 0
+			|| !hasOnlyWhitespaceAfterStatement(sourceCode, node.parent)
+		) {
+			return undefined;
+		}
+
+		const callee = sourceCode.getText(node.callee);
+		const indent = getIndent(sourceCode, node.parent);
+		if (indent === undefined) {
+			return undefined;
+		}
+
+		const replacement = operands
+			.map(operand => `${callee}(${getOperandText(sourceCode, operand)});`)
+			.join(`\n${indent}`);
+
+		return fixer.replaceText(node.parent, replacement);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const contextTracker = createContextTracker(imports, {trackHooks: true});
+
+	context.on('CallExpression', node => {
+		contextTracker.update(node);
+
+		const assertion = parseAssertionCall(node, imports);
+		if (assertion?.method !== 'ok') {
+			return;
+		}
+
+		if (assertion.contextReceiver && !contextTracker.isContextIdentifier(assertion.contextReceiver)) {
+			return;
+		}
+
+		const [firstArgument] = node.arguments;
+		if (!firstArgument || firstArgument.type === 'SpreadElement') {
+			return;
+		}
+
+		const argument = unwrapTypeScriptExpression(firstArgument);
+		if (argument.type !== 'LogicalExpression' || argument.operator !== '&&') {
+			return;
+		}
+
+		const operands = getConjunctionOperands(argument);
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			fix: buildFix({node, operands, sourceCode}),
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		contextTracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow compound truthiness assertions.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;