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

package/rules/require-mock-timers-advance.js

@@ -0,0 +1,313 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	resolveImports,
+	parseTestCall,
+	getTestCallback,
+	getSubtestReceiver,
+	HOOK_FUNCTIONS,
+	isGlobalMock,
+	MODIFIERS,
+} from './utils/node-test.js';
+import {getEnclosingFunction} from './utils/index.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'require-mock-timers-advance';
+const messages = {
+	[MESSAGE_ID]: '`mock.timers.enable()` must be followed by `tick()` or `runAll()` so mocked timer callbacks can run.',
+};
+
+const ADVANCE_METHODS = new Set(['tick', 'runAll']);
+
+function getStaticPropertyName(node) {
+	if (node.type === 'Identifier') {
+		return node.name;
+	}
+
+	if (node.type === 'Literal' && typeof node.value === 'string') {
+		return node.value;
+	}
+}
+
+function getPropertyName(property) {
+	if (property.type !== 'Property') {
+		return;
+	}
+
+	if (!property.computed) {
+		return getStaticPropertyName(property.key);
+	}
+
+	if (property.key.type === 'Literal' && typeof property.key.value === 'string') {
+		return property.key.value;
+	}
+}
+
+function isDynamicProperty(property) {
+	return property.type === 'Property' && property.computed && property.key.type !== 'Literal';
+}
+
+function mayEnableTimerApis(callExpression) {
+	const argument = unwrapTypeScriptExpression(callExpression.arguments[0]);
+	if (argument?.type !== 'ObjectExpression') {
+		return true;
+	}
+
+	let apisValue;
+	for (const property of argument.properties) {
+		if (property.type === 'SpreadElement') {
+			if (apisValue) {
+				return true;
+			}
+
+			continue;
+		}
+
+		if (getPropertyName(property) === 'apis') {
+			apisValue = property.value;
+		} else if (apisValue && isDynamicProperty(property)) {
+			return true;
+		}
+	}
+
+	if (!apisValue) {
+		return true;
+	}
+
+	const unwrappedApisValue = unwrapTypeScriptExpression(apisValue);
+	if (unwrappedApisValue.type !== 'ArrayExpression') {
+		return true;
+	}
+
+	for (const rawElement of unwrappedApisValue.elements) {
+		const element = rawElement && unwrapTypeScriptExpression(rawElement);
+		if (!element) {
+			continue;
+		}
+
+		if (element.type !== 'Literal' || typeof element.value !== 'string') {
+			return true;
+		}
+
+		if (element.value === 'Date') {
+			continue;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+function isImportedIdentifier(node, sourceCode) {
+	const variable = findVariable(sourceCode.getScope(node), node);
+	return variable?.defs.some(({type}) => type === 'ImportBinding') ?? false;
+}
+
+function getMockTimersReceiverKey(node, imports, sourceCode, contextVariables) {
+	if (
+		node.type !== 'MemberExpression'
+		|| node.computed
+		|| node.optional
+		|| getStaticPropertyName(node.property) !== 'timers'
+	) {
+		return;
+	}
+
+	if (isGlobalMock(node.object, imports)) {
+		return 'global';
+	}
+
+	if (
+		node.object.type === 'MemberExpression'
+		&& !node.object.computed
+		&& !node.object.optional
+		&& getStaticPropertyName(node.object.property) === 'mock'
+		&& node.object.object.type === 'Identifier'
+	) {
+		const variable = findVariable(sourceCode.getScope(node.object.object), node.object.object);
+		if (!variable || !contextVariables.includes(variable)) {
+			return;
+		}
+
+		return `context:${node.object.object.name}`;
+	}
+}
+
+function getMockTimersCall(callExpression, imports, sourceCode, contextVariables) {
+	const {callee} = callExpression;
+	if (
+		callee.type !== 'MemberExpression'
+		|| callee.computed
+		|| callee.optional
+	) {
+		return;
+	}
+
+	const method = getStaticPropertyName(callee.property);
+	const receiverKey = getMockTimersReceiverKey(callee.object, imports, sourceCode, contextVariables);
+	if (!method || !receiverKey) {
+		return;
+	}
+
+	return {method, receiverKey};
+}
+
+function satisfyPending(scope, receiverKey) {
+	for (const pending of scope.pending) {
+		if (!pending.satisfied && pending.receiverKey === receiverKey) {
+			pending.satisfied = true;
+		}
+	}
+}
+
+function getContextVariable(callback, sourceCode) {
+	const [parameter] = callback.params;
+	if (parameter?.type !== 'Identifier') {
+		return;
+	}
+
+	return findVariable(sourceCode.getScope(parameter), parameter);
+}
+
+function getCalleeRootIdentifier(node) {
+	while (
+		node.type === 'MemberExpression'
+		&& !node.computed
+		&& !node.optional
+	) {
+		node = node.object;
+	}
+
+	return node.type === 'Identifier' ? node : undefined;
+}
+
+function getContextVariables(scopeStack) {
+	return scopeStack
+		.map(scope => scope.contextVariable)
+		.filter(Boolean);
+}
+
+function getContextCallKind(node, sourceCode, contextVariables) {
+	const receiver = getSubtestReceiver(node);
+	if (receiver) {
+		const receiverVariable = findVariable(sourceCode.getScope(receiver), receiver);
+		return receiverVariable && contextVariables.includes(receiverVariable) ? 'test' : undefined;
+	}
+
+	const {callee} = node;
+	if (
+		callee.type !== 'MemberExpression'
+		|| callee.computed
+		|| callee.optional
+		|| callee.object.type !== 'Identifier'
+		|| !HOOK_FUNCTIONS.has(getStaticPropertyName(callee.property))
+	) {
+		return;
+	}
+
+	const receiverVariable = findVariable(sourceCode.getScope(callee.object), callee.object);
+	return receiverVariable && contextVariables.includes(receiverVariable) ? 'hook' : undefined;
+}
+
+function getScopeCallback(node, imports, sourceCode, contextVariables) {
+	const parsed = parseTestCall(node, imports);
+	const root = getCalleeRootIdentifier(node.callee);
+	if (
+		(parsed?.kind === 'test' || parsed?.kind === 'hook')
+		&& parsed.modifiers.every(modifier => MODIFIERS.has(modifier.name))
+		&& root
+		&& isImportedIdentifier(root, sourceCode)
+	) {
+		return getTestCallback(node);
+	}
+
+	const contextCallKind = getContextCallKind(node, sourceCode, contextVariables);
+	return contextCallKind === 'test' || contextCallKind === 'hook' ? getTestCallback(node) : undefined;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const scopeStack = [];
+
+	context.on('CallExpression', node => {
+		const callback = getScopeCallback(node, imports, sourceCode, getContextVariables(scopeStack));
+		if (callback) {
+			const contextVariable = getContextVariable(callback, sourceCode);
+			scopeStack.push({
+				callNode: node,
+				callback,
+				contextVariable,
+				pending: [],
+			});
+		}
+
+		if (scopeStack.length === 0) {
+			return;
+		}
+
+		const currentScope = scopeStack.at(-1);
+		if (getEnclosingFunction(node) !== currentScope.callback) {
+			return;
+		}
+
+		const timersCall = getMockTimersCall(node, imports, sourceCode, getContextVariables(scopeStack));
+		if (timersCall && ADVANCE_METHODS.has(timersCall.method)) {
+			satisfyPending(currentScope, timersCall.receiverKey);
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		let problems;
+		const currentScope = scopeStack.at(-1);
+		if (currentScope?.callNode === node) {
+			scopeStack.pop();
+			problems = currentScope.pending
+				.filter(pending => !pending.satisfied)
+				.map(pending => ({
+					node: pending.node,
+					messageId: pending.messageId,
+				}));
+		}
+
+		const newCurrentScope = scopeStack.at(-1);
+		if (
+			newCurrentScope
+			&& getEnclosingFunction(node) === newCurrentScope.callback
+		) {
+			const timersCall = getMockTimersCall(node, imports, sourceCode, getContextVariables(scopeStack));
+			if (timersCall?.method === 'enable' && mayEnableTimerApis(node)) {
+				newCurrentScope.pending.push({
+					node,
+					messageId: MESSAGE_ID,
+					receiverKey: timersCall.receiverKey,
+					satisfied: false,
+				});
+			}
+		}
+
+		return problems;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require mock timers to be advanced after enabling timer APIs.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/require-mock-timers-apis.js

@@ -0,0 +1,383 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {isFunction} from './ast/index.js';
+import {
+	getSubtestReceiver,
+	getTestCallback,
+	MODIFIERS,
+	parseTestCall,
+	resolveImports,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'require-mock-timers-apis';
+const CONTEXT_HOOKS = new Set(['before', 'beforeEach', 'after', 'afterEach']);
+const TEST_MODULES = new Set(['node:test', 'test']);
+const STATIC_NON_OPTIONS_VALUE_TYPES = new Set(['ArrayExpression', 'Literal', 'TemplateLiteral']);
+
+const messages = {
+	[MESSAGE_ID]: '`mock.timers.enable()` should explicitly specify the `apis` option to avoid unexpectedly mocking `Date`.',
+};
+
+function isMissingApisValue(node) {
+	const expression = unwrapTypeScriptExpression(node);
+	if (!expression) {
+		return true;
+	}
+
+	return (
+		(expression.type === 'Identifier' && expression.name === 'undefined')
+		|| (expression.type === 'UnaryExpression' && expression.operator === 'void')
+		|| (expression.type === 'Literal' && !expression.value)
+	);
+}
+
+function isStaticNonOptionsValue(node) {
+	return STATIC_NON_OPTIONS_VALUE_TYPES.has(node.type);
+}
+
+function isApisProperty(property) {
+	return property.type === 'Property'
+		&& !property.computed
+		&& (
+			(property.key.type === 'Identifier' && property.key.name === 'apis')
+			|| (property.key.type === 'Literal' && property.key.value === 'apis')
+		);
+}
+
+function getLastVisibleApisProperty(optionsObject) {
+	for (let index = optionsObject.properties.length - 1; index >= 0; index -= 1) {
+		const property = optionsObject.properties[index];
+		if (property.type === 'SpreadElement') {
+			return undefined;
+		}
+
+		if (isApisProperty(property)) {
+			return property;
+		}
+	}
+
+	return undefined;
+}
+
+function isImportedReference(node, sourceCode) {
+	const variable = findVariable(sourceCode.getScope(node), node);
+	return variable?.defs.some(({type}) => type === 'ImportBinding') ?? false;
+}
+
+function isMissingApisOption(callExpression) {
+	const firstArgument = unwrapTypeScriptExpression(callExpression.arguments[0]);
+	if (!firstArgument) {
+		return true;
+	}
+
+	if (isMissingApisValue(firstArgument)) {
+		return true;
+	}
+
+	if (firstArgument.type !== 'ObjectExpression') {
+		return isStaticNonOptionsValue(firstArgument);
+	}
+
+	const apisProperty = getLastVisibleApisProperty(firstArgument);
+	return !apisProperty || isMissingApisValue(apisProperty.value);
+}
+
+function isContextProvidingCall(testCall) {
+	if (testCall.kind === 'hook') {
+		return testCall.modifiers.length === 0;
+	}
+
+	return testCall.kind === 'test'
+		&& testCall.modifiers.every(modifier => MODIFIERS.has(modifier.name));
+}
+
+function getParameterIdentifier(parameter) {
+	if (parameter?.type === 'Identifier') {
+		return parameter;
+	}
+
+	if (parameter?.type === 'AssignmentPattern' && parameter.left.type === 'Identifier') {
+		return parameter.left;
+	}
+
+	return undefined;
+}
+
+function getContextHookReceiver(callExpression) {
+	const {callee} = callExpression;
+	if (
+		callee.type !== 'MemberExpression'
+		|| callee.computed
+		|| callee.property.type !== 'Identifier'
+		|| !CONTEXT_HOOKS.has(callee.property.name)
+	) {
+		return undefined;
+	}
+
+	const receiver = unwrapTypeScriptExpression(callee.object);
+	return receiver.type === 'Identifier' ? receiver : undefined;
+}
+
+function getTestContextImportLocals(sourceCode) {
+	const locals = new Set();
+
+	for (const node of sourceCode.ast.body) {
+		if (node.type !== 'ImportDeclaration' || !TEST_MODULES.has(node.source.value)) {
+			continue;
+		}
+
+		for (const specifier of node.specifiers) {
+			if (
+				specifier.type === 'ImportSpecifier'
+				&& specifier.imported.type === 'Identifier'
+				&& specifier.imported.name === 'getTestContext'
+			) {
+				locals.add(specifier.local.name);
+			}
+		}
+	}
+
+	return locals;
+}
+
+function getHookCallback(callExpression) {
+	const firstArgument = unwrapTypeScriptExpression(callExpression.arguments[0]);
+	return isFunction(firstArgument) ? firstArgument : undefined;
+}
+
+function getLocalTestHookCall(callExpression, imports, sourceCode) {
+	const callee = unwrapTypeScriptExpression(callExpression.callee);
+	if (
+		callee.type !== 'MemberExpression'
+		|| callee.computed
+		|| callee.property.type !== 'Identifier'
+		|| !CONTEXT_HOOKS.has(callee.property.name)
+	) {
+		return undefined;
+	}
+
+	const object = unwrapTypeScriptExpression(callee.object);
+	if (
+		object.type !== 'Identifier'
+		|| !['test', 'it'].includes(imports.locals.get(object.name))
+		|| !isImportedReference(object, sourceCode)
+	) {
+		return undefined;
+	}
+
+	return {
+		name: callee.property.name,
+		kind: 'hook',
+		modifiers: [],
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	const testContextLocals = getTestContextImportLocals(sourceCode);
+	if (!imports.isTestFile && testContextLocals.size === 0) {
+		return;
+	}
+
+	const contextVariables = [];
+	const pushedCalls = new Set();
+
+	const getImportedContextCall = node => {
+		const testCall = parseTestCall(node, imports);
+		if (testCall !== undefined && isContextProvidingCall(testCall)) {
+			return testCall;
+		}
+
+		return getLocalTestHookCall(node, imports, sourceCode);
+	};
+
+	const isSubtestCall = node => {
+		const receiver = getSubtestReceiver(node);
+		if (!receiver) {
+			return false;
+		}
+
+		const variable = findVariable(sourceCode.getScope(receiver), receiver);
+		return variable !== undefined && contextVariables.includes(variable);
+	};
+
+	const isContextHookCall = node => {
+		const receiver = getContextHookReceiver(node);
+		if (!receiver) {
+			return false;
+		}
+
+		const variable = findVariable(sourceCode.getScope(receiver), receiver);
+		return variable !== undefined && contextVariables.includes(variable);
+	};
+
+	const updateContext = node => {
+		const importedContextCall = getImportedContextCall(node);
+		const isContextHook = isContextHookCall(node);
+		if (!importedContextCall && !isSubtestCall(node) && !isContextHook) {
+			return;
+		}
+
+		const callback = importedContextCall?.kind === 'hook' || isContextHook
+			? getHookCallback(node)
+			: getTestCallback(node);
+		if (!callback) {
+			return;
+		}
+
+		const parameter = getParameterIdentifier(callback.params[0]);
+		const variable = parameter
+			? findVariable(sourceCode.getScope(parameter), parameter)
+			: undefined;
+
+		contextVariables.push(variable);
+		pushedCalls.add(node);
+	};
+
+	const leaveContext = node => {
+		if (!pushedCalls.has(node)) {
+			return;
+		}
+
+		pushedCalls.delete(node);
+		contextVariables.pop();
+	};
+
+	const isGlobalMock = node => {
+		const expression = unwrapTypeScriptExpression(node);
+		if (
+			expression.type === 'Identifier'
+			&& imports.mockLocals.has(expression.name)
+			&& isImportedReference(expression, sourceCode)
+		) {
+			return true;
+		}
+
+		if (
+			expression.type !== 'MemberExpression'
+			|| expression.computed
+			|| expression.property.type !== 'Identifier'
+			|| expression.property.name !== 'mock'
+		) {
+			return false;
+		}
+
+		const object = unwrapTypeScriptExpression(expression.object);
+		return object.type === 'Identifier'
+			&& (
+				object.name === imports.namespace
+				|| imports.locals.get(object.name) === 'test'
+				|| imports.locals.get(object.name) === 'it'
+			)
+			&& isImportedReference(object, sourceCode);
+	};
+
+	const isCurrentContextReference = node => {
+		const variable = findVariable(sourceCode.getScope(node), node);
+		return variable !== undefined && contextVariables.includes(variable);
+	};
+
+	const isGetTestContextCall = node => {
+		if (node.type !== 'CallExpression') {
+			return false;
+		}
+
+		const callee = unwrapTypeScriptExpression(node.callee);
+		if (
+			callee.type === 'Identifier'
+			&& testContextLocals.has(callee.name)
+			&& isImportedReference(callee, sourceCode)
+		) {
+			return true;
+		}
+
+		if (
+			callee.type !== 'MemberExpression'
+			|| callee.computed
+			|| callee.property.type !== 'Identifier'
+			|| callee.property.name !== 'getTestContext'
+		) {
+			return false;
+		}
+
+		const object = unwrapTypeScriptExpression(callee.object);
+		return object.type === 'Identifier'
+			&& (
+				object.name === imports.namespace
+				|| imports.locals.get(object.name) === 'test'
+				|| imports.locals.get(object.name) === 'it'
+			)
+			&& isImportedReference(object, sourceCode);
+	};
+
+	const isContextMock = node => {
+		const expression = unwrapTypeScriptExpression(node);
+		if (
+			expression.type !== 'MemberExpression'
+			|| expression.computed
+			|| expression.property.type !== 'Identifier'
+			|| expression.property.name !== 'mock'
+		) {
+			return false;
+		}
+
+		const object = unwrapTypeScriptExpression(expression.object);
+		return (
+			(object.type === 'Identifier' && isCurrentContextReference(object))
+			|| isGetTestContextCall(object)
+		);
+	};
+
+	const isMockTimers = node => {
+		const expression = unwrapTypeScriptExpression(node);
+		return expression.type === 'MemberExpression'
+			&& !expression.computed
+			&& expression.property.type === 'Identifier'
+			&& expression.property.name === 'timers'
+			&& (isGlobalMock(expression.object) || isContextMock(expression.object));
+	};
+
+	context.on('CallExpression', node => {
+		updateContext(node);
+	});
+
+	context.onExit('CallExpression', node => {
+		leaveContext(node);
+	});
+
+	context.on('CallExpression', node => {
+		const callee = unwrapTypeScriptExpression(node.callee);
+		if (
+			callee.type === 'MemberExpression'
+			&& !callee.computed
+			&& callee.property.type === 'Identifier'
+			&& callee.property.name === 'enable'
+			&& isMockTimers(callee.object)
+			&& isMissingApisOption(node)
+		) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require an explicit `apis` option when enabling `mock.timers`.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;