Display test results in CodeLens

package.json

@@ -131,6 +131,7 @@
  "vscode": "^1.0.0"
  },
  "dependencies": {
- "applicationinsights": "^0.21.0"
+ "applicationinsights": "^0.21.0",
+ "xmldom": "^0.1.27"
  }
 }

src/dotnetTestExplorer.ts

@@ -4,6 +4,7 @@ import { TreeDataProvider, TreeItem, TreeItemCollapsibleState } from "vscode";
 import { AppInsightsClient } from "./appInsightsClient";
 import { Executor } from "./executor";
 import { TestNode } from "./testNode";
+import { TestResultsFile } from "./testResultsFile";
 import { Utility } from "./utility";
 
 export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
@@ -16,7 +17,7 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  */
  private testDirectoryPath: string;
 
- constructor(private context: vscode.ExtensionContext) {}
+ constructor(private context: vscode.ExtensionContext, private resultsFile: TestResultsFile) { }
 
  /**
  * @description
@@ -41,7 +42,7 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  */
  public runAllTests(): void {
  this.evaluateTestDirectory();
- Executor.runInTerminal(`dotnet test${this.checkBuildOption()}${this.checkRestoreOption()}`, this.testDirectoryPath);
+ Executor.runInTerminal(`dotnet test${this.getDotNetTestOptions()}${this.outputTestResults()}`, this.testDirectoryPath);
  AppInsightsClient.sendEvent("runAllTests");
  }
 
@@ -53,7 +54,7 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  * to do a restore, so it can be very slow.
  */
  public runTest(test: TestNode): void {
- Executor.runInTerminal(`dotnet test${this.checkBuildOption()}${this.checkRestoreOption()} --filter FullyQualifiedName~${test.fullName}`, this.testDirectoryPath);
+ Executor.runInTerminal(`dotnet test${this.getDotNetTestOptions()}${this.outputTestResults()} --filter FullyQualifiedName~${test.fullName}`, this.testDirectoryPath);
  AppInsightsClient.sendEvent("runTest");
  }
 
@@ -175,6 +176,22 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  return option ? "" : " --no-restore";
  }
 
+ /**
+ * @description
+ * Gets the options for build/restore before running tests.
+ */
+ private getDotNetTestOptions(): string {
+ return this.checkBuildOption() + this.checkRestoreOption();
+ }
+
+ /**
+ * @description
+ * Gets the dotnet test argument to speicfy the output for the test results.
+ */
+ private outputTestResults(): string {
+ return " --logger 'trx;LogFileName=" + this.resultsFile.fileName + "'";
+ }
+
  /**
  * @description
  * Checks to see if the options specify a directory to run the
@@ -198,7 +215,7 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  return new Promise((c, e) => {
  try {
  const results = Executor
- .execSync(`dotnet test -t -v=q${this.checkBuildOption()}${this.checkRestoreOption()}`, this.testDirectoryPath)
+ .execSync(`dotnet test -t -v=q${this.getDotNetTestOptions()}`, this.testDirectoryPath)
  .split(/[\r\n]+/g)
  /*
  * The dotnet-cli prefixes all discovered unit tests
@@ -207,7 +224,7 @@ export class DotnetTestExplorer implements TreeDataProvider<TestNode> {
  * structures.
  **/
  .filter((item) => item && item.startsWith(" "))
- .sort((a, b) => a > b ? 1 : b > a ? - 1 : 0 )
+ .sort((a, b) => a > b ? 1 : b > a ? - 1 : 0)
  .map((item) => item.trim());
 
  c(results);

src/extension.ts

@@ -5,12 +5,24 @@ import { AppInsightsClient } from "./appInsightsClient";
 import { DotnetTestExplorer } from "./dotnetTestExplorer";
 import { Executor } from "./executor";
 import { TestNode } from "./testNode";
