Add TreeView data model and hook up existing test data

src/client/extension.ts

@@ -93,7 +93,6 @@ import { ReplProvider } from './providers/replProvider';
 import { registerTypes as providersRegisterTypes } from './providers/serviceRegistry';
 import { activateSimplePythonRefactorProvider } from './providers/simpleRefactorProvider';
 import { TerminalProvider } from './providers/terminalProvider';
-import { PythonTestTreeViewProvider } from './providers/testTreeViewProvider';
 import { ISortImportsEditingProvider } from './providers/types';
 import { activateUpdateSparkLibraryProvider } from './providers/updateSparkLibraryProvider';
 import { sendTelemetryEvent } from './telemetry';
@@ -208,8 +207,6 @@ async function activateUnsafe(context: ExtensionContext): Promise<IExtensionApi>
 
     context.subscriptions.push(languages.registerCodeActionsProvider(PYTHON, new PythonCodeActionProvider(), { providedCodeActionKinds: [CodeActionKind.SourceOrganizeImports] }));
 
-    context.subscriptions.push(window.registerTreeDataProvider('python_tests', new PythonTestTreeViewProvider()));
-
     serviceContainer.getAll<DebugConfigurationProvider>(IDebugConfigurationService).forEach(debugConfigProvider => {
         context.subscriptions.push(debug.registerDebugConfigurationProvider(DebuggerTypeName, debugConfigProvider));
     });

src/client/providers/types.ts

@@ -3,11 +3,22 @@
 
 'use strict';
 
-import { CancellationToken, Uri, WorkspaceEdit } from 'vscode';
+import {
+    CancellationToken, Event, ProviderResult,
+    TreeDataProvider, Uri, WorkspaceEdit
+} from 'vscode';
+import { TestTreeItem } from '../unittests/providers/testTreeViewItem';
 
 export const ISortImportsEditingProvider = Symbol('ISortImportsEditingProvider');
 export interface ISortImportsEditingProvider {
     provideDocumentSortImportsEdits(uri: Uri, token?: CancellationToken): Promise<WorkspaceEdit | undefined>;
     sortImports(uri?: Uri): Promise<void>;
     registerCommands(): void;
 }
+
+export const ITestTreeViewProvider = Symbol('ITestTreeViewProvider');
+export interface ITestTreeViewProvider extends TreeDataProvider<TestTreeItem> {
+    onDidChangeTreeData: Event<TestTreeItem | undefined>;
+    getTreeItem(element: TestTreeItem): Promise<TestTreeItem>;
+    getChildren(element?: TestTreeItem): ProviderResult<TestTreeItem[]>;
+}

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

@@ -1,13 +1,21 @@
 import { inject, injectable } from 'inversify';
