Ensure we track activation results (microsoft#2907)

* Ensure we track activation results * Update test suite title

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

@@ -4,21 +4,22 @@
 'use strict';
 
 import * as TypeMoq from 'typemoq';
+import { expect } from 'chai';
 import { Terminal } from 'vscode';
 import { BaseTerminalActivator } from '../../../../client/common/terminal/activator/base';
 import { ITerminalActivator, ITerminalHelper } from '../../../../client/common/terminal/types';
 import { noop } from '../../../../client/common/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');
+ });
  });
 });