Cherrypick PR #2907

Author: DonJayamanne

src/client/common/terminal/activator/base.ts

@@ -4,31 +4,33 @@
 'use strict';
 
 import { Terminal, Uri } from 'vscode';
-import { sleep } from '../../../../utils/async';
+import { createDeferred, sleep } from '../../../../utils/async';
 import { ITerminalActivator, ITerminalHelper, TerminalShellType } from '../types';
 
 export class BaseTerminalActivator implements ITerminalActivator {
-    private readonly activatedTerminals: Set<Terminal> = new Set<Terminal>();
+    private readonly activatedTerminals: Map<Terminal, Promise<boolean>> = new Map<Terminal, Promise<boolean>>();
     constructor(private readonly helper: ITerminalHelper) { }
     public async activateEnvironmentInTerminal(terminal: Terminal, resource: Uri | undefined, preserveFocus: boolean = true) {
         if (this.activatedTerminals.has(terminal)) {
-            return false;
+            return this.activatedTerminals.get(terminal)!;
         }
-        this.activatedTerminals.add(terminal);
+        const deferred = createDeferred<boolean>();
+        this.activatedTerminals.set(terminal, deferred.promise);
         const shellPath = this.helper.getTerminalShellPath();
         const terminalShellType = !shellPath || shellPath.length === 0 ? TerminalShellType.other : this.helper.identifyTerminalShell(shellPath);
 
         const activationCommamnds = await this.helper.getEnvironmentActivationCommands(terminalShellType, resource);
+        let activated = false;
         if (activationCommamnds) {
             for (const command of activationCommamnds!) {
                 terminal.show(preserveFocus);
                 terminal.sendText(command);
                 await this.waitForCommandToProcess(terminalShellType);
+                activated = true;
             }
-            return true;
-        } else {
-            return false;
         }
+        deferred.resolve(activated);
+        return activated;
     }
     protected async waitForCommandToProcess(shell: TerminalShellType) {
         // Give the command some time to complete.

src/test/common/terminals/activator/base.unit.test.ts

@@ -3,22 +3,23 @@
 
 'use strict';
 
+import { expect } from 'chai';
 import * as TypeMoq from 'typemoq';
 import { Terminal } from 'vscode';
 import { BaseTerminalActivator } from '../../../../client/common/terminal/activator/base';
 import { ITerminalActivator, ITerminalHelper } from '../../../../client/common/terminal/types';
 import { noop } from '../../../../utils/misc';
 
-// tslint:disable-next-line:max-func-body-length
-suite('Terminalx Base Activator', () => {
+// tslint:disable:max-func-body-length no-any
+suite('Terminal Base Activator', () => {
     let activator: ITerminalActivator;
     let helper: TypeMoq.IMock<ITerminalHelper>;
 
     setup(() => {
         helper = TypeMoq.Mock.ofType<ITerminalHelper>();
         activator = new class extends BaseTerminalActivator {
             public waitForCommandToProcess() { noop(); return Promise.resolve(); }
-        }(helper.object);
+        }(helper.object) as any as ITerminalActivator;
     });
     [
         { commandCount: 1, preserveFocus: false },
@@ -70,5 +71,30 @@ suite('Terminalx Base Activator', () => {
 
             terminal.verifyAll();
         });
+        test(`Terminal is activated only once ${titleSuffix} (even when not waiting)`, async () => {
+            helper.setup(h => h.getTerminalShellPath()).returns(() => '');
+            helper.setup(h => h.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(activationCommands));
+            const terminal = TypeMoq.Mock.ofType<Terminal>();
+
+            terminal
+                .setup(t => t.show(TypeMoq.It.isValue(item.preserveFocus)))
+                .returns(() => undefined)
+                .verifiable(TypeMoq.Times.exactly(activationCommands.length));
+            activationCommands.forEach(cmd => {
+                terminal
+                    .setup(t => t.sendText(TypeMoq.It.isValue(cmd)))
+                    .returns(() => undefined)
+                    .verifiable(TypeMoq.Times.exactly(1));
+            });
+
+            const activated = await Promise.all([
+                activator.activateEnvironmentInTerminal(terminal.object, undefined, item.preserveFocus),
+                activator.activateEnvironmentInTerminal(terminal.object, undefined, item.preserveFocus),
+                activator.activateEnvironmentInTerminal(terminal.object, undefined, item.preserveFocus)
+            ]);
+
+            terminal.verifyAll();
+            expect(activated).to.deep.equal([true, true, true], 'Invalid values');
+        });
     });
 });