eslint 9.39.1 → 10.0.0-alpha.1

package/lib/rule-tester/rule-tester.js

@@ -18,7 +18,8 @@ const assert = require("node:assert"),
 	{ Config } = require("../config/config"),
 	{ Linter, SourceCodeFixer } = require("../linter"),
 	{ interpolate, getPlaceholderMatcher } = require("../linter/interpolate"),
-	stringify = require("json-stable-stringify-without-jsonify");
+	stringify = require("json-stable-stringify-without-jsonify"),
+	{ isSerializable } = require("../shared/serialization");
 
 const { FlatConfigArray } = require("../config/flat-config-array");
 const {
@@ -30,7 +31,6 @@ const ajv = require("../shared/ajv")({ strictDefaults: true });
 
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { ConfigArraySymbol } = require("@eslint/config-array");
-const { isSerializable } = require("../shared/serialization");
 
 const jslang = require("../languages/js");
 const { SourceCode } = require("../languages/js/source-code");
@@ -78,7 +78,6 @@ const { SourceCode } = require("../languages/js/source-code");
  * @typedef {Object} TestCaseError
  * @property {string | RegExp} [message] Message.
  * @property {string} [messageId] Message ID.
- * @property {string} [type] The type of the reported AST node.
  * @property {{ [name: string]: string }} [data] The data used to fill the message template.
  * @property {number} [line] The 1-based line number of the reported start location.
  * @property {number} [column] The 1-based column number of the reported start location.
@@ -125,7 +124,6 @@ const errorObjectParameters = new Set([
 	"message",
 	"messageId",
 	"data",
-	"type",
 	"line",
 	"column",
 	"endLine",
@@ -145,11 +143,6 @@ const suggestionObjectParameters = new Set([
 ]);
 const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`;
 
-/*
- * Ignored test case properties when checking for test case duplicates.
- */
-const duplicationIgnoredParameters = new Set(["name", "errors", "output"]);
-
 const forbiddenMethods = [
 	"applyInlineConfig",
 	"applyLanguageOptions",
@@ -375,6 +368,221 @@ const metaSchemaDescription = `
 \thttps://eslint.org/docs/latest/extend/custom-rules#options-schemas
 `;
 
+/*
+ * Ignored test case properties when checking for test case duplicates.
+ */
+const duplicationIgnoredParameters = new Set(["name", "errors", "output"]);
+
+/**
+ * Normalizes a test case item, ensuring it is an object with a 'code' property.
+ * If the item is not an object, it returns an object with the 'code' property set to the item.
+ * @param {any} item The test case item to normalize.
+ * @returns {Object} The normalized test case object.
+ */
+function normalizeTestCase(item) {
+	return item && typeof item === "object" ? item : { code: item };
+}
+
+/**
+ * Asserts that the `errors` property of an invalid test case is valid.
+ * @param {number | string[]} errors The `errors` property of the invalid test case.
+ * @param {string} ruleName The name of the rule being tested.
+ * @returns {void}
+ */
+function assertErrorsProperty(errors, ruleName) {
+	const isNumber = typeof errors === "number";
+	const isArray = Array.isArray(errors);
+
+	if (!isNumber && !isArray) {
+		if (errors === void 0) {
+			assert.fail(
+				`Did not specify errors for an invalid test of ${ruleName}`,
+			);
+		} else {
+			assert.fail(
+				`Invalid 'errors' property for invalid test of ${ruleName}: expected a number or an array but got ${
+					errors === null ? "null" : typeof errors
+				}`,
+			);
+		}
+	}
+
+	if (isArray) {
+		assert.ok(
+			errors.length !== 0,
+			"Invalid cases must have at least one error",
+		);
+	} else {
+		assert.ok(
+			errors > 0,
+			"Invalid cases must have 'error' value greater than 0",
+		);
+	}
+}
+
+/**
+ * Check if this test case is a duplicate of one we have seen before.
+ * @param {Object} item test case object
+ * @param {Set<string>} seenTestCases set of serialized test cases we have seen so far (managed by this function)
+ * @returns {void}
+ */
+function checkDuplicateTestCase(item, seenTestCases) {
+	if (!isSerializable(item)) {
+		/*
+		 * If we can't serialize a test case (because it contains a function, RegExp, etc), skip the check.
+		 * This might happen with properties like: options, plugins, settings, languageOptions.parser, languageOptions.parserOptions.
+		 */
+		return;
+	}
+
+	const serializedTestCase = stringify(item, {
+		replacer(key, value) {
+			// "this" is the currently stringified object --> only ignore top-level properties
+			return item !== this || !duplicationIgnoredParameters.has(key)
+				? value
+				: void 0;
+		},
+	});
+
+	assert(
+		!seenTestCases.has(serializedTestCase),
+		"detected duplicate test case",
+	);
+	seenTestCases.add(serializedTestCase);
+}
+
+/**
+ * Asserts that a rule is valid.
+ * A valid rule must be an object with a `create` method.
+ * @param {Object} rule The rule to check.
+ * @param {string} ruleName The name of the rule.
+ * @returns {void}
+ * @throws {AssertionError} If the rule is not valid.
+ */
+function assertRule(rule, ruleName) {
+	assert.ok(
+		rule && typeof rule === "object" && typeof rule.create === "function",
+		`Rule ${ruleName} must be an object with a \`create\` method`,
+	);
+}
+
+/**
+ * Asserts that a test scenario object is valid.
+ * A valid test scenario object must have `valid` and `invalid` properties, both of
+ * which must be arrays.
+ * @param {Object} test The test scenario object to check.
+ * @param {string} ruleName The name of the rule being tested.
+ * @returns {void}
+ * @throws {AssertionError} If the test scenario object is not valid.
+ */
+function assertTest(test, ruleName) {
+	assert.ok(
+		test && typeof test === "object",
+		`Test Scenarios for rule ${ruleName} : Could not find test scenario object`,
+	);
+
+	const hasValid = Array.isArray(test.valid);
+	const hasInvalid = Array.isArray(test.invalid);
+
+	assert.ok(
+		hasValid,
+		`Test Scenarios for rule ${ruleName} is invalid: Could not find any valid test scenarios`,
+	);
+
+	assert.ok(
+		hasInvalid,
+		`Test Scenarios for rule ${ruleName} is invalid: Could not find any invalid test scenarios`,
+	);
+}
+
+/**
+ * Asserts that the common properties of a valid/invalid test case have the correct types.
+ * @param {Object} item The test case object to check.
+ * @returns {void}
+ */
+function assertTestCommonProperties(item) {
+	assert.ok(
+		typeof item.code === "string",
+		"Test case must specify a string value for 'code'",
+	);
+
+	// optional properties
+	if (item.name) {
+		assert.ok(
+			typeof item.name === "string",
+			"Optional test case property 'name' must be a string",
+		);
+	}
+	if (hasOwnProperty(item, "only")) {
+		assert.ok(
+			typeof item.only === "boolean",
+			"Optional test case property 'only' must be a boolean",
+		);
+	}
+	if (hasOwnProperty(item, "filename")) {
+		assert.ok(
+			typeof item.filename === "string",
+			"Optional test case property 'filename' must be a string",
+		);
+	}
+	if (hasOwnProperty(item, "options")) {
+		assert.ok(
+			Array.isArray(item.options),
+			"Optional test case property 'options' must be an array",
+		);
+	}
+}
+
+/**
+ * Asserts that a valid test case object is valid.
+ * A valid test case must specify a string value for 'code'.
+ * Optional properties are checked for correct types.
+ * @param {Object} item The valid test case object to check.
+ * @param {Set<string>} seenTestCases Set of serialized test cases to check for duplicates.
+ * @returns {void}
+ * @throws {AssertionError} If the test case is not valid.
+ */
+function assertValidTestCase(item, seenTestCases) {
+	// must not have properties of invalid test cases
+	assert.ok(
+		item.errors === void 0,
+		"Valid test case must not have 'errors' property",
+	);
+	assert.ok(
+		item.output === void 0,
+		"Valid test case must not have 'output' property",
+	);
+
+	assertTestCommonProperties(item);
+	checkDuplicateTestCase(item, seenTestCases);
+}
+
+/**
+ * Asserts that the invalid test case object is valid.
+ * An invalid test case must specify a string value for 'code' and must have 'errors' property.
+ * Optional properties are checked for correct types.
+ * @param {Object} item The invalid test case object to check.
+ * @param {Set<string>} seenTestCases Set of serialized test cases to check for duplicates.
+ * @param {string} ruleName The name of the rule being tested.
+ * @returns {void}
+ * @throws {AssertionError} If the test case is not valid.
+ */
+function assertInvalidTestCase(item, seenTestCases, ruleName) {
+	assertTestCommonProperties(item);
+
+	assertErrorsProperty(item.errors, ruleName);
+
+	// 'output' is optional, but if it exists it must be a string or null
+	if (hasOwnProperty(item, "output")) {
+		assert.ok(
+			item.output === null || typeof item.output === "string",
+			"Test property 'output', if specified, must be a string or null. If no autofix is expected, then omit the 'output' property or set it to null.",
+		);
+	}
+
+	checkDuplicateTestCase(item, seenTestCases);
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -564,45 +772,11 @@ class RuleTester {
 	 */
 	run(ruleName, rule, test) {
 		const testerConfig = this.testerConfig,
-			requiredScenarios = ["valid", "invalid"],
-			scenarioErrors = [],
 			linter = this.linter,
 			ruleId = `rule-to-test/${ruleName}`;
 
-		const seenValidTestCases = new Set();
-		const seenInvalidTestCases = new Set();
-
-		if (
-			!rule ||
-			typeof rule !== "object" ||
-			typeof rule.create !== "function"
-		) {
-			throw new TypeError(
-				"Rule must be an object with a `create` method",
-			);
-		}
-
-		if (!test || typeof test !== "object") {
-			throw new TypeError(
-				`Test Scenarios for rule ${ruleName} : Could not find test scenario object`,
-			);
-		}
-
-		requiredScenarios.forEach(scenarioType => {
-			if (!test[scenarioType]) {
-				scenarioErrors.push(
-					`Could not find any ${scenarioType} test scenarios`,
-				);
-			}
-		});
-
-		if (scenarioErrors.length > 0) {
-			throw new Error(
-				[`Test Scenarios for rule ${ruleName} is invalid:`]
-					.concat(scenarioErrors)
-					.join("\n"),
-			);
-		}
+		assertRule(rule, ruleName);
+		assertTest(test, ruleName);
 
 		const baseConfig = [
 			{
@@ -651,14 +825,14 @@ class RuleTester {
 
 		/**
 		 * Runs a hook on the given item when it's assigned to the given property
-		 * @param {string|Object} item Item to run the hook on
+		 * @param {Object} item Item to run the hook on
 		 * @param {string} prop The property having the hook assigned to
 		 * @throws {Error} If the property is not a function or that function throws an error
 		 * @returns {void}
 		 * @private
 		 */
 		function runHook(item, prop) {
-			if (typeof item === "object" && hasOwnProperty(item, prop)) {
+			if (hasOwnProperty(item, prop)) {
 				assert.strictEqual(
 					typeof item[prop],
 					"function",
@@ -667,22 +841,26 @@ class RuleTester {
 				item[prop]();
 			}
 		}
-
 		/**
 		 * Run the rule for the given item
-		 * @param {string|Object} item Item to run the rule against
+		 * @param {Object} item Item to run the rule against
 		 * @throws {Error} If an invalid schema.
 		 * @returns {Object} Eslint run result
 		 * @private
 		 */
 		function runRuleForItem(item) {
+			const code = item.code;
+			const filename = hasOwnProperty(item, "filename")
+				? item.filename
+				: void 0;
+			const options = hasOwnProperty(item, "options") ? item.options : [];
 			const flatConfigArrayOptions = {
 				baseConfig,
 			};
 
-			if (item.filename) {
+			if (filename) {
 				flatConfigArrayOptions.basePath =
-					path.parse(item.filename).root || void 0;
+					path.parse(filename).root || void 0;
 			}
 
 			const configs = new FlatConfigArray(
@@ -713,54 +891,27 @@ class RuleTester {
 				return calculatedConfig;
 			};
 
-			let code, filename, output, beforeAST, afterAST;
+			let output, beforeAST, afterAST;
 
-			if (typeof item === "string") {
-				code = item;
-			} else {
-				code = item.code;
-
-				/*
-				 * Assumes everything on the item is a config except for the
-				 * parameters used by this tester
-				 */
-				const itemConfig = { ...item };
-
-				for (const parameter of RuleTesterParameters) {
-					delete itemConfig[parameter];
-				}
-
-				/*
-				 * Create the config object from the tester config and this item
-				 * specific configurations.
-				 */
-				configs.push(itemConfig);
-			}
+			/*
+			 * Assumes everything on the item is a config except for the
+			 * parameters used by this tester
+			 */
+			const itemConfig = { ...item };
 
-			if (hasOwnProperty(item, "only")) {
-				assert.ok(
-					typeof item.only === "boolean",
-					"Optional test case property 'only' must be a boolean",
-				);
+			for (const parameter of RuleTesterParameters) {
+				delete itemConfig[parameter];
 			}
-			if (hasOwnProperty(item, "filename")) {
-				assert.ok(
-					typeof item.filename === "string",
-					"Optional test case property 'filename' must be a string",
-				);
-				filename = item.filename;
-			}
-
-			let ruleConfig = 1;
 
-			if (hasOwnProperty(item, "options")) {
-				assert(Array.isArray(item.options), "options must be an array");
-				ruleConfig = [1, ...item.options];
-			}
+			/*
+			 * Create the config object from the tester config and this item
+			 * specific configurations.
+			 */
+			configs.push(itemConfig);
 
 			configs.push({
 				rules: {
-					[ruleId]: ruleConfig,
+					[ruleId]: [1, ...options],
 				},
 			});
 
@@ -939,64 +1090,14 @@ class RuleTester {
 			}
 		}
 
-		/**
-		 * Check if this test case is a duplicate of one we have seen before.
-		 * @param {string|Object} item test case object
-		 * @param {Set<string>} seenTestCases set of serialized test cases we have seen so far (managed by this function)
-		 * @returns {void}
-		 * @private
-		 */
-		function checkDuplicateTestCase(item, seenTestCases) {
-			if (!isSerializable(item)) {
-				/*
-				 * If we can't serialize a test case (because it contains a function, RegExp, etc), skip the check.
-				 * This might happen with properties like: options, plugins, settings, languageOptions.parser, languageOptions.parserOptions.
-				 */
-				return;
-			}
-
-			const normalizedItem =
-				typeof item === "string" ? { code: item } : item;
-			const serializedTestCase = stringify(normalizedItem, {
-				replacer(key, value) {
-					// "this" is the currently stringified object --> only ignore top-level properties
-					return normalizedItem !== this ||
-						!duplicationIgnoredParameters.has(key)
-						? value
-						: void 0;
-				},
-			});
-
-			assert(
-				!seenTestCases.has(serializedTestCase),
-				"detected duplicate test case",
-			);
-			seenTestCases.add(serializedTestCase);
-		}
-
 		/**
 		 * Check if the template is valid or not
 		 * all valid cases go through this
-		 * @param {string|Object} item Item to run the rule against
+		 * @param {Object} item Item to run the rule against
 		 * @returns {void}
 		 * @private
 		 */
 		function testValidTemplate(item) {
-			const code = typeof item === "object" ? item.code : item;
-
-			assert.ok(
-				typeof code === "string",
-				"Test case must specify a string value for 'code'",
-			);
-			if (item.name) {
-				assert.ok(
-					typeof item.name === "string",
-					"Optional test case property 'name' must be a string",
-				);
-			}
-
-			checkDuplicateTestCase(item, seenValidTestCases);
-
 			const result = runRuleForItem(item);
 			const messages = result.messages;
 
@@ -1037,32 +1138,11 @@ class RuleTester {
 		/**
 		 * Check if the template is invalid or not
 		 * all invalid cases go through this.
-		 * @param {string|Object} item Item to run the rule against
+		 * @param {Object} item Item to run the rule against
 		 * @returns {void}
 		 * @private
 		 */
 		function testInvalidTemplate(item) {
-			assert.ok(
-				typeof item.code === "string",
-				"Test case must specify a string value for 'code'",
-			);
-			if (item.name) {
-				assert.ok(
-					typeof item.name === "string",
-					"Optional test case property 'name' must be a string",
-				);
-			}
-			assert.ok(
-				item.errors || item.errors === 0,
-				`Did not specify errors for an invalid test of ${ruleName}`,
-			);
-
-			if (Array.isArray(item.errors) && item.errors.length === 0) {
-				assert.fail("Invalid cases must have at least one error");
-			}
-
-			checkDuplicateTestCase(item, seenInvalidTestCases);
-
 			const ruleHasMetaMessages =
 				hasOwnProperty(rule, "meta") &&
 				hasOwnProperty(rule.meta, "messages");
@@ -1095,12 +1175,6 @@ class RuleTester {
 			}
 
 			if (typeof item.errors === "number") {
-				if (item.errors === 0) {
-					assert.fail(
-						"Invalid cases must have 'error' value greater than 0",
-					);
-				}
-
 				assert.strictEqual(
 					messages.length,
 					item.errors,
@@ -1148,8 +1222,7 @@ class RuleTester {
 					} else if (typeof error === "object" && error !== null) {
 						/*
 						 * Error object.
-						 * This may have a message, messageId, data, node type, line, and/or
-						 * column.
+						 * This may have a message, messageId, data, line, and/or column.
 						 */
 
 						Object.keys(error).forEach(propertyName => {
@@ -1231,14 +1304,6 @@ class RuleTester {
 							);
 						}
 
-						if (error.type) {
-							assert.strictEqual(
-								message.nodeType,
-								error.type,
-								`Error type should be ${error.type}, found ${message.nodeType}`,
-							);
-						}
-
 						const actualLocation = {};
 						const expectedLocation = {};
 
@@ -1533,19 +1598,18 @@ class RuleTester {
 		this.constructor.describe(ruleName, () => {
 			if (test.valid.length > 0) {
 				this.constructor.describe("valid", () => {
+					const seenTestCases = new Set();
 					test.valid.forEach(valid => {
+						const item = normalizeTestCase(valid);
 						this.constructor[valid.only ? "itOnly" : "it"](
-							sanitize(
-								typeof valid === "object"
-									? valid.name || valid.code
-									: valid,
-							),
+							sanitize(item.name || item.code),
 							() => {
 								try {
-									runHook(valid, "before");
-									testValidTemplate(valid);
+									runHook(item, "before");
+									assertValidTestCase(item, seenTestCases);
+									testValidTemplate(item);
 								} finally {
-									runHook(valid, "after");
+									runHook(item, "after");
 								}
 							},
 						);
@@ -1555,15 +1619,22 @@ class RuleTester {
 
 			if (test.invalid.length > 0) {
 				this.constructor.describe("invalid", () => {
+					const seenTestCases = new Set();
 					test.invalid.forEach(invalid => {
-						this.constructor[invalid.only ? "itOnly" : "it"](
-							sanitize(invalid.name || invalid.code),
+						const item = normalizeTestCase(invalid);
+						this.constructor[item.only ? "itOnly" : "it"](
+							sanitize(item.name || item.code),
 							() => {
 								try {
-									runHook(invalid, "before");
-									testInvalidTemplate(invalid);
+									runHook(item, "before");
+									assertInvalidTestCase(
+										item,
+										seenTestCases,
+										ruleName,
+									);
+									testInvalidTemplate(item);
 								} finally {
-									runHook(invalid, "after");
+									runHook(item, "after");
 								}
 							},
 						);

package/lib/rules/array-bracket-spacing.js

@@ -258,13 +258,13 @@ module.exports = {
 			if (astUtils.isTokenOnSameLine(first, second)) {
 				if (
 					openingBracketMustBeSpaced &&
-					!sourceCode.isSpaceBetweenTokens(first, second)
+					!sourceCode.isSpaceBetween(first, second)
 				) {
 					reportRequiredBeginningSpace(node, first);
 				}
 				if (
 					!openingBracketMustBeSpaced &&
-					sourceCode.isSpaceBetweenTokens(first, second)
+					sourceCode.isSpaceBetween(first, second)
 				) {
 					reportNoBeginningSpace(node, first);
 				}
@@ -276,13 +276,13 @@ module.exports = {
 			) {
 				if (
 					closingBracketMustBeSpaced &&
-					!sourceCode.isSpaceBetweenTokens(penultimate, last)
+					!sourceCode.isSpaceBetween(penultimate, last)
 				) {
 					reportRequiredEndingSpace(node, last);
 				}
 				if (
 					!closingBracketMustBeSpaced &&
-					sourceCode.isSpaceBetweenTokens(penultimate, last)
+					sourceCode.isSpaceBetween(penultimate, last)
 				) {
 					reportNoEndingSpace(node, last);
 				}

package/lib/rules/block-spacing.js

@@ -95,7 +95,7 @@ module.exports = {
 		function isValid(left, right) {
 			return (
 				!util.isTokenOnSameLine(left, right) ||
-				sourceCode.isSpaceBetweenTokens(left, right) === always
+				sourceCode.isSpaceBetween(left, right) === always
 			);
 		}
 

package/lib/rules/comma-spacing.js

@@ -178,10 +178,7 @@ module.exports = {
 						!commaTokensToIgnore.includes(token) &&
 						astUtils.isTokenOnSameLine(previousToken, token) &&
 						options.before !==
-							sourceCode.isSpaceBetweenTokens(
-								previousToken,
-								token,
-							)
+							sourceCode.isSpaceBetween(previousToken, token)
 					) {
 						report(token, "before", previousToken);
 					}
@@ -195,7 +192,7 @@ module.exports = {
 						!(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
 						astUtils.isTokenOnSameLine(token, nextToken) &&
 						options.after !==
-							sourceCode.isSpaceBetweenTokens(token, nextToken)
+							sourceCode.isSpaceBetween(token, nextToken)
 					) {
 						report(token, "after", nextToken);
 					}