eslint-node-test 0.0.1

package/rules/require-context-assert-with-plan.js

@@ -0,0 +1,127 @@
+import {
+	resolveImports,
+	parseTestCall,
+	parseAssertionCall,
+	createContextTracker,
+} from './utils/node-test.js';
+
+const MESSAGE_ID = 'require-context-assert-with-plan';
+
+const messages = {
+	[MESSAGE_ID]: 'This assertion is not counted by `{{context}}.plan()`. Use `{{context}}.assert` so the runner counts it toward the plan.',
+};
+
+/** Get the context name of a `<context>.plan(…)` call, or `undefined`. */
+function getPlanContextName(node) {
+	const {callee} = node;
+	if (
+		callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& callee.property.type === 'Identifier'
+		&& callee.property.name === 'plan'
+		&& callee.object.type === 'Identifier'
+	) {
+		return callee.object.name;
+	}
+
+	return undefined;
+}
+
+/** Whether a call is the `<context>.assert.method(…)` form, which the plan does count. */
+function isContextAssertCall(node, tracker) {
+	const {callee} = node;
+	return (
+		callee.type === 'MemberExpression'
+		&& callee.object.type === 'MemberExpression'
+		&& !callee.object.computed
+		&& callee.object.property.type === 'Identifier'
+		&& callee.object.property.name === 'assert'
+		&& callee.object.object.type === 'Identifier'
+		&& tracker.isContextName(callee.object.object.name)
+	);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	// Without a `node:assert` import the only assertions are `t.assert.*` (which count toward the
+	// plan and are excluded below), so there is nothing to report.
+	if (!imports.isTestFile || !imports.hasAssert) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports);
+
+	// One frame per enclosing test/subtest. Assertions attach to the innermost; the frame is
+	// reported only if its test called `plan()`.
+	const frames = [];
+
+	context.on('CallExpression', node => {
+		const isTest = parseTestCall(node, imports)?.kind === 'test' || tracker.isSubtestCall(node);
+		tracker.update(node);
+
+		if (isTest) {
+			frames.push({
+				node, contextName: tracker.current(), hasPlan: false, assertions: [],
+			});
+			return;
+		}
+
+		if (frames.length === 0) {
+			return;
+		}
+
+		const planContextName = getPlanContextName(node);
+		if (planContextName !== undefined) {
+			// Mark the innermost frame whose test owns this context.
+			for (let index = frames.length - 1; index >= 0; index -= 1) {
+				if (frames[index].contextName === planContextName) {
+					frames[index].hasPlan = true;
+					break;
+				}
+			}
+
+			return;
+		}
+
+		if (parseAssertionCall(node, imports) && !isContextAssertCall(node, tracker)) {
+			frames.at(-1).assertions.push(node);
+		}
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+
+		if (frames.at(-1)?.node !== node) {
+			return;
+		}
+
+		const frame = frames.pop();
+		if (!frame.hasPlan || frame.contextName === undefined) {
+			return;
+		}
+
+		return frame.assertions.map(assertion => ({
+			node: assertion,
+			messageId: MESSAGE_ID,
+			data: {context: frame.contextName},
+		}));
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require assertions to use the test context when the test sets a plan.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/require-hook.js

@@ -0,0 +1,108 @@
+import {
+	resolveImports,
+	parseTestCall,
+	parseAssertionCall,
+	getTestCallback,
+} from './utils/node-test.js';
+import isFunction from './ast/is-function.js';
+
+const MESSAGE_ID = 'require-hook';
+
+const messages = {
+	[MESSAGE_ID]: 'This runs when the file is loaded, not as part of a test. Move it into a `before`, `beforeEach`, `after`, or `afterEach` hook.',
+};
+
+/*
+Whether the statement sits directly in a registration-time scope: the module top level or a
+`describe`/`suite` body. Statements inside a test/hook callback or a helper function are fine.
+*/
+function isInRegistrationScope(statement, imports) {
+	const {parent} = statement;
+	if (parent.type === 'Program') {
+		return true;
+	}
+
+	if (parent.type !== 'BlockStatement') {
+		return false;
+	}
+
+	const callback = parent.parent;
+	if (
+		!isFunction(callback)
+		|| callback.parent?.type !== 'CallExpression'
+		|| getTestCallback(callback.parent) !== callback
+	) {
+		return false;
+	}
+
+	return parseTestCall(callback.parent, imports)?.kind === 'suite';
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const allow = new Set(context.options[0].allow);
+
+	context.on('ExpressionStatement', node => {
+		const call = node.expression;
+		if (call.type !== 'CallExpression') {
+			return;
+		}
+
+		// The test/suite/hook registration calls themselves belong here.
+		if (parseTestCall(call, imports)) {
+			return;
+		}
+
+		// Misplaced assertions are reported by `no-assert-in-describe`.
+		if (parseAssertionCall(call, imports)) {
+			return;
+		}
+
+		if (allow.has(sourceCode.getText(call.callee))) {
+			return;
+		}
+
+		if (!isInRegistrationScope(node, imports)) {
+			return;
+		}
+
+		return {node, messageId: MESSAGE_ID};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require setup and teardown code to be inside a hook.',
+			recommended: false,
+		},
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					allow: {
+						type: 'array',
+						items: {type: 'string'},
+						uniqueItems: true,
+						description: 'Callee expressions allowed at the top level (for example, `["console.log"]`).',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{allow: []}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/require-throws-expectation.js

@@ -0,0 +1,52 @@
+import {resolveImports, parseAssertionCall} from './utils/node-test.js';
+
+const MESSAGE_ID = 'require-throws-expectation';
+
+const messages = {
+	[MESSAGE_ID]: '`{{method}}()` accepts any thrown value. Pass an error matcher (error class, `RegExp`, validation object, or function) as the second argument.',
+};
+
+const THROWS_METHODS = new Set(['throws', 'rejects']);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const parsed = parseAssertionCall(node, imports);
+		if (!parsed || !THROWS_METHODS.has(parsed.method)) {
+			return;
+		}
+
+		// Only the single-argument form lacks a matcher. A spread could expand to one.
+		if (node.arguments.length !== 1 || node.arguments[0].type === 'SpreadElement') {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {method: parsed.method},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Require an error matcher for `assert.throws()`/`assert.rejects()`.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/require-top-level-describe.js

@@ -0,0 +1,89 @@
+import {resolveImports, parseTestCall, createSuiteDepthTracker} from './utils/node-test.js';
+
+const MESSAGE_ID_NOT_WRAPPED = 'require-top-level-describe/not-wrapped';
+const MESSAGE_ID_TOO_MANY = 'require-top-level-describe/too-many';
+
+const messages = {
+	[MESSAGE_ID_NOT_WRAPPED]: 'A {{kind}} must be placed inside a top-level `describe`.',
+	[MESSAGE_ID_TOO_MANY]: 'There should be no more than {{max}} top-level `describe` blocks in a file.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	const maxTopLevelDescribes = context.options[0]?.maxTopLevelDescribes;
+
+	const tracker = createSuiteDepthTracker();
+	let topLevelDescribeCount = 0;
+
+	context.on('CallExpression', node => {
+		const parsed = parseTestCall(node, imports);
+		if (!parsed) {
+			return;
+		}
+
+		let problem;
+		if (tracker.depth === 0) {
+			if (parsed.kind === 'test' || parsed.kind === 'hook') {
+				problem = {
+					node,
+					messageId: MESSAGE_ID_NOT_WRAPPED,
+					data: {kind: parsed.kind === 'hook' ? 'hook' : 'test'},
+				};
+			} else if (parsed.kind === 'suite') {
+				topLevelDescribeCount += 1;
+				if (maxTopLevelDescribes !== undefined && topLevelDescribeCount > maxTopLevelDescribes) {
+					problem = {
+						node,
+						messageId: MESSAGE_ID_TOO_MANY,
+						data: {max: maxTopLevelDescribes},
+					};
+				}
+			}
+		}
+
+		if (parsed.kind === 'suite') {
+			tracker.enterSuite(node);
+		}
+
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.exitSuite(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require tests and hooks to be inside a top-level `describe`.',
+			recommended: false,
+		},
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					maxTopLevelDescribes: {
+						type: 'integer',
+						minimum: 1,
+						description: 'The maximum number of top-level `describe` blocks allowed in a file.',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/rule/index.js

@@ -0,0 +1,9 @@
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornCreate} from './to-eslint-create.js';
+@import {UnicornRule} from './to-eslint-rule.js';
+@import {UnicornContext} from './unicorn-context.js';
+@import {TSESTree as Estree} from '@typescript-eslint/types';
+*/
+
+export {default as toEslintRules} from './to-eslint-rules.js';

package/rules/rule/to-eslint-create.js

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import createUnicornContext from './unicorn-context.js';
+import UnicornListeners from './unicorn-listeners.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornContext} from './unicorn-context.js';
+@import {EslintListers, ListenerType, EslintListener} from './to-eslint-listener.js'
+*/
+
+/**
+@typedef {ESLint.Rule.RuleModule['create']} EslintCreate
+@typedef {(context: UnicornContext) => void} UnicornCreate
+*/
+
+/**
+Convert Unicorn style of `create` to ESLint style
+
+@param {UnicornCreate} unicornCreate
+@returns {EslintCreate}
+*/
+function toEslintCreate(unicornCreate) {
+	return eslintContext => {
+		const unicornListeners = new UnicornListeners(eslintContext);
+		const unicornContext = createUnicornContext(eslintContext, unicornListeners);
+
+		const result = unicornCreate(unicornContext);
+
+		assert.equal(result, undefined, `[${eslintContext.id}] Rule \`create\` function should return \`undefined\`, please use \`context.on()\` instead of return listeners.`);
+
+		const eslintListeners = unicornListeners.toEslintListeners();
+
+		return eslintListeners;
+	};
+}
+
+export default toEslintCreate;

package/rules/rule/to-eslint-listener.js

@@ -0,0 +1,40 @@
+import {iterateFixOrProblems} from './utilities.js';
+import toEslintProblem from './to-eslint-problem.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornContext} from './unicorn-context.js'
+@import {UnicornProblems} from './to-eslint-problem.js'
+*/
+
+/**
+@typedef {ESLint.Rule.RuleListener} EslintListers
+@typedef {keyof EslintListers} ListenerType
+@typedef {EslintListers[ListenerType]} EslintListener
+@typedef {(...listenerArguments: Parameters<EslintListener>) => UnicornProblems} UnicornRuleListen
+*/
+
+/**
+@param {UnicornContext} context
+@param {UnicornRuleListen} listener
+@returns {Listener}
+*/
+function toEslintListener(context, listener) {
+	// Listener arguments can be `codePath, node` or `node`
+
+	/**
+	@type {UnicornRuleListen}
+	*/
+	return (...listenerArguments) => {
+		const unicornProblems = listener(...listenerArguments);
+
+		for (const unicornProblem of iterateFixOrProblems(unicornProblems)) {
+			if (unicornProblem) {
+				const eslintProblem = toEslintProblem(unicornProblem);
+				context.report(eslintProblem);
+			}
+		}
+	};
+}
+
+export default toEslintListener;

package/rules/rule/to-eslint-problem.js

@@ -0,0 +1,38 @@
+import toEslintFixer from './to-eslint-rule-fixer.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@typedef {Parameters<ESLint.Rule.RuleContext['report']>[0]} EslintProblem
+@typedef {EslintProblem} UnicornProblem
+@typedef {EslintProblem | undefined | EslintProblem[] | IterableIterator<EslintProblem>} UnicornProblems
+*/
+
+/**
+@param {UnicornProblem} unicornProblem
+@returns {EslintProblem}
+*/
+function toEslintProblem(unicornProblem) {
+	const eslintProblem = {...unicornProblem};
+
+	if (unicornProblem.fix) {
+		eslintProblem.fix = toEslintFixer(unicornProblem.fix);
+	}
+
+	if (Array.isArray(unicornProblem.suggest)) {
+		eslintProblem.suggest = unicornProblem.suggest.map(unicornSuggest => ({
+			...unicornSuggest,
+			fix: toEslintFixer(unicornSuggest.fix),
+			data: {
+				...unicornProblem.data,
+				...unicornSuggest.data,
+			},
+		}));
+	}
+
+	return eslintProblem;
+}
+
+export default toEslintProblem;

package/rules/rule/to-eslint-rule-fixer.js

@@ -0,0 +1,49 @@
+import {iterateFixOrProblems} from './utilities.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+class FixAbortError extends Error {
+	name = 'FixAbortError';
+}
+
+const fixOptions = {
+	abort() {
+		throw new FixAbortError('Fix aborted.');
+	},
+};
+
+/**
+@typedef {ESLint.Rule.ReportFixer | undefined} EslintReportFixer
+@typedef {EslintReportFixer | IterableIterator<EslintReportFixer>} UnicornReportFixer
+@typedef {(fixer: ESLint.Rule.RuleFixer, options: typeof fixOptions) => UnicornReportFixer} UnicornRuleFixer
+*/
+
+/**
+Convert Unicorn style fix function to ESLint style fix function
+
+@param {UnicornRuleFixer} fix
+@returns {ESLint.Rule.RuleFixer}
+*/
+function toEslintRuleFixer(fix) {
+	/** @param {UnicornReportFixer} fixer */
+	return fixer => {
+		const unicornReport = fix(fixer, fixOptions);
+
+		const eslintReport = iterateFixOrProblems(unicornReport);
+
+		try {
+			return [...eslintReport];
+		} catch (error) {
+			if (error instanceof FixAbortError) {
+				return;
+			}
+
+			/* c8 ignore next */
+			throw error;
+		}
+	};
+}
+
+export default toEslintRuleFixer;

package/rules/rule/to-eslint-rule.js

@@ -0,0 +1,38 @@
+import getDocumentationUrl from '../utils/get-documentation-url.js';
+import toEslintCreate from './to-eslint-create.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornCreate} from './to-eslint-create.js';
+*/
+
+/**
+@typedef {ESLint.Rule.RuleModule & {
+	create: UnicornCreate
+}} UnicornRule
+*/
+
+/**
+Convert Unicorn rule to ESLint rule
+
+@param {string} ruleId
+@param {UnicornRule} unicornRule
+@returns {ESLint.Rule.RuleModule}
+*/
+function toEslintRule(ruleId, unicornRule) {
+	return {
+		meta: {
+			// If there are no options, add `[]` so ESLint can validate that no data is passed to the rule.
+			// https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-schema.md
+			schema: [],
+			...unicornRule.meta,
+			docs: {
+				...unicornRule.meta.docs,
+				url: getDocumentationUrl(ruleId),
+			},
+		},
+		create: toEslintCreate(unicornRule.create),
+	};
+}
+
+export default toEslintRule;

package/rules/rule/to-eslint-rules.js

@@ -0,0 +1,10 @@
+import toEslintRule from './to-eslint-rule.js';
+
+function toEslintRules(rules) {
+	return Object.fromEntries(Object.entries(rules).map(([ruleId, rule]) => [
+		ruleId,
+		toEslintRule(ruleId, rule),
+	]));
+}
+
+export default toEslintRules;

package/rules/rule/unicorn-context.js

@@ -0,0 +1,36 @@
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornListeners, ListenerType, Listener} from './to-eslint-create.js'
+*/
+
+/**
+@typedef {(type: ListenerType | ListenerType[], listener: Listener) => ReturnType<Listener>} UnicornRuleListen
+@typedef {ESLint.Rule.RuleContext & {
+	on: UnicornRuleListen
+	onExit: UnicornRuleListen
+}} UnicornContext
+*/
+
+/**
+Create a better `Context` object with `on` and `onExit` method to add listeners
+
+@param {ESLint.Rule.RuleContext} eslintContext
+@param {UnicornListeners} listeners
+@returns {UnicornContext}
+*/
+function createUnicornContext(eslintContext, listeners) {
+	/** @type {UnicornContext} */
+	const context = new Proxy(eslintContext, {
+		get(target, property, receiver) {
+			if (property === 'on' || property === 'onExit') {
+				return listeners[property].bind(listeners);
+			}
+
+			return Reflect.get(target, property, receiver);
+		},
+	});
+
+	return context;
+}
+
+export default createUnicornContext;