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

package/rules/max-assertions.js

@@ -0,0 +1,88 @@
+import {
+	resolveImports,
+	parseTestCall,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'max-assertions';
+
+const messages = {
+	[MESSAGE_ID]: 'Too many assertions ({{count}}). Maximum allowed is {{max}}.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const {max} = context.options[0];
+	const tracker = createContextTracker(imports);
+
+	// One frame per enclosing test/subtest; assertions count toward the innermost.
+	const frames = [];
+
+	context.on('CallExpression', node => {
+		const isTest = parseTestCall(node, imports)?.kind === 'test' || tracker.isSubtestCall(node);
+		tracker.update(node);
+
+		if (isTest) {
+			frames.push({node, count: 0});
+			return;
+		}
+
+		if (frames.length > 0 && parseAssertionCall(node, imports) && isAssertionCallWithSupportedContext(node, tracker)) {
+			frames.at(-1).count += 1;
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+
+		if (frames.at(-1)?.node !== node) {
+			return;
+		}
+
+		const {count} = frames.pop();
+		if (count > max) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				data: {count, max},
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce a maximum number of assertions in a test.',
+			recommended: false,
+		},
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					max: {
+						type: 'integer',
+						minimum: 1,
+						description: 'The maximum number of assertions allowed in a test.',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{max: 5}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/max-nested-describe.js

@@ -0,0 +1,70 @@
+import {resolveImports, parseTestCall, createSuiteDepthTracker} from './utils/node-test.js';
+
+const MESSAGE_ID = 'max-nested-describe';
+
+const messages = {
+	[MESSAGE_ID]: 'Describe blocks are nested too deeply ({{depth}}). Maximum allowed is {{max}}.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const {max} = context.options[0];
+
+	const tracker = createSuiteDepthTracker();
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (parsed?.kind !== 'suite') {
+			return;
+		}
+
+		tracker.enterSuite(node);
+
+		if (tracker.depth > max) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				data: {depth: tracker.depth, max},
+			};
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.exitSuite(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce a maximum depth for nested `describe` blocks.',
+			recommended: true,
+		},
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					max: {
+						type: 'integer',
+						minimum: 1,
+						description: 'The maximum allowed depth of nested `describe` blocks.',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{max: 5}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-assert-in-describe.js

@@ -0,0 +1,61 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	nearestTestCallbackKind,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-assert-in-describe';
+
+const messages = {
+	[MESSAGE_ID]: 'Assertion runs when the suite is built, not when a test runs. Move it into a test or hook.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports);
+
+	context.on('CallExpression', node => {
+		tracker.update(node);
+
+		if (!parseAssertionCall(node, imports) || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		if (nearestTestCallbackKind(node, imports) !== 'suite') {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow assertions directly inside a `describe` body.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-assert-in-hook.js

@@ -0,0 +1,61 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	nearestTestCallbackKind,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-assert-in-hook';
+
+const messages = {
+	[MESSAGE_ID]: 'Avoid assertions inside a hook. A hook failure is attributed to every affected test rather than reported as a focused failure. Assert inside a test instead.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports, {trackHooks: true});
+
+	context.on('CallExpression', node => {
+		tracker.update(node);
+
+		if (!parseAssertionCall(node, imports) || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		if (nearestTestCallbackKind(node, imports) !== 'hook') {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow assertions inside hooks.',
+			recommended: false,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

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

@@ -0,0 +1,166 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import {isStringExpression, getStaticStringValue} from './ast/index.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID_ERROR = 'no-assert-match-string/error';
+const MESSAGE_ID_REGEXP_SUGGESTION = 'no-assert-match-string/regexp-suggestion';
+const MESSAGE_ID_ASSERTION_SUGGESTION = 'no-assert-match-string/assertion-suggestion';
+
+const messages = {
+	[MESSAGE_ID_ERROR]: 'The second argument to `{{method}}()` must be a `RegExp`, not a string.',
+	[MESSAGE_ID_REGEXP_SUGGESTION]: 'Wrap the string in `new RegExp()`.',
+	[MESSAGE_ID_ASSERTION_SUGGESTION]: 'Compare with `{{replacementMethod}}()`.',
+};
+
+const MATCH_METHODS = new Set(['match', 'doesNotMatch']);
+const EQUALITY_METHODS = new Map([
+	['match', 'strictEqual'],
+	['doesNotMatch', 'notStrictEqual'],
+]);
+
+function canConvertToRegExp(node) {
+	const value = getStaticStringValue(unwrapTypeScriptExpression(node));
+	if (value === undefined) {
+		return false;
+	}
+
+	try {
+		const regexp = new RegExp(value);
+		return regexp instanceof RegExp;
+	} catch {
+		return false;
+	}
+}
+
+function getSuggestions({node, parsed, regexpArgument, sourceCode}) {
+	const suggestions = [];
+
+	if (canConvertToRegExp(regexpArgument)) {
+		suggestions.push({
+			messageId: MESSAGE_ID_REGEXP_SUGGESTION,
+			fix: fixer => fixer.replaceText(regexpArgument, `new RegExp(${sourceCode.getText(regexpArgument)})`),
+		});
+	}
+
+	const replacementMethod = EQUALITY_METHODS.get(parsed.method);
+	if (
+		replacementMethod
+		&& parsed.methodNode
+		&& node.callee.type !== 'Identifier'
+	) {
+		const methodReplacementRange = getMethodReplacementRange(node, parsed, sourceCode);
+		if (methodReplacementRange) {
+			suggestions.push({
+				messageId: MESSAGE_ID_ASSERTION_SUGGESTION,
+				data: {replacementMethod},
+				fix: fixer => fixer.replaceTextRange(methodReplacementRange, replacementMethod),
+			});
+		}
+	}
+
+	return suggestions;
+}
+
+function getMethodReplacementRange(node, parsed, sourceCode) {
+	const {callee} = node;
+	if (
+		callee.type === 'MemberExpression'
+		&& callee.object.type === 'MemberExpression'
+		&& !callee.object.computed
+		&& callee.object.property.type === 'Identifier'
+		&& callee.object.property.name === 'strict'
+	) {
+		const range = [
+			sourceCode.getRange(callee.object.property)[0],
+			sourceCode.getRange(parsed.methodNode)[1],
+		];
+		if (hasCommentInRange(sourceCode, callee, range)) {
+			return undefined;
+		}
+
+		return range;
+	}
+
+	return sourceCode.getRange(parsed.methodNode);
+}
+
+function hasCommentInRange(sourceCode, node, range) {
+	return sourceCode.getCommentsInside(node).some(comment => {
+		const commentRange = sourceCode.getRange(comment);
+		return commentRange[0] >= range[0] && commentRange[1] <= range[1];
+	});
+}
+
+/** @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 || !MATCH_METHODS.has(parsed.method) || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		const regexpArgument = node.arguments[1];
+		if (
+			!regexpArgument
+			|| regexpArgument.type === 'SpreadElement'
+			|| !isStringExpression(unwrapTypeScriptExpression(regexpArgument))
+		) {
+			return;
+		}
+
+		const problem = {
+			node: regexpArgument,
+			messageId: MESSAGE_ID_ERROR,
+			data: {method: parsed.method},
+		};
+
+		const suggestions = getSuggestions({
+			node,
+			parsed,
+			regexpArgument,
+			sourceCode,
+		});
+		if (suggestions.length > 0) {
+			problem.suggest = suggestions;
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow strings as the regexp argument of `assert.match()`/`assert.doesNotMatch()`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

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

@@ -0,0 +1,113 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import isFunction from './ast/is-function.js';
+import {getEnclosingFunction} from './utils/index.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID_ERROR = 'no-assert-throws-async/error';
+const MESSAGE_ID_SUGGESTION = 'no-assert-throws-async/suggestion';
+
+const messages = {
+	[MESSAGE_ID_ERROR]: '`{{method}}` does not catch an async function, which never throws synchronously. Use `{{replacement}}` instead.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace with `{{replacement}}`.',
+};
+
+const SYNC_TO_ASYNC = new Map([
+	['throws', 'rejects'],
+	['doesNotThrow', 'doesNotReject'],
+]);
+
+/** @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 = SYNC_TO_ASYNC.get(assertion.method);
+		if (!replacement) {
+			return;
+		}
+
+		const [firstArgument] = node.arguments;
+		if (!firstArgument) {
+			return;
+		}
+
+		const callback = unwrapTypeScriptExpression(firstArgument);
+		if (!isFunction(callback) || !callback.async) {
+			return;
+		}
+
+		const {callee} = node;
+		const data = {method: assertion.method, replacement};
+		const problem = {
+			node: callee,
+			messageId: MESSAGE_ID_ERROR,
+			data,
+		};
+
+		// Only the member forms (`assert.throws`, `t.assert.throws`) can be rewritten. A bare named
+		// import (`throws`) would reference an unimported `rejects`, so leave it reported but unfixed.
+		if (callee.type === 'MemberExpression') {
+			const isAwaited = node.parent?.type === 'AwaitExpression';
+			const enclosingFunction = getEnclosingFunction(node);
+			// Prepend `await` only where it is both valid and needed: a bare call statement inside an
+			// async function. Otherwise just switch the method and let `no-unawaited-rejects` guide the await.
+			const shouldAwait = !isAwaited
+				&& node.parent?.type === 'ExpressionStatement'
+				&& enclosingFunction?.async === true;
+
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					data,
+					* fix(fixer) {
+						yield fixer.replaceText(callee.property, replacement);
+						if (shouldAwait) {
+							yield fixer.insertTextBefore(node, 'await ');
+						}
+					},
+				},
+			];
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow passing an async function to `assert.throws()`/`assert.doesNotThrow()`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

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

@@ -0,0 +1,106 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID_ERROR = 'no-assert-throws-call/error';
+const MESSAGE_ID_SUGGESTION = 'no-assert-throws-call/suggestion';
+
+const messages = {
+	[MESSAGE_ID_ERROR]: '`{{method}}()` expects a function callback. This call runs before the assertion can catch it.',
+	[MESSAGE_ID_SUGGESTION]: 'Wrap the call in an arrow function.',
+};
+
+function unwrapExpression(node) {
+	node = unwrapTypeScriptExpression(node);
+
+	while (node.type === 'ChainExpression') {
+		node = unwrapTypeScriptExpression(node.expression);
+	}
+
+	return node;
+}
+
+function isBindCall(node) {
+	const {callee} = node;
+
+	return callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.property.type === 'Identifier'
+		&& callee.property.name === 'bind';
+}
+
+function isFunctionConstructorCall(node) {
+	return node.callee.type === 'Identifier' && node.callee.name === 'Function';
+}
+
+function isFunctionProducingCall(node) {
+	return isBindCall(node) || isFunctionConstructorCall(node);
+}
+
+/** @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 assertion = parseAssertionCall(node, imports);
+		if (!assertion || assertion.method !== 'throws' || !isAssertionCallWithSupportedContext(node, tracker)) {
+			return;
+		}
+
+		const [firstArgument] = node.arguments;
+		if (!firstArgument || firstArgument.type === 'SpreadElement') {
+			return;
+		}
+
+		const call = unwrapExpression(firstArgument);
+		if (call.type !== 'CallExpression' || isFunctionProducingCall(call)) {
+			return;
+		}
+
+		return {
+			node: firstArgument,
+			messageId: MESSAGE_ID_ERROR,
+			data: {method: assertion.method},
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix: fixer => fixer.replaceText(firstArgument, `() => ${sourceCode.getText(firstArgument)}`),
+				},
+			],
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow calling the function passed to `assert.throws()`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;