Add telemetry reporting the number of times tests are run or debugged

.gitignore

@@ -1,6 +1,7 @@
 bin
 node_modules
 out
+.omnisharp/
 .omnisharp-*/
 .debugger
 .vscode-test

src/features/abstractProvider.ts

@@ -5,19 +5,26 @@
 
 'use strict';
 
-import {OmniSharpServer} from '../omnisharp/server';
-import {Disposable} from 'vscode';
+import { OmniSharpServer } from '../omnisharp/server';
+import { Disposable } from 'vscode';
+import TelemetryReporter from 'vscode-extension-telemetry';
 
-export default class AbstractProvider {
+export default abstract class AbstractProvider {
 
     protected _server: OmniSharpServer;
-    protected _disposables: Disposable[];
+    protected _reporter: TelemetryReporter;
+    private _disposables: Disposable[];
 
-    constructor(server: OmniSharpServer) {
+    constructor(server: OmniSharpServer, reporter: TelemetryReporter) {
         this._server = server;
+        this._reporter = reporter;
         this._disposables = [];
     }
 
+    protected addDisposables(...disposables: Disposable[]) {
+        this._disposables.push(...disposables);
+    }
+
     dispose() {
         while (this._disposables.length) {
             this._disposables.pop().dispose();

src/features/codeActionProvider.ts

@@ -11,21 +11,23 @@ import AbstractProvider from './abstractProvider';
 import * as protocol from '../omnisharp/protocol';
 import { toRange2 } from '../omnisharp/typeConvertion';
 import * as serverUtils from '../omnisharp/utils';
+import TelemetryReporter from 'vscode-extension-telemetry';
 
 export default class CodeActionProvider extends AbstractProvider implements vscode.CodeActionProvider {
 
     private _disabled: boolean;
     private _commandId: string;
 
-    constructor(server: OmniSharpServer) {
-        super(server);
+    constructor(server: OmniSharpServer, reporter: TelemetryReporter) {
+        super(server, reporter);
+
         this._commandId = 'omnisharp.runCodeAction';
 
         this._checkOption();
 
         let d1 = vscode.workspace.onDidChangeConfiguration(this._checkOption, this);
         let d2 = vscode.commands.registerCommand(this._commandId, this._runCodeAction, this);
-        this._disposables.push(d1, d2);
+        this.addDisposables(d1, d2);
     }
 
     private _checkOption(): void {

src/features/codeLensProvider.ts

@@ -5,24 +5,35 @@
 
 'use strict';
 
-import {CancellationToken, CodeLens, Range, Uri, TextDocument, CodeLensProvider} from 'vscode';
-import {toRange, toLocation} from '../omnisharp/typeConvertion';
-import AbstractSupport from './abstractProvider';
-import {updateCodeLensForTest} from './dotnetTest';
+import { OmniSharpServer } from '../omnisharp/server';
+import TelemetryReporter from 'vscode-extension-telemetry';
+import TestManager from './dotnetTest';
+import * as vscode from 'vscode';
+import { toRange, toLocation } from '../omnisharp/typeConvertion';
+import AbstractProvider from './abstractProvider';
 import * as protocol from '../omnisharp/protocol';
 import * as serverUtils from '../omnisharp/utils';
 
-class OmniSharpCodeLens extends CodeLens {
+class OmniSharpCodeLens extends vscode.CodeLens {
 
     fileName: string;
 
-    constructor(fileName: string, range: Range) {
+    constructor(fileName: string, range: vscode.Range) {
         super(range);
         this.fileName = fileName;
     }
 }
 
-export default class OmniSharpCodeLensProvider extends AbstractSupport implements CodeLensProvider {
+export default class OmniSharpCodeLensProvider extends AbstractProvider implements vscode.CodeLensProvider {
+
+    private _testManager: TestManager;
+
+    constructor(server: OmniSharpServer, reporter: TelemetryReporter, testManager: TestManager)
+    {
+        super(server, reporter);
+
+        this._testManager = testManager;
+    }
 
     private static filteredSymbolNames: { [name: string]: boolean } = {
         'Equals': true,
@@ -31,15 +42,15 @@ export default class OmniSharpCodeLensProvider extends AbstractSupport implement
         'ToString': true
     };
 
-    provideCodeLenses(document: TextDocument, token: CancellationToken): CodeLens[] | Thenable<CodeLens[]> {
+    provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.CodeLens[] | Thenable<vscode.CodeLens[]> {
         return serverUtils.currentFileMembersAsTree(this._server, { FileName: document.fileName }, token).then(tree => {
-            let ret: CodeLens[] = [];
+            let ret: vscode.CodeLens[] = [];
             tree.TopLevelTypeDefinitions.forEach(node => this._convertQuickFix(ret, document.fileName, node));
             return ret;
         });
     }
 
-    private _convertQuickFix(bucket: CodeLens[], fileName: string, node: protocol.Node): void {
+    private _convertQuickFix(bucket: vscode.CodeLens[], fileName: string, node: protocol.Node): void {
 
         if (node.Kind === 'MethodDeclaration' && OmniSharpCodeLensProvider.filteredSymbolNames[node.Location.Text]) {
             return;
@@ -52,10 +63,10 @@ export default class OmniSharpCodeLensProvider extends AbstractSupport implement
             this._convertQuickFix(bucket, fileName, child);
         }
 
-        updateCodeLensForTest(bucket, fileName, node, this._server.isDebugEnable());
+        this._updateCodeLensForTest(bucket, fileName, node);
     }
 
-    resolveCodeLens(codeLens: CodeLens, token: CancellationToken): Thenable<CodeLens> {
+    resolveCodeLens(codeLens: vscode.CodeLens, token: vscode.CancellationToken): Thenable<vscode.CodeLens> {
         if (codeLens instanceof OmniSharpCodeLens) {
 
             let req = <protocol.FindUsagesRequest>{
@@ -75,11 +86,40 @@ export default class OmniSharpCodeLensProvider extends AbstractSupport implement
                 codeLens.command = {
                     title: len === 1 ? '1 reference' : `${len} references`,
                     command: 'editor.action.showReferences',
-                    arguments: [Uri.file(req.FileName), codeLens.range.start, res.QuickFixes.map(toLocation)]
+                    arguments: [vscode.Uri.file(req.FileName), codeLens.range.start, res.QuickFixes.map(toLocation)]
                 };
 
                 return codeLens;
             });
         }
     }
+
+    private _updateCodeLensForTest(bucket: vscode.CodeLens[], fileName: string, node: protocol.Node) {
+        // backward compatible check: Features property doesn't present on older version OmniSharp
+        if (node.Features === undefined) {
+            return;
+        }
+
+        let testFeature = node.Features.find(value => (value.Name == 'XunitTestMethod' || value.Name == 'NUnitTestMethod' || value.Name == 'MSTestMethod'));
+        if (testFeature) {
+            // this test method has a test feature
+            let testFrameworkName = 'xunit';
+            if (testFeature.Name == 'NunitTestMethod') {
+                testFrameworkName = 'nunit';
+            }
+            else if (testFeature.Name == 'MSTestMethod') {
+                testFrameworkName = 'mstest';
+            }
+
+            bucket.push(new vscode.CodeLens(
+                toRange(node.Location),
+                { title: "run test", command: 'dotnet.test.run', arguments: [testFeature.Data, fileName, testFrameworkName] }));
+
+            if (this._server.isDebugEnable()) {
+                bucket.push(new vscode.CodeLens(
+                    toRange(node.Location),
+                    { title: "debug test", command: 'dotnet.test.debug', arguments: [testFeature.Data, fileName, testFrameworkName] }));
+            }
+        }
+    }
 }

src/features/commands.ts

@@ -5,21 +5,21 @@
 
 'use strict';
 
-import {OmniSharpServer} from '../omnisharp/server';
+import { OmniSharpServer } from '../omnisharp/server';
 import * as serverUtils from '../omnisharp/utils';
-import {findLaunchTargets} from '../omnisharp/launcher';
+import { findLaunchTargets } from '../omnisharp/launcher';
 import * as cp from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as protocol from '../omnisharp/protocol';
 import * as vscode from 'vscode';
-import * as dotnetTest from './dotnetTest';
-import {DotNetAttachItemsProviderFactory, AttachPicker, RemoteAttachPicker} from './processPicker';
-import {generateAssets} from '../assets';
+import { DotNetAttachItemsProviderFactory, AttachPicker, RemoteAttachPicker } from './processPicker';
+import { generateAssets } from '../assets';
+import TelemetryReporter from 'vscode-extension-telemetry';
 
 let channel = vscode.window.createOutputChannel('.NET');
 
-export default function registerCommands(server: OmniSharpServer, extensionPath: string) {
+export default function registerCommands(server: OmniSharpServer, reporter: TelemetryReporter) {
     let d1 = vscode.commands.registerCommand('o.restart', () => restartOmniSharp(server));
     let d2 = vscode.commands.registerCommand('o.pickProjectAndStart', () => pickProjectAndStart(server));
     let d3 = vscode.commands.registerCommand('o.showOutput', () => server.getChannel().show(vscode.ViewColumn.Three));
@@ -29,19 +29,15 @@ export default function registerCommands(server: OmniSharpServer, extensionPath:
     // running the command activates the extension, which is all we need for installation to kickoff
     let d5 = vscode.commands.registerCommand('csharp.downloadDebugger', () => { });
 
-    // register two commands for running and debugging xunit tests
-    let d6 = dotnetTest.registerDotNetTestRunCommand(server);
-    let d7 = dotnetTest.registerDotNetTestDebugCommand(server);
-
     // register process picker for attach
     let attachItemsProvider = DotNetAttachItemsProviderFactory.Get();
     let attacher = new AttachPicker(attachItemsProvider);
-    let d8 = vscode.commands.registerCommand('csharp.listProcess', () => attacher.ShowAttachEntries());
+    let d6 = vscode.commands.registerCommand('csharp.listProcess', () => attacher.ShowAttachEntries());
     // Register command for generating tasks.json and launch.json assets.
-    let d9 = vscode.commands.registerCommand('dotnet.generateAssets', () => generateAssets(server));
-    let d10 = vscode.commands.registerCommand('csharp.listRemoteProcess', (args) => RemoteAttachPicker.ShowAttachEntries(args));
+    let d7 = vscode.commands.registerCommand('dotnet.generateAssets', () => generateAssets(server));
+    let d8 = vscode.commands.registerCommand('csharp.listRemoteProcess', (args) => RemoteAttachPicker.ShowAttachEntries(args));
 
-    return vscode.Disposable.from(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10);
+    return vscode.Disposable.from(d1, d2, d3, d4, d5, d6, d7, d8);
 }
 
 function restartOmniSharp(server: OmniSharpServer) {

src/features/definitionProvider.ts

@@ -11,13 +11,14 @@ import * as serverUtils from '../omnisharp/utils';
 import {createRequest, toLocation} from '../omnisharp/typeConvertion';
 import {Uri, TextDocument, Position, Location, CancellationToken, DefinitionProvider} from 'vscode';
 import DefinitionMetadataDocumentProvider from './definitionMetadataDocumentProvider';
-
+import TelemetryReporter from 'vscode-extension-telemetry';
 
 export default class CSharpDefinitionProvider extends AbstractSupport implements DefinitionProvider {
     private _definitionMetadataDocumentProvider: DefinitionMetadataDocumentProvider;
 
-    constructor(server, definitionMetadataDocumentProvider: DefinitionMetadataDocumentProvider) {
-        super(server);
+    constructor(server,reporter: TelemetryReporter, definitionMetadataDocumentProvider: DefinitionMetadataDocumentProvider) {
+        super(server, reporter);
+
         this._definitionMetadataDocumentProvider = definitionMetadataDocumentProvider;
     }
 

src/features/diagnosticsProvider.ts

@@ -9,6 +9,7 @@ import * as protocol from '../omnisharp/protocol';
 import * as serverUtils from '../omnisharp/utils';
 import { toRange } from '../omnisharp/typeConvertion';
 import * as vscode from 'vscode';
+import TelemetryReporter from 'vscode-extension-telemetry';
 
 export class Advisor {
 
@@ -108,8 +109,8 @@ export class Advisor {
     }
 }
 
-export default function reportDiagnostics(server: OmniSharpServer, advisor: Advisor): vscode.Disposable {
-    return new DiagnosticsProvider(server, advisor);
+export default function reportDiagnostics(server: OmniSharpServer, reporter: TelemetryReporter, advisor: Advisor): vscode.Disposable {
+    return new DiagnosticsProvider(server, reporter, advisor);
 }
 
 class DiagnosticsProvider extends AbstractSupport {
@@ -120,8 +121,9 @@ class DiagnosticsProvider extends AbstractSupport {
     private _projectValidation: vscode.CancellationTokenSource;
     private _diagnostics: vscode.DiagnosticCollection;
 
-    constructor(server: OmniSharpServer, validationAdvisor: Advisor) {
-        super(server);
+    constructor(server: OmniSharpServer, reporter: TelemetryReporter, validationAdvisor: Advisor) {
+        super(server, reporter);
+
         this._validationAdvisor = validationAdvisor;
         this._diagnostics = vscode.languages.createDiagnosticCollection('csharp');