feat: add error message id generic type support (#14)

Author: 9romise

src/rule-tester.ts

@@ -15,7 +15,7 @@ import { isUsingTypeScriptParser, normalizeCaseError, normalizeTestCase } from '
 import { getAjvInstance, getRuleOptionsSchema } from './vendor/ajv'
 import { applyFixes } from './vendor/fixer'
 
-export function createRuleTester<RuleOptions = any>(options: RuleTesterInitOptions): RuleTester<RuleOptions> {
+export function createRuleTester<RuleOptions = any, MessageId extends string = string>(options: RuleTesterInitOptions): RuleTester<RuleOptions, MessageId> {
   const languageOptions = deepMerge(
     options.languageOptions ?? {
       parser: options.parser,
@@ -48,7 +48,7 @@ export function createRuleTester<RuleOptions = any>(options: RuleTesterInitOptio
     ...options.defaultFilenames,
   }
 
-  async function each(c: TestCase<RuleOptions>) {
+  async function each(c: TestCase<RuleOptions, MessageId>) {
     const testcase = normalizeTestCase(c, languageOptions, defaultFilenames)
 
     const {
@@ -207,13 +207,13 @@ export function createRuleTester<RuleOptions = any>(options: RuleTesterInitOptio
     return result
   }
 
-  async function invalid(arg: InvalidTestCase<RuleOptions> | string) {
+  async function invalid(arg: InvalidTestCase<RuleOptions, MessageId> | string) {
     const result = await each(arg)
     expect.soft(result.result.messages, 'expect errors').not.toEqual([])
     return result
   }
 
-  async function run(cases: TestCasesOptions<RuleOptions>) {
+  async function run(cases: TestCasesOptions<RuleOptions, MessageId>) {
     describe(options.name || 'rule-to-test', () => {
       if (cases.valid?.length) {
         describe('valid', () => {

src/run.ts

@@ -4,21 +4,21 @@ import { createRuleTester } from './rule-tester'
 /**
  * Shortcut to run test cases for a rule
  */
-export function run<RuleOptions = any>(options: TestCasesOptions<RuleOptions> & RuleTesterInitOptions) {
-  const tester = createRuleTester<RuleOptions>(options)
+export function run<RuleOptions = any, MessageId extends string = string>(options: TestCasesOptions<RuleOptions, MessageId> & RuleTesterInitOptions) {
+  const tester = createRuleTester<RuleOptions, MessageId>(options)
   return tester.run(options)
 }
 
 /**
  * Shortcut to run test cases for a rule in classic style
  */
-export function runClassic<RuleOptions = any>(
+export function runClassic<RuleOptions = any, MessageId extends string = string>(
   ruleName: string,
   rule: RuleModule,
-  cases: TestCasesOptions<RuleOptions>,
+  cases: TestCasesOptions<RuleOptions, MessageId>,
   options?: RuleTesterInitOptions,
 ) {
-  const tester = createRuleTester<RuleOptions>({
+  const tester = createRuleTester<RuleOptions, MessageId>({
     rule,
     name: ruleName,
     ...options,

src/types.ts

@@ -1,24 +1,24 @@
 import type { Linter } from 'eslint'
 
 export type Awaitable<T> = Promise<T> | T
-export interface ValidTestCaseBase<RuleOptions = any> extends CompatConfigOptions, RuleTesterBehaviorOptions {
+export interface ValidTestCaseBase<RuleOptions = any, MessageId extends string = string> extends CompatConfigOptions, RuleTesterBehaviorOptions {
   name?: string
   description?: string
   code: string
   options?: RuleOptions
   filename?: string
   only?: boolean
   skip?: boolean
-  before?: (this: NormalizedTestCase, configs: Linter.Config[]) => Awaitable<void>
-  after?: (this: NormalizedTestCase, result: Linter.FixReport) => Awaitable<void>
+  before?: (this: NormalizedTestCase<RuleOptions, MessageId>, configs: Linter.Config[]) => Awaitable<void>
+  after?: (this: NormalizedTestCase<RuleOptions, MessageId>, result: Linter.FixReport) => Awaitable<void>
 
   /**
    * @deprecated Use `after` instead
    */
   onResult?: (result: Linter.FixReport) => void
 }
 
-export interface TestCaseError extends Partial<Linter.LintMessage> {
+export type TestCaseError<MessageId extends string = string> = Partial<Linter.LintMessage> & {
   /**
    * Data for interpolate the error message
    */
@@ -27,32 +27,33 @@ export interface TestCaseError extends Partial<Linter.LintMessage> {
    * Alias to `nodeType`
    */
   type?: string
+  messageId?: MessageId
 }
 
-export interface InvalidTestCaseBase<RuleOptions = any> extends ValidTestCaseBase<RuleOptions> {
+export interface InvalidTestCaseBase<RuleOptions = any, MessageId extends string = string> extends ValidTestCaseBase<RuleOptions, MessageId> {
   /**
    * Expected errors.
    * If a number is provided, it asserts that the number of errors is equal to the number provided.
    * If an array of strings is provided, it asserts that the error messageIds are equal to the array provided.
    * If an array of objects is provided, it asserts that the errors are partially equal to the objects provided.
    */
-  errors?: number | (string | TestCaseError)[] | ((errors: Linter.LintMessage[]) => Awaitable<void>)
+  errors?: number | (MessageId | TestCaseError<MessageId>)[] | ((errors: Linter.LintMessage[]) => Awaitable<void>)
   /**
    * Assert if output is expected.
    * Pass `null` to assert that the output is the same as the input.
    */
   output?: string | null | ((output: string, input: string) => Awaitable<void>)
 }
 
-export interface NormalizedTestCase extends InvalidTestCaseBase {
+export interface NormalizedTestCase<RuleOptions = any, MessageId extends string = string> extends InvalidTestCaseBase<RuleOptions, MessageId> {
   type: 'valid' | 'invalid'
   code: string
 }
 
-export type InvalidTestCase<RuleOptions = any> = InvalidTestCaseBase<RuleOptions> | string
+export type InvalidTestCase<RuleOptions = any, MessageId extends string = string> = InvalidTestCaseBase<RuleOptions, MessageId> | string
 export type ValidTestCase<RuleOptions = any> = ValidTestCaseBase<RuleOptions> | string
 
-export type TestCase<RuleOptions = any> = ValidTestCase<RuleOptions> | InvalidTestCase<RuleOptions>
+export type TestCase<RuleOptions = any, MessageId extends string = string> = ValidTestCase<RuleOptions> | InvalidTestCase<RuleOptions, MessageId>
 
 export interface TestExecutionResult extends Linter.FixReport {
   /**
@@ -73,23 +74,23 @@ export interface CompatConfigOptions {
 
 export type RuleModule = any // to allow any rule module
 
-export interface RuleTester<RuleOptions = any> {
+export interface RuleTester<RuleOptions = any, MessageId extends string = string> {
   /**
    * Run a single test case
    */
-  each: (arg: TestCase<RuleOptions>) => Promise<{ testcase: NormalizedTestCase, result: TestExecutionResult }>
+  each: (arg: TestCase<RuleOptions, MessageId>) => Promise<{ testcase: NormalizedTestCase<RuleOptions, MessageId>, result: TestExecutionResult }>
   /**
    * Run a single valid test case
    */
-  valid: (arg: ValidTestCase<RuleOptions>) => Promise<{ testcase: NormalizedTestCase, result: TestExecutionResult }>
+  valid: (arg: ValidTestCase<RuleOptions>) => Promise<{ testcase: NormalizedTestCase<RuleOptions, MessageId>, result: TestExecutionResult }>
   /**
    * Run a single invalid test case
    */
-  invalid: (arg: InvalidTestCase<RuleOptions>) => Promise<{ testcase: NormalizedTestCase, result: TestExecutionResult }>
+  invalid: (arg: InvalidTestCase<RuleOptions, MessageId>) => Promise<{ testcase: NormalizedTestCase<RuleOptions, MessageId>, result: TestExecutionResult }>
   /**
    * ESLint's RuleTester style test runner, that runs multiple test cases
    */
-  run: (options: TestCasesOptions<RuleOptions>) => Promise<void>
+  run: (options: TestCasesOptions<RuleOptions, MessageId>) => Promise<void>
 }
 
 export interface RuleTesterBehaviorOptions {
@@ -137,11 +138,11 @@ export interface RuleTesterInitOptions extends CompatConfigOptions, RuleTesterBe
   defaultFilenames?: Partial<DefaultFilenames>
 }
 
-export interface TestCasesOptions<RuleOptions = any> {
+export interface TestCasesOptions<RuleOptions = any, MessageId extends string = string> {
   valid?: (ValidTestCase<RuleOptions> | string)[]
-  invalid?: (InvalidTestCase<RuleOptions> | string)[]
+  invalid?: (InvalidTestCase<RuleOptions, MessageId> | string)[]
   /**
    * Callback to be called after each test case
    */
-  onResult?: (_case: NormalizedTestCase, result: Linter.FixReport) => void | Promise<void>
+  onResult?: (_case: NormalizedTestCase<RuleOptions, MessageId>, result: Linter.FixReport) => void | Promise<void>
 }

src/utils.ts

@@ -7,16 +7,16 @@ import { interpolate } from './vendor/interpolate'
 
 export { unindent as $, unindent }
 
-export function normalizeTestCase(
-  c: TestCase,
+export function normalizeTestCase<RuleOptions = any, MessageId extends string = string>(
+  c: TestCase<RuleOptions, MessageId>,
   languageOptions: Linter.Config['languageOptions'],
   defaultFilenames: DefaultFilenames,
   type?: 'valid' | 'invalid',
-): NormalizedTestCase {
+): NormalizedTestCase<RuleOptions, MessageId> {
   const obj = typeof c === 'string'
     ? { code: c }
     : { ...c }
-  const normalized = obj as NormalizedTestCase
+  const normalized = obj as NormalizedTestCase<RuleOptions, MessageId>
   normalized.type ||= type || (('errors' in obj || 'output' in obj) ? 'invalid' : 'valid')
 
   const merged: Linter.Config['languageOptions'] = {
@@ -47,7 +47,7 @@ export function normalizeTestCase(
   return normalized
 }
 
-export function normalizeCaseError(error: TestCaseError | string, rule?: RuleModule): Partial<Linter.LintMessage> {
+export function normalizeCaseError<MessageId extends string = string>(error: TestCaseError<MessageId> | MessageId, rule?: RuleModule): Partial<Linter.LintMessage> {
   if (typeof error === 'string')
     return { messageId: error }
   const clone = { ...error }