fix(watcher): renaming/deleting/creating folders correctly updates the test tree

Author: sheremet-va

packages/extension/src/apiProcess.ts

@@ -33,6 +33,10 @@ export class VitestProjectConfig {
     return this.pkg.prefix
   }
 
+  get cwd() {
+    return this.pkg.cwd
+  }
+
   get configs() {
     return this.projects.map((p) => p.config).filter((n) => n != null)
   }
@@ -62,6 +66,7 @@ export class VitestProjectConfig {
     return metadata
   }
 
+  // TODO: if dir is set, this doesn't seem to work properly
   matchesTestGlob(project: SerializedProject, moduleId: string, source: () => string) {
     const relativeId = relative(project.dir || project.root, moduleId)
     if (pm.isMatch(relativeId, project.exclude)) {

packages/extension/src/testTree.ts

@@ -213,6 +213,13 @@ export class TestTree extends vscode.Disposable {
     items?.forEach((item) => this.recursiveDelete(item))
   }
 
+  public removeFolder(folderPath: string) {
+    const folderItem = this.folderItems.get(normalize(folderPath))
+    if (folderItem) {
+      this.recursiveDelete(folderItem)
+    }
+  }
+
   private recursiveDelete(item: vscode.TestItem) {
     if (!item.parent) return
     item.parent.children.delete(item.id)

packages/extension/src/watcher.ts

@@ -2,7 +2,7 @@ import type { VitestProcessAPI } from './apiProcess'
 import type { TransformSchemaProvider } from './schemaProvider'
 import type { TestTree } from './testTree'
 import { relative } from 'node:path'
-import { normalize } from 'pathe'
+import { normalize, resolve } from 'pathe'
 import * as vscode from 'vscode'
 import { getConfig } from './config'
 import { log } from './log'
@@ -46,19 +46,26 @@ export class ExtensionWatcher extends vscode.Disposable {
 
     watcher.onDidDelete(async (uri) => {
       const path = normalize(uri.fsPath)
-      if (await this.shouldIgnoreFile(api, path, uri)) {
+      if (this.isCommondIgnore(path)) {
         return
       }
-      log.verbose?.('[VSCODE] File deleted:', this.relative(api, uri))
-      this.testTree.removeFile(normalize(uri.fsPath))
+
+      log.verbose?.('[VSCODE] Item deleted:', this.relative(api, uri))
+
       this.transformSchemaProvider.emitChange(uri)
+
+      // We don't know if it is a file or a folder
+      this.testTree.removeFile(path)
+      this.testTree.removeFolder(path)
     })
 
     watcher.onDidChange(async (uri) => {
       const path = normalize(uri.fsPath)
-      if (await this.shouldIgnoreFile(api, path, uri)) {
+      const type = await this.getFsType(api, path, uri)
+      if (type !== 'file') {
         return
       }
+
       this.transformSchemaProvider.emitChange(uri)
       log.verbose?.('[VSCODE] File changed:', this.relative(api, uri))
       const apis = this.apisByFolder.get(folder) || []
@@ -76,18 +83,38 @@ export class ExtensionWatcher extends vscode.Disposable {
 
     watcher.onDidCreate(async (uri) => {
       const path = normalize(uri.fsPath)
-      if (await this.shouldIgnoreFile(api, path, uri)) {
+      const type = await this.getFsType(api, path, uri)
+
+      if (!type) {
         return
       }
-      log.verbose?.('[VSCODE] File created:', this.relative(api, uri))
+
+      log.verbose?.('[VSCODE]', 'New', type, 'created:', this.relative(api, uri))
+
       const apis = this.apisByFolder.get(folder) || []
-      apis.forEach((api) => {
-        const metadata = api.getPotentialTestFileMetadata(path)
-        metadata.forEach((meta) => {
-          this.testTree.getOrCreateFileTestItem(api, meta, path)
-          if (!api.getPersistentProcessMeta() && !api.isSpawningPersistentProcess) {
-            api.collectTests(meta.project, path)
-          }
+      const roots = apis.flatMap((api) =>
+        // TODO: resolve should be done on the worker side
+        api.config.projects.map((p) => normalize(resolve(api.config.cwd, p.dir || p.root))),
+      )
+      const files = type === 'file' ? [path] : await this.readFilesRecursively(uri, roots)
+      const openedFiles = vscode.workspace.textDocuments.map((d) => normalize(d.uri.fsPath))
+
+      files.forEach((file) => {
+        apis.forEach((api) => {
+          const metadata = api.getPotentialTestFileMetadata(file)
+          metadata.forEach((meta) => {
+            this.testTree.getOrCreateFileTestItem(api, meta, file)
+
+            // If file is open and not a continuous run,
+            // Collect its tests immidetly, otherwise ignore
+            if (
+              openedFiles.includes(file) &&
+              !api.getPersistentProcessMeta() &&
+              !api.isSpawningPersistentProcess
+            ) {
+              api.collectTests(meta.project, file)
+            }
+          })
         })
       })
     })
@@ -97,15 +124,47 @@ export class ExtensionWatcher extends vscode.Disposable {
     return relative(api.workspaceFolder.uri.fsPath, uri.fsPath)
   }
 
-  private async shouldIgnoreFile(api: VitestProcessAPI, path: string, uri: vscode.Uri) {
-    if (
+  private isCommondIgnore(path: string) {
+    return (
       path.includes('/node_modules/') ||
       path.includes('\\node_modules\\') ||
       path.includes('/.git/') ||
       path.includes('\\.git\\') ||
       path.endsWith('.git')
-    ) {
-      return true
+    )
+  }
+
+  private async readFilesRecursively(uri: vscode.Uri, roots: string[]): Promise<string[]> {
+    const dirPath = normalize(uri.fsPath)
+    // skip if this directory is not inside any project root and no root is inside it
+    if (!roots.some((root) => dirPath.startsWith(root) || root.startsWith(dirPath))) {
+      return []
+    }
+    const entries = await vscode.workspace.fs.readDirectory(uri)
+    const files: string[] = []
+    for (const [name, type] of entries) {
+      const childUri = vscode.Uri.joinPath(uri, name)
+      if (
+        type === vscode.FileType.Directory ||
+        type === (vscode.FileType.Directory | vscode.FileType.SymbolicLink)
+      ) {
+        if (this.isCommondIgnore(normalize(childUri.fsPath))) {
+          continue
+        }
+        files.push(...(await this.readFilesRecursively(childUri, roots)))
+      } else if (
+        type === vscode.FileType.File ||
+        type === (vscode.FileType.File | vscode.FileType.SymbolicLink)
+      ) {
+        files.push(normalize(childUri.fsPath))
+      }
+    }
+    return files
+  }
+
+  private async getFsType(api: VitestProcessAPI, path: string, uri: vscode.Uri) {
+    if (this.isCommondIgnore(path)) {
+      return null
     }
     try {
       const stats = await vscode.workspace.fs.stat(uri)
@@ -115,12 +174,11 @@ export class ExtensionWatcher extends vscode.Disposable {
         // if not a symlinked file
         stats.type !== (vscode.FileType.File | vscode.FileType.SymbolicLink)
       ) {
-        log.verbose?.('[VSCODE]', this.relative(api, uri), 'is not a file. Ignoring.')
-        return true
+        return 'folder'
       }
-      return false
+      return 'file'
     } catch {
-      return true
+      return null
     }
   }
 }