Initial Visual Studio Code unit tests

As promised in #1439 this is an initial attempt at unit testing the
VSCode extension. There are two separate parts to this: getting the test
framework working and unit testing the code in #1439.

The test framework nearly intact from the VSCode extension generator.
The main thing missing was `test/index.ts` which acts as an entry point
for Mocha. This was simply copied back in. I also needed to open the
test VSCode instance inside a workspace as our file URI generation
depends on a workspace being open.

There are two ways to run the test framework:

1. Opening the extension's source in VSCode, pressing F5 and selecting
   the "Extensions Test" debug target.

2. Closing all copies of VSCode and running `npm test`. This is started
   from the command line but actually opens a temporary VSCode window to
   host the tests.

This doesn't attempt to wire this up to CI. That requires running a
headless X11 server which is a bit daunting. I'll assess the difficulty
of that in a follow-up branch. This PR is at least helpful for local
development without having to induce errors on a Rust project.

For the actual tests this uses snapshots of `rustc` output from a real
Rust project captured from the command line. Except for extracting the
`message` object and reformatting they're copied verbatim into fixture
JSON files.

Only four different types of diagnostics are tested but they represent
the main combinations of code actions and related information possible.
They can be considered the happy path tests; as we encounter
corner-cases we can introduce new tests fixtures.

1 files changed, 161 insertions, 0 deletions

diff --git a/editors/code/src/test/rust_diagnostics.test.ts b/editors/code/src/test/rust_diagnostics.test.ts
new file mode 100644
index 000000000..5eb064b97
--- /dev/null
+++ b/editors/code/src/test/rust_diagnostics.test.ts
@@ -0,0 +1,161 @@
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as vscode from 'vscode';
+
+import {
+    MappedRustDiagnostic,
+    mapRustDiagnosticToVsCode,
+    RustDiagnostic
+} from '../utils/rust_diagnostics';
+
+function loadDiagnosticFixture(name: string): RustDiagnostic {
+    const jsonText = fs
+        .readFileSync(
+            // We're actually in our JavaScript output directory, climb out
+            `${__dirname}/../../src/test/fixtures/rust-diagnostics/${name}.json`
+        )
+        .toString();
+
+    return JSON.parse(jsonText);
+}
+
+function mapFixtureToVsCode(name: string): MappedRustDiagnostic {
+    const rd = loadDiagnosticFixture(name);
+    const mapResult = mapRustDiagnosticToVsCode(rd);
+
+    if (!mapResult) {
+        return assert.fail('Mapping unexpectedly failed');
+    }
+    return mapResult;
+}
+
+describe('mapRustDiagnosticToVsCode', () => {
+    it('should map an incompatible type for trait error', () => {
+        const { diagnostic, codeActions } = mapFixtureToVsCode('error/E0053');
+
+        assert.strictEqual(
+            diagnostic.severity,
+            vscode.DiagnosticSeverity.Error
+        );
+        assert.strictEqual(
+            diagnostic.message,
+            [
+                `method \`next\` has an incompatible type for trait`,
+                `expected type \`fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>\``,
+                `   found type \`fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>\``
+            ].join('\n')
+        );
+        assert.strictEqual(diagnostic.code, 'E0053');
+        assert.strictEqual(diagnostic.tags, undefined);
+
+        // No related information
+        assert.deepStrictEqual(diagnostic.relatedInformation, []);
+
+        // There are no code actions available
+        assert.strictEqual(codeActions.length, 0);
+    });
+
+    it('should map an unused variable warning', () => {
+        const { diagnostic, codeActions } = mapFixtureToVsCode(
+            'warning/unused_variables'
+        );
+
+        assert.strictEqual(
+            diagnostic.severity,
+            vscode.DiagnosticSeverity.Warning
+        );
+        assert.strictEqual(
+            diagnostic.message,
+            [
+                'unused variable: `foo`',
+                '#[warn(unused_variables)] on by default'
+            ].join('\n')
+        );
+        assert.strictEqual(diagnostic.code, 'unused_variables');
+        assert.deepStrictEqual(diagnostic.tags, [
+            vscode.DiagnosticTag.Unnecessary
+        ]);
+
+        // No related information
+        assert.deepStrictEqual(diagnostic.relatedInformation, []);
+
+        // One code action available to prefix the variable
+        assert.strictEqual(codeActions.length, 1);
+        const [codeAction] = codeActions;
+        assert.strictEqual(
+            codeAction.title,
+            'consider prefixing with an underscore: `_foo`'
+        );
+        assert(codeAction.isPreferred);
+    });
+
+    it('should map a wrong number of parameters error', () => {
+        const { diagnostic, codeActions } = mapFixtureToVsCode('error/E0061');
+
+        assert.strictEqual(
+            diagnostic.severity,
+            vscode.DiagnosticSeverity.Error
+        );
+        assert.strictEqual(
+            diagnostic.message,
+            'this function takes 2 parameters but 3 parameters were supplied'
+        );
+        assert.strictEqual(diagnostic.code, 'E0061');
+        assert.strictEqual(diagnostic.tags, undefined);
+
+        // One related information for the original definition
+        const relatedInformation = diagnostic.relatedInformation;
+        if (!relatedInformation) {
+            return assert.fail('Related information unexpectedly undefined');
+        }
+        assert.strictEqual(relatedInformation.length, 1);
+        const [related] = relatedInformation;
+        assert.strictEqual(related.message, 'defined here');
+
+        // There are no actions available
+        assert.strictEqual(codeActions.length, 0);
+    });
+
+    it('should map a Clippy copy pass by ref warning', () => {
+        const { diagnostic, codeActions } = mapFixtureToVsCode(
+            'clippy/trivially_copy_pass_by_ref'
+        );
+
+        assert.strictEqual(
+            diagnostic.severity,
+            vscode.DiagnosticSeverity.Warning
+        );
+        assert.strictEqual(
+            diagnostic.message,
+            [
+                'this argument is passed by reference, but would be more efficient if passed by value',
+                '#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]',
+                'for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref'
+            ].join('\n')
+        );
+        assert.strictEqual(
+            diagnostic.code,
+            'clippy::trivially_copy_pass_by_ref'
+        );
+        assert.strictEqual(diagnostic.tags, undefined);
+
+        // One related information for the lint definition
+        const relatedInformation = diagnostic.relatedInformation;
+        if (!relatedInformation) {
+            return assert.fail('Related information unexpectedly undefined');
+        }
+        assert.strictEqual(relatedInformation.length, 1);
+        const [related] = relatedInformation;
+        assert.strictEqual(related.message, 'lint level defined here');
+
+        // One code action available to pass by value
+        assert.strictEqual(codeActions.length, 1);
+        const [codeAction] = codeActions;
+        assert.strictEqual(
+            codeAction.title,
+            'consider passing by value instead: `self`'
+        );
+        // Clippy does not mark this as machine applicable
+        assert.strictEqual(codeAction.isPreferred, false);
+    });
+});