eslint-node-test 0.0.1

package/configs/core-rule-replacements.js

@@ -0,0 +1,9 @@
+const coreRuleReplacements = [
+	'id-match',
+	'logical-assignment-operators',
+	'no-negated-condition',
+	'no-nested-ternary',
+	'no-process-exit',
+];
+
+export default coreRuleReplacements;

package/configs/flat-config-base.js

@@ -0,0 +1,9 @@
+import globals from 'globals';
+
+const config = {
+	languageOptions: {
+		globals: globals.builtin,
+	},
+};
+
+export default config;

package/index.d.ts

@@ -0,0 +1,11 @@
+import type {ESLint, Linter} from 'eslint';
+
+declare const eslintNodeTest: ESLint.Plugin & {
+	configs: {
+		recommended: Linter.Config;
+		unopinionated: Linter.Config;
+		all: Linter.Config;
+	};
+};
+
+export default eslintNodeTest;

package/index.js

@@ -0,0 +1,51 @@
+import flatConfigBase from './configs/flat-config-base.js';
+import * as rawRules from './rules/index.js';
+import {toEslintRules} from './rules/rule/index.js';
+import packageJson from './package.json' with {type: 'json'};
+
+const rules = toEslintRules(rawRules);
+
+const recommendedRules = Object.fromEntries(Object.entries(rules).map(([id, rule]) => [
+	`node-test/${id}`,
+	rule.meta.docs.recommended ? 'error' : 'off',
+]));
+
+const unopinionatedRules = Object.fromEntries(Object.entries(rules).map(([id, rule]) => [
+	`node-test/${id}`,
+	rule.meta.docs.recommended === 'unopinionated' ? 'error' : 'off',
+]));
+
+const allRules = Object.fromEntries(Object.keys(rules).map(id => [
+	`node-test/${id}`,
+	'error',
+]));
+
+const createConfig = (rules, flatConfigName) => ({
+	...flatConfigBase,
+	name: flatConfigName,
+	plugins: {
+		'node-test': nodeTest,
+	},
+	rules,
+});
+
+const nodeTest = {
+	meta: {
+		// `eslint-doc-generator` derives the rule prefix from this name, expecting either the
+		// `eslint-plugin-<prefix>` convention or the prefix itself; our package name doesn't
+		// follow that convention, so use the prefix directly to keep doc generation working.
+		name: 'node-test',
+		version: packageJson.version,
+	},
+	rules,
+};
+
+const configs = {
+	recommended: createConfig(recommendedRules, 'node-test/recommended'),
+	unopinionated: createConfig(unopinionatedRules, 'node-test/unopinionated'),
+	all: createConfig(allRules, 'node-test/all'),
+};
+
+nodeTest.configs = configs;
+
+export default nodeTest;

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,106 @@
+{
+	"name": "eslint-node-test",
+	"version": "0.0.1",
+	"description": "ESLint rules for the Node.js built-in test runner (`node:test`)",
+	"license": "MIT",
+	"repository": "sindresorhus/eslint-node-test",
+	"funding": "https://github.com/sindresorhus/eslint-node-test?sponsor=1",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=22"
+	},
+	"scripts": {
+		"coverage": "node --test --experimental-test-coverage test/*.js test/unit/*.js",
+		"create-rule": "node ./scripts/create-rule.js && npm run create-rules-index-file && npm run fix:eslint-docs",
+		"create-rules-index-file": "node ./scripts/create-rules-index-file.js",
+		"fix": "run-p --continue-on-error \"fix:*\"",
+		"fix:eslint-docs": "eslint-doc-generator",
+		"fix:js": "npm run lint:js -- --fix",
+		"fix:markdown": "npm run lint:markdown -- --fix",
+		"fix:snapshots": "node --test --test-update-snapshots test/*.js test/unit/*.js",
+		"lint": "run-p --continue-on-error \"lint:*\"",
+		"lint:dogfooding": "eslint --config=./eslint.dogfooding.config.js",
+		"lint:eslint-docs": "npm run fix:eslint-docs -- --check",
+		"lint:js": "eslint",
+		"lint:markdown": "markdownlint \"**/*.md\"",
+		"lint:package-json": "npmPkgJsonLint .",
+		"rename-rule": "node ./scripts/rename-rule.js && npm run create-rules-index-file && npm run fix:eslint-docs",
+		"run-rules-on-codebase": "npm run lint:dogfooding",
+		"test": "npm-run-all --node-run --continue-on-error lint \"test:*\"",
+		"test:js": "node --test test/*.js test/unit/*.js"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"rules",
+		"configs"
+	],
+	"keywords": [
+		"eslint",
+		"eslintplugin",
+		"eslint-plugin",
+		"node-test",
+		"node:test",
+		"test-runner",
+		"testing",
+		"test",
+		"linter",
+		"lint",
+		"style",
+		"xo"
+	],
+	"dependencies": {
+		"@babel/helper-validator-identifier": "^7.29.7",
+		"@eslint-community/eslint-utils": "^4.9.1",
+		"globals": "^17.6.0",
+		"jsesc": "^3.1.0",
+		"pluralize": "^8.0.0"
+	},
+	"devDependencies": {
+		"@babel/code-frame": "^8.0.0-rc.6",
+		"@eslint/css": "^1.3.0",
+		"@eslint/eslintrc": "^3.3.5",
+		"@eslint/json": "^2.0.0",
+		"@eslint/markdown": "^8.0.2",
+		"@html-eslint/eslint-plugin": "^0.62.0",
+		"@html-eslint/parser": "^0.62.0",
+		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
+		"@typescript-eslint/parser": "^8.61.0",
+		"@typescript-eslint/types": "^8.61.0",
+		"enquirer": "^2.4.1",
+		"eslint": "^10.4.1",
+		"eslint-config-xo": "^0.52.0",
+		"eslint-doc-generator": "^3.6.0",
+		"eslint-plugin-eslint-plugin": "^7.4.0",
+		"eslint-plugin-jsdoc": "^63.0.2",
+		"eslint-plugin-unicorn": "^65.0.1",
+		"eslint-scope": "^9.1.2",
+		"espree": "^11.2.0",
+		"indent-string": "^5.0.0",
+		"listr2": "^10.2.1",
+		"markdownlint-cli": "^0.48.0",
+		"nano-spawn": "^2.1.0",
+		"node-style-text": "^2.1.2",
+		"npm-package-json-lint": "^10.4.0",
+		"npm-run-all2": "^9.0.1",
+		"open-editor": "^6.0.0",
+		"outdent": "^0.8.0",
+		"pretty-ms": "^9.3.0",
+		"typescript": "^6.0.3",
+		"vue-eslint-parser": "^10.4.1",
+		"yaml": "^2.9.0"
+	},
+	"peerDependencies": {
+		"eslint": ">=10.4"
+	}
+}

