@typescript-eslint/rule-tester 8.59.5-alpha.5 → 8.59.5-alpha.6

package/dist/RuleTester.d.ts

@@ -30,6 +30,11 @@ export declare class RuleTester extends TestFramework {
      */
     static only<MessageIds extends string, Options extends readonly unknown[]>(item: InvalidTestCase<MessageIds, Options>): InvalidTestCase<MessageIds, Options>;
     defineRule(name: string, rule: AnyRuleModule): void;
+    /**
+     * Verifies that the assertion options are valid
+     * @throws {Error} if the options aren't the correct type
+     */
+    private verifyAssertionOptions;
     /**
      * Adds a new rule test to execute.
      */

package/dist/RuleTester.js

@@ -346,10 +346,31 @@ class RuleTester extends TestFramework_1.TestFramework {
             item[prop]();
         }
     }
+    /**
+     * Verifies that the assertion options are valid
+     * @throws {Error} if the options aren't the correct type
+     */
+    verifyAssertionOptions(assertionOption) {
+        if (assertionOption == null) {
+            return;
+        }
+        const dataOption = assertionOption.requireData;
+        if (dataOption != null &&
+            typeof dataOption !== 'boolean' &&
+            dataOption !== 'error' &&
+            dataOption !== 'suggestion') {
+            throw new Error("The assertion option `requireData` should be of type boolean | 'error' | 'suggestion'");
+        }
+        const locationOption = assertionOption.requireLocation;
+        if (locationOption != null && typeof locationOption !== 'boolean') {
+            throw new Error('The assertion option `requireLocation` should be of type boolean');
+        }
+    }
     /**
      * Adds a new rule test to execute.
      */
     run(ruleName, rule, test) {
+        this.verifyAssertionOptions(test.assertionOptions);
         const constructor = this.constructor;
         if (this.#testerConfig.dependencyConstraints &&
             !(0, dependencyConstraints_1.satisfiesAllDependencyConstraints)(this.#testerConfig.dependencyConstraints)) {
@@ -431,7 +452,7 @@ class RuleTester extends TestFramework_1.TestFramework {
                                 this.#runHook(invalid, 'before');
                                 this.#testInvalidTemplate(ruleName, rule, 
                                 // no need to pass no infer type parameter down to private methods
-                                invalid, seenInvalidTestCases);
+                                invalid, seenInvalidTestCases, test.assertionOptions);
                             }
                             finally {
                                 this.#runHook(invalid, 'after');
@@ -644,7 +665,7 @@ class RuleTester extends TestFramework_1.TestFramework {
      * Check if the template is invalid or not
      * all invalid cases go through this.
      */
-    #testInvalidTemplate(ruleName, rule, item, seenInvalidTestCases) {
+    #testInvalidTemplate(ruleName, rule, item, seenInvalidTestCases, assertionOptions = {}) {
         node_assert_1.default.ok(typeof item.code === 'string', "Test case must specify a string value for 'code'");
         if (item.name) {
             node_assert_1.default.ok(typeof item.name === 'string', "Optional test case property 'name' must be a string");
@@ -689,6 +710,7 @@ class RuleTester extends TestFramework_1.TestFramework {
         else {
             node_assert_1.default.strictEqual(messages.length, item.errors.length, node_util_1.default.format('Should have %d error%s but had %d: %s', item.errors.length, item.errors.length === 1 ? '' : 's', messages.length, node_util_1.default.inspect(messages)));
             const hasMessageOfThisRule = messages.some(m => m.ruleId === ruleName);
+            const { requireData = false, requireLocation = false } = assertionOptions;
             // console.log({ messages });
             for (let i = 0, l = item.errors.length; i < l; i++) {
                 const error = item.errors[i];
@@ -734,6 +756,12 @@ class RuleTester extends TestFramework_1.TestFramework {
                             const rehydratedMessage = (0, interpolate_1.interpolate)(unformattedOriginalMessage, error.data);
                             node_assert_1.default.strictEqual(message.message, rehydratedMessage, `Hydrated message "${rehydratedMessage}" does not match "${message.message}"`);
                         }
+                        else {
+                            const requiresDataProperty = requireData === true || requireData === 'error';
+                            const hasPlaceholders = getMessagePlaceholders(rule.meta.messages[error.messageId])
+                                .length > 0;
+                            node_assert_1.default.ok(!requiresDataProperty || !hasPlaceholders, `Error should specify the 'data' property as the referenced message has placeholders.`);
+                        }
                     }
                     else {
                         node_assert_1.default.fail("Test error must specify either a 'messageId' or 'message'.");
@@ -750,6 +778,11 @@ class RuleTester extends TestFramework_1.TestFramework {
                     if ((0, hasOwnProperty_1.hasOwnProperty)(error, 'endColumn')) {
                         node_assert_1.default.strictEqual(message.endColumn, error.endColumn, `Error endColumn should be ${error.endColumn}`);
                     }
+                    if (requireLocation) {
+                        const locationProperties = ['line', 'column', 'endLine', 'endColumn'];
+                        const missingKeys = locationProperties.filter(key => !(0, hasOwnProperty_1.hasOwnProperty)(error, key) && (0, hasOwnProperty_1.hasOwnProperty)(message, key));
+                        node_assert_1.default.ok(missingKeys.length === 0, `Error is missing expected location properties: ${missingKeys.join(', ')}`);
+                    }
                     node_assert_1.default.ok(!message.suggestions || (0, hasOwnProperty_1.hasOwnProperty)(error, 'suggestions'), `Error at index ${i} has suggestions. Please specify 'suggestions' property on the test error object.`);
                     if ((0, hasOwnProperty_1.hasOwnProperty)(error, 'suggestions')) {
                         // Support asserting there are no suggestions
@@ -792,13 +825,20 @@ class RuleTester extends TestFramework_1.TestFramework {
                                         node_assert_1.default.ok(ruleHasMetaMessages, `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`);
                                         node_assert_1.default.ok((0, hasOwnProperty_1.hasOwnProperty)(rule.meta.messages, expectedSuggestion.messageId), `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`);
                                         node_assert_1.default.strictEqual(actualSuggestion.messageId, expectedSuggestion.messageId, `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`);
-                                        const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(actualSuggestion.desc, rule.meta.messages[expectedSuggestion.messageId], expectedSuggestion.data);
+                                        const rawSuggestionMessage = rule.meta.messages[expectedSuggestion.messageId];
+                                        const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(actualSuggestion.desc, rawSuggestionMessage, expectedSuggestion.data);
                                         node_assert_1.default.ok(unsubstitutedPlaceholders.length === 0, `The message of the suggestion has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(', ')}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? 'values' : 'value'} via the 'data' property for the suggestion in the context.report() call.`);
                                         if ((0, hasOwnProperty_1.hasOwnProperty)(expectedSuggestion, 'data')) {
                                             const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
                                             const rehydratedDesc = (0, interpolate_1.interpolate)(unformattedMetaMessage, expectedSuggestion.data);
                                             node_assert_1.default.strictEqual(actualSuggestion.desc, rehydratedDesc, `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`);
                                         }
+                                        else {
+                                            const requiresDataProperty = requireData === true || requireData === 'suggestion';
+                                            const hasPlaceholders = getMessagePlaceholders(rawSuggestionMessage).length >
+                                                0;
+                                            node_assert_1.default.ok(!requiresDataProperty || !hasPlaceholders, `${suggestionPrefix} Suggestion should specify the 'data' property as the referenced message has placeholders.`);
+                                        }
                                     }
                                     else if ((0, hasOwnProperty_1.hasOwnProperty)(expectedSuggestion, 'data')) {
                                         node_assert_1.default.fail(`${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`);

package/dist/types/AssertionOptions.d.ts

@@ -0,0 +1,14 @@
+export interface AssertionOptions {
+    /**
+     * - If `true`, each error object and each suggestion object must also specify `data` if the message referenced by `messageId` has placeholders.
+     * - If `'error'`, each error object must also specify `data` if the message referenced by `messageId` has placeholders.
+     * - If `'suggestion'`, each suggestion object must also specify `data` if the message referenced by `messageId` has placeholders.
+     * @default `false`
+     */
+    readonly requireData?: boolean | 'error' | 'suggestion';
+    /**
+     * If `true`, each `errors` block must contain location properties `line`, `column`, `endLine`, and `endColumn`. Properties `endLine` and `endColumn` may be omitted if the actual error does not contain them.
+     * @default `false`
+     */
+    readonly requireLocation?: boolean;
+}

package/dist/types/AssertionOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+import type { AssertionOptions } from './AssertionOptions';
 import type { InvalidTestCase } from './InvalidTestCase';
 import type { RuleTesterConfig } from './RuleTesterConfig';
 import type { ValidTestCase } from './ValidTestCase';
@@ -6,10 +7,12 @@ type Mutable<T> = {
 };
 export type TesterConfigWithDefaults = Mutable<Required<Pick<RuleTesterConfig, 'defaultFilenames' | 'languageOptions' | 'rules'>> & RuleTesterConfig>;
 export interface RunTests<MessageIds extends string, Options extends readonly unknown[]> {
+    readonly assertionOptions?: AssertionOptions;
     readonly invalid: readonly InvalidTestCase<MessageIds, Options>[];
     readonly valid: readonly (string | ValidTestCase<Options>)[];
 }
 export interface NormalizedRunTests<MessageIds extends string, Options extends readonly unknown[]> {
+    readonly assertionOptions?: AssertionOptions;
     readonly invalid: readonly InvalidTestCase<MessageIds, Options>[];
     readonly valid: readonly ValidTestCase<Options>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/rule-tester",
-  "version": "8.59.5-alpha.5",
+  "version": "8.59.5-alpha.6",
   "description": "Tooling to test ESLint rules",
   "files": [
     "dist",
@@ -40,9 +40,9 @@
     "json-stable-stringify-without-jsonify": "^1.0.1",
     "lodash.merge": "4.6.2",
     "semver": "^7.7.3",
-    "@typescript-eslint/parser": "8.59.5-alpha.5",
-    "@typescript-eslint/utils": "8.59.5-alpha.5",
-    "@typescript-eslint/typescript-estree": "8.59.5-alpha.5"
+    "@typescript-eslint/parser": "8.59.5-alpha.6",
+    "@typescript-eslint/typescript-estree": "8.59.5-alpha.6",
+    "@typescript-eslint/utils": "8.59.5-alpha.6"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",