-import { Disposable, Uri, workspace } from 'vscode';
+import {
+    Disposable, Event, EventEmitter,
+    Uri, workspace
+} from 'vscode';
 import { IDisposableRegistry } from '../../../common/types';
 import { FlattenedTestFunction, FlattenedTestSuite, ITestCollectionStorageService, TestFunction, Tests, TestSuite } from './../types';
 
 @injectable()
 export class TestCollectionStorageService implements ITestCollectionStorageService {
+    public readonly onUpdated: Event<Uri>;
+
     private testsIndexedByWorkspaceUri = new Map<string, Tests | undefined>();
+    private _onTestStoreUpdated: EventEmitter<Uri> = new EventEmitter<Uri>();
+
     constructor(@inject(IDisposableRegistry) disposables: Disposable[]) {
         disposables.push(this);
+        this.onUpdated = this._onTestStoreUpdated.event;
     }
     public getTests(wkspace: Uri): Tests | undefined {
         const workspaceFolder = this.getWorkspaceFolderPath(wkspace) || '';
@@ -16,6 +24,7 @@ export class TestCollectionStorageService implements ITestCollectionStorageServi
     public storeTests(wkspace: Uri, tests: Tests | undefined): void {
         const workspaceFolder = this.getWorkspaceFolderPath(wkspace) || '';
         this.testsIndexedByWorkspaceUri.set(workspaceFolder, tests);
+        this._onTestStoreUpdated.fire(wkspace);
     }
     public findFlattendTestFunction(resource: Uri, func: TestFunction): FlattenedTestFunction | undefined {
         const tests = this.getTests(resource);
@@ -33,6 +42,7 @@ export class TestCollectionStorageService implements ITestCollectionStorageServi
     }
     public dispose() {
         this.testsIndexedByWorkspaceUri.clear();
+        this._onTestStoreUpdated.dispose();
     }
     private getWorkspaceFolderPath(resource: Uri): string | undefined {
         const folder = workspace.getWorkspaceFolder(resource);

src/client/unittests/common/types.ts

@@ -1,4 +1,7 @@
-import { CancellationToken, DiagnosticCollection, Disposable, OutputChannel, Uri } from 'vscode';
+import {
+    CancellationToken, DiagnosticCollection, Disposable,
+    Event, OutputChannel, Uri
+} from 'vscode';
 import { IUnitTestSettings, Product } from '../../common/types';
 import { IPythonUnitTestMessage } from '../types';
 import { CommandSource } from './constants';
@@ -181,6 +184,7 @@ export interface ITestVisitor {
 export const ITestCollectionStorageService = Symbol('ITestCollectionStorageService');
 
 export interface ITestCollectionStorageService extends Disposable {
+    onUpdated: Event<Uri>;
     getTests(wkspace: Uri): Tests | undefined;
     storeTests(wkspace: Uri, tests: Tests | null | undefined): void;
     findFlattendTestFunction(resource: Uri, func: TestFunction): FlattenedTestFunction | undefined;

src/client/unittests/main.ts

@@ -3,32 +3,50 @@
 // tslint:disable:no-duplicate-imports no-unnecessary-callback-wrapper
 
 import { inject, injectable } from 'inversify';
-import { ConfigurationChangeEvent, Disposable, OutputChannel, TextDocument, Uri } from 'vscode';
-import * as vscode from 'vscode';
-import { ICommandManager, IDocumentManager, IWorkspaceService } from '../common/application/types';
+import {
+    ConfigurationChangeEvent, Disposable,
+    DocumentSymbolProvider, EventEmitter,
+    OutputChannel, TextDocument, Uri, window
+} 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 {
+    IConfigurationService, IDisposableRegistry,
+    ILogger, IOutputChannel
+} from '../common/types';
 import { IServiceContainer } from '../ioc/types';
+import { ITestTreeViewProvider } from '../providers/types';
 import { EventName } from '../telemetry/constants';
 import { sendTelemetryEvent } from '../telemetry/index';
 import { activateCodeLenses } from './codeLenses/main';
-import { CANCELLATION_REASON, CommandSource, TEST_OUTPUT_CHANNEL } from './common/constants';
+import {
+    CANCELLATION_REASON, CommandSource, TEST_OUTPUT_CHANNEL
+} from './common/constants';
 import { selectTestWorkspace } from './common/testUtils';
-import { ITestCollectionStorageService, ITestManager, IWorkspaceTestManagerService, TestFile, TestFunction, TestStatus, TestsToRun } from './common/types';
-import { ITestDisplay, ITestResultDisplay, IUnitTestConfigurationService, IUnitTestManagementService } from './types';
+import {
+    ITestCollectionStorageService, ITestManager,
+    IWorkspaceTestManagerService, TestFile,
+    TestFunction, TestStatus, TestsToRun
+} from './common/types';
+import {
+    ITestDisplay, ITestResultDisplay,
+    IUnitTestConfigurationService, IUnitTestManagementService
+} from './types';
 
 @injectable()
 export class UnitTestManagementService implements IUnitTestManagementService, Disposable {
-    private readonly outputChannel: vscode.OutputChannel;
+    private readonly outputChannel: OutputChannel;
     private readonly disposableRegistry: Disposable[];
     private workspaceTestManagerService?: IWorkspaceTestManagerService;
     private documentManager: IDocumentManager;
     private workspaceService: IWorkspaceService;
     private testResultDisplay?: ITestResultDisplay;
     private autoDiscoverTimer?: NodeJS.Timer;
     private configChangedTimer?: NodeJS.Timer;
-    private readonly onDidChange: vscode.EventEmitter<void> = new vscode.EventEmitter<void>();
+    private readonly onDidChange: EventEmitter<void> = new EventEmitter<void>();
 
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
         this.disposableRegistry = serviceContainer.get<Disposable[]>(IDisposableRegistry);
@@ -43,15 +61,28 @@ export class UnitTestManagementService implements IUnitTestManagementService, Di
             this.workspaceTestManagerService.dispose();
         }
     }
-    public async activate(symboldProvider: vscode.DocumentSymbolProvider): Promise<void> {
+    public async activate(symbolProvider: DocumentSymbolProvider): Promise<void> {
         this.workspaceTestManagerService = this.serviceContainer.get<IWorkspaceTestManagerService>(IWorkspaceTestManagerService);
+        const disposablesRegistry = this.serviceContainer.get<Disposable[]>(IDisposableRegistry);
 
         this.registerHandlers();
         this.registerCommands();
+
+        // register provider...
+        const testViewProvider = this.serviceContainer.get<ITestTreeViewProvider>(ITestTreeViewProvider);
+        const disposable = window.registerTreeDataProvider('python_tests', testViewProvider);
+        disposablesRegistry.push(disposable);
+
         this.autoDiscoverTests()
             .catch(ex => this.serviceContainer.get<ILogger>(ILogger).logError('Failed to auto discover tests upon activation', ex));
-        await this.registerSymbolProvider(symboldProvider);
+        await this.registerSymbolProvider(symbolProvider);
     }
+
+    public async activateCodeLenses(symbolProvider: DocumentSymbolProvider): Promise<void> {
+        const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);
+        this.disposableRegistry.push(activateCodeLenses(this.onDidChange, symbolProvider, testCollectionStorage));
+    }
+
     public async getTestManager(displayTestNotConfiguredMessage: boolean, resource?: Uri): Promise<ITestManager | undefined | void> {
         let wkspace: Uri | undefined;
         if (resource) {
@@ -278,9 +309,9 @@ export class UnitTestManagementService implements IUnitTestManagementService, Di
         this.testResultDisplay.displayProgressStatus(promise, debug);
         await promise;
     }
-    private async registerSymbolProvider(symboldProvider: vscode.DocumentSymbolProvider): Promise<void> {
+    private async registerSymbolProvider(symbolProvider: DocumentSymbolProvider): Promise<void> {
         const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);
-        this.disposableRegistry.push(activateCodeLenses(this.onDidChange, symboldProvider, testCollectionStorage));
+        this.disposableRegistry.push(activateCodeLenses(this.onDidChange, symbolProvider, testCollectionStorage));
     }
     private registerCommands(): void {
         const disposablesRegistry = this.serviceContainer.get<Disposable[]>(IDisposableRegistry);