Exclude bundled gems from test discovery

Test discovery was finding tests in .bundle/gems and vendor/bundle
directories, which contain bundled gem code. This adds an exclude
pattern to prevent these directories from being scanned during test
discovery.

Fixes #3949.

Author: rafaelfranca

jekyll/test_explorer.markdown

@@ -56,6 +56,8 @@ To discover all test files in the workspace with decent performance, the Ruby LS
 conventions. For a test file to be discovered, the file path must match this glob:
 `**/{test,spec,features}/**/{*_test.rb,test_*.rb,*_spec.rb,*.feature}`
 
+Tests in bundled gems (located in `.bundle/` or `vendor/bundle/`) are automatically excluded from discovery.
+
 ### Dynamically defined tests
 
 There is limited support for tests defined via meta-programming. Initially, they will not be present in the test

vscode/src/test/suite/testController.test.ts

@@ -147,23 +147,50 @@ suite("TestController", () => {
     );
   }
 
-  function createWorkspaceWithTestFile() {
+  function createWorkspaceWithTestFile(
+    options: {
+      testDir?: string;
+      testFileName?: string;
+      testContent?: string;
+      index?: number;
+      additionalFiles?: Array<{ path: string; content: string }>;
+    } = {},
+  ) {
+    const {
+      testDir = "test",
+      testFileName = "foo_test.rb",
+      testContent = "require 'test_helper'\n\nclass FooTest < Minitest::Test; def test_foo; end; end",
+      index = 1,
+      additionalFiles = [],
+    } = options;
+
     const workspacePath = fs.mkdtempSync(path.join(os.tmpdir(), "ruby-lsp-test-controller-"));
     const workspaceUri = vscode.Uri.file(workspacePath);
 
-    fs.mkdirSync(path.join(workspaceUri.fsPath, "test"));
-    const testFilePath = path.join(workspaceUri.fsPath, "test", "foo_test.rb");
-    fs.writeFileSync(testFilePath, "require 'test_helper'\n\nclass FooTest < Minitest::Test; def test_foo; end; end");
+    fs.mkdirSync(path.join(workspaceUri.fsPath, testDir), { recursive: true });
+    const testFilePath = path.join(workspaceUri.fsPath, testDir, testFileName);
+    fs.writeFileSync(testFilePath, testContent);
+
+    // Create additional files if specified
+    additionalFiles.forEach(({ path: filePath, content }) => {
+      const fullPath = path.join(workspaceUri.fsPath, filePath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, content);
+    });
 
     const workspaceFolder: vscode.WorkspaceFolder = {
       uri: workspaceUri,
       name: path.basename(workspacePath),
-      index: 1,
+      index,
     };
 
     return { workspaceFolder, testFileUri: vscode.Uri.file(testFilePath) };
   }
 
+  function cleanupWorkspace(workspaceFolder: vscode.WorkspaceFolder) {
+    fs.rmSync(workspaceFolder.uri.fsPath, { recursive: true, force: true });
+  }
+
   function stubWorkspaceOperations(...workspaces: vscode.WorkspaceFolder[]) {
     workspaceStubs.forEach((stub) => stub.restore());
     workspaceStubs = [];
@@ -927,4 +954,110 @@ suite("TestController", () => {
 
     assert.ok(spy.calledOnce);
   });
+
+  test("does not discover tests in .bundle directory", async () => {
+    const { workspaceFolder, testFileUri } = createWorkspaceWithTestFile({
+      testFileName: "my_test.rb",
+      testContent: "class MyTest < Minitest::Test; end",
+      index: 0,
+      additionalFiles: [
+        {
+          path: ".bundle/gems/test/gem_test.rb",
+          content: "class GemTest < Minitest::Test; end",
+        },
+      ],
+    });
+
+    stubWorkspaceOperations(workspaceFolder);
+
+    await controller.testController.resolveHandler!(undefined);
+
+    const collection = controller.testController.items;
+    const testDir = collection.get(vscode.Uri.joinPath(workspaceFolder.uri, "test").toString());
+
+    // Should find the regular test file
+    assert.ok(testDir);
+    const regularTest = testDir.children.get(testFileUri.toString());
+    assert.ok(regularTest, "Regular test file should be discovered");
+
+    // Should NOT find the bundled gem test file
+    const bundledTestDir = collection.get(
+      vscode.Uri.joinPath(workspaceFolder.uri, ".bundle", "gems", "test").toString(),
+    );
+    assert.strictEqual(bundledTestDir, undefined, "Bundled gem directory should not be discovered");
+
+    cleanupWorkspace(workspaceFolder);
+  });
+
+  test("does not discover tests in vendor/bundle directory", async () => {
+    const { workspaceFolder, testFileUri } = createWorkspaceWithTestFile({
+      testDir: "spec",
+      testFileName: "my_spec.rb",
+      testContent: "RSpec.describe 'MySpec' do; end",
+      index: 0,
+      additionalFiles: [
+        {
+          path: "vendor/bundle/gems/spec/gem_spec.rb",
+          content: "RSpec.describe 'GemSpec' do; end",
+        },
+      ],
+    });
+
+    stubWorkspaceOperations(workspaceFolder);
+
+    await controller.testController.resolveHandler!(undefined);
+
+    const collection = controller.testController.items;
+    const specDir = collection.get(vscode.Uri.joinPath(workspaceFolder.uri, "spec").toString());
+
+    // Should find the regular spec file
+    assert.ok(specDir);
+    const regularSpec = specDir.children.get(testFileUri.toString());
+    assert.ok(regularSpec, "Regular spec file should be discovered");
+
+    // Should NOT find the bundled gem test file
+    const bundledTestDir = collection.get(
+      vscode.Uri.joinPath(workspaceFolder.uri, "vendor", "bundle", "gems", "test").toString(),
+    );
+    assert.strictEqual(bundledTestDir, undefined, "Bundled gem directory should not be discovered");
+
+    cleanupWorkspace(workspaceFolder);
+  });
+
+  suite("isInBundledGems", () => {
+    test("detects files in .bundle directory", () => {
+      const uri = vscode.Uri.file("/workspace/.bundle/gems/ruby/3.3.0/gems/rspec-core-3.12.0/spec/rspec_spec.rb");
+      assert.ok((controller as any).isInBundledGems(uri));
+    });
+
+    test("detects files in vendor/bundle directory", () => {
+      const uri = vscode.Uri.file("/workspace/vendor/bundle/ruby/3.3.0/gems/rspec-core-3.12.0/spec/rspec_spec.rb");
+      assert.ok((controller as any).isInBundledGems(uri));
+    });
+
+    test("detects files in nested .bundle paths", () => {
+      const uri = vscode.Uri.file("/workspace/subfolder/.bundle/ruby/3.3.0/gems/minitest-5.0.0/test/minitest_test.rb");
+      assert.ok((controller as any).isInBundledGems(uri));
+    });
+
+    test("does not detect regular test files", () => {
+      const uri = vscode.Uri.file("/workspace/test/models/user_test.rb");
+      assert.strictEqual((controller as any).isInBundledGems(uri), false);
+    });
+
+    test("does not detect spec files in regular paths", () => {
+      const uri = vscode.Uri.file("/workspace/spec/models/user_spec.rb");
+      assert.strictEqual((controller as any).isInBundledGems(uri), false);
+    });
+
+    test("does not detect files with 'bundle' in name but not in bundled gems directory", () => {
+      const uri = vscode.Uri.file("/workspace/test/bundle_test.rb");
+      assert.strictEqual((controller as any).isInBundledGems(uri), false);
+    });
+
+    test("does not detect files with 'vendor' in name but not in vendor/bundle", () => {
+      const uri = vscode.Uri.file("/workspace/test/vendor_test.rb");
+      assert.strictEqual((controller as any).isInBundledGems(uri), false);
+    });
+  });
 });

