Enable support for Integration Tests (#1441)

* Enable support for Integration Tests

Added Logger to help tests retrieve output from the installation of the
extension.

Author: WardenGnaw

.travis.yml

@@ -3,23 +3,41 @@ language: node_js
 node_js:
 - "8"
 
+before_install:
+  # Do not modify. Required for GUI based tests: See https://docs.travis-ci.com/user/gui-and-headless-browsers/#Using-xvfb-to-Run-Tests-That-Require-a-GUI
+  - if [ $TRAVIS_OS_NAME == "linux" ]; then
+      export CXX="g++-4.9" CC="gcc-4.9" DISPLAY=:99.0;
+      sh -e /etc/init.d/xvfb start;
+      sleep 3;
+    fi
+
 addons:
   apt:
     sources:
       - ubuntu-toolchain-r-test
       - sourceline: 'deb https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main'
         key_url: 'https://packages.microsoft.com/keys/microsoft.asc'
+    packages:
+      - gdb
+      - g++-4.9
+
 
 script:
+  # Download debugAdapters from an existing extension version. See TravisCI settings to set CPPTOOL_VERSION
+  - mkdir -p ~/.vscode/extensions/ms-vscode.cpptools-$CPPTOOL_VERSION
+  - wget https://github.com/Microsoft/vscode-cpptools/releases/download/$CPPTOOL_VERSION/cpptools.vsix -O ~/cpptools.vsix
+  - unzip ~/cpptools.vsix "extension/debugAdapters/*" -d ~/.
+  - mv ~/extension/debugAdapters ~/.vscode/extensions/ms-vscode.cpptools-$CPPTOOL_VERSION/debugAdapters
+  # Build and then run tests
   - cd Extension
   - npm install
   - npm run tslint
-  - npm run pretest
+  - npm run compile
   - npm run test
 
 after_failure:
-  - ./.travis/printLogs.sh
+  - find ~ -name "integrationTests.log" -type f -exec cat {} \;
 
 after_success:
-  - ./.travis/printLogs.sh
+  - find ~ -name "integrationTests.log" -type f -exec cat {} \;
 

Extension/.gitignore

@@ -14,4 +14,7 @@ bin/Microsoft.VSCode.CPP.*
 install.lock
 
 # ignore generated packages
-*.vsix
+*.vsix
+
+# ignore vscode test
+.vscode-test/

Extension/.vscode/launch.json

@@ -29,6 +29,22 @@
 			"type": "node",
 			"request": "attach",
 			"port": 5858
-		}
+		},
+		{
+            "name": "Launch Integration Tests",
+            "type": "extensionHost",
+            "request": "launch",
+            "runtimeExecutable": "${execPath}",
+            "args": [
+                "${workspaceRoot}/test/integrationTests/testAssets/SimpleCppProject",
+                "--extensionDevelopmentPath=${workspaceRoot}",
+                "--extensionTestsPath=${workspaceRoot}/out/test/integrationTests"
+            ],
+            "stopOnEntry": false,
+            "sourceMaps": true,
+            "outFiles": [
+                "${workspaceRoot}/out/test/**/*.js"
+            ]
+        },
 	]
 }

Extension/gulpfile.js

@@ -6,15 +6,45 @@
 'use strict';
 
 const gulp = require('gulp');
+const env = require('gulp-env')
 const tslint = require('gulp-tslint');
 const mocha = require('gulp-mocha');
 
