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

package/rules/no-duplicate-assertions.js

@@ -0,0 +1,172 @@
+import {
+	resolveImports,
+	parseTestCall,
+	parseAssertionCall,
+	getTestCallback,
+	createContextTracker,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID = 'no-duplicate-assertions';
+
+const messages = {
+	[MESSAGE_ID]: 'Duplicate adjacent assertion.',
+};
+
+const STRICT_MODE_METHODS = new Map([
+	['equal', 'strictEqual'],
+	['notEqual', 'notStrictEqual'],
+	['deepEqual', 'deepStrictEqual'],
+	['notDeepEqual', 'notDeepStrictEqual'],
+]);
+
+function getAssertionMethod(assertion) {
+	if (assertion.isStrict && STRICT_MODE_METHODS.has(assertion.method)) {
+		return STRICT_MODE_METHODS.get(assertion.method);
+	}
+
+	return assertion.method;
+}
+
+function getTestContextAssertionName(node) {
+	const {callee} = node;
+	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 undefined;
+	}
+
+	return callee.object.object.name;
+}
+
+function getAssertionKey(assertionExpression, context, imports, tracker) {
+	const {node, isAwaited} = assertionExpression;
+	const assertion = parseAssertionCall(node, imports);
+	const testContextName = getTestContextAssertionName(node);
+	if (
+		!assertion
+		|| (
+			testContextName !== undefined
+			&& !tracker.isContextName(testContextName)
+		)
+	) {
+		return undefined;
+	}
+
+	const argumentKeys = node.arguments.map(argument => {
+		if (argument.type === 'SpreadElement') {
+			return `...${context.sourceCode.getText(unwrapTypeScriptExpression(argument.argument))}`;
+		}
+
+		return context.sourceCode.getText(unwrapTypeScriptExpression(argument));
+	});
+
+	return JSON.stringify([isAwaited, getAssertionMethod(assertion), argumentKeys]);
+}
+
+function getAssertionExpression(statement) {
+	if (statement.type !== 'ExpressionStatement') {
+		return undefined;
+	}
+
+	const {expression} = statement;
+	if (expression.type === 'CallExpression') {
+		return {
+			node: expression,
+			isAwaited: false,
+		};
+	}
+
+	if (
+		expression.type === 'AwaitExpression'
+		&& expression.argument.type === 'CallExpression'
+	) {
+		return {
+			node: expression.argument,
+			isAwaited: true,
+		};
+	}
+
+	return undefined;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports);
+	const testCallbackBodies = new WeakSet();
+
+	context.on('CallExpression', node => {
+		const isTest = parseTestCall(node, imports)?.kind === 'test' || tracker.isSubtestCall(node);
+		tracker.update(node);
+
+		const callback = getTestCallback(node);
+		if (
+			!isTest
+			|| !callback
+			|| callback.body.type !== 'BlockStatement'
+		) {
+			return;
+		}
+
+		testCallbackBodies.add(callback.body);
+	});
+
+	context.onExit('BlockStatement', function * (node) {
+		if (!testCallbackBodies.has(node)) {
+			return;
+		}
+
+		let previousAssertionKey;
+		for (const statement of node.body) {
+			const assertionExpression = getAssertionExpression(statement);
+			const assertionKey = assertionExpression
+				&& getAssertionKey(assertionExpression, context, imports, tracker);
+
+			if (!assertionKey) {
+				previousAssertionKey = undefined;
+				continue;
+			}
+
+			if (assertionKey === previousAssertionKey) {
+				yield {
+					node: statement,
+					messageId: MESSAGE_ID,
+				};
+			}
+
+			previousAssertionKey = assertionKey;
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow adjacent duplicate assertions.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-duplicate-hooks.js

@@ -0,0 +1,75 @@
+import {resolveImports, parseTestCall, getTestCallback} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-duplicate-hooks';
+
+const messages = {
+	[MESSAGE_ID]: 'Duplicate `{{name}}` hook in the same scope.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	// Stack of scopes; each scope tracks the hook names already declared in it.
+	const scopeStack = [new Set()];
+	// Calls whose callback opened a scope, so we can pop on exit.
+	const pushedCalls = new Set();
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed) {
+			return;
+		}
+
+		let problem;
+		if (parsed.kind === 'hook') {
+			const scope = scopeStack.at(-1);
+			if (scope.has(parsed.name)) {
+				problem = {
+					node,
+					messageId: MESSAGE_ID,
+					data: {name: parsed.name},
+				};
+			} else {
+				scope.add(parsed.name);
+			}
+		} else if (parsed.kind === 'test' || parsed.kind === 'suite') {
+			const callback = getTestCallback(node);
+			if (callback) {
+				scopeStack.push(new Set());
+				pushedCalls.add(node);
+			}
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		if (!pushedCalls.has(node)) {
+			return;
+		}
+
+		pushedCalls.delete(node);
+		scopeStack.pop();
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow duplicate hooks within the same scope.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-duplicate-plan.js

@@ -0,0 +1,209 @@
+import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
+import {
+	MODIFIERS,
+	resolveImports,
+	parseTestCall,
+	getTestCallback,
+	getSubtestReceiver,
+	getTestOptions,
+	findOptionsProperty,
+} from './utils/node-test.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID_DUPLICATE_CALL = 'no-duplicate-plan/duplicate-call';
+const MESSAGE_ID_PLAN_OPTION = 'no-duplicate-plan/plan-option';
+const MAX_PLAN_COUNT = 4_294_967_295;
+
+const messages = {
+	[MESSAGE_ID_DUPLICATE_CALL]: 'Do not call `{{context}}.plan()` more than once in the same test.',
+	[MESSAGE_ID_PLAN_OPTION]: 'Do not call `{{context}}.plan()` when this test already has a `plan` option.',
+};
+
+function getPlanContextIdentifier(node) {
+	const {callee} = node;
+	if (
+		node.optional !== true
+		&& callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.optional !== true
+		&& callee.property.type === 'Identifier'
+		&& callee.property.name === 'plan'
+	) {
+		const object = unwrapTypeScriptExpression(callee.object);
+		return object.type === 'Identifier' ? object : undefined;
+	}
+
+	return undefined;
+}
+
+function getIdentifierVariable(sourceCode, identifier) {
+	return findVariable(sourceCode.getScope(identifier), identifier);
+}
+
+function isTestCall(parsed) {
+	return parsed !== undefined && parsed.kind === 'test' && parsed.modifiers.every(modifier => MODIFIERS.has(modifier.name));
+}
+
+function hasSkipModifier(node) {
+	node = unwrapTypeScriptExpression(node);
+
+	while (node.type === 'MemberExpression') {
+		if (
+			!node.computed
+			&& node.property.type === 'Identifier'
+			&& node.property.name === 'skip'
+		) {
+			return true;
+		}
+
+		node = unwrapTypeScriptExpression(node.object);
+	}
+
+	return false;
+}
+
+function hasEnabledSkipOption(node, sourceCode) {
+	const property = findOptionsProperty(getTestOptions(node), 'skip');
+	if (property === undefined) {
+		return false;
+	}
+
+	const staticValue = getStaticValue(property.value, sourceCode.getScope(property.value));
+	return staticValue !== null && Boolean(staticValue.value);
+}
+
+function isSkippedTestCall(node, sourceCode) {
+	return hasSkipModifier(node.callee) || hasEnabledSkipOption(node, sourceCode);
+}
+
+function hasEnabledPlanOption(node, sourceCode) {
+	const property = findOptionsProperty(getTestOptions(node), 'plan');
+	if (property === undefined) {
+		return false;
+	}
+
+	const staticValue = getStaticValue(property.value, sourceCode.getScope(property.value));
+	return typeof staticValue?.value === 'number' && Number.isSafeInteger(staticValue.value) && staticValue.value > 0 && staticValue.value <= MAX_PLAN_COUNT;
+}
+
+function isInsideSkippedCallback(node, skippedCallbacks) {
+	let current = node;
+	while (current) {
+		if (skippedCallbacks.has(current)) {
+			return true;
+		}
+
+		current = current.parent;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const {sourceCode} = context;
+	const frames = [];
+	const skippedCallbacks = new WeakSet();
+
+	const isSubtestCall = node => {
+		const receiver = getSubtestReceiver(node);
+		if (receiver === undefined) {
+			return false;
+		}
+
+		const receiverVariable = getIdentifierVariable(sourceCode, receiver);
+		return receiverVariable !== undefined && frames.some(frame => frame.contextVariable === receiverVariable);
+	};
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		const isImportedTestCall = isTestCall(parsed);
+		const isTest = isImportedTestCall || isSubtestCall(node);
+
+		if (isTest) {
+			if (isSkippedTestCall(node, sourceCode)) {
+				const callback = getTestCallback(node);
+				if (callback) {
+					skippedCallbacks.add(callback);
+				}
+
+				return;
+			}
+
+			const parameter = getTestCallback(node)?.params[0];
+			if (parameter?.type !== 'Identifier') {
+				return;
+			}
+
+			const hasPlanOption = hasEnabledPlanOption(node, sourceCode);
+			frames.push({
+				node,
+				contextName: parameter.name,
+				contextVariable: getIdentifierVariable(sourceCode, parameter),
+				hasPlan: hasPlanOption,
+				hasPlanOption,
+			});
+			return;
+		}
+
+		const contextIdentifier = getPlanContextIdentifier(node);
+		if (contextIdentifier === undefined) {
+			return;
+		}
+
+		if (isInsideSkippedCallback(node, skippedCallbacks)) {
+			return;
+		}
+
+		const contextVariable = getIdentifierVariable(sourceCode, contextIdentifier);
+		if (contextVariable === undefined) {
+			return;
+		}
+
+		for (let index = frames.length - 1; index >= 0; index -= 1) {
+			const frame = frames[index];
+			if (frame.contextVariable !== contextVariable) {
+				continue;
+			}
+
+			if (frame.hasPlan) {
+				return {
+					node,
+					messageId: frame.hasPlanOption ? MESSAGE_ID_PLAN_OPTION : MESSAGE_ID_DUPLICATE_CALL,
+					data: {context: frame.contextName},
+				};
+			}
+
+			frame.hasPlan = true;
+			break;
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		if (frames.at(-1)?.node === node) {
+			frames.pop();
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow setting a test plan more than once in the same test.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/no-export.js

@@ -0,0 +1,45 @@
+import {resolveImports} from './utils/node-test.js';
+
+const MESSAGE_ID = 'no-export';
+
+const messages = {
+	[MESSAGE_ID]: 'Do not export from a test file.',
+};
+
+/** @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);
+};
+
+/** @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,84 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} 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;
+	}
+
+	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 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,
+		};
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @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;