vscode/src/testController.ts

@@ -15,6 +15,7 @@ const asyncExec = promisify(exec);
 
 const NESTED_TEST_DIR_PATTERN = "**/{test,spec,features}/**/";
 const TEST_FILE_PATTERN = `${NESTED_TEST_DIR_PATTERN}{*_test.rb,test_*.rb,*_spec.rb,*.feature}`;
+const BUNDLED_GEMS_EXCLUDE_PATTERN = "{**/.bundle/**,**/vendor/bundle/**}";
 
 interface CodeLensData {
   type: string;
@@ -142,6 +143,10 @@ export class TestController {
       testFileWatcher,
       nestedTestDirWatcher,
       testFileWatcher.onDidCreate(async (uri) => {
+        if (this.isInBundledGems(uri)) {
+          return;
+        }
+
         const workspace = vscode.workspace.getWorkspaceFolder(uri);
 
         if (!workspace || !vscode.workspace.workspaceFolders) {
@@ -160,6 +165,10 @@ export class TestController {
         await this.addTestItemsForFile(uri, workspace, initialCollection);
       }),
       testFileWatcher.onDidChange(async (uri) => {
+        if (this.isInBundledGems(uri)) {
+          return;
+        }
+
         const item = await this.getParentTestItem(uri);
 
         if (item) {
@@ -172,6 +181,10 @@ export class TestController {
         }
       }),
       nestedTestDirWatcher.onDidDelete(async (uri) => {
+        if (this.isInBundledGems(uri)) {
+          return;
+        }
+
         const pathParts = uri.fsPath.split(path.sep);
         if (pathParts.includes(".git")) {
           return;
@@ -184,6 +197,10 @@ export class TestController {
         }
       }),
       testFileWatcher.onDidDelete(async (uri) => {
+        if (this.isInBundledGems(uri)) {
+          return;
+        }
+
         const item = await this.getParentTestItem(uri);
 
         if (item) {
@@ -981,7 +998,7 @@ export class TestController {
       for (const workspaceFolder of workspaceFolders) {
         // Check if there is at least one Ruby test file in the workspace, otherwise we don't consider it
         const pattern = this.testPattern(workspaceFolder);
-        const files = await vscode.workspace.findFiles(pattern, undefined, 1);
+        const files = await vscode.workspace.findFiles(pattern, BUNDLED_GEMS_EXCLUDE_PATTERN, 1);
         if (files.length === 0) {
           continue;
         }
@@ -1002,7 +1019,7 @@ export class TestController {
   ) {
     const initialCollection = item ? item.children : this.testController.items;
     const pattern = this.testPattern(workspaceFolder);
-    const filePaths = await vscode.workspace.findFiles(pattern);
+    const filePaths = await vscode.workspace.findFiles(pattern, BUNDLED_GEMS_EXCLUDE_PATTERN);
     const increment = Math.floor(filePaths.length / 100);
 
     for (const uri of filePaths) {
@@ -1146,6 +1163,11 @@ export class TestController {
     return false;
   }
 
+  private isInBundledGems(uri: vscode.Uri): boolean {
+    const pathParts = uri.fsPath.split(path.sep);
+    return pathParts.includes(".bundle") || pathParts.includes("vendor");
+  }
+
   private testPattern(workspaceFolder: vscode.WorkspaceFolder) {
     return new vscode.RelativePattern(workspaceFolder, TEST_FILE_PATTERN);
   }