Merge pull request #1839 from TheRealPiotrP/dev/piotrp/launchConfigIntegrationTests

Add Debug Launch integration test

Author: Piotr Puszkiewicz

src/assets.ts

@@ -5,13 +5,14 @@
 
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import * as vscode from 'vscode';
+import * as protocol from './omnisharp/protocol';
+import * as serverUtils from './omnisharp/utils';
 import * as tasks from 'vscode-tasks';
+import * as util from './common';
+import * as vscode from 'vscode';
+
 import { OmniSharpServer } from './omnisharp/server';
-import * as serverUtils from './omnisharp/utils';
-import * as protocol from './omnisharp/protocol';
 import { tolerantParse } from './json';
-import * as util from './common';
 
 export class AssetGenerator {
     public rootPath: string;
@@ -546,24 +547,20 @@ function shouldGenerateAssets(generator: AssetGenerator) {
     });
 }
 
-export function generateAssets(server: OmniSharpServer) {
-    serverUtils.requestWorkspaceInformation(server).then(info => {
-        if (protocol.containsDotNetCoreProjects(info)) {
-            const generator = new AssetGenerator(info);
-            getOperations(generator).then(operations => {
-                if (hasAddOperations(operations)) {
-                    shouldGenerateAssets(generator).then(res => {
-                        if (res) {
-                            fs.ensureDir(generator.vscodeFolder, err => {
-                                addAssets(generator, operations);
-                            });
-                        }
-                    });
-                }
-            });
-        }
-        else {
-            vscode.window.showErrorMessage("Could not locate .NET Core project. Assets were not generated.");
+export async function generateAssets(server: OmniSharpServer) {
+    let workspaceInformation = await serverUtils.requestWorkspaceInformation(server);
+    if (protocol.containsDotNetCoreProjects(workspaceInformation)) {
+        const generator = new AssetGenerator(workspaceInformation);
+        let operations = await getOperations(generator);
+        if (hasAddOperations(operations)) {
+            let doGenerateAssets = await shouldGenerateAssets(generator);
+            if (doGenerateAssets) {
+                await fs.ensureDir(generator.vscodeFolder);
+                await addAssets(generator, operations);
+            }
         }
-    });
+    }
+    else {
+        await vscode.window.showErrorMessage("Could not locate .NET Core project. Assets were not generated.");
+    }
 }

src/coreclr-debug/activate.ts

@@ -4,40 +4,49 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as vscode from 'vscode';
+import * as debugInstall from './install';
 import * as os from 'os';
-import TelemetryReporter from 'vscode-extension-telemetry';
+import * as vscode from 'vscode';
+
 import { CoreClrDebugUtil, DotnetInfo, } from './util';
-import * as debugInstall from './install';
+
 import { Logger } from './../logger';
 import { PlatformInformation } from './../platform';
+import TelemetryReporter from 'vscode-extension-telemetry';
 
 let _debugUtil: CoreClrDebugUtil = null;
 let _reporter: TelemetryReporter = null;
 let _logger: Logger = null;
 
-export function activate(thisExtension : vscode.Extension<any>, context: vscode.ExtensionContext, reporter: TelemetryReporter, logger: Logger, channel: vscode.OutputChannel) {
+export async function activate(thisExtension : vscode.Extension<any>, context: vscode.ExtensionContext, reporter: TelemetryReporter, logger: Logger, channel: vscode.OutputChannel) {
     _debugUtil = new CoreClrDebugUtil(context.extensionPath, logger);
     _reporter = reporter;
     _logger = logger;
 
     if (!CoreClrDebugUtil.existsSync(_debugUtil.debugAdapterDir())) {
-        PlatformInformation.GetCurrent().then((info) => {
-            if (info.architecture !== "x86_64") {
-                if (info.isWindows() && info.architecture === "x86") {
+        let platformInformation: PlatformInformation;
+        
+        try {
+            platformInformation = await PlatformInformation.GetCurrent();
+        }
+        catch (err) {
+            // Somehow we couldn't figure out the platform we are on
+            logger.appendLine("[ERROR]: C# Extension failed to install the debugger package");
+            showInstallErrorMessage(channel);
+        }
+        
+        if (platformInformation) {
+            if (platformInformation.architecture !== "x86_64") {
+                if (platformInformation.isWindows() && platformInformation.architecture === "x86") {
                     logger.appendLine(`[WARNING]: x86 Windows is not currently supported by the .NET Core debugger. Debugging will not be available.`);
                 } else {
-                    logger.appendLine(`[WARNING]: Processor architecture '${info.architecture}' is not currently supported by the .NET Core debugger. Debugging will not be available.`);
+                    logger.appendLine(`[WARNING]: Processor architecture '${platformInformation.architecture}' is not currently supported by the .NET Core debugger. Debugging will not be available.`);
                 }
             } else {
                 logger.appendLine("[ERROR]: C# Extension failed to install the debugger package");
                 showInstallErrorMessage(channel);
             }
-        }, (err) => {
-            // Somehow we couldn't figure out the platform we are on
-            logger.appendLine("[ERROR]: C# Extension failed to install the debugger package");
-            showInstallErrorMessage(channel);
-        });
+        }
     } else if (!CoreClrDebugUtil.existsSync(_debugUtil.installCompleteFilePath())) {
         completeDebuggerInstall(logger, channel);
     }

src/main.ts

@@ -3,19 +3,19 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as vscode from 'vscode';
-import TelemetryReporter from 'vscode-extension-telemetry';
-
-import * as coreclrdebug from './coreclr-debug/activate';
 import * as OmniSharp from './omnisharp/extension';
+import * as coreclrdebug from './coreclr-debug/activate';
 import * as util from './common';
-import { Logger } from './logger';
+import * as vscode from 'vscode';
+
 import { CSharpExtDownloader } from './CSharpExtDownloader';
+import { Logger } from './logger';
+import TelemetryReporter from 'vscode-extension-telemetry';
 import { addJSONProviders } from './features/json/jsonContributions';
 
 let _channel: vscode.OutputChannel = null;
 
-export function activate(context: vscode.ExtensionContext): any {
+export async function activate(context: vscode.ExtensionContext): Promise<{ initializationFinished: Promise<void> }> {
 
     const extensionId = 'ms-vscode.csharp';
     const extension = vscode.extensions.getExtension(extensionId);
@@ -29,19 +29,24 @@ export function activate(context: vscode.ExtensionContext): any {
 
     let logger = new Logger(text => _channel.append(text));
 
-    ensureRuntimeDependencies(extension, logger, reporter)
-        .then((success : boolean) => {
-            // activate language services
-            OmniSharp.activate(context, reporter, _channel);
-
-            // register JSON completion & hover providers for project.json
-            context.subscriptions.push(addJSONProviders());
-            
-            if (success) {
-                // activate coreclr-debug
-                coreclrdebug.activate(extension, context, reporter, logger, _channel);
-            }
-        });
+    let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, logger, reporter);
+    
+    // activate language services
+    let omniSharpPromise = OmniSharp.activate(context, reporter, _channel);
+
+    // register JSON completion & hover providers for project.json
+    context.subscriptions.push(addJSONProviders());
+    
+    let coreClrDebugPromise = Promise.resolve();
+    if (runtimeDependenciesExist) {
+        // activate coreclr-debug
+        coreClrDebugPromise = coreclrdebug.activate(extension, context, reporter, logger, _channel);
+    }
+    
+    return {
+        initializationFinished: Promise.all([omniSharpPromise, coreClrDebugPromise])
+        .then(a => {})
+    };
 }
 
 function ensureRuntimeDependencies(extension: vscode.Extension<any>, logger: Logger, reporter: TelemetryReporter): Promise<boolean> {

src/omnisharp/extension.ts

@@ -157,4 +157,6 @@ export function activate(context: vscode.ExtensionContext, reporter: TelemetryRe
     disposables.push(vscode.debug.registerDebugConfigurationProvider('coreclr', new CSharpConfigurationProvider(server)));
 
     context.subscriptions.push(...disposables);
+    
+    return new Promise<string>(resolve => server.onServerStart(e => resolve(e)));
 }

test/integrationTests/index.ts

@@ -21,7 +21,7 @@ var testRunner = require('vscode/lib/testrunner');
 // See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
 
 testRunner.configure({
-    timeout: 10000,
+    timeout: 60000,
     ui: 'tdd',      // the TDD UI is being used in extension.test.ts (suite, test, etc.)
     useColors: true // colored output from test results
 });

test/integrationTests/launchConfiguration.integration.test.ts

@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------------------------- 
+ *  Copyright (c) Microsoft Corporation. All rights reserved. 
+ *  Licensed under the MIT License. See License.txt in the project root for license information. 
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'async-file';
+import * as vscode from 'vscode';
+
+import poll from './poll';
+import { should } from 'chai';
+import testAssetWorkspace from './testAssets/testAssetWorkspace';
+
+const chai = require('chai'); 
+chai.use(require('chai-arrays')); 
+chai.use(require('chai-fs')); 
+ 
+suite(`Tasks generation: ${testAssetWorkspace.description}`, function() {
+    suiteSetup(async function() { 
+        should();
+
+        let csharpExtension = vscode.extensions.getExtension("ms-vscode.csharp"); 
+        if (!csharpExtension.isActive) { 
+            await csharpExtension.activate(); 
+        }
+
+        testAssetWorkspace.deleteBuildArtifacts();
+
+        await fs.rimraf(testAssetWorkspace.vsCodeDirectoryPath);
+
+        await csharpExtension.exports.initializationFinished;
+        
+        await vscode.commands.executeCommand("dotnet.generateAssets");
+
+        await poll(async () => await fs.exists(testAssetWorkspace.launchJsonPath), 10000, 100);
+    }); 
+ 
+    test("Starting .NET Core Launch (console) from the workspace root should create an Active Debug Session", async () => { 
+        await vscode.debug.startDebugging(vscode.workspace.workspaceFolders[0], ".NET Core Launch (console)");
+
+        let debugSessionTerminated = new Promise(resolve => {
+            vscode.debug.onDidTerminateDebugSession((e) => resolve());
+        });
+        
+        vscode.debug.activeDebugSession.type.should.equal("coreclr");
+
+        await debugSessionTerminated;
+    });
+}); 

test/integrationTests/poll.ts

@@ -0,0 +1,24 @@
+/*--------------------------------------------------------------------------------------------- 
+ *  Copyright (c) Microsoft Corporation. All rights reserved. 
+ *  Licensed under the MIT License. See License.txt in the project root for license information. 
+ *--------------------------------------------------------------------------------------------*/ 
+ 
+export default async function poll<T>(getValue: () => T, duration: number, step: number): Promise<T> { 
+    while (duration > 0) { 
+        let value = await getValue();
+ 
+        if (value) { 
+            return value; 
+        } 
+ 
+        await sleep(step); 
+ 
+        duration -= step; 
+    } 
+ 
+    throw new Error("Polling did not succeed within the alotted duration."); 
+} 
+ 
+function sleep(ms = 0) {
+    return new Promise(r => setTimeout(r, ms)); 
+}

test/integrationTests/testAssets/testAssets.ts

@@ -45,6 +45,18 @@ export class TestAssetWorkspace {
     async deleteBuildArtifacts(): Promise<void> {
         this.projects.forEach(async p => await p.deleteBuildArtifacts());
     }
+    
+    get vsCodeDirectoryPath(): string {
+        return path.join(vscode.workspace.rootPath, ".vscode");;
+    }
+
+    get launchJsonPath(): string {
+        return path.join(this.vsCodeDirectoryPath, "launch.json");
+    }
+    
+    get tasksJsonPath(): string {
+        return path.join(this.vsCodeDirectoryPath, "tasks.json");
+    }
 
     description: string;