feat(lint/js): add useConsistentTestIt (#9350)

Author: dyc3

.changeset/add-use-consistent-test-it.md

@@ -0,0 +1,15 @@
+---
+"@biomejs/biome": patch
+---
+
+Added the new nursery rule [useConsistentTestIt](https://biomejs.dev/linter/rules/use-consistent-test-it/) in the `test` domain. The rule enforces consistent use of either `it` or `test` for test functions in Jest/Vitest suites, with separate control for top-level tests and tests inside `describe` blocks.
+
+Invalid:
+
+```js
+test("should fly", () => {}); // Top-level test using 'test' flagged, convert to 'it'
+
+describe('pig', () => {
+  test("should fly", () => {}); // Test inside 'describe' using 'test' flagged, convert to 'it'
+});
+```

crates/biome_cli/src/execute/migrate.rs

@@ -29,6 +29,7 @@ use std::fmt::Debug;
 mod eslint;
 mod eslint_any_rule_to_biome;
 mod eslint_eslint;
+mod eslint_jest;
 mod eslint_jsxa11y;
 mod eslint_to_biome;
 mod eslint_typescript;

crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs

@@ -11,7 +11,7 @@ use std::ops::DerefMut;
 use std::vec;
 use std::{any::TypeId, marker::PhantomData, ops::Deref};
 
-use super::{eslint_jsxa11y, eslint_typescript, eslint_unicorn, ignorefile};
+use super::{eslint_jest, eslint_jsxa11y, eslint_typescript, eslint_unicorn, ignorefile};
 
 /// This modules includes implementations for deserializing an eslint configuration.
 ///
@@ -546,6 +546,11 @@ impl Deserializable for Rules {
                             }
                         }
                         // Eslint plugin rules with options that we handle
+                        "jest/consistent-test-it" | "vitest/consistent-test-it" => {
+                            if let Some(conf) = RuleConf::deserialize(ctx, &value, name) {
+                                result.insert(Rule::JestConsistentTestIt(conf));
+                            }
+                        }
                         "jsx-a11y/aria-role" => {
                             if let Some(conf) = RuleConf::deserialize(ctx, &value, name) {
                                 result.insert(Rule::Jsxa11yArioaRoles(conf));
@@ -655,6 +660,7 @@ pub(crate) enum Rule {
     NoConsole(RuleConf<Box<NoConsoleOptions>>),
     NoRestrictedGlobals(RuleConf<Box<NoRestrictedGlobal>>),
     // Eslint plugins
+    JestConsistentTestIt(RuleConf<eslint_jest::ConsistentTestItOptions>),
     Jsxa11yArioaRoles(RuleConf<Box<eslint_jsxa11y::AriaRoleOptions>>),
     TypeScriptArrayType(RuleConf<eslint_typescript::ArrayTypeOptions>),
     TypeScriptConsistentTypeImports(RuleConf<eslint_typescript::ConsistentTypeImportsOptions>),
@@ -671,6 +677,7 @@ impl Rule {
             Self::Any(name, _) => name.clone(),
             Self::NoConsole(_) => Cow::Borrowed("no-console"),
             Self::NoRestrictedGlobals(_) => Cow::Borrowed("no-restricted-globals"),
+            Self::JestConsistentTestIt(_) => Cow::Borrowed("jest/consistent-test-it"),
             Self::Jsxa11yArioaRoles(_) => Cow::Borrowed("jsx-a11y/aria-role"),
             Self::TypeScriptArrayType(_) => Cow::Borrowed("@typescript-eslint/array-type"),
             Self::TypeScriptConsistentTypeImports(_) => {

crates/biome_cli/src/execute/migrate/eslint_eslint.rs

@@ -0,0 +1,53 @@
+/// Configuration related to the
+/// [eslint-plugin-jest](https://github.com/jest-community/eslint-plugin-jest).
+///
+/// Also, the module includes implementation to convert rule options to Biome's rule options.
+use biome_deserialize_macros::Deserializable;
+use biome_rule_options::use_consistent_test_it::{TestFunctionKind, UseConsistentTestItOptions};
+
+/// Options for the [jest/consistent-test-it](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/consistent-test-it.md) rule.
+///
+/// Note: ESLint's default for `fn` is `"test"`, while Biome's default is `"it"`.
+#[derive(Debug, Default, Deserializable)]
+pub(crate) struct ConsistentTestItOptions {
+    /// The function to prefer for top-level tests. Defaults to `"test"` in ESLint.
+    #[deserializable(rename = "fn")]
+    pub function: Option<EslintTestFunctionKind>,
+    /// The function to prefer inside `describe` blocks. Defaults to the value of `fn`.
+    #[deserializable(rename = "withinDescribe")]
+    pub within_describe: Option<EslintTestFunctionKind>,
+}
+
+/// ESLint's test function kind — matches `"it"` | `"test"`.
+#[derive(Debug, Deserializable)]
+pub(crate) enum EslintTestFunctionKind {
+    It,
+    Test,
+}
+
+impl From<EslintTestFunctionKind> for TestFunctionKind {
+    fn from(val: EslintTestFunctionKind) -> Self {
+        match val {
+            EslintTestFunctionKind::It => Self::It,
+            EslintTestFunctionKind::Test => Self::Test,
+        }
+    }
+}
+
+impl From<ConsistentTestItOptions> for UseConsistentTestItOptions {
+    fn from(val: ConsistentTestItOptions) -> Self {
+        // ESLint's defaults: `fn` → "test", `withinDescribe` → "it".
+        // Always set both explicitly so the migrated config preserves ESLint behavior
+        // regardless of Biome's own defaults.
+        let fn_kind = val
+            .function
+            .map_or(TestFunctionKind::Test, TestFunctionKind::from);
+        let within_describe = val
+            .within_describe
+            .map_or(TestFunctionKind::It, TestFunctionKind::from);
+        Self {
+            function: Some(fn_kind),
+            within_describe: Some(within_describe),
+        }
+    }
+}

crates/biome_cli/src/execute/migrate/eslint_jest.rs

@@ -2,7 +2,10 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use crate::execute::migrate::unsupported_rules::UNSUPPORTED_RULES;
 
-use super::{eslint_any_rule_to_biome::migrate_eslint_any_rule, eslint_eslint, eslint_typescript};
+use super::{
+    eslint_any_rule_to_biome::migrate_eslint_any_rule, eslint_eslint, eslint_jest,
+    eslint_typescript,
+};
 use biome_analyze::RuleSource;
 use biome_configuration::analyzer::SeverityOrGroup;
 use biome_configuration::{self as biome_config};
@@ -652,6 +655,29 @@ fn migrate_eslint_rule(
                 }
             }
         }
+        eslint_eslint::Rule::JestConsistentTestIt(conf) => {
+            if migrate_eslint_any_rule(rules, &name, conf.severity(), opts, results) {
+                let severity = conf.severity();
+                let group = rules.nursery.get_or_insert_with(Default::default);
+                if let SeverityOrGroup::Group(group) = group {
+                    let rule_options =
+                        if let eslint_eslint::RuleConf::Option(_, rule_options) = conf {
+                            rule_options.into()
+                        } else {
+                            eslint_jest::ConsistentTestItOptions::default().into()
+                        };
+                    group.use_consistent_test_it =
+                        Some(biome_config::RuleFixConfiguration::WithOptions(
+                            biome_config::RuleWithFixOptions {
+                                level: severity.into(),
+                                fix: None,
+                                options: rule_options,
+                            },
+                        ));
+                }
+                results.add(&name, RuleMigrationResult::Migrated);
+            }
+        }
         eslint_eslint::Rule::Jsxa11yArioaRoles(conf) => {
             if migrate_eslint_any_rule(rules, &name, conf.severity(), opts, results)
                 && let eslint_eslint::RuleConf::Option(severity, rule_options) = conf

crates/biome_cli/src/execute/migrate/eslint_to_biome.rs

@@ -743,3 +743,132 @@ fn migrate_rules_covered_by_formatter() {
         result,
     ));
 }
+
+#[test]
+fn migrate_jest_consistent_test_it_no_options() {
+    // With both flags and --write, biome.json should get the rule at its default options.
+    let biomejson = r#"{}"#;
+    let eslintrc = r#"{ "rules": { "jest/consistent-test-it": "error" } }"#;
+
+    let fs = MemoryFileSystem::default();
+    fs.insert(Utf8Path::new("biome.json").into(), biomejson.as_bytes());
+    fs.insert(Utf8Path::new(".eslintrc.json").into(), eslintrc.as_bytes());
+
+    let mut console = BufferConsole::default();
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(
+            [
+                "migrate",
+                "eslint",
+                "--include-inspired",
+                "--include-nursery",
+                "--write",
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    // rerun with linting to verify the configuration is valid
+
+    let (fs, result) = run_cli(fs, &mut console, Args::from(["lint"].as_slice()));
+
+    assert!(result.is_ok(), "run_cli rerun returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "migrate_jest_consistent_test_it_no_options",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn migrate_jest_consistent_test_it_with_options() {
+    // Options from ESLint (fn + withinDescribe) must be preserved in biome.json.
+    let biomejson = r#"{}"#;
+    let eslintrc = r#"{
+        "rules": {
+            "jest/consistent-test-it": ["error", {
+                "fn": "it",
+                "withinDescribe": "test"
+            }]
+        }
+    }"#;
+
+    let fs = MemoryFileSystem::default();
+    fs.insert(Utf8Path::new("biome.json").into(), biomejson.as_bytes());
+    fs.insert(Utf8Path::new(".eslintrc.json").into(), eslintrc.as_bytes());
+
+    let mut console = BufferConsole::default();
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(
+            [
+                "migrate",
+                "eslint",
+                "--include-inspired",
+                "--include-nursery",
+                "--write",
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "migrate_jest_consistent_test_it_with_options",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn migrate_vitest_consistent_test_it_with_options() {
+    // vitest/consistent-test-it maps to the same Biome rule; options must be preserved.
+    let biomejson = r#"{}"#;
+    let eslintrc = r#"{
+        "rules": {
+            "vitest/consistent-test-it": ["error", {
+                "fn": "it",
+                "withinDescribe": "test"
+            }]
+        }
+    }"#;
+
+    let fs = MemoryFileSystem::default();
+    fs.insert(Utf8Path::new("biome.json").into(), biomejson.as_bytes());
+    fs.insert(Utf8Path::new(".eslintrc.json").into(), eslintrc.as_bytes());
+
+    let mut console = BufferConsole::default();
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(
+            [
+                "migrate",
+                "eslint",
+                "--include-inspired",
+                "--include-nursery",
+                "--write",
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "migrate_vitest_consistent_test_it_with_options",
+        fs,
+        console,
+        result,
+    ));
+}

crates/biome_cli/tests/commands/migrate_eslint.rs

@@ -95,6 +95,34 @@ test1.js:1:10 lint/suspicious/noFocusedTests  FIXABLE  ━━━━━━━━
 
 ```
 
+```block
+test2.js:5:5 lint/nursery/useConsistentTestIt  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Prefer using it over test for test functions.
+  
+    3 │ 	beforeEach(() => {});
+    4 │     beforeEach(() => {});
+  > 5 │     test("bar", () => {
+      │     ^^^^
+    6 │         someFn();
+    7 │     });
+  
+  i Use it consistently for all test function calls.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Safe fix: Use it instead.
+  
+    3 3 │   	beforeEach(() => {});
+    4 4 │       beforeEach(() => {});
+    5   │ - ····test("bar",·()·=>·{
+      5 │ + ····it("bar",·()·=>·{
+    6 6 │           someFn();
+    7 7 │       });
+  
+
+```
+
 ```block
 test2.js:4:5 lint/suspicious/noDuplicateTestHooks ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
@@ -115,6 +143,6 @@ test2.js:4:5 lint/suspicious/noDuplicateTestHooks ━━━━━━━━━━
 ```block
 Checked 2 files in <TIME>. No fixes applied.
 Found 1 error.
-Found 1 warning.
+Found 2 warnings.
 Found 1 info.
 ```