Add command to create a python terminal (microsoft#625)

Fixes microsoft#622

Author: DonJayamanne

package.json

@@ -106,6 +106,11 @@
 "title": "%python.command.python.startREPL.title%",
 "category": "Python"
 },
+{
+"command": "python.createTerminal",
+"title": "%python.command.python.createTerminal.title%",
+"category": "Python"
+},
 {
 "command": "python.buildWorkspaceSymbols",
 "title": "%python.command.python.buildWorkspaceSymbols.title%",

package.nls.json

@@ -1,6 +1,7 @@
 {
  "python.command.python.sortImports.title": "Sort Imports",
  "python.command.python.startREPL.title": "Start REPL",
+ "python.command.python.createTerminal.title": "Create Terminal",
  "python.command.python.buildWorkspaceSymbols.title": "Build Workspace Symbols",
  "python.command.python.runtests.title": "Run All Unit Tests",
  "python.command.python.debugtests.title": "Debug All Unit Tests",

src/client/common/constants.ts

@@ -28,6 +28,7 @@ export namespace Commands {
  export const Update_SparkLibrary = 'python.updateSparkLibrary';
  export const Build_Workspace_Symbols = 'python.buildWorkspaceSymbols';
  export const Start_REPL = 'python.startREPL';
+ export const Create_Terminal = 'python.createTerminal';
  export const Set_Linter = 'python.setLinter';
  export const Enable_Linter = 'python.enableLinting';
 }

src/client/common/terminal/factory.ts

@@ -27,6 +27,10 @@ export class TerminalServiceFactory implements ITerminalServiceFactory {
 
  return this.terminalServices.get(id)!;
  }
+ public createTerminalService(resource?: Uri, title?: string): ITerminalService {
+ const terminalTitle = typeof title === 'string' && title.trim().length > 0 ? title.trim() : 'Python';
+ return new TerminalService(this.serviceContainer, resource, terminalTitle);
+ }
  private getTerminalId(title: string, resource?: Uri): string {
  if (!resource) {
  return title;

src/client/common/terminal/types.ts

@@ -18,7 +18,7 @@ export interface ITerminalService {
  readonly onDidCloseTerminal: Event<void>;
  sendCommand(command: string, args: string[]): Promise<void>;
  sendText(text: string): Promise<void>;
- show(): void;
+ show(): Promise<void>;
 }
 
 export const ITerminalServiceFactory = Symbol('ITerminalServiceFactory');
@@ -33,6 +33,7 @@ export interface ITerminalServiceFactory {
  * @memberof ITerminalServiceFactory
  */
  getTerminalService(resource?: Uri, title?: string): ITerminalService;
+ createTerminalService(resource?: Uri, title?: string): ITerminalService;
 }
 
 export const ITerminalHelper = Symbol('ITerminalHelper');

src/client/extension.ts

@@ -7,8 +7,8 @@ if ((Reflect as any).metadata === undefined) {
 }
 import { Container } from 'inversify';
 import * as os from 'os';
-import * as vscode from 'vscode';
 import { Disposable, Memento, OutputChannel, window } from 'vscode';
+import * as vscode from 'vscode';
 import { BannerService } from './banner';
 import { PythonSettings } from './common/configSettings';
 import * as settings from './common/configSettings';
@@ -47,6 +47,7 @@ import { ReplProvider } from './providers/replProvider';
 import { PythonSignatureProvider } from './providers/signatureProvider';
 import { activateSimplePythonRefactorProvider } from './providers/simpleRefactorProvider';
 import { PythonSymbolProvider } from './providers/symbolProvider';
+import { TerminalProvider } from './providers/terminalProvider';
 import { activateUpdateSparkLibraryProvider } from './providers/updateSparkLibraryProvider';
 import * as sortImports from './sortImports';
 import { sendTelemetryEvent } from './telemetry';
@@ -118,6 +119,7 @@ export async function activate(context: vscode.ExtensionContext) {
  context.subscriptions.push(...activateGoToObjectDefinitionProvider(jediFactory));
 
  context.subscriptions.push(new ReplProvider(serviceContainer));
+ context.subscriptions.push(new TerminalProvider(serviceContainer));
 
  // Enable indentAction
  // tslint:disable-next-line:no-non-null-assertion

src/client/providers/terminalProvider.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Disposable, Uri } from 'vscode';
+import { ICommandManager, IDocumentManager, IWorkspaceService } from '../common/application/types';
+import { Commands } from '../common/constants';
+import { ITerminalServiceFactory } from '../common/terminal/types';
+import { IServiceContainer } from '../ioc/types';
+
+export class TerminalProvider implements Disposable {
+ private disposables: Disposable[] = [];
+ constructor(private serviceContainer: IServiceContainer) {
+ this.registerCommands();
+ }
+ public dispose() {
+ this.disposables.forEach(disposable => disposable.dispose());
+ }
+ private registerCommands() {
+ const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
+ const disposable = commandManager.registerCommand(Commands.Create_Terminal, this.onCreateTerminal, this);
+
+ this.disposables.push(disposable);
+ }
+ private async onCreateTerminal() {
+ const terminalService = this.serviceContainer.get<ITerminalServiceFactory>(ITerminalServiceFactory);
+ const activeResource = this.getActiveResource();
+ await terminalService.createTerminalService(activeResource, 'Python').show();
+ }
+ private getActiveResource(): Uri | undefined {
+ const documentManager = this.serviceContainer.get<IDocumentManager>(IDocumentManager);
+ if (documentManager.activeTextEditor && !documentManager.activeTextEditor.document.isUntitled) {
+ return documentManager.activeTextEditor.document.uri;
+ }
+ const workspace = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+ return Array.isArray(workspace.workspaceFolders) && workspace.workspaceFolders.length > 0 ? workspace.workspaceFolders[0].uri : undefined;
+ }
+}

src/test/common/terminals/factory.test.ts

@@ -6,6 +6,7 @@ import * as TypeMoq from 'typemoq';
 import { Disposable, Uri, WorkspaceFolder } from 'vscode';
 import { ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
 import { TerminalServiceFactory } from '../../../client/common/terminal/factory';
+import { TerminalService } from '../../../client/common/terminal/service';
 import { ITerminalHelper, ITerminalServiceFactory } from '../../../client/common/terminal/types';
 import { IDisposableRegistry } from '../../../client/common/types';
 import { IInterpreterService } from '../../../client/interpreter/contracts';
@@ -54,6 +55,8 @@ suite('Terminal Service Factory', () => {
 
  test('Ensure different instance of terminal service is returned when title is provided', () => {
  const defaultInstance = factory.getTerminalService();
+ expect(defaultInstance instanceof TerminalService).to.equal(true, 'Not an instance of Terminal service');
+
  const notSameAsDefaultInstance = factory.getTerminalService(undefined, 'New Title') === defaultInstance;
  expect(notSameAsDefaultInstance).to.not.equal(true, 'Instances are the same as default instance');
 
@@ -66,6 +69,22 @@ suite('Terminal Service Factory', () => {
  expect(notTheSameInstance).not.to.equal(true, 'Instances are the same');
  });
 
+ test('Ensure different instance of terminal services are created', () => {
+ const instance1 = factory.createTerminalService();
+ expect(instance1 instanceof TerminalService).to.equal(true, 'Not an instance of Terminal service');
+
+ const notSameAsFirstInstance = factory.createTerminalService() === instance1;
+ expect(notSameAsFirstInstance).to.not.equal(true, 'Instances are the same');
+
+ const instance2 = factory.createTerminalService(Uri.file('a'), 'Title');
+ const notSameAsSecondInstance = instance1 === instance2;
+ expect(notSameAsSecondInstance).to.not.equal(true, 'Instances are the same');
+
+ const instance3 = factory.createTerminalService(Uri.file('a'), 'Title');
+ const notSameAsThirdInstance = instance2 === instance3;
+ expect(notSameAsThirdInstance).to.not.equal(true, 'Instances are the same');
+ });
+
  test('Ensure same terminal is returned when using resources from the same workspace', () => {
  const file1A = Uri.file('1a');
  const file2A = Uri.file('2a');

src/test/providers/terminal.test.ts

@@ -0,0 +1,152 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as TypeMoq from 'typemoq';
+import { Disposable, TextDocument, TextEditor, Uri, WorkspaceFolder } from 'vscode';
+import { ICommandManager, IDocumentManager, IWorkspaceService } from '../../client/common/application/types';
+import { Commands } from '../../client/common/constants';
+import { TerminalService } from '../../client/common/terminal/service';
+import { ITerminalServiceFactory } from '../../client/common/terminal/types';
+import { IServiceContainer } from '../../client/ioc/types';
+import { TerminalProvider } from '../../client/providers/terminalProvider';
+
+// tslint:disable-next-line:max-func-body-length
+suite('Terminal Provider', () => {
+ let serviceContainer: TypeMoq.IMock<IServiceContainer>;
+ let commandManager: TypeMoq.IMock<ICommandManager>;
+ let workspace: TypeMoq.IMock<IWorkspaceService>;
+ let documentManager: TypeMoq.IMock<IDocumentManager>;
+ let terminalProvider: TerminalProvider;
+ setup(() => {
+ serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+ commandManager = TypeMoq.Mock.ofType<ICommandManager>();
+ workspace = TypeMoq.Mock.ofType<IWorkspaceService>();
+ documentManager = TypeMoq.Mock.ofType<IDocumentManager>();
+ serviceContainer.setup(c => c.get(ICommandManager)).returns(() => commandManager.object);
+ serviceContainer.setup(c => c.get(IWorkspaceService)).returns(() => workspace.object);
+ serviceContainer.setup(c => c.get(IDocumentManager)).returns(() => documentManager.object);
+ });
+ teardown(() => {
+ try {
+ terminalProvider.dispose();
+ // tslint:disable-next-line:no-empty
+ } catch { }
+ });
+
+ test('Ensure command is registered', () => {
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ commandManager.verify(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
+ });
+
+ test('Ensure command handler is disposed', () => {
+ const disposable = TypeMoq.Mock.ofType<Disposable>();
+ commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => disposable.object);
+
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ terminalProvider.dispose();
+
+ disposable.verify(d => d.dispose(), TypeMoq.Times.once());
+ });
+
+ test('Ensure terminal is created and displayed when command is invoked', () => {
+ const disposable = TypeMoq.Mock.ofType<Disposable>();
+ let commandHandler: undefined | (() => void);
+ commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
+ commandHandler = callback;
+ return disposable.object;
+ });
+ documentManager.setup(d => d.activeTextEditor).returns(() => undefined);
+ workspace.setup(w => w.workspaceFolders).returns(() => undefined);
+
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
+
+ const terminalServiceFactory = TypeMoq.Mock.ofType<ITerminalServiceFactory>();
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(ITerminalServiceFactory))).returns(() => terminalServiceFactory.object);
+ const terminalService = TypeMoq.Mock.ofType<TerminalService>();
+ terminalServiceFactory.setup(t => t.createTerminalService(TypeMoq.It.isValue(undefined), TypeMoq.It.isValue('Python'))).returns(() => terminalService.object);
+
+ commandHandler!.call(terminalProvider);
+ terminalService.verify(t => t.show(), TypeMoq.Times.once());
+ });
+
+ test('Ensure terminal creation does not use uri of the active documents which is untitled', () => {
+ const disposable = TypeMoq.Mock.ofType<Disposable>();
+ let commandHandler: undefined | (() => void);
+ commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
+ commandHandler = callback;
+ return disposable.object;
+ });
+ const editor = TypeMoq.Mock.ofType<TextEditor>();
+ documentManager.setup(d => d.activeTextEditor).returns(() => editor.object);
+ const document = TypeMoq.Mock.ofType<TextDocument>();
+ document.setup(d => d.isUntitled).returns(() => true);
+ editor.setup(e => e.document).returns(() => document.object);
+ workspace.setup(w => w.workspaceFolders).returns(() => undefined);
+
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
+
+ const terminalServiceFactory = TypeMoq.Mock.ofType<ITerminalServiceFactory>();
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(ITerminalServiceFactory))).returns(() => terminalServiceFactory.object);
+ const terminalService = TypeMoq.Mock.ofType<TerminalService>();
+ terminalServiceFactory.setup(t => t.createTerminalService(TypeMoq.It.isValue(undefined), TypeMoq.It.isValue('Python'))).returns(() => terminalService.object);
+
+ commandHandler!.call(terminalProvider);
+ terminalService.verify(t => t.show(), TypeMoq.Times.once());
+ });
+
+ test('Ensure terminal creation uses uri of active document', () => {
+ const disposable = TypeMoq.Mock.ofType<Disposable>();
+ let commandHandler: undefined | (() => void);
+ commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
+ commandHandler = callback;
+ return disposable.object;
+ });
+ const editor = TypeMoq.Mock.ofType<TextEditor>();
+ documentManager.setup(d => d.activeTextEditor).returns(() => editor.object);
+ const document = TypeMoq.Mock.ofType<TextDocument>();
+ const documentUri = Uri.file('a');
+ document.setup(d => d.isUntitled).returns(() => false);
+ document.setup(d => d.uri).returns(() => documentUri);
+ editor.setup(e => e.document).returns(() => document.object);
+ workspace.setup(w => w.workspaceFolders).returns(() => undefined);
+
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
+
+ const terminalServiceFactory = TypeMoq.Mock.ofType<ITerminalServiceFactory>();
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(ITerminalServiceFactory))).returns(() => terminalServiceFactory.object);
+ const terminalService = TypeMoq.Mock.ofType<TerminalService>();
+ terminalServiceFactory.setup(t => t.createTerminalService(TypeMoq.It.isValue(documentUri), TypeMoq.It.isValue('Python'))).returns(() => terminalService.object);
+
+ commandHandler!.call(terminalProvider);
+ terminalService.verify(t => t.show(), TypeMoq.Times.once());
+ });
+
+ test('Ensure terminal creation uses uri of active workspace', () => {
+ const disposable = TypeMoq.Mock.ofType<Disposable>();
+ let commandHandler: undefined | (() => void);
+ commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Create_Terminal), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
+ commandHandler = callback;
+ return disposable.object;
+ });
+ documentManager.setup(d => d.activeTextEditor).returns(() => undefined);
+ const workspaceUri = Uri.file('a');
+ const workspaceFolder = TypeMoq.Mock.ofType<WorkspaceFolder>();
+ workspaceFolder.setup(w => w.uri).returns(() => workspaceUri);
+ workspace.setup(w => w.workspaceFolders).returns(() => [workspaceFolder.object]);
+
+ terminalProvider = new TerminalProvider(serviceContainer.object);
+ expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
+
+ const terminalServiceFactory = TypeMoq.Mock.ofType<ITerminalServiceFactory>();
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(ITerminalServiceFactory))).returns(() => terminalServiceFactory.object);
+ const terminalService = TypeMoq.Mock.ofType<TerminalService>();
+ terminalServiceFactory.setup(t => t.createTerminalService(TypeMoq.It.isValue(workspaceUri), TypeMoq.It.isValue('Python'))).returns(() => terminalService.object);
+
+ commandHandler!.call(terminalProvider);
+ terminalService.verify(t => t.show(), TypeMoq.Times.once());
+ });
+});