-gulp.task('unitTest', () => {
+gulp.task('allTests', () => {
+    gulp.start('unitTests');
+    gulp.start('integrationTests');
+});
+
+gulp.task('unitTests', () => {
     gulp.src('./out/test/unitTests', {read: false}).pipe(
         mocha({
             ui: "tdd"
         })
+    ).once('error', err => {
+        process.exit(1);
+    })
+    .once('end', () => {
+        process.exit();
+    })
+});
+
+gulp.task('integrationTests', () => {
+    env.set({
+            CODE_TESTS_PATH: "./out/test/integrationTests",
+            CODE_TESTS_WORKSPACE: "./test/integrationTests/testAssets/SimpleCppProject"
+        }
     );
+    gulp.src('./test/runVsCodeTestsWithAbsolutePaths.js', {read: false}).pipe(
+        mocha({
+            ui: "tdd",
+            delay: true
+        })
+    ).once('error', err => {
+        process.exit(1);
+    })
+    .once('end', () => {
+        process.exit();
+    })
 });
 
 /// Misc Tasks

Extension/package-lock.json

@@ -1041,16 +1041,19 @@
   },
   "scripts": {
     "compile": "npm run vscode:prepublish && tsc -p ./",
+    "integrationTests": "gulp integrationTests",
     "postinstall": "node ./node_modules/vscode/bin/install",
     "pretest": "tsc -p ./",
-    "test": "gulp unitTest",
+    "test": "gulp allTests",
     "tslint": "gulp tslint",
+    "unitTests": "gulp unitTests",
     "vscode:prepublish": "npm install && tsc -p ./ && node ./out/src/Debugger/copyScript.js",
     "watch": "tsc -watch -p ./"
   },
   "devDependencies": {
     "@types/mocha": "^2.2.43",
     "@types/node": "^8.0.46",
+    "gulp-env": "0.4.0",
     "gulp-mocha": "5.0.0",
     "gulp-tslint": "8.1.2",
     "gulp": "3.9.1",

Extension/package.json

@@ -20,6 +20,7 @@ import { ClientCollection } from './clientCollection';
 import { createProtocolFilter } from './protocolFilter';
 import { DataBinding } from './dataBinding';
 import minimatch = require("minimatch");
+import * as logger from '../logger';
 
 let ui: UI;
 
@@ -491,7 +492,7 @@ class DefaultClient implements Client {
                 if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 1) {
                     this.outputChannel = vscode.window.createOutputChannel(`C/C++: ${this.Name}`);
                 } else {
-                    this.outputChannel = util.getOutputChannel();
+                    this.outputChannel = logger.getOutputChannel();
                 }
                 this.disposables.push(this.outputChannel);
             }

Extension/src/LanguageServer/client.ts

@@ -12,6 +12,7 @@ import * as Telemetry from './telemetry';
 import HttpsProxyAgent = require('https-proxy-agent');
 import * as url from 'url';
 import { PlatformInformation } from './platform';
+import { getOutputChannelLogger, showOutputChannel } from './logger';
 
 export let extensionContext: vscode.ExtensionContext;
 export function setExtensionContext(context: vscode.ExtensionContext): void {
@@ -45,9 +46,9 @@ export function displayExtensionNotReadyPrompt(): void {
 
     if (!isExtensionNotReadyPromptDisplayed) {
         isExtensionNotReadyPromptDisplayed = true; 
-        outputChannel.show();
+        showOutputChannel();
 
-        vscode.window.showInformationMessage(extensionNotReadyString).then(
+        getOutputChannelLogger().showInformationMessage(extensionNotReadyString).then(
             () => { isExtensionNotReadyPromptDisplayed = false; },
             () => { isExtensionNotReadyPromptDisplayed = false; }
         );
@@ -347,15 +348,6 @@ export function spawnChildProcess(process: string, args: string[], workingDirect
     });
 }
 
-let outputChannel: vscode.OutputChannel;
-
-export function getOutputChannel(): vscode.OutputChannel {
-    if (outputChannel == undefined) {
-        outputChannel = vscode.window.createOutputChannel("C/C++");
-    }
-    return outputChannel;
-}
-
 export function allowExecution(file: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         if (process.platform != 'win32') {
@@ -369,8 +361,8 @@ export function allowExecution(file: string): Promise<void> {
                         resolve();
                     });
                 } else {
-                    getOutputChannel().appendLine("");
-                    getOutputChannel().appendLine(`Warning: Expected file ${file} is missing.`);
+                    getOutputChannelLogger().appendLine("");
+                    getOutputChannelLogger().appendLine(`Warning: Expected file ${file} is missing.`);
                     resolve();
                 }
             });
@@ -397,6 +389,6 @@ export function checkDistro(platformInfo: PlatformInformation): void {
     if (platformInfo.platform != 'win32' && platformInfo.platform != 'linux' && platformInfo.platform != 'darwin') {
         // this should never happen because VSCode doesn't run on FreeBSD
         // or SunOS (the other platforms supported by node)
-        outputChannel.appendLine(`Warning: Debugging has not been tested for this platform. ${getReadmeMessage()}`);
+        getOutputChannelLogger().appendLine(`Warning: Debugging has not been tested for this platform. ${getReadmeMessage()}`);
     }
 }

Extension/src/common.ts

@@ -0,0 +1,76 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+
+import * as vscode from 'vscode';
+import * as os from 'os';
+
+// This is used for testing purposes
+let Subscriber: (message: string) => void;
+export function subscribeToAllLoggers(subscriber: (message: string) => void): void {
+    Subscriber = subscriber;
+}
+
+export class Logger {
+    private writer: (message: string) => void;
+
+    constructor(writer: (message: string) => void) {
+        this.writer = writer;
+    }
+
+    public append(message: string): void {
+        this.writer(message);
+        if (Subscriber) {
+            Subscriber(message);
+        }
+    }
+
+    public appendLine(message: string): void {
+        this.writer(message + os.EOL);
+        if (Subscriber) {
+            Subscriber(message + os.EOL);
+        }
+    }
+
+    public showInformationMessage(message: string, items?: string[]): Thenable<string> {
+        this.appendLine(message);
+        
+        return vscode.window.showInformationMessage(message, ...items);
+    }
+
+    public showWarningMessage(message: string, items?: string[]): Thenable<string> {
+        this.appendLine(message);
+        
+        return vscode.window.showWarningMessage(message, ...items);
+    }
+
+    public showErrorMessage(message: string, items?: string[]): Thenable<string> {
+        this.appendLine(message);
+
+        return vscode.window.showErrorMessage(message, ...items);
+    }
+}
+
+let outputChannel: vscode.OutputChannel;
+
+export function getOutputChannel(): vscode.OutputChannel {
+    if (outputChannel == undefined) {
+        outputChannel = vscode.window.createOutputChannel("C/C++");
+    }
+    return outputChannel;
+}
+
+export function showOutputChannel(): void {
+    getOutputChannel().show();
+}
+
+let outputChannelLogger: Logger;
+
+export function getOutputChannelLogger(): Logger {
+    if (!outputChannelLogger) {
+        outputChannelLogger = new Logger(message => getOutputChannel().append(message));
+    }
+    return outputChannelLogger;
+}