Merge pull request #6575 from dibarbet/doc_symbol_tests

Add document symbol integration tests

Author: dibarbet

test/integrationTests/documentSymbolProvider.integration.test.ts

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { expect, test, beforeAll, afterAll, describe } from '@jest/globals';
+import * as vscode from 'vscode';
+import * as path from 'path';
+import testAssetWorkspace from './testAssets/testAssetWorkspace';
+import { activateCSharpExtension, openFileInWorkspaceAsync } from './integrationHelpers';
+
+describe(`DocumentSymbolProvider: ${testAssetWorkspace.description}`, function () {
+    let fileUri: vscode.Uri;
+
+    beforeAll(async function () {
+        await activateCSharpExtension();
+        const relativePath = path.join('src', 'app', 'documentSymbols.cs');
+        fileUri = await openFileInWorkspaceAsync(relativePath);
+    });
+
+    afterAll(async () => {
+        await testAssetWorkspace.cleanupWorkspace();
+    });
+
+    test('Returns all elements', async function () {
+        const symbols = await GetDocumentSymbols(fileUri);
+
+        expect(symbols).toHaveLength(5);
+
+        // Class C
+        expect(symbols[0].name).toBe('C');
+        expect(symbols[0].detail).toBe('Test.C');
+        expect(symbols[0].kind).toBe(vscode.SymbolKind.Class);
+        // The range is the entire class, but the selection range is the class name
+        expect(symbols[0].range).toStrictEqual(new vscode.Range(new vscode.Position(4, 4), new vscode.Position(37, 5)));
+        expect(symbols[0].selectionRange).toStrictEqual(
+            new vscode.Range(new vscode.Position(4, 10), new vscode.Position(4, 11))
+        );
+        expect(symbols[0].children).toHaveLength(20);
+
+        // Field _f
+        expect(symbols[0].children[0].name).toBe('_f');
+        expect(symbols[0].children[0].kind).toBe(vscode.SymbolKind.Field);
+
+        // Finalize
+        expect(symbols[0].children[3].name).toBe('Finalize');
+        expect(symbols[0].children[3].kind).toBe(vscode.SymbolKind.Method);
+
+        // Ctor
+        expect(symbols[0].children[4].name).toBe('.ctor');
+        expect(symbols[0].children[4].kind).toBe(vscode.SymbolKind.Method);
+
+        // EventHandler E1
+        expect(symbols[0].children[5].name).toBe('E1');
+        expect(symbols[0].children[5].kind).toBe(vscode.SymbolKind.Event);
+
+        // explicit operator int(C c1)
+        expect(symbols[0].children[11].name).toBe('op_Explicit');
+        expect(symbols[0].children[11].detail).toBe('explicit operator int(C c1)');
+        expect(symbols[0].children[11].kind).toBe(vscode.SymbolKind.Operator);
+
+        // implicit operator int(C c1)
+        expect(symbols[0].children[12].name).toBe('op_Implicit');
+        expect(symbols[0].children[12].detail).toBe('implicit operator C(int i)');
+        expect(symbols[0].children[12].kind).toBe(vscode.SymbolKind.Operator);
+
+        // implicit operator int(C c1)
+        expect(symbols[0].children[12].name).toBe('op_Implicit');
+        expect(symbols[0].children[12].detail).toBe('implicit operator C(int i)');
+        expect(symbols[0].children[12].kind).toBe(vscode.SymbolKind.Operator);
+
+        // Method M1
+        expect(symbols[0].children[13].name).toBe('M1');
+        expect(symbols[0].children[13].detail).toBe('M1(int i, string s, params object[] args)');
+        expect(symbols[0].children[13].kind).toBe(vscode.SymbolKind.Method);
+
+        // operator !=
+        expect(symbols[0].children[14].name).toBe('op_Inequality');
+        expect(symbols[0].children[14].detail).toBe('operator !=(C c1, int i)');
+        expect(symbols[0].children[14].kind).toBe(vscode.SymbolKind.Operator);
+
+        // Property P1
+        expect(symbols[0].children[16].name).toBe('P1');
+        expect(symbols[0].children[16].kind).toBe(vscode.SymbolKind.Property);
+
+        // Struct S
+        expect(symbols[1].name).toBe('S');
+        expect(symbols[1].detail).toBe('Test.S');
+        expect(symbols[1].kind).toBe(vscode.SymbolKind.Struct);
+
+        // Interface I
+        expect(symbols[2].name).toBe('I');
+        expect(symbols[2].detail).toBe('Test.I');
+        expect(symbols[2].kind).toBe(vscode.SymbolKind.Interface);
+
+        // Delegate D
+        expect(symbols[3].name).toBe('D');
+        expect(symbols[3].detail).toBe('Test.D');
+        expect(symbols[3].kind).toBe(vscode.SymbolKind.Method);
+
+        // Enum E
+        expect(symbols[4].name).toBe('E');
+        expect(symbols[4].detail).toBe('Test.E');
+        expect(symbols[4].kind).toBe(vscode.SymbolKind.Enum);
+    });
+});
+
+async function GetDocumentSymbols(fileUri: vscode.Uri) {
+    return <vscode.DocumentSymbol[]>(
+        await vscode.commands.executeCommand('vscode.executeDocumentSymbolProvider', fileUri)
+    );
+}

test/integrationTests/integrationHelpers.ts

@@ -55,14 +55,16 @@ export async function activateCSharpExtension(): Promise<void> {
     }
 }
 
-export async function openFileInWorkspaceAsync(relativeFilePath: string): Promise<void> {
+export async function openFileInWorkspaceAsync(relativeFilePath: string): Promise<vscode.Uri> {
     const root = vscode.workspace.workspaceFolders![0].uri.fsPath;
     const filePath = path.join(root, relativeFilePath);
     if (!existsSync(filePath)) {
         throw new Error(`File ${filePath} does not exist`);
     }
 
-    await vscode.commands.executeCommand('vscode.open', vscode.Uri.file(filePath));
+    const uri = vscode.Uri.file(filePath);
+    await vscode.commands.executeCommand('vscode.open', uri);
+    return uri;
 }
 
 export function isRazorWorkspace(workspace: typeof vscode.workspace) {