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

package/rules/no-snapshot-in-loop.js

@@ -0,0 +1,132 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	resolveImports,
+	createContextTracker,
+	getCalleeChain,
+} from './utils/node-test.js';
+import {isLoop, isFunction} from './ast/index.js';
+
+const MESSAGE_ID = 'no-snapshot-in-loop';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not use positional snapshots inside loops. Changing the iteration count shifts every following snapshot.',
+};
+
+function isInCurrentCallback(node, tracker) {
+	const callback = tracker.currentCallback();
+	if (!callback) {
+		return false;
+	}
+
+	let current = node.parent;
+	while (current) {
+		if (current === callback) {
+			return true;
+		}
+
+		if (isFunction(current)) {
+			return false;
+		}
+
+		current = current.parent;
+	}
+
+	return false;
+}
+
+function isCurrentContextReference(node, tracker, sourceCode) {
+	const parameter = tracker.currentCallback()?.params[0];
+	if (
+		parameter?.type !== 'Identifier'
+		|| node.name !== parameter.name
+	) {
+		return false;
+	}
+
+	const variable = findVariable(sourceCode.getScope(node), node);
+	return variable?.defs.some(definition => definition.name === parameter) ?? false;
+}
+
+function isCurrentContextSnapshotCall(node, tracker, sourceCode) {
+	const chain = getCalleeChain(node.callee);
+	return (
+		chain?.members.length === 2
+		&& chain.members[0].name === 'assert'
+		&& chain.members[1].name === 'snapshot'
+		&& isInCurrentCallback(node, tracker)
+		&& isCurrentContextReference(chain.root, tracker, sourceCode)
+	);
+}
+
+function isInLoopBody(node) {
+	let child = node;
+	let current = node.parent;
+
+	while (current) {
+		if (isFunction(current)) {
+			return false;
+		}
+
+		if (
+			isLoop(current)
+			&& current.body === child
+		) {
+			return true;
+		}
+
+		child = current;
+		current = current.parent;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports);
+
+	context.on('CallExpression', node => {
+		let problem;
+
+		if (
+			isCurrentContextSnapshotCall(node, tracker, sourceCode)
+			&& isInLoopBody(node)
+		) {
+			problem = {
+				node,
+				messageId: MESSAGE_ID,
+			};
+		}
+
+		tracker.update(node);
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow snapshot assertions inside loop bodies.',
+			recommended: false,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-standalone-assert.js

@@ -0,0 +1,51 @@
+import {resolveImports, parseAssertionCall} from './utils/node-test.js';
+import isFunction from './ast/is-function.js';
+
+const MESSAGE_ID = 'no-standalone-assert';
+
+const messages = {
+	[MESSAGE_ID]: 'Assertion runs when the module is loaded, not as part of a test. Move it into a test or hook.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile || !imports.hasAssert) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		if (!parseAssertionCall(node, imports)) {
+			return;
+		}
+
+		// Any enclosing function (test/hook callback or a helper) means it is not standalone.
+		for (let current = node.parent; current; current = current.parent) {
+			if (isFunction(current)) {
+				return;
+			}
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow assertions outside of a test.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-test-inside-hook.js

@@ -0,0 +1,68 @@
+import {resolveImports, parseTestCall, getHookCallback} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-test-inside-hook';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not define a test or suite inside a hook. Define it at the top level or inside a `describe`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	// Stack of hook callback function nodes we are currently inside.
+	const hookCallbackStack = [];
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed) {
+			return;
+		}
+
+		if ((parsed.kind === 'test' || parsed.kind === 'suite') && hookCallbackStack.length > 0) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+			};
+		}
+
+		if (parsed.kind === 'hook') {
+			const callback = getHookCallback(node);
+			if (callback) {
+				hookCallbackStack.push(callback);
+			}
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (parsed?.kind !== 'hook') {
+			return;
+		}
+
+		const callback = getHookCallback(node);
+		if (callback && hookCallbackStack.at(-1) === callback) {
+			hookCallbackStack.pop();
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow defining tests and suites inside a hook.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-test-return-statement.js

@@ -0,0 +1,217 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	HOOK_FUNCTIONS,
+	MODIFIERS,
+	resolveImports,
+	parseTestCall,
+	getHookCallback,
+	getTestCallback,
+	getSubtestReceiver,
+	isHookMemberTestCall,
+} from './utils/node-test.js';
+import isFunction from './ast/is-function.js';
+import isPromiseType from './utils/is-promise-type.js';
+
+const MESSAGE_ID = 'no-test-return-statement';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not return a concrete value from a test or hook. Return a Promise to signal async completion, or return nothing.',
+};
+
+// "Nothing" types and types we cannot pin down, all fine to return.
+const ALLOWED_TYPE_STRINGS = new Set(['void', 'undefined', 'null', 'any', 'never', 'unknown']);
+
+/*
+Whether the type is safe to return from a test or hook: a returned Promise (awaited by `node:test`),
+a "nothing" type, or a type we cannot resolve. Anything else is a concrete value.
+*/
+function isAllowedReturnType(type, checker) {
+	if (type.isUnion()) {
+		return type.types.every(member => isAllowedReturnType(member, checker));
+	}
+
+	// `isPromiseType` returns `undefined` when indeterminate; only a definite `false` is a value.
+	if (isPromiseType(type, checker) !== false) {
+		return true;
+	}
+
+	return ALLOWED_TYPE_STRINGS.has(checker.typeToString(type));
+}
+
+function isDisallowedReturnValue(node, parserServices, checker) {
+	let type;
+	try {
+		type = parserServices.getTypeAtLocation(node);
+	} catch {
+		return false;
+	}
+
+	return !isAllowedReturnType(type, checker);
+}
+
+function getCallbackContextVariable(callback, sourceCode) {
+	const parameter = callback.params[0];
+	if (parameter?.type !== 'Identifier') {
+		return undefined;
+	}
+
+	return sourceCode.getDeclaredVariables(callback).find(variable => variable.identifiers.includes(parameter));
+}
+
+function isContextReference(node, state) {
+	if (node?.type !== 'Identifier') {
+		return false;
+	}
+
+	const variable = findVariable(state.sourceCode.getScope(node), node);
+	return variable !== undefined && state.contextVariables.includes(variable);
+}
+
+function isContextHookCall(callExpression, state) {
+	const {callee} = callExpression;
+	return callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.object.type === 'Identifier'
+		&& isContextReference(callee.object, state)
+		&& callee.property.type === 'Identifier'
+		&& HOOK_FUNCTIONS.has(callee.property.name);
+}
+
+function isContextSubtestCall(callExpression, state) {
+	const receiver = getSubtestReceiver(callExpression);
+	return receiver !== undefined && isContextReference(receiver, state);
+}
+
+function getCheckedCallback(callExpression, state) {
+	const parsed = parseTestCall(callExpression, state.imports);
+	if (isHookMemberTestCall(parsed)) {
+		return getHookCallback(callExpression);
+	}
+
+	if (parsed?.kind === 'test') {
+		if (parsed.modifiers.some(modifier => !MODIFIERS.has(modifier.name))) {
+			return undefined;
+		}
+
+		return getTestCallback(callExpression);
+	}
+
+	if (parsed?.kind === 'hook' && parsed.modifiers.length === 0) {
+		return getHookCallback(callExpression);
+	}
+
+	if (isContextSubtestCall(callExpression, state)) {
+		return getTestCallback(callExpression);
+	}
+
+	if (isContextHookCall(callExpression, state)) {
+		return getHookCallback(callExpression);
+	}
+
+	return undefined;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	// This rule relies on type information to tell a Promise from a plain value. Without it
+	// (plain JavaScript, or TypeScript linted without a program), do nothing.
+	const {parserServices} = context.sourceCode;
+	if (!parserServices?.program) {
+		return;
+	}
+
+	const checker = parserServices.program.getTypeChecker();
+	const checkedCallbacks = new Set();
+	const state = {
+		imports,
+		sourceCode,
+		contextVariables: [],
+	};
+	const contextCalls = new Set();
+
+	context.on('CallExpression', node => {
+		const callback = getCheckedCallback(node, state);
+		if (!callback) {
+			return;
+		}
+
+		checkedCallbacks.add(callback);
+		state.contextVariables.push(getCallbackContextVariable(callback, sourceCode));
+		contextCalls.add(node);
+
+		if (
+			callback.type === 'ArrowFunctionExpression'
+			&& callback.body.type !== 'BlockStatement'
+			&& !callback.async
+			&& isDisallowedReturnValue(callback.body, parserServices, checker)
+		) {
+			return {
+				node: callback.body,
+				messageId: MESSAGE_ID,
+			};
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		if (!contextCalls.has(node)) {
+			return;
+		}
+
+		contextCalls.delete(node);
+		state.contextVariables.pop();
+	});
+
+	context.on('ReturnStatement', node => {
+		if (!node.argument) {
+			return;
+		}
+
+		// The return must belong to the test/hook callback itself, not a nested helper function.
+		let enclosing = node.parent;
+		while (enclosing && !isFunction(enclosing)) {
+			enclosing = enclosing.parent;
+		}
+
+		if (!enclosing || !checkedCallbacks.has(enclosing)) {
+			return;
+		}
+
+		// An `async` function always wraps its return value in a Promise, which `node:test`
+		// awaits, so returning a plain value there is fine.
+		if (enclosing.async) {
+			return;
+		}
+
+		if (!isDisallowedReturnValue(node.argument, parserServices, checker)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow returning a concrete non-Promise value from a test or hook.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-todo-test.js

@@ -0,0 +1,11 @@
+import createTestModifierRule from './shared/test-modifier-rule.js';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = createTestModifierRule({
+	modifier: 'todo',
+	description: 'Disallow the `.todo` test modifier.',
+	errorMessage: 'Do not commit `.todo` tests.',
+	recommended: false,
+});
+
+export default config;