chore: Cleanup and todo resolving

Author: Danielku15

README.md

@@ -5,13 +5,12 @@ This is the Mocha extension for VS Code enabling developers to run and debug tes
 ## Credits
 
 This project started as a fork of the `Extension Test Runner` and `Command-line runner for VS Code tests` developed by Microsoft and then was adapted to work with Mocha directly.
-The main credits of this extension go over to the folks at Microsoft (and their contributors) and without them it would have been 
-a lot more effort to ship a Mocha test runner for VS Code. 
-
-* https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner
-* https://github.com/microsoft/vscode-extension-test-runner
-* https://github.com/microsoft/vscode-test-cl
+The main credits of this extension go over to the folks at Microsoft (and their contributors) and without them it would have been
+a lot more effort to ship a Mocha test runner for VS Code.
 
+- https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner
+- https://github.com/microsoft/vscode-extension-test-runner
+- https://github.com/microsoft/vscode-test-cl
 
 ## Getting Started
 
@@ -26,6 +25,7 @@ This extension automatically discovers and works with the `.mocharc.js/cjs/yaml/
 - `mocha-vscode.extractSettings`: configures how tests get extracted. You can configure:
 
   - The `extractWith` mode, that specifies if tests are extracted via evaluation or syntax-tree parsing. Evaluation is likely to lead to better results, but may have side-effects. Defaults to `evaluation`.
+  - The `extractTimeout` limiting how long the extraction of tests for a single file is allowed to take.
   - The `test` and `suite` identifiers the process extracts. Defaults to `["it", "test"]` and `["describe", "suite"]` respectively, covering Mocha's common interfaces.
 
 - `mocha-vscode.debugOptions`: options, normally found in the launch.json, to pass when debugging the extension. See [the docs](https://code.visualstudio.com/docs/nodejs/nodejs-debugging#_launch-configuration-attributes) for a complete list of options.

package.json

@@ -38,7 +38,7 @@
         "title": "Extension Test Runner",
         "properties": {
           "mocha-vscode.extractSettings": {
-            "markdownDescription": "Configures how tests get extracted. You can configure:\n\n- The `extractWith` mode, that specifies if tests are extracted via evaluation or syntax-tree parsing.\n- The `test` and `suite` identifiers the process extracts.",
+            "markdownDescription": "Configures how tests get extracted. You can configure:\n\n- The `extractWith` mode, that specifies if tests are extracted via evaluation or syntax-tree parsing.\n- The `extractTimeout` limiting how long the extraction of tests for a single file is allowed to take.\n- The `test` and `suite` identifiers the process extracts.",
             "type": "object",
             "properties": {
               "suite": {
@@ -59,6 +59,9 @@
                   "evaluation",
                   "syntax"
                 ]
+              },
+              "extractTimeout": {
+                "type": "number"
               }
             },
             "default": {
@@ -70,12 +73,14 @@
                 "it",
                 "test"
               ],
-              "extractWith": "evaluation"
+              "extractWith": "evaluation",
+              "extractTimeout": 10000
             },
             "required": [
               "suite",
               "test",
-              "extractWith"
+              "extractWith",
+              "extractTimeout"
             ]
           },
           "mocha-vscode.debugOptions": {

src/configurationFile.ts

@@ -14,14 +14,17 @@ import { DisposableStore } from './disposable';
 import { HumanError } from './errors';
 
 type OptionsModule = {
-  loadOptions(): IResolvedConfiguration
+  loadOptions(): IResolvedConfiguration;
 };
 
 type ConfigModule = {
-  findConfig(): string
+  findConfig(): string;
 };
 
-export type IResolvedConfiguration = Mocha.MochaOptions & { "_": string[] | undefined, "node-option": string[] | undefined }
+export type IResolvedConfiguration = Mocha.MochaOptions & {
+  _: string[] | undefined;
+  'node-option': string[] | undefined;
+};
 
 export class ConfigurationFile implements vscode.Disposable {
   private readonly ds = new DisposableStore();
@@ -89,29 +92,20 @@ export class ConfigurationFile implements vscode.Disposable {
     // We cannot use process.execPath as this points to code.exe which is an electron application
     // also with ELECTRON_RUN_AS_NODE this can lead to errors (e.g. with the --import option)
     // we prefer to use the system level node
-    this._pathToNode ??= (await which("node", { nothrow: true })) ?? process.execPath;
+    this._pathToNode ??= (await which('node', { nothrow: true })) ?? process.execPath;
     return this._pathToNode;
   }
 
   async getMochaSpawnArgs(customArgs: readonly string[]): Promise<string[]> {
-    // TODO: resolve from package.json? 
     this._pathToMocha ??= await this._resolveLocalMochaPath('/bin/mocha.js');
 
-    return [await this.getPathToNode(), this._pathToMocha, '--config', this.uri.fsPath, ...customArgs];
-  }
-
-  public async spawnMocha(args: readonly string[]) {
-
-    const spawnArgs = await this.getMochaSpawnArgs(args);
-
-    return await new Promise<ChildProcessWithoutNullStreams>((resolve, reject) => {
-      const p = spawn(spawnArgs[0], spawnArgs.slice(1), {
-        cwd: path.dirname(this.uri.fsPath),
-        env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
-      });
-      p.on('spawn', () => resolve(p));
-      p.on('error', reject);
-    });
+    return [
+      await this.getPathToNode(),
+      this._pathToMocha,
+      '--config',
+      this.uri.fsPath,
+      ...customArgs,
+    ];
   }
 
   private async _resolveLocalMochaPath(suffix?: string): Promise<string> {
@@ -124,11 +118,17 @@ export class ConfigurationFile implements vscode.Disposable {
       this._resolver!.resolve(
         {},
         path.dirname(this.uri.fsPath),
-        'mocha' + (suffix ?? ""),
+        'mocha' + (suffix ?? ''),
         {},
         (err, res) => {
           if (err) {
-            reject(new HumanError(`Could not find mocha in working directory '${path.dirname(this.uri.fsPath)}', please install mocha to run tests.`));
+            reject(
+              new HumanError(
+                `Could not find mocha in working directory '${path.dirname(
+                  this.uri.fsPath,
+                )}', please install mocha to run tests.`,
+              ),
+            );
           } else {
             resolve(res as string);
           }
