Add ability to navigate to tests (#4289)

* Ability to navigate to tests

* Add tests

* Added telemetry

* Change line width

* Fix formatting

* Custom symbol provider

* Fixed linters

* Fix tests

Author: DonJayamanne

.vscode/settings.json

@@ -27,5 +27,6 @@
     "javascript.preferences.quoteStyle": "single",
     "typescriptHero.imports.stringQuoteStyle": "'",
     "prettier.tslintIntegration": false,
-    "prettier.printWidth": 120,
+    "prettier.printWidth": 180,
+    "prettier.singleQuote": true
 }

pythonFiles/symbolProvider.py

@@ -0,0 +1,95 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import ast
+import json
+import sys
+
+
+class Visitor(ast.NodeVisitor):
+    def __init__(self):
+        self.symbols = {"classes": [], "methods": [], "functions": []}
+
+    def visit_Module(self, node):
+        self.visitChildren(node)
+
+    def visitChildren(self, node, namespace=""):
+        for child in node.body:
+            if isinstance(child, ast.FunctionDef):
+                self.visitDef(child, namespace)
+            if isinstance(child, ast.ClassDef):
+                self.visitClassDef(child, namespace)
+            try:
+                if isinstance(child, ast.AsyncFunctionDef):
+                    self.visitDef(child, namespace)
+            except Exception:
+                pass
+
+    def visitDef(self, node, namespace=""):
+        end_position = self.getEndPosition(node)
+        symbol = "functions" if namespace == "" else "methods"
+        self.symbols[symbol].append(self.getDataObject(node, namespace))
+
+    def visitClassDef(self, node, namespace=""):
+        end_position = self.getEndPosition(node)
+        self.symbols['classes'].append(self.getDataObject(node, namespace))
+
+        if len(namespace) > 0:
+            namespace = "{0}::{1}".format(namespace, node.name)
+        else:
+            namespace = node.name
+        self.visitChildren(node, namespace)
+
+    def getDataObject(self, node, namespace=""):
+        end_position = self.getEndPosition(node)
+        return {
+            "namespace": namespace,
+            "name": node.name,
+            "range": {
+                "start": {
+                    "line": node.lineno,
+                    "character": node.col_offset
+                },
+                "end": {
+                    "line": end_position[0],
+                    "character": end_position[1]
+                }
+            }
+        }
+
+    def getEndPosition(self, node):
+        if not hasattr(node, 'body') or len(node.body) == 0:
+            return (node.lineno, node.col_offset)
+        return self.getEndPosition(node.body[-1])
+
+
+def provide_symbols(source):
+    """Provides a list of all symbols in provided code.
+
+    The list comprises of 3-item tuples that contain the starting line number,
+    ending line number and whether the statement is a single line.
+
+    """
+    tree = ast.parse(source)
+    visitor = Visitor()
+    visitor.visit(tree)
+    sys.stdout.write(json.dumps(visitor.symbols))
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3:
+        contents = sys.argv[2]
+    else:
+        with open(sys.argv[1], "r") as source:
+            contents = source.read()
+
+    try:
+        default_encoding = sys.getdefaultencoding()
+        encoded_contents = contents.encode(default_encoding, 'surrogateescape')
+        contents = encoded_contents.decode(default_encoding, 'replace')
+    except (UnicodeError, LookupError):
+        pass
+    if isinstance(contents, bytes):
+        contents = contents.decode('utf8')
+    provide_symbols(contents)

src/client/activation/jedi.ts

@@ -107,8 +107,7 @@ export class JediExtensionActivator implements ILanguageServerActivator {
 
         const testManagementService = this.serviceManager.get<IUnitTestManagementService>(IUnitTestManagementService);
         testManagementService
-            .activate()
-            .then(() => testManagementService.activateCodeLenses(symbolProvider))
+            .activate(symbolProvider)
             .catch(ex => this.serviceManager.get<ILogger>(ILogger).logError('Failed to activate Unit Tests', ex));
     }
 

src/client/activation/languageServer/languageServer.ts

@@ -90,7 +90,6 @@ export class LanguageServer implements ILanguageServer {
         if (!this.languageClient) {
             throw new Error('languageClient not initialized');
         }
-        await this.testManager.activate();
-        await this.testManager.activateCodeLenses(new LanguageServerSymbolProvider(this.languageClient!));
+        await this.testManager.activate(new LanguageServerSymbolProvider(this.languageClient!));
     }
 }

src/client/common/constants.ts

