'use strict';

// tslint:disable:no-duplicate-imports no-unnecessary-callback-wrapper

import { inject, injectable } from 'inversify';

import { ConfigurationChangeEvent, Disposable, DocumentSymbolProvider, Event, EventEmitter, OutputChannel, TextDocument, Uri } from 'vscode';

import { IApplicationShell, ICommandManager, IDocumentManager, IWorkspaceService } from '../common/application/types';

import * as constants from '../common/constants';

import { AlwaysDisplayTestExplorerGroups } from '../common/experimentGroups';

import '../common/extensions';

import { IConfigurationService, IDisposableRegistry, IExperimentsManager, ILogger, IOutputChannel, Resource } from '../common/types';

import { noop } from '../common/utils/misc';

import { IServiceContainer } from '../ioc/types';

import { EventName } from '../telemetry/constants';

import { captureTelemetry, sendTelemetryEvent } from '../telemetry/index';

import { activateCodeLenses } from './codeLenses/main';

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 { ITestConfigurationService, ITestDisplay, ITestManagementService, ITestResultDisplay, TestWorkspaceFolder, WorkspaceTestStatus } from './types';

// tslint:disable:no-any

@injectable()

export class UnitTestManagementService implements ITestManagementService, Disposable {

private readonly outputChannel: OutputChannel;

private activatedOnce: boolean = false;

private readonly disposableRegistry: Disposable[];

private workspaceTestManagerService?: IWorkspaceTestManagerService;

private documentManager: IDocumentManager;

private workspaceService: IWorkspaceService;

private testResultDisplay?: ITestResultDisplay;

private autoDiscoverTimer?: NodeJS.Timer | number;

private configChangedTimer?: NodeJS.Timer | number;

private testManagers = new Set<ITestManager>();

private readonly _onDidStatusChange: EventEmitter<WorkspaceTestStatus> = new EventEmitter<WorkspaceTestStatus>();

constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {

this.disposableRegistry = serviceContainer.get<Disposable[]>(IDisposableRegistry);

this.outputChannel = serviceContainer.get<OutputChannel>(IOutputChannel, TEST_OUTPUT_CHANNEL);

this.workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);

this.documentManager = serviceContainer.get<IDocumentManager>(IDocumentManager);

this.disposableRegistry.push(this);

}

public dispose() {

if (this.workspaceTestManagerService) {

this.workspaceTestManagerService.dispose();

}

if (this.configChangedTimer) {

clearTimeout(this.configChangedTimer as any);

this.configChangedTimer = undefined;

}

if (this.autoDiscoverTimer) {

clearTimeout(this.autoDiscoverTimer as any);

this.autoDiscoverTimer = undefined;

}

}

public get onDidStatusChange(): Event<WorkspaceTestStatus> {

return this._onDidStatusChange.event;

}

public async activate(symbolProvider: DocumentSymbolProvider): Promise<void> {

if (this.activatedOnce) {

return;

}

this.activatedOnce = true;

this.workspaceTestManagerService = this.serviceContainer.get<IWorkspaceTestManagerService>(IWorkspaceTestManagerService);

this.registerHandlers();

this.registerCommands();

this.checkExperiments();

this.autoDiscoverTests(undefined).catch(ex => this.serviceContainer.get<ILogger>(ILogger).logError('Failed to auto discover tests upon activation', ex));

await this.registerSymbolProvider(symbolProvider);

}

public checkExperiments() {

const experiments = this.serviceContainer.get<IExperimentsManager>(IExperimentsManager);

if (experiments.inExperiment(AlwaysDisplayTestExplorerGroups.experiment)) {

const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);

commandManager.executeCommand('setContext', 'testsDiscovered', true).then(noop, noop);

} else {

experiments.sendTelemetryIfInExperiment(AlwaysDisplayTestExplorerGroups.control);

}

}

public async getTestManager(displayTestNotConfiguredMessage: boolean, resource?: Uri): Promise<ITestManager | undefined | void> {

let wkspace: Uri | undefined;

if (resource) {

const wkspaceFolder = this.workspaceService.getWorkspaceFolder(resource);

wkspace = wkspaceFolder ? wkspaceFolder.uri : undefined;

} else {

const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);

wkspace = await selectTestWorkspace(appShell);

}

if (!wkspace) {

return;

}

const testManager = this.workspaceTestManagerService!.getTestManager(wkspace);

if (testManager) {

if (!this.testManagers.has(testManager)) {

this.testManagers.add(testManager);

const handler = testManager.onDidStatusChange(e => this._onDidStatusChange.fire(e));

this.disposableRegistry.push(handler);

}

return testManager;

}

if (displayTestNotConfiguredMessage) {

const configurationService = this.serviceContainer.get<ITestConfigurationService>(ITestConfigurationService);

await configurationService.displayTestFrameworkError(wkspace);

}

}