package/readme.md

@@ -0,0 +1,143 @@
+# eslint-node-test
+
+> ESLint rules for the [Node.js built-in test runner](https://nodejs.org/api/test.html) (`node:test`)
+
+This plugin helps you avoid common mistakes and write more consistent tests with `node:test`, the test runner built into Node.js.
+
+## Install
+
+```sh
+npm install --save-dev eslint eslint-node-test
+```
+
+**Requires ESLint `>=10.4`, [flat config](https://eslint.org/docs/latest/use/configure/configuration-files), and [ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c#how-can-i-make-my-typescript-project-output-esm).**
+
+## Usage
+
+Use a [preset config](#preset-configs) or configure each rule in `eslint.config.js`.
+
+```js
+import eslintNodeTest from 'eslint-node-test';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	eslintNodeTest.configs.recommended,
+]);
+```
+
+Or configure rules individually:
+
+```js
+import eslintNodeTest from 'eslint-node-test';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	{
+		plugins: {
+			'node-test': eslintNodeTest,
+		},
+		rules: {
+			'node-test/no-only-test': 'error',
+			'node-test/no-identical-title': 'error',
+		},
+	},
+]);
+```
+
+The rules only activate in files that import from `node:test` (and, for assertion rules, `node:assert`), so you can safely apply the plugin across your whole project.
+
+## Rules
+
+<!-- begin auto-generated rules list -->
+
+💼 [Configurations](https://github.com/sindresorhus/eslint-node-test#preset-configs) enabled in.\
+✅ Set in the `recommended` [configuration](https://github.com/sindresorhus/eslint-node-test#preset-configs).\
+☑️ Set in the `unopinionated` [configuration](https://github.com/sindresorhus/eslint-node-test#preset-configs).\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+| Name                                                                                   | Description                                                                                                | 💼   | 🔧 | 💡 |
+| :------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- | :--- | :- | :- |
+| [assertion-arguments](docs/rules/assertion-arguments.md)                               | Enforce the correct number of arguments for `node:assert` assertions.                                      | ✅ ☑️ |    |    |
+| [consistent-modifier-style](docs/rules/consistent-modifier-style.md)                   | Enforce a consistent style for test modifiers.                                                             |      |    |    |
+| [consistent-test-context-name](docs/rules/consistent-test-context-name.md)             | Enforce a consistent name for the test context parameter.                                                  | ✅ ☑️ |    |    |
+| [consistent-test-filename](docs/rules/consistent-test-filename.md)                     | Enforce a consistent test file name pattern.                                                               |      |    |    |
+| [consistent-test-it](docs/rules/consistent-test-it.md)                                 | Enforce consistent use of `test` or `it`.                                                                  |      |    |    |
+| [hooks-order](docs/rules/hooks-order.md)                                               | Enforce a consistent order of hook declarations.                                                           | ✅ ☑️ | 🔧 |    |
+| [max-assertions](docs/rules/max-assertions.md)                                         | Enforce a maximum number of assertions in a test.                                                          |      |    |    |
+| [max-nested-describe](docs/rules/max-nested-describe.md)                               | Enforce a maximum depth for nested `describe` blocks.                                                      | ✅    |    |    |
+| [no-assert-in-describe](docs/rules/no-assert-in-describe.md)                           | Disallow assertions directly inside a `describe` body.                                                     | ✅    |    |    |
+| [no-assert-in-hook](docs/rules/no-assert-in-hook.md)                                   | Disallow assertions inside hooks.                                                                          |      |    |    |
+| [no-assert-throws-async](docs/rules/no-assert-throws-async.md)                         | Disallow passing an async function to `assert.throws()`/`assert.doesNotThrow()`.                           | ✅ ☑️ |    | 💡 |
+| [no-assert-throws-string](docs/rules/no-assert-throws-string.md)                       | Disallow a string as the error matcher of `assert.throws()`/`assert.rejects()`.                            | ✅ ☑️ |    | 💡 |
+| [no-async-describe](docs/rules/no-async-describe.md)                                   | Disallow `async` `describe` callbacks.                                                                     | ✅ ☑️ |    |    |
+| [no-async-fn-without-await](docs/rules/no-async-fn-without-await.md)                   | Disallow async test/hook functions that have no `await` expression.                                        | ✅ ☑️ |    | 💡 |
+| [no-callback-and-promise](docs/rules/no-callback-and-promise.md)                       | Disallow a test or hook from using both a callback and a Promise.                                          | ✅ ☑️ |    |    |
+| [no-commented-tests](docs/rules/no-commented-tests.md)                                 | Disallow commented-out tests.                                                                              |      |    |    |
+| [no-conditional-assertion](docs/rules/no-conditional-assertion.md)                     | Disallow assertions inside conditional code within a test.                                                 | ✅ ☑️ |    |    |
+| [no-conditional-in-test](docs/rules/no-conditional-in-test.md)                         | Disallow conditional logic inside tests.                                                                   |      |    |    |
+| [no-conditional-tests](docs/rules/no-conditional-tests.md)                             | Disallow conditionally registering tests and suites.                                                       | ✅    |    |    |
+| [no-conflicting-modifiers](docs/rules/no-conflicting-modifiers.md)                     | Disallow conflicting `only`/`skip`/`todo` modifiers.                                                       | ✅ ☑️ |    |    |
+| [no-done-callback](docs/rules/no-done-callback.md)                                     | Disallow callback (`done`) parameters in tests and hooks.                                                  |      |    |    |
+| [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                                 | Disallow duplicate hooks within the same scope.                                                            | ✅    |    |    |
+| [no-export](docs/rules/no-export.md)                                                   | Disallow exports from test files.                                                                          | ✅    |    |    |
+| [no-identical-assertion-arguments](docs/rules/no-identical-assertion-arguments.md)     | Disallow comparing a value to itself in an assertion.                                                      | ✅ ☑️ |    |    |
+| [no-identical-title](docs/rules/no-identical-title.md)                                 | Disallow identical test titles within the same scope.                                                      | ✅ ☑️ |    |    |
+| [no-incorrect-deep-equal](docs/rules/no-incorrect-deep-equal.md)                       | Disallow `deepEqual`/`deepStrictEqual` (and their `notDeep*` variants) when comparing with primitives.     | ✅ ☑️ | 🔧 |    |
+| [no-incorrect-strict-equal](docs/rules/no-incorrect-strict-equal.md)                   | Disallow `strictEqual`/`equal` (and their `not*` variants) when comparing with an object or array literal. | ✅ ☑️ | 🔧 |    |
+| [no-loop-static-title](docs/rules/no-loop-static-title.md)                             | Disallow a static test or suite title inside a loop.                                                       | ✅ ☑️ |    |    |
+| [no-misused-concurrency](docs/rules/no-misused-concurrency.md)                         | Disallow the `concurrency` option on a test without subtests.                                              | ✅ ☑️ |    |    |
+| [no-mock-timers-destructured-import](docs/rules/no-mock-timers-destructured-import.md) | Disallow destructured timer imports when using `mock.timers`.                                              | ✅ ☑️ |    |    |
+| [no-nested-tests](docs/rules/no-nested-tests.md)                                       | Disallow tests and suites nested inside a test body.                                                       | ✅ ☑️ |    |    |
+| [no-only-test](docs/rules/no-only-test.md)                                             | Disallow the `.only` test modifier.                                                                        | ✅ ☑️ |    | 💡 |
+| [no-skip-test](docs/rules/no-skip-test.md)                                             | Disallow the `.skip` test modifier.                                                                        | ✅    |    | 💡 |
+| [no-skip-without-reason](docs/rules/no-skip-without-reason.md)                         | Require a reason when skipping or marking a test as todo.                                                  |      |    |    |
+| [no-skip-without-return](docs/rules/no-skip-without-return.md)                         | Disallow `t.skip()`/`t.todo()` without returning afterwards.                                               | ✅    |    | 💡 |
+| [no-standalone-assert](docs/rules/no-standalone-assert.md)                             | Disallow assertions outside of a test.                                                                     | ✅ ☑️ |    |    |
+| [no-test-inside-hook](docs/rules/no-test-inside-hook.md)                               | Disallow defining tests and suites inside a hook.                                                          | ✅ ☑️ |    |    |
+| [no-test-return-statement](docs/rules/no-test-return-statement.md)                     | Disallow returning a non-Promise value from a test.                                                        | ✅    |    |    |
+| [no-todo-test](docs/rules/no-todo-test.md)                                             | Disallow the `.todo` test modifier.                                                                        |      |    | 💡 |
+| [no-unawaited-rejects](docs/rules/no-unawaited-rejects.md)                             | Require `assert.rejects()`/`assert.doesNotReject()` to be awaited or returned.                             | ✅ ☑️ | 🔧 |    |
+| [no-unawaited-subtest](docs/rules/no-unawaited-subtest.md)                             | Require subtests created with the test context to be awaited or returned.                                  | ✅    | 🔧 |    |
+| [no-unknown-test-options](docs/rules/no-unknown-test-options.md)                       | Disallow unknown options in test and hook option objects.                                                  | ✅    |    |    |
+| [no-useless-assertion](docs/rules/no-useless-assertion.md)                             | Disallow `assert.doesNotThrow()` and `assert.doesNotReject()`.                                             | ✅    |    |    |
+| [prefer-assert-match](docs/rules/prefer-assert-match.md)                               | Prefer `assert.match()`/`assert.doesNotMatch()` over asserting `RegExp#test()` / `String#match()` results. | ✅ ☑️ | 🔧 |    |
+| [prefer-assert-throws](docs/rules/prefer-assert-throws.md)                             | Prefer `assert.throws()`/`assert.rejects()` over try/catch with an assertion.                              | ✅    |    |    |
+| [prefer-async-await](docs/rules/prefer-async-await.md)                                 | Prefer async/await over returning a Promise.                                                               | ✅    |    |    |
+| [prefer-context-mock](docs/rules/prefer-context-mock.md)                               | Prefer the test context `t.mock` over the global `mock`.                                                   | ✅    |    |    |
+| [prefer-diagnostic](docs/rules/prefer-diagnostic.md)                                   | Prefer the test context `diagnostic()` over `console` inside tests.                                        |      |    | 💡 |
+| [prefer-equality-assertion](docs/rules/prefer-equality-assertion.md)                   | Prefer an equality assertion over a truthiness assertion on a comparison.                                  | ✅ ☑️ | 🔧 |    |
+| [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                               | Require hooks to be declared before the tests in their scope.                                              | ✅    |    |    |
+| [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)                         | Enforce lowercase test titles.                                                                             |      | 🔧 |    |
+| [prefer-mock-method](docs/rules/prefer-mock-method.md)                                 | Prefer `mock.method()` over assigning `mock.fn()` to an object property.                                   | ✅    |    | 💡 |
+| [prefer-strict-assert](docs/rules/prefer-strict-assert.md)                             | Prefer strict assertion methods over their legacy loose counterparts.                                      | ✅ ☑️ | 🔧 |    |
+| [prefer-test-context-assert](docs/rules/prefer-test-context-assert.md)                 | Prefer the test context `t.assert` over the imported `node:assert`.                                        | ✅    |    | 💡 |
+| [prefer-todo](docs/rules/prefer-todo.md)                                               | Prefer `.todo` for empty placeholder tests.                                                                | ✅    |    | 💡 |
+| [require-assertion](docs/rules/require-assertion.md)                                   | Require that each test contains at least one assertion.                                                    | ✅    |    |    |
+| [require-await-concurrent-subtests](docs/rules/require-await-concurrent-subtests.md)   | Require subtests created in a loop callback to be awaited.                                                 | ✅ ☑️ |    |    |
+| [require-context-assert-with-plan](docs/rules/require-context-assert-with-plan.md)     | Require assertions to use the test context when the test sets a plan.                                      | ✅ ☑️ |    |    |
+| [require-hook](docs/rules/require-hook.md)                                             | Require setup and teardown code to be inside a hook.                                                       |      |    |    |
+| [require-throws-expectation](docs/rules/require-throws-expectation.md)                 | Require an error matcher for `assert.throws()`/`assert.rejects()`.                                         | ✅ ☑️ |    |    |
+| [require-top-level-describe](docs/rules/require-top-level-describe.md)                 | Require tests and hooks to be inside a top-level `describe`.                                               |      |    |    |
+| [test-title](docs/rules/test-title.md)                                                 | Require tests to have a title.                                                                             | ✅    | 🔧 |    |
+| [test-title-format](docs/rules/test-title-format.md)                                   | Require test titles to match a configured pattern.                                                         |      |    |    |
+| [valid-describe-callback](docs/rules/valid-describe-callback.md)                       | Enforce valid `describe` callbacks.                                                                        | ✅ ☑️ |    |    |
+
+<!-- end auto-generated rules list -->
+
+## Preset configs
+
+This plugin exports these configs:
+
+- `recommended` — Enables the recommended rules.
+- `unopinionated` — A subset of `recommended` with only the most uncontroversial rules.
+- `all` — Enables every rule (not recommended for general use; useful to discover new rules).
+
+```js
+import eslintNodeTest from 'eslint-node-test';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	eslintNodeTest.configs.recommended,
+]);
+```

package/rules/assertion-arguments.js

@@ -0,0 +1,134 @@
+import {resolveImports, parseAssertionCall} from './utils/node-test.js';
+import {isFunction} from './ast/index.js';
+import unwrapTypeScriptExpression from './utils/unwrap-typescript-expression.js';
+
+const MESSAGE_ID_TOO_FEW = 'too-few-arguments';
+const MESSAGE_ID_TOO_MANY = 'too-many-arguments';
+const MESSAGE_ID_NOT_STRING = 'not-string-message';
+
+/*
+Map of node:assert method -> required argument count.
+Each method also accepts one optional trailing `message` argument, making max = required + 1.
+`fail` is omitted because it accepts 0 or 1 args (ambiguous) — not checkable.
+`throws`/`doesNotThrow`/`rejects`/`doesNotReject` accept 1 required + optional error + optional message (max 3).
+`ifError` is the exception with no trailing message argument — it accepts exactly one value (max = min = 1).
+`snapshot` is omitted because its optional second argument is an options object, not a message string,
+so it does not fit this map's "trailing string message" model (and it is a `node:test` context
+assertion rather than a `node:assert` method).
+*/
+const ASSERTION_ARGS = new Map([
+	['ok', {min: 1, max: 2}],
+	['equal', {min: 2, max: 3}],
+	['notEqual', {min: 2, max: 3}],
+	['strictEqual', {min: 2, max: 3}],
+	['notStrictEqual', {min: 2, max: 3}],
+	['deepEqual', {min: 2, max: 3}],
+	['notDeepEqual', {min: 2, max: 3}],
+	['deepStrictEqual', {min: 2, max: 3}],
+	['notDeepStrictEqual', {min: 2, max: 3}],
+	['match', {min: 2, max: 3}],
+	['doesNotMatch', {min: 2, max: 3}],
+	['throws', {min: 1, max: 3}],
+	['doesNotThrow', {min: 1, max: 3}],
+	['rejects', {min: 1, max: 3}],
+	['doesNotReject', {min: 1, max: 3}],
+	['ifError', {min: 1, max: 1}],
+]);
+
+/*
+The optional trailing `message` argument accepts a string or an `Error`. Only flag values that
+are statically known to be neither: object/array/function literals, or non-string literals
+(numbers, booleans, `null`, regexes). Identifiers, calls, member expressions, template
+literals, conditionals, logical/binary expressions, and TypeScript casts can all resolve to a
+string or `Error` at runtime, so they are left alone to avoid false positives.
+*/
+function isInvalidMessageArgument(node) {
+	node = unwrapTypeScriptExpression(node);
+
+	if (node.type === 'ArrayExpression' || node.type === 'ObjectExpression' || isFunction(node)) {
+		return true;
+	}
+
+	return node.type === 'Literal' && typeof node.value !== 'string';
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const assertion = parseAssertionCall(node, imports);
+		if (!assertion) {
+			return;
+		}
+
+		const {method} = assertion;
+		const expected = ASSERTION_ARGS.get(method);
+		if (!expected) {
+			// Unknown method or `fail` — skip.
+			return;
+		}
+
+		// Skip calls with spread arguments — arg count is not statically known.
+		if (node.arguments.some(argument => argument.type === 'SpreadElement')) {
+			return;
+		}
+
+		const {min, max} = expected;
+		const count = node.arguments.length;
+
+		if (count < min) {
+			return {
+				node,
+				messageId: MESSAGE_ID_TOO_FEW,
+				data: {min},
+			};
+		}
+
+		if (count > max) {
+			return {
+				node,
+				messageId: MESSAGE_ID_TOO_MANY,
+				data: {max},
+			};
+		}
+
+		// If a trailing message argument is present, it must be a string.
+		// The message argument is the last arg when count > min (i.e. it is optional and present).
+		// For methods where max === min there is no message slot — skip.
+		if (count === max && max > min) {
+			const lastArg = node.arguments.at(-1);
+			if (isInvalidMessageArgument(lastArg)) {
+				return {
+					node: lastArg,
+					messageId: MESSAGE_ID_NOT_STRING,
+				};
+			}
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce the correct number of arguments for `node:assert` assertions.',
+			recommended: 'unopinionated',
+		},
+		fixable: undefined,
+		schema: [],
+		messages: {
+			[MESSAGE_ID_TOO_FEW]: 'Not enough arguments. Expected at least {{min}}.',
+			[MESSAGE_ID_TOO_MANY]: 'Too many arguments. Expected at most {{max}}.',
+			[MESSAGE_ID_NOT_STRING]: 'Assertion message must be a string.',
+		},
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/ast/call-or-new-expression.js

@@ -0,0 +1,100 @@
+/**
+@typedef {
+	{
+		name?: string,
+		names?: string[],
+		argumentsLength?: number,
+		minimumArguments?: number,
+		maximumArguments?: number,
+		allowSpreadElement?: boolean,
+		optional?: boolean,
+	} | string | string[]
+} CallOrNewExpressionCheckOptions
+*/
+// eslint-disable-next-line complexity
+function create(node, options, types) {
+	if (!types.includes(node?.type)) {
+		return false;
+	}
+
+	if (typeof options === 'string') {
+		options = {names: [options]};
+	}
+
+	if (Array.isArray(options)) {
+		options = {names: options};
+	}
+
+	let {
+		name,
+		names,
+		argumentsLength,
+		minimumArguments,
+		maximumArguments,
+		allowSpreadElement,
+		optional,
+	} = {
+		minimumArguments: 0,
+		maximumArguments: Infinity,
+		allowSpreadElement: false,
+		...options,
+	};
+
+	if (name) {
+		names = [name];
+	}
+
+	if (
+		(optional === true && (node.optional !== optional))
+		|| (
+			optional === false
+			// `node.optional` can be `undefined` in some parsers
+			&& node.optional
+		)
+	) {
+		return false;
+	}
+
+	if (typeof argumentsLength === 'number' && node.arguments.length !== argumentsLength) {
+		return false;
+	}
+
+	if (minimumArguments !== 0 && node.arguments.length < minimumArguments) {
+		return false;
+	}
+
+	if (Number.isFinite(maximumArguments) && node.arguments.length > maximumArguments) {
+		return false;
+	}
+
+	if (!allowSpreadElement) {
+		const maximumArgumentsLength = Number.isFinite(maximumArguments) ? maximumArguments : argumentsLength;
+		if (
+			typeof maximumArgumentsLength === 'number'
+			&& node.arguments.some((node, index) =>
+				node.type === 'SpreadElement'
+				&& index < maximumArgumentsLength)
+		) {
+			return false;
+		}
+	}
+
+	if (
+		Array.isArray(names)
+		&& names.length > 0
+		&& (
+			node.callee.type !== 'Identifier'
+			|| !names.includes(node.callee.name)
+		)
+	) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+@param {CallOrNewExpressionCheckOptions} [options]
+@returns {boolean}
+*/
+export const isCallExpression = (node, options) => create(node, options, ['CallExpression']);

package/rules/ast/function-types.js

@@ -0,0 +1,7 @@
+const functionTypes = [
+	'FunctionDeclaration',
+	'FunctionExpression',
+	'ArrowFunctionExpression',
+];
+
+export default functionTypes;

package/rules/ast/index.js

@@ -0,0 +1,17 @@
+export {
+	isLiteral,
+	isStringExpression,
+	isBooleanLiteral,
+	getStaticStringValue,
+	isRegexLiteral,
+} from './literal.js';
+
+export {isCallExpression} from './call-or-new-expression.js';
+
+export {default as isExpressionStatement} from './is-expression-statement.js';
+export {default as isFunction} from './is-function.js';
+export {default as isLoop} from './is-loop.js';
+export {default as isMemberExpression} from './is-member-expression.js';
+export {default as isMethodCall} from './is-method-call.js';
+export {default as functionTypes} from './function-types.js';
+export {default as loopTypes} from './loop-types.js';

package/rules/ast/is-expression-statement.js

@@ -0,0 +1,7 @@
+export default function isExpressionStatement(node) {
+	return node.type === 'ExpressionStatement'
+		|| (
+			node.type === 'ChainExpression'
+			&& node.parent.type === 'ExpressionStatement'
+		);
+}

package/rules/ast/is-function.js

@@ -0,0 +1,5 @@
+import functionTypes from './function-types.js';
+
+export default function isFunction(node) {
+	return functionTypes.includes(node.type);
+}

package/rules/ast/is-loop.js

@@ -0,0 +1,5 @@
+import loopTypes from './loop-types.js';
+
+export default function isLoop(node) {
+	return loopTypes.includes(node.type);
+}