+import { TestResultsFile } from "./testResultsFile";
+import { TestStatusCodeLensProvider } from "./testStatusCodeLensProvider";
+import { Utility } from "./utility";
 
 export function activate(context: vscode.ExtensionContext) {
- const dotnetTestExplorer = new DotnetTestExplorer(context);
+ const testResults = new TestResultsFile();
+ context.subscriptions.push(testResults);
+
+ const dotnetTestExplorer = new DotnetTestExplorer(context, testResults);
  vscode.window.registerTreeDataProvider("dotnetTestExplorer", dotnetTestExplorer);
  AppInsightsClient.sendEvent("loadExtension");
 
+ const codeLensProvider = new TestStatusCodeLensProvider(testResults);
+ context.subscriptions.push(codeLensProvider);
+ context.subscriptions.push(vscode.languages.registerCodeLensProvider(
+ { language: "csharp", scheme: "file" },
+ codeLensProvider));
+
  context.subscriptions.push(vscode.commands.registerCommand("dotnet-test-explorer.refreshTestExplorer", () => {
  dotnetTestExplorer.refreshTestExplorer();
  }));

src/testResult.ts

@@ -0,0 +1,12 @@
+export class TestResult {
+ public constructor(private _name: string, private _outcome: string) {
+ }
+
+ public get testName(): string {
+ return this._name;
+ }
+
+ public get outcome(): string {
+ return this._outcome;
+ }
+}

src/testResultsFile.ts

@@ -0,0 +1,74 @@
+"use strict";
+import * as fs from "fs";
+import * as path from "path";
+import { setTimeout } from "timers";
+import { Disposable, Event, EventEmitter } from "vscode";
+import { DOMParser } from "xmldom";
+import { TestResult } from "./testResult";
+
+function getAttributeValue(node, name: string): string {
+ const attribute = node.attributes.getNamedItem(name);
+ return (attribute === null) ? null : attribute.nodeValue;
+}
+
+export class TestResultsFile implements Disposable {
+ private static readonly ResultsFileName = "TestExplorerResults.trx";
+ private onNewResultsEmitter = new EventEmitter<TestResult[]>();
+ private resultsFile: string;
+ private watcher: fs.FSWatcher;
+
+ public constructor() {
+ const tempFolder = process.platform === "win32" ? process.env.TEMP : "/tmp";
+ this.resultsFile = path.join(tempFolder, TestResultsFile.ResultsFileName);
+
+ // The change event gets called multiple times, so use a one-second
+ // delay before we read anything to avoid doing too much work
+ const me = this;
+ let changeDelay: NodeJS.Timer;
+ this.watcher = fs.watch(tempFolder, (eventType, fileName) => {
+ if ((fileName === TestResultsFile.ResultsFileName) && (eventType === "change")) {
+ clearTimeout(changeDelay);
+ changeDelay = setTimeout(() => {
+ me.parseResults();
+ }, 1000);
+ }
+ });
+ }
+
+ public dispose(): void {
+ try {
+ this.watcher.close();
+ fs.unlinkSync(this.resultsFile);
+ } catch (error) {
+ }
+ }
+
+ public get fileName(): string {
+ return this.resultsFile;
+ }
+
+ public get onNewResults(): Event<TestResult[]> {
+ return this.onNewResultsEmitter.event;
+ }
+
+ private parseResults(): void {
+ const emitter = this.onNewResultsEmitter;
+ fs.readFile(this.resultsFile, (err, data) => {
+ if (!err) {
+ const results: TestResult[] = [];
+ const xdoc = new DOMParser().parseFromString(data.toString(), "application/xml");
+ const nodes = xdoc.documentElement.getElementsByTagName("UnitTestResult");
+
+ // TSLint wants to use for-of here, but nodes doesn't support it
+ for (let i = 0; i < nodes.length; i++) { // tslint:disable-line
+ results.push(new TestResult(
+ getAttributeValue(nodes[i], "testName"),
+ getAttributeValue(nodes[i], "outcome"),
+ ));
+ }
+
+ emitter.fire(results);
+ }
+ });
+ }
+}

src/testStatusCodeLens.ts

@@ -0,0 +1,25 @@
+"use strict";
+import { CodeLens, Range } from "vscode";
+
+export class TestStatusCodeLens extends CodeLens {
+ public static parseOutcome(outcome: string): string {
+ if (outcome === "Passed") {
+ return "✔️";
+ } else if (outcome === "Failed") {
+ return "❌";
+ } else if (outcome === "NotExecuted") {
+ return "️️⚠️";
+ } else {
+ return null;
+ }
+ }
+
+ public constructor(range: Range, status: string) {
+ super(range);
+
+ this.command = {
+ title: status,
+ command: null,
+ };
+ }
+}

src/testStatusCodeLensProvider.ts

@@ -0,0 +1,78 @@
+"use strict";
+import { CancellationToken, CodeLens, CodeLensProvider, commands, Disposable, Event, EventEmitter, Range, SymbolInformation, SymbolKind, TextDocument, workspace } from "vscode";
+import { TestResult } from "./testResult";
+import { TestResultsFile } from "./testResultsFile";
+import { TestStatusCodeLens } from "./testStatusCodeLens";
+
+export class TestStatusCodeLensProvider implements CodeLensProvider {
+ private disposables: Disposable[] = [];
+ private enabled: boolean;
+ private onDidChangeCodeLensesEmitter = new EventEmitter<void>();
+
+ // Store everything in a map so we can remember old tests results for the
+ // scenario where a single test is ran. If the test no longer exists in
+ // code it will never be mapped to the symbol, so no harm (though there is
+ // a memory impact)
+ private testResults = new Map<string, TestResult>();
+
+ public constructor(testResultFile: TestResultsFile) {
+ this.checkEnabledOption();
+
+ this.disposables.push(
+ testResultFile.onNewResults(this.addTestResults, this));
+
+ this.disposables.push(
+ workspace.onDidChangeConfiguration(this.checkEnabledOption, this));
+ }
+
+ public dispose() {
+ while (this.disposables.length) {
+ this.disposables.pop().dispose();
+ }
+ }
+
+ public get onDidChangeCodeLenses(): Event<void> {
+ return this.onDidChangeCodeLensesEmitter.event;
+ }
+
+ public provideCodeLenses(document: TextDocument, token: CancellationToken): CodeLens[] | Thenable<CodeLens[]> {
+ if (!this.enabled) {
+ return [];
+ }
+
+ const results = this.testResults;
+ return commands.executeCommand<SymbolInformation[]>("vscode.executeDocumentSymbolProvider", document.uri)
+ .then((symbols) => {
+ const mapped: CodeLens[] = [];
+ for (const symbol of symbols.filter((x) => x.kind === SymbolKind.Method)) {
+ const fullName = symbol.containerName + "." + symbol.name;
+ for (const result of results.values()) {
+ if (result.testName.endsWith(fullName)) {
+ const state = TestStatusCodeLens.parseOutcome(result.outcome);
+ if (state) {
+ mapped.push(new TestStatusCodeLens(symbol.location.range, state));
+ }
+ }
+ }
+ }
+
+ return mapped;
+ });
+ }
+
+ public resolveCodeLens(codeLens: CodeLens, token: CancellationToken): CodeLens {
+ return codeLens;
+ }
+
+ private addTestResults(results: TestResult[]) {
+ for (const result of results) {
+ this.testResults.set(result.testName, result);
+ }
+
+ this.onDidChangeCodeLensesEmitter.fire();
+ }
+
+ private checkEnabledOption(): void {
+ this.enabled = workspace.getConfiguration("csharp").get<boolean>("testsCodeLens.enabled", true);
+ }
+}