Await active workspace being set in tests

Author: Xanewok

src/extension.ts

@@ -106,7 +106,7 @@ function onDidChangeActiveTextEditor(editor: TextEditor | undefined) {
     return;
   }
 
-  activeWorkspace = workspace;
+  activeWorkspace.value = workspace;
 
   const updateProgress = (progress: WorkspaceProgress) => {
     if (progress.state === 'progress') {
@@ -121,9 +121,9 @@ function onDidChangeActiveTextEditor(editor: TextEditor | undefined) {
   if (progressObserver) {
     progressObserver.dispose();
   }
-  progressObserver = activeWorkspace.progress.observe(updateProgress);
+  progressObserver = workspace.progress.observe(updateProgress);
   // Update UI ourselves immediately and don't wait for value update callbacks
-  updateProgress(activeWorkspace.progress.value);
+  updateProgress(workspace.progress.value);
 }
 
 function whenChangingWorkspaceFolders(e: WorkspaceFoldersChangeEvent) {
@@ -176,7 +176,7 @@ type WorkspaceProgress =
 // We run one RLS and one corresponding language client per workspace folder
 // (VSCode workspace, not Cargo workspace). This class contains all the per-client
 // and per-workspace stuff.
-class ClientWorkspace {
+export class ClientWorkspace {
   public readonly folder: WorkspaceFolder;
   // FIXME(#233): Don't only rely on lazily initializing it once on startup,
   // handle possible `rust-client.*` value changes while extension is running
@@ -440,7 +440,7 @@ class ClientWorkspace {
  * Tracks the most current VSCode workspace as opened by the user. Used by the
  * commands to know in which workspace these should be executed.
  */
-let activeWorkspace: ClientWorkspace | null;
+const activeWorkspace = new Observable<ClientWorkspace | null>(null);
 
 /**
  * Registers the VSCode [commands] used by the extension.
@@ -451,23 +451,24 @@ function registerCommands(): Disposable[] {
   return [
     commands.registerCommand(
       'rls.update',
-      () => activeWorkspace && activeWorkspace.rustupUpdate(),
+      () => activeWorkspace.value && activeWorkspace.value.rustupUpdate(),
     ),
     commands.registerCommand(
       'rls.restart',
-      async () => activeWorkspace && activeWorkspace.restart(),
+      async () => activeWorkspace.value && activeWorkspace.value.restart(),
     ),
     commands.registerCommand(
       'rls.run',
-      (cmd: Execution) => activeWorkspace && activeWorkspace.runRlsCommand(cmd),
+      (cmd: Execution) =>
+        activeWorkspace.value && activeWorkspace.value.runRlsCommand(cmd),
     ),
     commands.registerCommand(
       'rls.start',
-      () => activeWorkspace && activeWorkspace.start(),
+      () => activeWorkspace.value && activeWorkspace.value.start(),
     ),
     commands.registerCommand(
       'rls.stop',
-      () => activeWorkspace && activeWorkspace.stop(),
+      () => activeWorkspace.value && activeWorkspace.value.stop(),
     ),
   ];
 }

test/suite/extension.test.ts

@@ -2,7 +2,9 @@ import * as assert from 'assert';
 import * as path from 'path';
 import * as vscode from 'vscode';
 // tslint:disable-next-line: no-duplicate-imports
-import { Uri } from 'vscode';
+import { Disposable, Uri } from 'vscode';
+
+import * as extension from '../../src/extension';
 
 const fixtureDir = path.resolve(
   path.join(__dirname, '..', '..', '..', 'fixtures'),
@@ -25,6 +27,10 @@ suite('Extension Tests', () => {
     ];
 
     await vscode.commands.executeCommand('vscode.openFolder', projectUri);
+    const whenWorkspacesActive = projects.map(path => {
+      const fsPath = Uri.file(path).fsPath;
+      return whenWorkspaceActive(fsPath);
+    });
 
     // This makes sure that we set the focus on the opened files (which is what
     // actually triggers the extension for the project)
@@ -36,9 +42,9 @@ suite('Extension Tests', () => {
       'workbench.action.acceptSelectedQuickOpenItem',
     );
     await vscode.commands.executeCommand('workbench.action.keepEditor');
-    // Unfortunately, we need to wait a bit for the extension to kick in :(
-    // FIXME: See if we can directly import our extension and await its progress
-    await new Promise(resolve => setTimeout(resolve, 500));
+    // Wait until the first server is ready
+    await Promise.race([whenWorkspacesActive[0], timeoutReject(3000)]);
+
     assert(await currentTasksInclude([expected[0]]));
 
     // Now test for the second project
@@ -49,7 +55,8 @@ suite('Extension Tests', () => {
     await vscode.commands.executeCommand(
       'workbench.action.acceptSelectedQuickOpenItem',
     );
-    await new Promise(resolve => setTimeout(resolve, 500));
+    // Wait until the second server is ready
+    await Promise.race([whenWorkspacesActive[1], timeoutReject(3000)]);
     assert(await currentTasksInclude(expected));
   }).timeout(0);
 });
@@ -77,3 +84,30 @@ async function currentTasksInclude(
     ),
   );
 }
+
+/**
+ * Returns a promise when a client workspace will become active with a given path.
+ * @param fsPath normalized file system path of a URI
+ */
+function whenWorkspaceActive(
+  fsPath: string,
+): Promise<extension.ClientWorkspace> {
+  return new Promise(resolve => {
+    let disposable: Disposable | undefined;
+    disposable = extension.activeWorkspace.observe(value => {
+      if (value && value.folder.uri.fsPath === fsPath) {
+        if (disposable) {
+          disposable.dispose();
+          disposable = undefined;
+        }
+
+        resolve(value);
+      }
+    });
+  });
+}
+
+const timeoutReject = (ms: number) =>
+  new Promise((_, reject) =>
+    setTimeout(() => reject(new Error('Timed out')), ms),
+  );