public async configurationChangeHandler(eventArgs: ConfigurationChangeEvent) {

// If there's one workspace, then stop the tests and restart,

// else let the user do this manually.

if (!this.workspaceService.hasWorkspaceFolders || this.workspaceService.workspaceFolders!.length > 1) {

return;

}

if (!Array.isArray(this.workspaceService.workspaceFolders)) {

return;

}

const workspaceFolderUri = this.workspaceService.workspaceFolders.find(w => eventArgs.affectsConfiguration('python.testing', w.uri));

if (!workspaceFolderUri) {

return;

}

const workspaceUri = workspaceFolderUri.uri;

const settings = this.serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings(workspaceUri);

if (!settings.testing.nosetestsEnabled && !settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {

if (this.testResultDisplay) {

this.testResultDisplay.enabled = false;

}

// tslint:disable-next-line:no-suspicious-comment

// TODO: Why are we disposing, what happens when tests are enabled.

if (this.workspaceTestManagerService) {

this.workspaceTestManagerService.dispose();

}

return;

}

if (this.testResultDisplay) {

this.testResultDisplay.enabled = true;

}

this.autoDiscoverTests(workspaceUri).catch(ex => this.serviceContainer.get<ILogger>(ILogger).logError('Failed to auto discover tests upon activation', ex));

}

public async discoverTestsForDocument(doc: TextDocument): Promise<void> {

const testManager = await this.getTestManager(false, doc.uri);

if (!testManager) {

return;

}

const tests = await testManager.discoverTests(CommandSource.auto, false, true);

if (!tests || !Array.isArray(tests.testFiles) || tests.testFiles.length === 0) {

return;

}

if (tests.testFiles.findIndex((f: TestFile) => f.fullPath === doc.uri.fsPath) === -1) {

return;

}

if (this.autoDiscoverTimer) {

clearTimeout(this.autoDiscoverTimer as any);

}

this.autoDiscoverTimer = setTimeout(() => this.discoverTests(CommandSource.auto, doc.uri, true, false, true), 1000);

}

public async autoDiscoverTests(resource: Resource) {

if (!this.workspaceService.hasWorkspaceFolders) {

return;

}

// Default to discovering tests in first folder if none specified.

if (!resource) {

resource = this.workspaceService.workspaceFolders![0].uri;

}

const configurationService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);

const settings = configurationService.getSettings(resource);

if (!settings.testing.nosetestsEnabled && !settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {

return;

}

this.discoverTests(CommandSource.auto, resource, true).ignoreErrors();

}

public async discoverTests(cmdSource: CommandSource, resource?: Uri, ignoreCache?: boolean, userInitiated?: boolean, quietMode?: boolean, clearTestStatus?: boolean) {

const testManager = await this.getTestManager(true, resource);

if (!testManager) {

return;

}

if (testManager.status === TestStatus.Discovering || testManager.status === TestStatus.Running) {

return;

}

if (!this.testResultDisplay) {

this.testResultDisplay = this.serviceContainer.get<ITestResultDisplay>(ITestResultDisplay);

}

const discoveryPromise = testManager.discoverTests(cmdSource, ignoreCache, quietMode, userInitiated, clearTestStatus);

this.testResultDisplay.displayDiscoverStatus(discoveryPromise, quietMode).catch(ex => console.error('Python Extension: displayDiscoverStatus', ex));

await discoveryPromise;

}

public async stopTests(resource: Uri) {

sendTelemetryEvent(EventName.UNITTEST_STOP);

const testManager = await this.getTestManager(true, resource);

if (testManager) {

testManager.stop();

}

}

public async displayStopUI(message: string): Promise<void> {

const testManager = await this.getTestManager(true);

if (!testManager) {

return;

}

const testDisplay = this.serviceContainer.get<ITestDisplay>(ITestDisplay);

testDisplay.displayStopTestUI(testManager.workspaceFolder, message);

}

public async displayUI(cmdSource: CommandSource) {

const testManager = await this.getTestManager(true);

if (!testManager) {

return;

}

const testDisplay = this.serviceContainer.get<ITestDisplay>(ITestDisplay);

testDisplay.displayTestUI(cmdSource, testManager.workspaceFolder);

}

public async displayPickerUI(cmdSource: CommandSource, file: Uri, testFunctions: TestFunction[], debug?: boolean) {

const testManager = await this.getTestManager(true, file);

if (!testManager) {

return;

}

const testDisplay = this.serviceContainer.get<ITestDisplay>(ITestDisplay);

testDisplay.displayFunctionTestPickerUI(cmdSource, testManager.workspaceFolder, testManager.workingDirectory, file, testFunctions, debug);

}

public viewOutput(_cmdSource: CommandSource) {

sendTelemetryEvent(EventName.UNITTEST_VIEW_OUTPUT);

this.outputChannel.show();

}

public async selectAndRunTestMethod(cmdSource: CommandSource, resource: Uri, debug?: boolean) {

const testManager = await this.getTestManager(true, resource);

if (!testManager) {

return;

}

try {

await testManager.discoverTests(cmdSource, true, true, true);

} catch (ex) {

return;

}

const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);

const tests = testCollectionStorage.getTests(testManager.workspaceFolder)!;

const testDisplay = this.serviceContainer.get<ITestDisplay>(ITestDisplay);

const selectedTestFn = await testDisplay.selectTestFunction(testManager.workspaceFolder.fsPath, tests);

if (!selectedTestFn) {

return;

}

// tslint:disable-next-line:prefer-type-cast no-object-literal-type-assertion

await this.runTestsImpl(cmdSource, testManager.workspaceFolder, { testFunction: [selectedTestFn.testFunction] } as TestsToRun, false, debug);

}

