Display test results in CodeLens

package.json

@@ -112,6 +112,11 @@
  "type": "boolean",
  "default": true,
  "description": "If true, dotnet restore will run when refreshing the test explorer."
+ },
+ "dotnet-test-explorer.showCodeLens": {
+ "type": "boolean",
+ "default": true,
+ "description": "Determines whether to show the CodeLens test status or not."
  }
  }
  }
@@ -131,6 +136,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,37 @@
+export class TestResult {
+ private className: string;
+ private method: string;
+
+ public constructor(private _testId: string, private _outcome: string) {
+ }
+
+ public get fullName(): string {
+ return this.className + "." + this.method;
+ }
+
+ public get id(): string {
+ return this._testId;
+ }
+
+ public get outcome(): string {
+ return this._outcome;
+ }
+
+ public matches(className: string, method: string): boolean {
+ // The passed in class name won't have the namespace, hence the
+ // check with endsWith
+ return (this.method === method) && this.className.endsWith(className);
+ }
+
+ public updateName(className: string, method: string): void {
+ this.className = className;
+
+ // xUnit includes the class name in the name of the unit test
+ // i.e. classname.method
+ if (method.startsWith(className)) {
+ this.method = method.substring(className.length + 1); // +1 to include the .
+ } else {
+ this.method = method;
+ }
+ }
+}

src/testResultsFile.ts

@@ -0,0 +1,124 @@
+"use strict";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { setTimeout } from "timers";
+import { Disposable, Event, EventEmitter } from "vscode";
+import { DOMParser, Element, Node } from "xmldom";
+import { TestResult } from "./testResult";
+
+function findChildElement(node: Node, name: string): Node {
+ let child = node.firstChild;
+ while (child) {
+ if (child.nodeName === name) {
+ return child;
+ }
+
+ child = child.nextSibling;
+ }
+
+ return null;
+}
+
+function getAttributeValue(node: Node, name: string): string {
+ const attribute = node.attributes.getNamedItem(name);
+ return (attribute === null) ? null : attribute.nodeValue;
+}
+
+function parseUnitTestResults(xml: Element): TestResult[] {
+ const results: TestResult[] = [];
+ const nodes = xml.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], "testId"),
+ getAttributeValue(nodes[i], "outcome"),
+ ));
+ }
+
+ return results;
+}
+
+function updateUnitTestDefinitions(xml: Element, results: TestResult[]): void {
+ const nodes = xml.getElementsByTagName("UnitTest");
+ const names = new Map<string, any>();
+
+ for (let i = 0; i < nodes.length; i++) { // tslint:disable-line
+ const id = getAttributeValue(nodes[i], "id");
+ const testMethod = findChildElement(nodes[i], "TestMethod");
+ if (testMethod) {
+ names.set(id, {
+ className: getAttributeValue(testMethod, "className"),
+ method: getAttributeValue(testMethod, "name"),
+ });
+ }
+ }
+
+ for (const result of results) {
+ const name = names.get(result.id);
+ if (name) {
+ result.updateName(name.className, name.method);
+ }
+ }
+}
+
+export class TestResultsFile implements Disposable {
+ private static readonly ResultsFileName = "Results.trx";
+ private onNewResultsEmitter = new EventEmitter<TestResult[]>();
+ private resultsFile: string;
+ private watcher: fs.FSWatcher;
+
+ public constructor() {
+ const tempFolder = fs.mkdtempSync(path.join(os.tmpdir(), "test-explorer-"));
+ 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();
+
+ // When we ask for a random directory it creates one for us,
+ // however, we can't delete it if there's a file inside of it
+ if (fs.existsSync(this.resultsFile)) {
+ fs.unlinkSync(this.resultsFile);
+ }
+
+ fs.rmdir(path.dirname(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 xdoc = new DOMParser().parseFromString(data.toString(), "application/xml");
+ const results = parseUnitTestResults(xdoc.documentElement);
+ updateUnitTestDefinitions(xdoc.documentElement, results);
+ 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";
+import { Utility } from "./utility";
+
+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)) {
+ for (const result of results.values()) {
+ if (result.matches(symbol.containerName, symbol.name)) {
+ 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.fullName, result);
+ }
+
+ this.onDidChangeCodeLensesEmitter.fire();
+ }
+
+ private checkEnabledOption(): void {
+ this.enabled = Utility.getConfiguration().get<boolean>("showCodeLens", true);
+ }
+}