feat(test): refactor for v9

test/configs.ts

@@ -1,77 +1,75 @@
-import { ESLint } from 'eslint';
+import babelPlugin from '@babel/eslint-plugin';
+import type { Linter } from 'eslint';
+import eslintPluginUnicorn from 'eslint-plugin-unicorn';
+
+import disableAutofix from 'eslint-plugin-disable-autofix';
 
 const baseConfig = {
-  root: true,
-  env: {
-    es2024: true,
-  },
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
+  languageOptions: {
+    ecmaVersion: 2024,
   },
 };
 
 export const builtin = {
   fix: {
     ...baseConfig,
-    extends: ['eslint:all'],
     rules: {
-      'no-unused-vars': 0,
-      'prefer-const': 1,
-      'eol-last': 0,
+      'no-unused-vars': 'off',
+      'prefer-const': 'warn',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
   disable: {
     ...baseConfig,
-    plugins: ['disable-autofix'],
-    extends: ['eslint:all'],
+    plugins: { 'disable-autofix': disableAutofix },
     rules: {
-      'prefer-const': 0,
-      'disable-autofix/prefer-const': 1,
-      'no-unused-vars': 0,
-      'eol-last': 0,
+      'prefer-const': 'off',
+      'disable-autofix/prefer-const': 'warn',
+      'no-unused-vars': 'off',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
 };
 
 export const unicorn = {
   fix: {
     ...baseConfig,
-    plugins: ['unicorn'],
-    extends: ['plugin:unicorn/recommended'],
+    plugins: { unicorn: eslintPluginUnicorn },
     rules: {
-      'unicorn/prevent-abbreviations': 1,
-      'eol-last': 0,
+      'unicorn/prevent-abbreviations': 'warn',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
   disable: {
     ...baseConfig,
-    plugins: ['disable-autofix', 'unicorn'],
-    extends: ['plugin:unicorn/recommended'],
+    plugins: {
+      'disable-autofix': disableAutofix,
+      unicorn: eslintPluginUnicorn,
+    },
     rules: {
-      'unicorn/prevent-abbreviations': 0,
-      'disable-autofix/unicorn/prevent-abbreviations': 1,
-      'eol-last': 0,
+      'unicorn/prevent-abbreviations': 'off',
+      'disable-autofix/unicorn/prevent-abbreviations': 'warn',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
 };
 
 export const babel = {
   fix: {
     ...baseConfig,
-    plugins: ['@babel'],
+    plugins: { '@babel': babelPlugin },
     rules: {
-      '@babel/object-curly-spacing': 1,
-      'eol-last': 0,
+      '@babel/object-curly-spacing': 'warn',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
   disable: {
     ...baseConfig,
-    plugins: ['disable-autofix', '@babel'],
+    plugins: { 'disable-autofix': disableAutofix, '@babel': babelPlugin },
     rules: {
-      '@babel/object-curly-spacing': 0,
-      'disable-autofix/@babel/object-curly-spacing': 1,
-      'eol-last': 0,
+      '@babel/object-curly-spacing': 'off',
+      'disable-autofix/@babel/object-curly-spacing': 'warn',
+      'eol-last': 'off',
     },
-  } as ESLint.ConfigData,
+  } as Linter.FlatConfig,
 };

test/eslint.ts

@@ -1,20 +1,9 @@
-import { ESLint } from 'eslint';
+import { Linter } from 'eslint';
 
-const eslint = async (text: string, config: ESLint.ConfigData) => {
+const eslint = async (text: string, config: Linter.FlatConfig) => {
   try {
-    const options: ESLint.Options = {
-      fix: true,
-      overrideConfig: config,
-      useEslintrc: false,
-      plugins: {
-        'eslint-plugin-disable-autofix': require('../dist') as ESLint.Plugin,
-      },
-    };
-
-    const eslint = new ESLint(options);
-    const results = await eslint.lintText(text);
-
-    return results[0].output;
+    const linter = new Linter();
+    return linter.verifyAndFix(text, [config]);
   } catch (error) {
     return error;
   }

test/rule.test.ts

@@ -1,54 +1,67 @@
+import { describe, expect, it } from '@jest/globals';
+import type { Linter } from 'eslint';
+
 import { builtin, unicorn, babel } from './configs';
 import eslint from './eslint';
 
-interface Results {
-  output: string | undefined;
-  message: string | undefined;
-}
-
 describe('test rule fix disable', () => {
   it('fixes the builtin rule', async () => {
     expect.hasAssertions();
     const inputText = 'let test = true;';
     const outputText = 'const test = true;';
-    const results = (await eslint(inputText, builtin.fix)) as Results;
-    expect(results).toBe(outputText);
+    const results = (await eslint(inputText, builtin.fix)) as Linter.FixReport;
+    expect(results.output).toBe(outputText);
+    expect(results.fixed).toBe(true);
   });
 
   it('does not fix the builtin rule', async () => {
     expect.hasAssertions();
     const inputText = 'let test = true;';
-    const results = (await eslint(inputText, builtin.disable)) as Results;
-    expect(results).toBeUndefined();
+    const results = (await eslint(
+      inputText,
+      builtin.disable,
+    )) as Linter.FixReport;
+    expect(results.output).toBe(inputText);
+    expect(results.fixed).toBe(false);
   });
 
   it('fixes the plugin rule', async () => {
     expect.hasAssertions();
     const inputText = 'const env = true';
     const outputText = 'const environment = true';
-    const results = (await eslint(inputText, unicorn.fix)) as Results;
-    expect(results).toBe(outputText);
+    const results = (await eslint(inputText, unicorn.fix)) as Linter.FixReport;
+    expect(results.output).toBe(outputText);
+    expect(results.fixed).toBe(true);
   });
 
   it('does not fix the plugin rule', async () => {
     expect.hasAssertions();
     const inputText = 'const environment = true';
-    const results = (await eslint(inputText, unicorn.disable)) as Results;
-    expect(results).toBeUndefined();
+    const results = (await eslint(
+      inputText,
+      unicorn.disable,
+    )) as Linter.FixReport;
+    expect(results.output).toBe(inputText);
+    expect(results.fixed).toBe(false);
   });
 
   it('fixes the scoped plugin rule', async () => {
     expect.hasAssertions();
     const inputText = 'const object = { property: true }';
     const outputText = 'const object = {property: true}';
-    const results = (await eslint(inputText, babel.fix)) as Results;
-    expect(results).toBe(outputText);
+    const results = (await eslint(inputText, babel.fix)) as Linter.FixReport;
+    expect(results.output).toBe(outputText);
+    expect(results.fixed).toBe(true);
   });
 
   it('does not fix the scoped plugin rule', async () => {
     expect.hasAssertions();
     const inputText = 'const object = { property: true }';
-    const results = (await eslint(inputText, babel.disable)) as Results;
-    expect(results).toBeUndefined();
+    const results = (await eslint(
+      inputText,
+      babel.disable,
+    )) as Linter.FixReport;
+    expect(results.output).toBe(inputText);
+    expect(results.fixed).toBe(false);
   });
 });