public async selectAndRunTestFile(cmdSource: CommandSource) {

const testManager = await this.getTestManager(true);

if (!testManager) {

return;

}

try {

await testManager.discoverTests(cmdSource, true, true, true);

} catch (ex) {

return;

}

const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);

const tests = testCollectionStorage.getTests(testManager.workspaceFolder)!;

const testDisplay = this.serviceContainer.get<ITestDisplay>(ITestDisplay);

const selectedFile = await testDisplay.selectTestFile(testManager.workspaceFolder.fsPath, tests);

if (!selectedFile) {

return;

}

await this.runTestsImpl(cmdSource, testManager.workspaceFolder, { testFile: [selectedFile] });

}

public async runCurrentTestFile(cmdSource: CommandSource) {

if (!this.documentManager.activeTextEditor) {

return;

}

const testManager = await this.getTestManager(true, this.documentManager.activeTextEditor.document.uri);

if (!testManager) {

return;

}

try {

await testManager.discoverTests(cmdSource, true, true, true);

} catch (ex) {

return;

}

const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);

const tests = testCollectionStorage.getTests(testManager.workspaceFolder)!;

const testFiles = tests.testFiles.filter(testFile => {

return testFile.fullPath === this.documentManager.activeTextEditor!.document.uri.fsPath;

});

if (testFiles.length < 1) {

return;

}

await this.runTestsImpl(cmdSource, testManager.workspaceFolder, { testFile: [testFiles[0]] });

}

public async runTestsImpl(cmdSource: CommandSource, resource?: Uri, testsToRun?: TestsToRun, runFailedTests?: boolean, debug: boolean = false) {

const testManager = await this.getTestManager(true, resource);

if (!testManager) {

return;

}

if (!this.testResultDisplay) {

this.testResultDisplay = this.serviceContainer.get<ITestResultDisplay>(ITestResultDisplay);

}

const promise = testManager.runTest(cmdSource, testsToRun, runFailedTests, debug).catch(reason => {

if (reason !== CANCELLATION_REASON) {

this.outputChannel.appendLine(`Error: ${reason}`);

}

return Promise.reject(reason);

});

this.testResultDisplay.displayProgressStatus(promise, debug);

await promise;

}

public async registerSymbolProvider(symbolProvider: DocumentSymbolProvider): Promise<void> {

const testCollectionStorage = this.serviceContainer.get<ITestCollectionStorageService>(ITestCollectionStorageService);

const event = new EventEmitter<void>();

this.disposableRegistry.push(event);

const handler = this._onDidStatusChange.event(e => {

if (e.status !== TestStatus.Discovering && e.status !== TestStatus.Running) {

event.fire();

}

});

this.disposableRegistry.push(handler);

this.disposableRegistry.push(activateCodeLenses(event, symbolProvider, testCollectionStorage));

}

@captureTelemetry(EventName.UNITTEST_CONFIGURE, undefined, false)

public async configureTests(resource?: Uri) {

let wkspace: Uri | undefined;

if (resource) {

const wkspaceFolder = this.workspaceService.getWorkspaceFolder(resource);

wkspace = wkspaceFolder ? wkspaceFolder.uri : undefined;

} else {

const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);

wkspace = await selectTestWorkspace(appShell);

}

if (!wkspace) {

return;

}

const configurationService = this.serviceContainer.get<ITestConfigurationService>(ITestConfigurationService);

await configurationService.promptToEnableAndConfigureTestFramework(wkspace!);

}

public registerCommands(): void {

const disposablesRegistry = this.serviceContainer.get<Disposable[]>(IDisposableRegistry);

const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);