@@ -138,13 +138,17 @@ export class ConfigurationFile implements vscode.Disposable {
   }
 
   private async _read() {
-    this._optionsModule ??= require(await this._resolveLocalMochaPath('/lib/cli/options')) as OptionsModule;
-    this._configModule ??= require(await this._resolveLocalMochaPath('/lib/cli/config')) as ConfigModule;
+    this._optionsModule ??= require(
+      await this._resolveLocalMochaPath('/lib/cli/options'),
+    ) as OptionsModule;
+    this._configModule ??= require(
+      await this._resolveLocalMochaPath('/lib/cli/config'),
+    ) as ConfigModule;
     let config: IResolvedConfiguration;
 
-    // need to change to the working dir for loading the config, 
+    // need to change to the working dir for loading the config,
     // TODO[mocha]: allow specifying the cwd in loadOptions()
-    const currentCwd = process.cwd();;
+    const currentCwd = process.cwd();
     try {
       process.chdir(path.dirname(this.uri.fsPath));
 
@@ -154,14 +158,12 @@ export class ConfigurationFile implements vscode.Disposable {
       try {
         const resolved = require.resolve(configFile);
         delete require.cache[resolved];
-      }
-      catch (e) {
+      } catch (e) {
         // ignore
       }
 
       config = this._optionsModule.loadOptions();
-    }
-    finally {
+    } finally {
       process.chdir(currentCwd);
     }
 
@@ -199,7 +201,7 @@ export class ConfigurationList {
       positional = ['./test/*.{js,cjs,mjs}'];
     }
 
-    this.patterns = positional.map(f => {
+    this.patterns = positional.map((f) => {
       if (path.isAbsolute(f)) {
         return { glob: false, value: path.normalize(f) };
       } else {

src/constants.ts

@@ -13,6 +13,7 @@ export const defaultTestSymbols: ITestSymbols = {
   suite: ['describe', 'suite'],
   test: ['it', 'test'],
   extractWith: 'evaluation',
+  extractTimeout: 10_000,
 };
 
 export const showConfigErrorCommand = 'mocha-vscode.showConfigError';
@@ -25,12 +26,17 @@ function equalsIgnoreCase(a: string, b: string) {
 export function isTypeScript(filePath: string) {
   const ext = path.extname(filePath);
   // TODO: configuration for this extension list?
-  return equalsIgnoreCase(ext, '.ts') || equalsIgnoreCase(ext, '.mts') || equalsIgnoreCase(ext, '.tsx') || equalsIgnoreCase(ext, '.cts') || equalsIgnoreCase(ext, '.jsx');
+  return (
+    equalsIgnoreCase(ext, '.ts') ||
+    equalsIgnoreCase(ext, '.mts') ||
+    equalsIgnoreCase(ext, '.tsx') ||
+    equalsIgnoreCase(ext, '.cts') ||
+    equalsIgnoreCase(ext, '.jsx')
+  );
 }
 
-
 export function isEsm(filePath: string, code: string): boolean {
   const ext = path.extname(filePath);
   // very basic detection
-  return equalsIgnoreCase(ext, '.mjs') || code.includes("import ") || code.includes("export ");
-}
+  return equalsIgnoreCase(ext, '.mjs') || code.includes('import ') || code.includes('export ');
+}

src/controller.ts

@@ -60,6 +60,7 @@ export class Controller {
   }
 
   constructor(
+    private readonly logChannel: vscode.LogOutputChannel,
     public readonly ctrl: vscode.TestController,
     private readonly wf: vscode.WorkspaceFolder,
     private readonly smStore: SourceMapStore,
@@ -110,7 +111,7 @@ export class Controller {
 
     let tree: IParsedNode[];
     try {
-      tree = await extract(uri.fsPath, contents, this.extractMode.value);
+      tree = await extract(this.logChannel, uri.fsPath, contents, this.extractMode.value);
     } catch (e) {
       this.deleteFileTests(uri.toString());
       return;
@@ -175,8 +176,7 @@ export class Controller {
         node.endLine !== undefined && node.endColumn !== undefined
           ? sourceMap.originalPositionFor(node.endLine, node.endColumn)
           : start;
-      const file = last(this.getContainingItemsForFile(start.uri, { compiledFile: uri }))!
-        .item!;
+      const file = last(this.getContainingItemsForFile(start.uri, { compiledFile: uri }))!.item!;
       diagnosticCollection.delete(start.uri);
       newTestsInFile.set(node.name, add(file, node, start, end));
     }
@@ -280,14 +280,14 @@ export class Controller {
     if (prev) {
       this.runProfiles.set(name, prev);
       oldRunHandlers.delete(name);
-      return
+      return;
     }
 
     const run = this.runner.makeHandler(this.ctrl, this.configFile, false);
     const debug = this.runner.makeHandler(this.ctrl, this.configFile, true);
     const profiles = [
       this.ctrl.createRunProfile(name, vscode.TestRunProfileKind.Run, run, true),
-      this.ctrl.createRunProfile(name, vscode.TestRunProfileKind.Debug, debug, true)
+      this.ctrl.createRunProfile(name, vscode.TestRunProfileKind.Debug, debug, true),
     ];
 
     this.runProfiles.set(name, profiles);

src/errors.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------*/
 
 /** Errors with a human-readable message. */
-export class HumanError extends Error { }
+export class HumanError extends Error {}
 
 export class ConfigProcessReadError extends HumanError {
   constructor(output: string) {

src/extension.ts

@@ -23,13 +23,17 @@ const enum FolderSyncState {
 }
 
 export function activate(context: vscode.ExtensionContext) {
+  const logChannel = vscode.window.createOutputChannel('Mocha VS Code Extension', { log: true });
+
   const smStore = new SourceMapStore();
-  const runner = new TestRunner(smStore, new ConfigValue('debugOptions', {}));
+  const runner = new TestRunner(logChannel, smStore, new ConfigValue('debugOptions', {}));
 
   let ctrls: Controller[] = [];
   let resyncState: FolderSyncState = FolderSyncState.Idle;
 
   const syncWorkspaceFolders = async () => {
+    logChannel.debug('Syncing workspace folders', resyncState);
+
     if (resyncState === FolderSyncState.Syncing) {
       resyncState = FolderSyncState.ReSyncNeeded;
     }
@@ -45,8 +49,12 @@ export function activate(context: vscode.ExtensionContext) {
     await Promise.all(
       folders.map(async (folder) => {
         const files = await vscode.workspace.findFiles(
-          new vscode.RelativePattern(folder, configFilePattern), '**/node_modules/**'
+          new vscode.RelativePattern(folder, configFilePattern),
+          '**/node_modules/**',
         );
+
+        logChannel.debug('Checking workspace folder for config files', folder);
+
         for (const file of files) {
           const rel = path.relative(folder.uri.fsPath, path.dirname(file.fsPath));
           const ctrl = vscode.tests.createTestController(
@@ -58,7 +66,7 @@ export function activate(context: vscode.ExtensionContext) {
               : folder.name,
           );
 
-          ctrls.push(new Controller(ctrl, folder, smStore, file, runner));
+          ctrls.push(new Controller(logChannel, ctrl, folder, smStore, file, runner));
         }
       }),
     );
@@ -71,24 +79,6 @@ export function activate(context: vscode.ExtensionContext) {
     }
   };
 
-  const openUntitledEditor = async (contents: string) => {
-    const untitledDoc = await vscode.workspace.openTextDocument({ content: contents });
-    await vscode.window.showTextDocument(untitledDoc);
-  };
-
-  const showConfigError = async (configUriStr: string) => {
-    const configUri = vscode.Uri.parse(configUriStr);
-    const ctrl = ctrls.find((c) => c.configFile.uri.toString() === configUri.toString());
-    try {
-      await ctrl?.configFile.read();
-    } catch (e) {
-      await openUntitledEditor(String(e));
-      return;
-    }
-
-    vscode.window.showInformationMessage('No configuration error detected');
-  };
-
   const initialSync = (async () => {
     // Workaround for vscode#179203 where findFiles doesn't work on startup.
     // This extension is only activated on workspaceContains, so we have pretty
@@ -105,12 +95,12 @@ export function activate(context: vscode.ExtensionContext) {
 
   context.subscriptions.push(
     vscode.workspace.onDidChangeWorkspaceFolders(syncWorkspaceFolders),
-    vscode.commands.registerCommand(showConfigErrorCommand, showConfigError),
     vscode.commands.registerCommand(getControllersForTestCommand, () =>
       initialSync.then(() => ctrls),
     ),
     new vscode.Disposable(() => ctrls.forEach((c) => c.dispose())),
+    logChannel,
   );
 }
 
-export function deactivate() { }
+export function deactivate() {}