refactoring in progress

src/extension.ts

@@ -5,17 +5,27 @@ import { TestCase } from './testing/Model/TestCase';
 import { ExecutableTestFinder } from './testing/TestFinder/ExecutableTestFinder';
 import { ChildProcessSpawner } from './utilities/Spawner/ChildProcessSpawner';
 import { TestTree } from './testing/Model/TestTree';
+import { WorkspaceWatcher } from './utilities/Workspace/WorkspaceWatcher';
 
 const spawner = new ChildProcessSpawner();
 const testFinder = new ExecutableTestFinder(spawner);
 const controller = vscode.tests.createTestController('CUTETestController', 'CUTE Tests');
 const testData = new TestTree(controller, testFinder);
+const workspaceWatcher = new WorkspaceWatcher(testFinder, testData);
 
 export function activate(context: vscode.ExtensionContext) {
 	vscode.window.showInformationMessage("CUTE testing extension is active now :)");
 
 	context.subscriptions.push(controller);
 
+	controller.resolveHandler = async item => {
+		if (!item) {
+			const fsWatcher = await workspaceWatcher.startTestFileObservation(context, controller);
+			context.subscriptions.push(...fsWatcher);
+			return;
+		}
+	};
+	
 	const runHandler = async (request: vscode.TestRunRequest, cancellation: vscode.CancellationToken) => {
 		const queue: { test: vscode.TestItem; data: TestCase }[] = [];
 		const runId = uuid.v4();

src/testing/Model/TestTree.ts

@@ -44,6 +44,6 @@ export class TestTree {
 
     public async refresh(): Promise<void> {
         this.clear();
-        this.testFinder.findTests()
+        this.testFinder.findTestsInWorkspaces(this.testController, this);
     }
 }
\ No newline at end of file

src/testing/TestFinder/ExecutableTestFinder.ts

@@ -9,7 +9,15 @@ import { TestFinder } from './TestFinder';
 export class ExecutableTestFinder implements TestFinder {
     constructor(private readonly spawner: ExecutableSpawner) { }
 
-    public async findTests(uri: vscode.Uri, controller: vscode.TestController, testData: TestTree) : Promise<void> {
+    public async findTestsInWorkspaces(controller: vscode.TestController, testData: TestTree) : Promise<void> {
+        const testExecutables = await this.getTestExecutables();
+
+        testExecutables.forEach(async testExecutable => {
+            await this.findTestsInFile(testExecutable, controller, testData);
+        });
+    }
+
+    public async findTestsInFile(uri: vscode.Uri, controller: vscode.TestController, testData: TestTree) : Promise<void> {
         const args = ["--display-tests"];
         const options = {
             cwd: path.dirname(uri.fsPath),
@@ -64,4 +72,31 @@ export class ExecutableTestFinder implements TestFinder {
       
         return result.stdout.includes("This program contains tests written using CUTE.");
     }
+
+    public  getTestPatterns(){
+        if (!vscode.workspace.workspaceFolders) {
+            return [];
+        }
+      
+        return vscode.workspace.workspaceFolders.map(workspaceFolder => 
+            new vscode.RelativePattern(workspaceFolder,  '**/*.exe'),
+        );
+    }
+
+    private async getTestExecutables() : Promise<vscode.Uri[]> {
+        const patterns = this.getTestPatterns();
+        const testfiles : vscode.Uri[] = [];
+
+        for(let fileN = 0; fileN < patterns.length; fileN++){
+            const executables = await vscode.workspace.findFiles(patterns[fileN]);
+            for(let execN = 0; execN < executables.length; execN++){
+                const executable = executables[execN];
+                if(await this.isTestFile(executable)){
+                    testfiles.push(executable);
+                }
+            }
+        }
+        
+        return testfiles;
+    }
 }
\ No newline at end of file

src/testing/TestFinder/TestFinder.ts

@@ -2,6 +2,8 @@ import * as vscode from 'vscode';
 import { TestTree } from '../Model/TestTree';
 
 export interface TestFinder{
-    findTests(uri: vscode.Uri, controller: vscode.TestController, testData: TestTree) : Promise<void>
+    findTestsInWorkspaces(controller: vscode.TestController, testData: TestTree) : Promise<void>
+    findTestsInFile(uri: vscode.Uri, controller: vscode.TestController, testData: TestTree) : Promise<void>
     isTestFile(file: vscode.Uri) : Promise<boolean>
+    getTestPatterns() : vscode.RelativePattern[]
 }
\ No newline at end of file

src/utilities/Workspace/WorkspaceWatcher.ts

@@ -8,8 +8,13 @@ export class WorkspaceWatcher {
         private readonly testTree: TestTree
     ) {}
 
-    startTestFileObservation(context: vscode.ExtensionContext, controller: vscode.TestController) {
-        return this.getTestPatterns().map(pattern => {
+    async startTestFileObservation(context: vscode.ExtensionContext, controller: vscode.TestController) : Promise<vscode.FileSystemWatcher[]> {
+        const fsWatcher : vscode.FileSystemWatcher[] = [];
+        
+        const testFilePatterns = this.testFinder.getTestPatterns();
+        for(let i = 0; i < testFilePatterns.length; i++){
+            const pattern = testFilePatterns[i];
+
             const watcher = vscode.workspace.createFileSystemWatcher(pattern);
         
             watcher.onDidCreate(async file => {
@@ -26,35 +31,10 @@ export class WorkspaceWatcher {
                 await this.testTree.refresh();    
             });
         
-            findInitialFiles(context, controller, pattern);
-            this.testTree.refresh();
-        
-            return watcher;
-        });
-    }
-
-    private getTestPatterns(){
-        if (!vscode.workspace.workspaceFolders) {
-            return [];
+            await this.testTree.refresh();
+            fsWatcher.push(watcher);
         }
-      
-        return vscode.workspace.workspaceFolders.map(workspaceFolder => 
-            new vscode.RelativePattern(workspaceFolder,  '**/*.exe'),
-        );
-    }
 
-    private async getTestExecutables() {
-        const patterns = this.getTestPatterns();
-        const testfiles : vscode.Uri[] = [];
-
-        for(let fileN = 0; fileN < patterns.length; fileN++){
-            const executables = await vscode.workspace.findFiles(patterns[fileN]);
-            for(let execN = 0; execN < executables.length; execN++){
-                const executable = executables[execN];
-                if(await this.testFinder.isTestFile(executable)){
-                    testfiles.push(executable);
-                }
-            }
-        } 
+        return fsWatcher;
     }
 }
\ No newline at end of file