Create TM syntax highlighting test infrastructure

Author: eliericha

integration/vscode/ada/test/suite/highlighting.test.ts

@@ -1,8 +1,11 @@
 import assert from 'assert';
+import { spawnSync } from 'child_process';
+import { existsSync, renameSync } from 'fs';
+import path from 'path';
 import * as vscode from 'vscode';
 import { SemanticTokensParams, SemanticTokensRequest, integer } from 'vscode-languageclient';
 import { contextClients } from '../../src/extension';
-import { assertEqualToFileContent } from './utils';
+import { assertEqualToFileContent, update } from './utils';
 
 suite('Semantic Highlighting', function () {
     this.beforeAll(async function () {
@@ -13,19 +16,28 @@ suite('Semantic Highlighting', function () {
         await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
     });
 
-    test('test1', async function () {
+    suite('test1', function () {
         const relFilePath = 'src/gnatpp.adb';
-        await testFile(relFilePath);
+
+        test('syntax.main', function () {
+            testSyntaxHighlighting(relFilePath, 'syntaxes');
+        });
+
+        test('syntax.advanced', function () {
+            testSyntaxHighlighting(relFilePath, 'advanced');
+        });
+
+        test('semantic', async function () {
+            await testSemanticHighlighting(relFilePath);
+        });
     });
 });
 
-async function testFile(relFilePath: string) {
+async function testSemanticHighlighting(relFilePath: string) {
     const docUri = getDocUri(relFilePath);
     const expFilePath = `${relFilePath}.sem.tokens`;
     const expectedUri = getDocUri(expFilePath);
 
-    //   const doc = await vscode.workspace.openTextDocument(docUri);
-    //   await vscode.window.showTextDocument(doc);
     const initResult = contextClients.adaClient.initializeResult;
     const legend = initResult?.capabilities.semanticTokensProvider?.legend;
 
@@ -129,3 +141,71 @@ function getDocUri(path: string): vscode.Uri {
     assert(vscode.workspace.workspaceFolders !== undefined);
     return vscode.Uri.joinPath(vscode.workspace.workspaceFolders[0].uri, path);
 }
+
+const extensionRootPath = path.resolve(__dirname, '../../../');
+
+type Syntaxes = 'syntaxes' | 'advanced';
+
+function testSyntaxHighlighting(relFilePath: string, syntax: Syntaxes) {
+    const syntaxPath = path.join(extensionRootPath, syntax, 'ada.tmLanguage.json');
+
+    const basename = path.basename(relFilePath);
+    const adaFilePath = getDocUri(relFilePath).fsPath;
+    const workDirPath = path.dirname(adaFilePath);
+
+    /*
+     * vscode-tmgrammar-snap works with .snap files, but since we're testing two
+     * grammars, the snapshots are stored as .snap.<syntax-name> files. Before
+     * calling vscode-tmgrammar-snap, the test will rename the
+     * .snap.<syntax-name> file to .snap and rename it back after.
+     */
+    const workSnapPath = path.join(workDirPath, `${basename}.snap`);
+    const refSnapPath = `${workSnapPath}.${syntax}`;
+
+    try {
+        if (existsSync(refSnapPath)) {
+            // Rename .snap.<syntax> --> .snap
+            renameSync(refSnapPath, workSnapPath);
+        } else if (!update()) {
+            // Complain if the reference snapshot doesn't exist, except if we're
+            // running in update mode, in which case the test will create the
+            // snapshot.
+            throw Error(
+                `Could not find reference snapshot: ${refSnapPath}\n` +
+                    'Re-run testsuite in update mode to create a snapshot.'
+            );
+        }
+
+        const cmd = ['vscode-tmgrammar-snap', '-g', syntaxPath, '-s', 'source.ada', adaFilePath];
+
+        if (update()) {
+            cmd.push('--updateSnapshot');
+        }
+
+        const proc = spawnSync(cmd[0], cmd.slice(1));
+
+        if (proc.error) {
+            // proc.error is set if we fail to spawn the child process
+            throw proc.error;
+        }
+
+        if (proc.status === null) {
+            const msg =
+                `Null return code for command: ${cmd.join(' ')}\n` +
+                String(proc.stdout) +
+                String(proc.stderr);
+            assert.fail(msg);
+        } else if (proc.status != 0) {
+            const msg =
+                `Return code ${proc.status.toString()} for command: ${cmd.join(' ')}\n` +
+                String(proc.stdout) +
+                String(proc.stderr);
+            assert.fail(msg);
+        }
+    } finally {
+        if (existsSync(workSnapPath)) {
+            // Rename .snap --> .snap.<syntax>
+            renameSync(workSnapPath, refSnapPath);
+        }
+    }
+}

integration/vscode/ada/test/suite/index.ts

@@ -1,9 +1,14 @@
 import { Glob, GlobOptionsWithFileTypesUnset } from 'glob';
 import Mocha, { MochaOptions } from 'mocha';
-import { resolve } from 'path';
+import path, { resolve } from 'path';
 import { env } from 'process';
 
 export function run(): Promise<void> {
+    // Make package executables visible
+    const extensionRootPath = path.resolve(__dirname, '../../../');
+    const nodeModulesBin = path.join(extensionRootPath, 'node_modules', '.bin');
+    process.env.PATH = `${nodeModulesBin}${path.delimiter}${process.env.PATH as string}`;
+
     const mochaOptions: MochaOptions = {
         ui: 'tdd',
         color: true,

integration/vscode/ada/test/suite/utils.ts

@@ -13,7 +13,7 @@ import * as vscode from 'vscode';
  * @param expectedUri - path to the file containing the expected output
  */
 export function assertEqualToFileContent(actual: string, expectedUri: vscode.Uri) {
-    if (process.env.MOCHA_ALS_UPDATE) {
+    if (update()) {
         writeFileSync(expectedUri.fsPath, actual);
     } else {
         if (!existsSync(expectedUri.fsPath)) {
@@ -24,3 +24,12 @@ export function assertEqualToFileContent(actual: string, expectedUri: vscode.Uri
         assert.strictEqual(actual, expected);
     }
 }
+
+/**
+ *
+ * @returns true if the testsuite is running in update mode, i.e. the
+ * environment variable MOCHA_ALS_UPDATE is set
+ */
+export function update(): boolean {
+    return process.env.MOCHA_ALS_UPDATE ? true : false;
+}