Move getActiveResource to a common place

Kartik Raj · Kartik Raj · commit 1fe106bae9e2 · 2019-11-19T15:42:19.000-08:00
diff --git a/src/client/activation/activationManager.ts b/src/client/activation/activationManager.ts
@@ -4,15 +4,15 @@
 'use strict';
 
 import { inject, injectable, multiInject } from 'inversify';
-import { TextDocument, workspace } from 'vscode';
+import { TextDocument } from 'vscode';
 import { IApplicationDiagnostics } from '../application/types';
 import { IDocumentManager, IWorkspaceService } from '../common/application/types';
 import { PYTHON_LANGUAGE } from '../common/constants';
 import { traceDecorators } from '../common/logger';
 import { IDisposable, Resource } from '../common/types';
 import { IInterpreterAutoSelectionService } from '../interpreter/autoSelection/types';
 import { IInterpreterService } from '../interpreter/contracts';
-import { IExtensionActivationManager, IExtensionActivationService, IExtensionSingleActivationService } from './types';
+import { IActiveResourceService, IExtensionActivationManager, IExtensionActivationService, IExtensionSingleActivationService } from './types';
 
 @injectable()
 export class ExtensionActivationManager implements IExtensionActivationManager {
@@ -26,7 +26,8 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
         @inject(IInterpreterAutoSelectionService) private readonly autoSelection: IInterpreterAutoSelectionService,
         @inject(IApplicationDiagnostics) private readonly appDiagnostics: IApplicationDiagnostics,
-        @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService
+        @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService,
+        @inject(IActiveResourceService) private readonly activeResourceService: IActiveResourceService
     ) { }
 
     public dispose() {
@@ -44,7 +45,7 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         // Activate all activation services together.
         await Promise.all([
             Promise.all(this.singleActivationServices.map(item => item.activate())),
-            this.activateWorkspace(this.getActiveResource())
+            this.activateWorkspace(this.activeResourceService.getActiveResource())
         ]);
         await this.autoSelection.autoSelectInterpreter(undefined);
     }
@@ -114,12 +115,4 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
     protected getWorkspaceKey(resource: Resource) {
         return this.workspaceService.getWorkspaceFolderIdentifier(resource, '');
     }
-    private getActiveResource(): Resource {
-        if (this.documentManager.activeTextEditor && !this.documentManager.activeTextEditor.document.isUntitled) {
-            return this.documentManager.activeTextEditor.document.uri;
-        }
-        return Array.isArray(this.workspaceService.workspaceFolders) && workspace.workspaceFolders!.length > 0
-            ? workspace.workspaceFolders![0].uri
-            : undefined;
-    }
 }
diff --git a/src/client/providers/replProvider.ts b/src/client/providers/replProvider.ts
@@ -1,5 +1,6 @@
-import { Disposable, Uri } from 'vscode';
-import { ICommandManager, IDocumentManager, IWorkspaceService } from '../common/application/types';
+import { Disposable } from 'vscode';
+import { IActiveResourceService } from '../activation/types';
+import { ICommandManager } from '../common/application/types';
 import { Commands } from '../common/constants';
 import { IServiceContainer } from '../ioc/types';
 import { captureTelemetry } from '../telemetry';
@@ -8,7 +9,9 @@ import { ICodeExecutionService } from '../terminals/types';
 
 export class ReplProvider implements Disposable {
     private readonly disposables: Disposable[] = [];
+    private activeResourceService: IActiveResourceService;
     constructor(private serviceContainer: IServiceContainer) {
+        this.activeResourceService = this.serviceContainer.get<IActiveResourceService>(IActiveResourceService);
         this.registerCommand();
     }
     public dispose() {
@@ -21,18 +24,8 @@ export class ReplProvider implements Disposable {
     }
     @captureTelemetry(EventName.REPL)
     private async commandHandler() {
-        const resource = this.getActiveResourceUri();
+        const resource = this.activeResourceService.getActiveResource();
         const replProvider = this.serviceContainer.get<ICodeExecutionService>(ICodeExecutionService, 'repl');
         await replProvider.initializeRepl(resource);
     }
-    private getActiveResourceUri(): 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);
-        if (Array.isArray(workspace.workspaceFolders) && workspace.workspaceFolders.length > 0) {
-            return workspace.workspaceFolders[0].uri;
-        }
-    }
 }
