fix: harden additional test source discovery

Author: sudovinay01

package.nls.json

@@ -7,7 +7,7 @@
     "contributes.commands.java.test.goToTest.title": "Go to Test",
     "contributes.commands.java.test.goToTestSubject.title": "Go to Test Subject",
     "configuration.java.test.defaultConfig.description": "Specify the name of the default test configuration.",
-    "configuration.java.test.additionalTestSourcePaths.description": "Additional source paths or glob patterns to scan for Java tests.",
+    "configuration.java.test.additionalTestSourcePaths.description": "Additional source paths or glob patterns to scan for Java tests. Broad patterns may slow discovery.",
     "configuration.java.test.config.description": "Specify the configurations for running the tests.",
     "configuration.java.test.config.item.description": "Specify the configuration item for running the tests.",
     "configuration.java.test.config.name.description": "Specify the name of the configuration item.",

package.nls.zh.json

@@ -1,5 +1,5 @@
 {
-    "configuration.java.test.additionalTestSourcePaths.description": "用于搜索 Java 测试的其他源路径或 glob 模式。",
+    "configuration.java.test.additionalTestSourcePaths.description": "用于搜索 Java 测试的其他源路径或 glob 模式。过于宽泛的模式可能会降低发现速度。",
     "description": "运行并调试 JUnit 或 TestNG 测试用例",
     "contributes.commands.java.test.editor.run.title": "运行测试用例",
     "contributes.commands.java.test.editor.debug.title": "调试测试用例",

src/controller/testController.ts

@@ -51,10 +51,24 @@ export function creatTestProfile(name: string, kind: TestRunProfileKind): void {
     testController?.createRunProfile(name, kind, runHandler, false, runnableTag);
 }
 
-export async function refreshTestSourcePaths(): Promise<void> {
-    testSourceProvider.clear();
-    await refreshExplorer();
-    await startWatchingWorkspace();
+let refreshTestSourcePathsPromise: Promise<void> | undefined;
+let refreshTestSourcePathsRequested: boolean = false;
+
+export function refreshTestSourcePaths(): Promise<void> {
+    refreshTestSourcePathsRequested = true;
+    if (!refreshTestSourcePathsPromise) {
+        refreshTestSourcePathsPromise = (async () => {
+            while (refreshTestSourcePathsRequested) {
+                refreshTestSourcePathsRequested = false;
+                testSourceProvider.clear();
+                await refreshExplorer();
+                await startWatchingWorkspace();
+            }
+        })().finally(() => {
+            refreshTestSourcePathsPromise = undefined;
+        });
+    }
+    return refreshTestSourcePathsPromise;
 }
 
 export const loadChildren: (item: TestItem, token?: CancellationToken, force?: boolean) => Promise<void> = instrumentOperation('java.test.explorer.loadChildren', async (_operationId: string, item: TestItem, token?: CancellationToken, force: boolean = false) => {

src/provider/testSourceProvider.ts

@@ -91,6 +91,7 @@ class TestSourcePathProvider {
 }
 
 let additionalTestSourceOutputChannel: OutputChannel | undefined;
+const LARGE_ADDITIONAL_TEST_SOURCE_COUNT: number = 100;
 
 export function mergeTestSourcePaths(testPaths: ITestSourcePath[], additionalPaths: string[]): ITestSourcePath[] {
     const mergedPaths: ITestSourcePath[] = [];
@@ -153,14 +154,22 @@ export async function resolveAdditionalTestSourcePaths(workspacePath: string, co
             }
         } catch (error) {
             const message: string = error instanceof Error ? error.message : String(error);
-            additionalTestSourceOutputChannel ??= window.createOutputChannel('Test Runner for Java');
-            additionalTestSourceOutputChannel.appendLine(
-                `Failed to expand additional test source pattern "${configuredPath}": ${message}`);
+            logAdditionalTestSourceMessage(`Failed to expand additional test source pattern "${configuredPath}": ${message}`);
         }
     }
+
+    if (paths.length > LARGE_ADDITIONAL_TEST_SOURCE_COUNT) {
+        logAdditionalTestSourceMessage(
+            `Additional test source patterns matched ${paths.length} directories. Broad patterns may slow discovery.`);
+    }
     return paths;
 }
 
+function logAdditionalTestSourceMessage(message: string): void {
+    additionalTestSourceOutputChannel ??= window.createOutputChannel('Test Runner for Java');
+    additionalTestSourceOutputChannel.appendLine(message);
+}
+
 function addUniquePath(paths: string[], pathKeys: Set<string>, sourcePath: string): void {
     const key: string = getPathKey(sourcePath);
     if (!pathKeys.has(key)) {

test/suite/testController.loadChildren.test.ts

@@ -56,6 +56,37 @@ suite('testController - loadChildren', () => {
         sinon.assert.callOrder(clearPathsStub, refreshExplorerStub, watcherPatternsStub, additionalPathsStub);
     });
 
+    test('serializes overlapping source-path refresh requests', async () => {
+        let releaseFirstRefresh!: () => void;
+        let signalFirstRefreshStarted!: () => void;
+        const firstRefreshStarted: Promise<void> = new Promise((resolve) => {
+            signalFirstRefreshStarted = resolve;
+        });
+        const firstRefreshGate: Promise<void> = new Promise((resolve) => {
+            releaseFirstRefresh = resolve;
+        });
+        const clearPathsStub = sinon.stub(testSourceProvider, 'clear');
+        const refreshExplorerStub = sinon.stub(testExplorerCommands, 'refreshExplorer').callsFake(async () => {
+            if (refreshExplorerStub.callCount === 1) {
+                signalFirstRefreshStarted();
+                await firstRefreshGate;
+            }
+        });
+        const watcherPatternsStub = sinon.stub(testSourceProvider, 'getTestSourcePattern').resolves([]);
+        const additionalPathsStub = sinon.stub(testSourceProvider, 'getAdditionalTestSourcePaths').resolves([]);
+
+        const firstRefresh: Promise<void> = refreshTestSourcePaths();
+        await firstRefreshStarted;
+        const overlappingRefresh: Promise<void> = refreshTestSourcePaths();
+        releaseFirstRefresh();
+        await Promise.all([firstRefresh, overlappingRefresh]);
+
+        assert.strictEqual(clearPathsStub.callCount, 2);
+        assert.strictEqual(refreshExplorerStub.callCount, 2);
+        assert.strictEqual(watcherPatternsStub.callCount, 2);
+        assert.strictEqual(additionalPathsStub.callCount, 2);
+    });
+
     test('scans Java files found under configured additional source roots', async () => {
         const javaFile: Uri = Uri.file('/workspace/additional/src/MainSourceTest.java');
         const refreshExplorerStub = sinon.stub(testExplorerCommands, 'refreshExplorer').resolves();

test/suite/testSourceProvider.test.ts

@@ -5,7 +5,10 @@ import * as assert from 'assert';
 import * as fse from 'fs-extra';
 import * as os from 'os';
 import * as path from 'path';
-import { ITestSourcePath, mergeTestSourcePaths, resolveAdditionalTestSourcePaths } from '../../src/provider/testSourceProvider';
+import * as sinon from 'sinon';
+import { RelativePattern, Uri, WorkspaceConfiguration, WorkspaceFolder, workspace } from 'vscode';
+import * as commandUtils from '../../src/utils/commandUtils';
+import { ITestSourcePath, mergeTestSourcePaths, resolveAdditionalTestSourcePaths, testSourceProvider } from '../../src/provider/testSourceProvider';
 
 suite('testSourceProvider', () => {
     test('returns no extra paths by default', async () => {
@@ -70,6 +73,41 @@ suite('testSourceProvider', () => {
         }
     });
 
+    test('includes additional source roots in file watcher patterns', async () => {
+        const workspacePath: string = fse.mkdtempSync(path.join(os.tmpdir(), 'java-test-source-paths-'));
+        const sourceRoots: string[] = [
+            path.join(workspacePath, 'modules', 'app', 'src', 'main', 'java'),
+            path.join(workspacePath, 'modules', 'cli', 'src', 'main', 'java'),
+        ];
+        sourceRoots.forEach((sourceRoot: string) => fse.ensureDirSync(sourceRoot));
+        const workspaceFolder: WorkspaceFolder = {
+            uri: Uri.file(workspacePath),
+            name: 'additional-source-paths-test',
+            index: 0,
+        };
+        const configuration: WorkspaceConfiguration = {
+            get: () => ['modules/*/src/main/java'],
+        } as unknown as WorkspaceConfiguration;
+
+        testSourceProvider.clear();
+        sinon.stub(workspace, 'getConfiguration').returns(configuration);
+        sinon.stub(commandUtils, 'executeJavaLanguageServerCommand').resolves([]);
+        try {
+            const patterns: RelativePattern[] = await testSourceProvider.getTestSourcePattern(workspaceFolder);
+
+            const normalizePath = (sourcePath: string): string => process.platform === 'win32'
+                ? path.normalize(sourcePath).toLowerCase()
+                : path.normalize(sourcePath);
+            assert.deepStrictEqual(
+                patterns.map((pattern: RelativePattern) => normalizePath(pattern.baseUri.fsPath)).sort(),
+                sourceRoots.map(normalizePath).sort());
+        } finally {
+            testSourceProvider.clear();
+            sinon.restore();
+            fse.removeSync(workspacePath);
+        }
+    });
+
     test('supports Windows separators in source-root patterns', async () => {
         const workspacePath: string = fse.mkdtempSync(path.join(os.tmpdir(), 'java-test-source-paths-'));
         const sourceRoot: string = path.join(workspacePath, 'modules', 'app', 'src', 'main', 'java');