@@ -41,6 +41,9 @@ export namespace Commands {
     export const Enable_Linter = 'python.enableLinting';
     export const Run_Linter = 'python.runLinting';
     export const Enable_SourceMap_Support = 'python.enableSourceMapSupport';
+    export const navigateToTestFunction = 'navigateToTestFunction';
+    export const navigateToTestSuite = 'navigateToTestSuite';
+    export const navigateToTestFile = 'navigateToTestFile';
 }
 export namespace Octicons {
     export const Test_Pass = '$(check)';

src/client/common/types.ts

@@ -3,11 +3,12 @@
 'use strict';
 
 import { Socket } from 'net';
-import { ConfigurationTarget, DiagnosticSeverity, Disposable, Event, Extension, ExtensionContext, OutputChannel, Uri, WorkspaceEdit } from 'vscode';
+import { ConfigurationTarget, DiagnosticSeverity, Disposable, DocumentSymbolProvider, Event, Extension, ExtensionContext, OutputChannel, Uri, WorkspaceEdit } from 'vscode';
 import { EnvironmentVariables } from './variables/types';
 export const IOutputChannel = Symbol('IOutputChannel');
-export interface IOutputChannel extends OutputChannel { }
+export interface IOutputChannel extends OutputChannel {}
 export const IDocumentSymbolProvider = Symbol('IDocumentSymbolProvider');
+export interface IDocumentSymbolProvider extends DocumentSymbolProvider {}
 export const IsWindows = Symbol('IS_WINDOWS');
 export const IDisposableRegistry = Symbol('IDiposableRegistry');
 export type IDisposableRegistry = { push(disposable: Disposable): void };
@@ -293,7 +294,7 @@ export interface IDataScienceSettings {
     showCellInputCode: boolean;
     collapseCellInputCodeByDefault: boolean;
     maxOutputSize: number;
-    sendSelectionToInteractiveWindow : boolean;
+    sendSelectionToInteractiveWindow: boolean;
     markdownRegularExpression: string;
     codeRegularExpression: string;
 }
@@ -313,7 +314,7 @@ export interface ISocketServer extends Disposable {
 }
 
 export const IExtensionContext = Symbol('ExtensionContext');
-export interface IExtensionContext extends ExtensionContext { }
+export interface IExtensionContext extends ExtensionContext {}
 
 export const IExtensions = Symbol('IExtensions');
 export interface IExtensions {

src/client/extension.ts

@@ -102,6 +102,7 @@ import { EditorLoadTelemetry } from './telemetry/types';
 import { registerTypes as commonRegisterTerminalTypes } from './terminals/serviceRegistry';
 import { ICodeExecutionManager, ITerminalAutoActivation } from './terminals/types';
 import { TEST_OUTPUT_CHANNEL } from './unittests/common/constants';
+import { ITestCodeNavigatorCommandHandler } from './unittests/navigation/types';
 import { registerTypes as unitTestsRegisterTypes } from './unittests/serviceRegistry';
 
 durations.codeLoadingTime = stopWatch.elapsedTime;
@@ -294,6 +295,7 @@ function initializeServices(context: ExtensionContext, serviceManager: ServiceMa
     serviceContainer.get<InterpreterLocatorProgressHandler>(InterpreterLocatorProgressHandler).register();
     serviceContainer.get<IInterpreterLocatorProgressService>(IInterpreterLocatorProgressService).register();
     serviceContainer.get<IApplicationDiagnostics>(IApplicationDiagnostics).register();
+    serviceContainer.get<ITestCodeNavigatorCommandHandler>(ITestCodeNavigatorCommandHandler).register();
 }
 
 // tslint:disable-next-line:no-any

src/client/telemetry/constants.ts

@@ -40,6 +40,9 @@ export enum EventName {
     UNITTEST_RUN = 'UNITTEST.RUN',
     UNITTEST_DISCOVER = 'UNITTEST.DISCOVER',
     UNITTEST_VIEW_OUTPUT = 'UNITTEST.VIEW_OUTPUT',
+    UNITTEST_NAVIGATE_TEST_FILE = 'UNITTEST.NAVIGATE.TEST_FILE',
+    UNITTEST_NAVIGATE_TEST_FUNCTION = 'UNITTEST.NAVIGATE.TEST_FUNCTION',
+    UNITTEST_NAVIGATE_TEST_SUITE = 'UNITTEST.NAVIGATE.TEST_SUITE',
     PYTHON_LANGUAGE_SERVER_ANALYSISTIME = 'PYTHON_LANGUAGE_SERVER.ANALYSIS_TIME',
     PYTHON_LANGUAGE_SERVER_ENABLED = 'PYTHON_LANGUAGE_SERVER.ENABLED',
     PYTHON_LANGUAGE_SERVER_EXTRACTED = 'PYTHON_LANGUAGE_SERVER.EXTRACTED',

src/client/telemetry/index.ts

@@ -324,4 +324,7 @@ interface IEventNamePropertyMapping {
     [Telemetry.StartJupyter]: never | undefined;
     [Telemetry.SubmitCellThroughInput]: never | undefined;
     [Telemetry.Undo]: never | undefined;
+    [EventName.UNITTEST_NAVIGATE_TEST_FILE]: never | undefined;
+    [EventName.UNITTEST_NAVIGATE_TEST_FUNCTION]: never | undefined;
+    [EventName.UNITTEST_NAVIGATE_TEST_SUITE]: never | undefined;
 }

src/client/unittests/codeLenses/main.ts

@@ -3,14 +3,18 @@ import { PYTHON } from '../../common/constants';
 import { ITestCollectionStorageService } from '../common/types';
 import { TestFileCodeLensProvider } from './testFiles';
 
-export function activateCodeLenses(onDidChange: vscode.EventEmitter<void>,
-    symboldProvider: vscode.DocumentSymbolProvider, testCollectionStorage: ITestCollectionStorageService): vscode.Disposable {
-
+export function activateCodeLenses(
+    onDidChange: vscode.EventEmitter<void>,
+    symbolProvider: vscode.DocumentSymbolProvider,
+    testCollectionStorage: ITestCollectionStorageService
+): vscode.Disposable {
     const disposables: vscode.Disposable[] = [];
-    const codeLensProvider = new TestFileCodeLensProvider(onDidChange, symboldProvider, testCollectionStorage);
+    const codeLensProvider = new TestFileCodeLensProvider(onDidChange, symbolProvider, testCollectionStorage);
     disposables.push(vscode.languages.registerCodeLensProvider(PYTHON, codeLensProvider));
 
     return {
-        dispose: () => { disposables.forEach(d => d.dispose()); }
+        dispose: () => {
+            disposables.forEach(d => d.dispose());
+        }
     };
 }

src/client/unittests/common/services/storageService.ts

@@ -1,7 +1,7 @@
 import { inject, injectable } from 'inversify';
 import { Disposable, Uri, workspace } from 'vscode';
 import { IDisposableRegistry } from '../../../common/types';
-import { ITestCollectionStorageService, Tests } from './../types';
+import { FlattenedTestFunction, FlattenedTestSuite, ITestCollectionStorageService, TestFunction, Tests, TestSuite } from './../types';
 
 @injectable()
 export class TestCollectionStorageService implements ITestCollectionStorageService {
@@ -17,6 +17,20 @@ export class TestCollectionStorageService implements ITestCollectionStorageServi
         const workspaceFolder = this.getWorkspaceFolderPath(wkspace) || '';
         this.testsIndexedByWorkspaceUri.set(workspaceFolder, tests);
     }
+    public findFlattendTestFunction(resource: Uri, func: TestFunction): FlattenedTestFunction | undefined {
+        const tests = this.getTests(resource);
+        if (!tests) {
+            return;
+        }
+        return tests.testFunctions.find(f => f.testFunction === func);
+    }
+    public findFlattendTestSuite(resource: Uri, suite: TestSuite): FlattenedTestSuite | undefined {
+        const tests = this.getTests(resource);
+        if (!tests) {
+            return;
+        }
+        return tests.testSuites.find(f => f.testSuite === suite);
+    }
     public dispose() {
         this.testsIndexedByWorkspaceUri.clear();
     }

src/client/unittests/common/types.ts

@@ -183,6 +183,8 @@ export const ITestCollectionStorageService = Symbol('ITestCollectionStorageServi
 export interface ITestCollectionStorageService extends Disposable {
     getTests(wkspace: Uri): Tests | undefined;
     storeTests(wkspace: Uri, tests: Tests | null | undefined): void;
+    findFlattendTestFunction(resource: Uri, func: TestFunction): FlattenedTestFunction | undefined;
+    findFlattendTestSuite(resource: Uri, func: TestSuite): FlattenedTestSuite | undefined;
 }
 
 export const ITestResultsService = Symbol('ITestResultsService');

src/client/unittests/display/picker.ts

@@ -237,9 +237,9 @@ function onItemSelected(cmdSource: CommandSource, wkspace: Uri, selection: TestI
             break;
         }
         case Type.RunMethod: {
-            cmd = constants.Commands.Tests_Run;
+            cmd = constants.Commands.navigateToTestFunction;
             // tslint:disable-next-line:prefer-type-cast no-object-literal-type-assertion
-            args.push({ testFunction: [selection.fn!.testFunction] } as TestsToRun);
+            args.push(selection.fn!.testFunction);
             break;
         }
         case Type.DebugMethod: {

src/client/unittests/main.ts

@@ -7,6 +7,7 @@ import { ConfigurationChangeEvent, Disposable, OutputChannel, TextDocument, Uri
 import * as vscode from 'vscode';
 import { ICommandManager, IDocumentManager, IWorkspaceService } from '../common/application/types';
 import * as constants from '../common/constants';
+import '../common/extensions';
 import { IConfigurationService, IDisposableRegistry, ILogger, IOutputChannel } from '../common/types';
 import { IServiceContainer } from '../ioc/types';
 import { EventName } from '../telemetry/constants';
@@ -42,17 +43,14 @@ export class UnitTestManagementService implements IUnitTestManagementService, Di
             this.workspaceTestManagerService.dispose();
         }
     }
-    public async activate(): Promise<void> {
+    public async activate(symboldProvider: vscode.DocumentSymbolProvider): Promise<void> {
         this.workspaceTestManagerService = this.serviceContainer.get<IWorkspaceTestManagerService>(IWorkspaceTestManagerService);
 
         this.registerHandlers();
         this.registerCommands();
         this.autoDiscoverTests()
             .catch(ex => this.serviceContainer.get<ILogger>(ILogger).logError('Failed to auto discover tests upon activation', ex));
-    }
-    public async activateCodeLenses(symboldProvider: vscode.DocumentSymbolProvider): Promise<void> {
-        const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);
-        this.disposableRegistry.push(activateCodeLenses(this.onDidChange, symboldProvider, testCollectionStorage));
+        await this.registerSymbolProvider(symboldProvider);
     }
     public async getTestManager(displayTestNotConfiguredMessage: boolean, resource?: Uri): Promise<ITestManager | undefined | void> {
         let wkspace: Uri | undefined;
@@ -280,6 +278,10 @@ export class UnitTestManagementService implements IUnitTestManagementService, Di
         this.testResultDisplay.displayProgressStatus(promise, debug);
         await promise;
     }
+    private async registerSymbolProvider(symboldProvider: vscode.DocumentSymbolProvider): Promise<void> {
+        const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);
+        this.disposableRegistry.push(activateCodeLenses(this.onDidChange, symboldProvider, testCollectionStorage));
+    }
     private registerCommands(): void {
         const disposablesRegistry = this.serviceContainer.get<Disposable[]>(IDisposableRegistry);
         const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);

src/client/unittests/navigation/commandHandler.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable, named } from 'inversify';
+import { ICommandManager } from '../../common/application/types';
+import { Commands } from '../../common/constants';
+import { IDisposable, IDisposableRegistry } from '../../common/types';
+import { ITestCodeNavigator, ITestCodeNavigatorCommandHandler, NavigableItemType } from './types';
+
+@injectable()
+export class TestCodeNavigatorCommandHandler implements ITestCodeNavigatorCommandHandler {
+    private disposables: IDisposable[] = [];
+    constructor(
+        @inject(ICommandManager) private readonly commandManager: ICommandManager,
+        @inject(ITestCodeNavigator) @named(NavigableItemType.testFile) private readonly testFileNavigator: ITestCodeNavigator,
+        @inject(ITestCodeNavigator) @named(NavigableItemType.testFunction) private readonly testFunctionNavigator: ITestCodeNavigator,
+        @inject(ITestCodeNavigator) @named(NavigableItemType.testSuite) private readonly testSuiteNavigator: ITestCodeNavigator,
+        @inject(IDisposableRegistry) disposableRegistry: IDisposableRegistry
+    ) {
+        disposableRegistry.push(this);
+    }
+    public dispose() {
+        this.disposables.forEach(item => item.dispose());
+    }
+    public register(): void {
+        if (this.disposables.length > 0) {
+            return;
+        }
+        let disposable = this.commandManager.registerCommand(Commands.navigateToTestFile, this.testFileNavigator.navigateTo, this.testFileNavigator);
+        this.disposables.push(disposable);
+        disposable = this.commandManager.registerCommand(Commands.navigateToTestFunction, this.testFunctionNavigator.navigateTo, this.testFunctionNavigator);
+        this.disposables.push(disposable);
+        disposable = this.commandManager.registerCommand(Commands.navigateToTestSuite, this.testSuiteNavigator.navigateTo, this.testSuiteNavigator);
+        this.disposables.push(disposable);
+    }
+}

src/client/unittests/navigation/fileNavigator.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { swallowExceptions } from '../../common/utils/decorators';
+import { captureTelemetry } from '../../telemetry';
+import { EventName } from '../../telemetry/constants';
+import { TestFile } from '../common/types';
+import { ITestCodeNavigator, ITestNavigatorHelper } from './types';
+
+@injectable()
+export class TestFileCodeNavigator implements ITestCodeNavigator {
+    constructor(@inject(ITestNavigatorHelper) private readonly helper: ITestNavigatorHelper) {}
+    @swallowExceptions('Navigate to test file')
+    @captureTelemetry(EventName.UNITTEST_NAVIGATE_TEST_FILE, undefined, true)
+    public async navigateTo(_: Uri, item: TestFile): Promise<void> {
+        await this.helper.openFile(Uri.file(item.fullPath));
+    }
+}