diff --git a/src/test/activation/activationManager.unit.test.ts b/src/test/activation/activationManager.unit.test.ts
@@ -9,7 +9,8 @@ import * as typemoq from 'typemoq';
 import { TextDocument, Uri } from 'vscode';
 import { ExtensionActivationManager } from '../../client/activation/activationManager';
 import { LanguageServerExtensionActivationService } from '../../client/activation/activationService';
-import { IExtensionActivationService } from '../../client/activation/types';
+import { ActiveResourceService } from '../../client/activation/activeResource';
+import { IActiveResourceService, IExtensionActivationService } from '../../client/activation/types';
 import { IApplicationDiagnostics } from '../../client/application/types';
 import { IDocumentManager, IWorkspaceService } from '../../client/common/application/types';
 import { WorkspaceService } from '../../client/common/application/workspace';
@@ -41,11 +42,13 @@ suite('Activation - ActivationManager', () => {
     let appDiagnostics: typemoq.IMock<IApplicationDiagnostics>;
     let autoSelection: typemoq.IMock<IInterpreterAutoSelectionService>;
     let interpreterService: IInterpreterService;
+    let activeResourceService: IActiveResourceService;
     let documentManager: typemoq.IMock<IDocumentManager>;
     let activationService1: IExtensionActivationService;
     let activationService2: IExtensionActivationService;
     setup(() => {
         workspaceService = mock(WorkspaceService);
+        activeResourceService = mock(ActiveResourceService);
         appDiagnostics = typemoq.Mock.ofType<IApplicationDiagnostics>();
         autoSelection = typemoq.Mock.ofType<IInterpreterAutoSelectionService>();
         interpreterService = mock(InterpreterService);
@@ -58,7 +61,8 @@ suite('Activation - ActivationManager', () => {
             instance(interpreterService),
             autoSelection.object,
             appDiagnostics.object,
-            instance(workspaceService)
+            instance(workspaceService),
+            instance(activeResourceService)
         );
     });
     test('Initialize will add event handlers and will dispose them when running dispose', async () => {
diff --git a/src/test/providers/repl.unit.test.ts b/src/test/providers/repl.unit.test.ts
@@ -3,7 +3,8 @@
 
 import { expect } from 'chai';
 import * as TypeMoq from 'typemoq';
-import { Disposable, TextDocument, TextEditor, Uri, WorkspaceFolder } from 'vscode';
+import { Disposable, Uri } from 'vscode';
+import { IActiveResourceService } from '../../client/activation/types';
 import { ICommandManager, IDocumentManager, IWorkspaceService } from '../../client/common/application/types';
 import { Commands } from '../../client/common/constants';
 import { IServiceContainer } from '../../client/ioc/types';
@@ -17,17 +18,20 @@ suite('REPL Provider', () => {
     let workspace: TypeMoq.IMock<IWorkspaceService>;
     let codeExecutionService: TypeMoq.IMock<ICodeExecutionService>;
     let documentManager: TypeMoq.IMock<IDocumentManager>;
+    let activeResourceService: TypeMoq.IMock<IActiveResourceService>;
     let replProvider: ReplProvider;
     setup(() => {
         serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
         commandManager = TypeMoq.Mock.ofType<ICommandManager>();
         workspace = TypeMoq.Mock.ofType<IWorkspaceService>();
         codeExecutionService = TypeMoq.Mock.ofType<ICodeExecutionService>();
         documentManager = TypeMoq.Mock.ofType<IDocumentManager>();
+        activeResourceService = TypeMoq.Mock.ofType<IActiveResourceService>();
         serviceContainer.setup(c => c.get(ICommandManager)).returns(() => commandManager.object);
         serviceContainer.setup(c => c.get(IWorkspaceService)).returns(() => workspace.object);
         serviceContainer.setup(c => c.get(ICodeExecutionService, TypeMoq.It.isValue('repl'))).returns(() => codeExecutionService.object);
         serviceContainer.setup(c => c.get(IDocumentManager)).returns(() => documentManager.object);
+        serviceContainer.setup(c => c.get(IActiveResourceService)).returns(() => activeResourceService.object);
     });
     teardown(() => {
         try {
@@ -51,86 +55,24 @@ suite('REPL Provider', () => {
         disposable.verify(d => d.dispose(), TypeMoq.Times.once());
     });
 
-    test('Ensure resource is \'undefined\' if there\s no active document nor a workspace', () => {
+    test('Ensure execution is carried smoothly in the handler if there are no errors', () => {
+        const resource = Uri.parse('a');
         const disposable = TypeMoq.Mock.ofType<Disposable>();
         let commandHandler: undefined | (() => void);
         commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Start_REPL), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
             commandHandler = callback;
             return disposable.object;
         });
-        documentManager.setup(d => d.activeTextEditor).returns(() => undefined);
+        activeResourceService
+            .setup(a => a.getActiveResource())
+            .returns(() => resource)
+            .verifiable(TypeMoq.Times.once());
 
         replProvider = new ReplProvider(serviceContainer.object);
         expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
         commandHandler!.call(replProvider);
 
         serviceContainer.verify(c => c.get(TypeMoq.It.isValue(ICodeExecutionService), TypeMoq.It.isValue('repl')), TypeMoq.Times.once());
-        codeExecutionService.verify(c => c.initializeRepl(TypeMoq.It.isValue(undefined)), TypeMoq.Times.once());
-    });
-
-    test('Ensure resource is uri of the active document', () => {
-        const disposable = TypeMoq.Mock.ofType<Disposable>();
-        let commandHandler: undefined | (() => void);
-        commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Start_REPL), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
-            commandHandler = callback;
-            return disposable.object;
-        });
-        const documentUri = Uri.file('a');
-        const editor = TypeMoq.Mock.ofType<TextEditor>();
-        const document = TypeMoq.Mock.ofType<TextDocument>();
-        document.setup(d => d.uri).returns(() => documentUri);
-        document.setup(d => d.isUntitled).returns(() => false);
-        editor.setup(e => e.document).returns(() => document.object);
-        documentManager.setup(d => d.activeTextEditor).returns(() => editor.object);
-
-        replProvider = new ReplProvider(serviceContainer.object);
-        expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
-        commandHandler!.call(replProvider);
-
-        serviceContainer.verify(c => c.get(TypeMoq.It.isValue(ICodeExecutionService), TypeMoq.It.isValue('repl')), TypeMoq.Times.once());
-        codeExecutionService.verify(c => c.initializeRepl(TypeMoq.It.isValue(documentUri)), TypeMoq.Times.once());
-    });
-
-    test('Ensure resource is \'undefined\' if the active document is not used if it is untitled (new document)', () => {
-        const disposable = TypeMoq.Mock.ofType<Disposable>();
-        let commandHandler: undefined | (() => void);
-        commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Start_REPL), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_cmd, callback) => {
-            commandHandler = callback;
-            return disposable.object;
-        });
-        const editor = TypeMoq.Mock.ofType<TextEditor>();
-        const document = TypeMoq.Mock.ofType<TextDocument>();
-        document.setup(d => d.isUntitled).returns(() => true);
-        editor.setup(e => e.document).returns(() => document.object);
-        documentManager.setup(d => d.activeTextEditor).returns(() => editor.object);
-
-        replProvider = new ReplProvider(serviceContainer.object);
-        expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
-        commandHandler!.call(replProvider);
-
-        serviceContainer.verify(c => c.get(TypeMoq.It.isValue(ICodeExecutionService), TypeMoq.It.isValue('repl')), TypeMoq.Times.once());
-        codeExecutionService.verify(c => c.initializeRepl(TypeMoq.It.isValue(undefined)), TypeMoq.Times.once());
-    });
-
-    test('Ensure first available workspace folder is used if there no document', () => {
-        const disposable = TypeMoq.Mock.ofType<Disposable>();
-        let commandHandler: undefined | (() => void);
-        commandManager.setup(c => c.registerCommand(TypeMoq.It.isValue(Commands.Start_REPL), 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]);
-
-        replProvider = new ReplProvider(serviceContainer.object);
-        expect(commandHandler).not.to.be.equal(undefined, 'Handler not set');
-        commandHandler!.call(replProvider);
-
-        serviceContainer.verify(c => c.get(TypeMoq.It.isValue(ICodeExecutionService), TypeMoq.It.isValue('repl')), TypeMoq.Times.once());
-        codeExecutionService.verify(c => c.initializeRepl(TypeMoq.It.isValue(workspaceUri)), TypeMoq.Times.once());
+        codeExecutionService.verify(c => c.initializeRepl(TypeMoq.It.isValue(resource)), TypeMoq.Times.once());
     });
 });
diff --git a/src/test/providers/terminal.unit.test.ts b/src/test/providers/terminal.unit.test.ts