const disposables = [

commandManager.registerCommand(

constants.Commands.Tests_Discover,

(treeNode?: TestWorkspaceFolder, cmdSource: CommandSource = CommandSource.commandPalette, resource?: Uri) => {

if (treeNode && treeNode instanceof TestWorkspaceFolder) {

resource = treeNode.resource;

cmdSource = CommandSource.testExplorer;

}

// Ignore the exceptions returned.

// This command will be invoked from other places of the extension.

return this.discoverTests(cmdSource, resource, true, true, false, true).ignoreErrors();

}

),

commandManager.registerCommand(constants.Commands.Tests_Configure, (_, _cmdSource: CommandSource = CommandSource.commandPalette, resource?: Uri) => {

// Ignore the exceptions returned.

// This command will be invoked from other places of the extension.

this.configureTests(resource).ignoreErrors();

}),

commandManager.registerCommand(constants.Commands.Tests_Run_Failed, (_, cmdSource: CommandSource = CommandSource.commandPalette, resource: Uri) =>

this.runTestsImpl(cmdSource, resource, undefined, true)

),

commandManager.registerCommand(

constants.Commands.Tests_Run,

(treeNode?: TestWorkspaceFolder, cmdSource: CommandSource = CommandSource.commandPalette, resource?: Uri, testToRun?: TestsToRun) => {

if (treeNode && treeNode instanceof TestWorkspaceFolder) {

resource = treeNode.resource;

cmdSource = CommandSource.testExplorer;

}

return this.runTestsImpl(cmdSource, resource, testToRun);

}

),

commandManager.registerCommand(

constants.Commands.Tests_Debug,

(treeNode?: TestWorkspaceFolder, cmdSource: CommandSource = CommandSource.commandPalette, resource?: Uri, testToRun?: TestsToRun) => {

if (treeNode && treeNode instanceof TestWorkspaceFolder) {

resource = treeNode.resource;

cmdSource = CommandSource.testExplorer;

}

return this.runTestsImpl(cmdSource, resource, testToRun, false, true);

}

),

commandManager.registerCommand(constants.Commands.Tests_View_UI, () => this.displayUI(CommandSource.commandPalette)),

commandManager.registerCommand(

constants.Commands.Tests_Picker_UI,

(_, cmdSource: CommandSource = CommandSource.commandPalette, file: Uri, testFunctions: TestFunction[]) => this.displayPickerUI(cmdSource, file, testFunctions)

),

commandManager.registerCommand(

constants.Commands.Tests_Picker_UI_Debug,

(_, cmdSource: CommandSource = CommandSource.commandPalette, file: Uri, testFunctions: TestFunction[]) => this.displayPickerUI(cmdSource, file, testFunctions, true)

),

commandManager.registerCommand(constants.Commands.Tests_Stop, (_, resource: Uri) => this.stopTests(resource)),

commandManager.registerCommand(constants.Commands.Tests_ViewOutput, (_, cmdSource: CommandSource = CommandSource.commandPalette) => this.viewOutput(cmdSource)),

commandManager.registerCommand(constants.Commands.Tests_Ask_To_Stop_Discovery, () => this.displayStopUI('Stop discovering tests')),

commandManager.registerCommand(constants.Commands.Tests_Ask_To_Stop_Test, () => this.displayStopUI('Stop running tests')),

commandManager.registerCommand(constants.Commands.Tests_Select_And_Run_Method, (_, cmdSource: CommandSource = CommandSource.commandPalette, resource: Uri) =>

this.selectAndRunTestMethod(cmdSource, resource)

),

commandManager.registerCommand(constants.Commands.Tests_Select_And_Debug_Method, (_, cmdSource: CommandSource = CommandSource.commandPalette, resource: Uri) =>

this.selectAndRunTestMethod(cmdSource, resource, true)

),

commandManager.registerCommand(constants.Commands.Tests_Select_And_Run_File, (_, cmdSource: CommandSource = CommandSource.commandPalette) =>

this.selectAndRunTestFile(cmdSource)

),

commandManager.registerCommand(constants.Commands.Tests_Run_Current_File, (_, cmdSource: CommandSource = CommandSource.commandPalette) =>

this.runCurrentTestFile(cmdSource)

),

commandManager.registerCommand(constants.Commands.Tests_Discovering, noop)

];

disposablesRegistry.push(...disposables);

}

public onDocumentSaved(doc: TextDocument) {

const settings = this.serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings(doc.uri);

if (!settings.testing.autoTestDiscoverOnSaveEnabled) {

return;

}

this.discoverTestsForDocument(doc).ignoreErrors();

}

public registerHandlers() {

const documentManager = this.serviceContainer.get<IDocumentManager>(IDocumentManager);

this.disposableRegistry.push(documentManager.onDidSaveTextDocument(this.onDocumentSaved.bind(this)));

this.disposableRegistry.push(

this.workspaceService.onDidChangeConfiguration(e => {

if (this.configChangedTimer) {

clearTimeout(this.configChangedTimer as any);

}

this.configChangedTimer = setTimeout(() => this.configurationChangeHandler(e), 1000);

})

);

}

}