Close all text editors after each test.

test/integrationTests/buildDiagnostics.integration.test.ts

@@ -4,21 +4,28 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { describe, test, expect, beforeAll, afterAll } from '@jest/globals';
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import { AnalysisSetting, BuildDiagnosticsService } from '../../src/lsptoolshost/buildDiagnosticsService';
 import * as integrationHelpers from './integrationHelpers';
 import path = require('path');
-describe(`Build and live diagnostics dedupe ${testAssetWorkspace.description}`, function () {
-    beforeAll(async function () {
-        await integrationHelpers.openFileInWorkspaceAsync(path.join('src', 'app', 'inlayHints.cs'));
+describe(`Build and live diagnostics dedupe ${testAssetWorkspace.description}`, () => {
+    beforeAll(async () => {
         await integrationHelpers.activateCSharpExtension();
     });
 
+    beforeEach(async () => {
+        await integrationHelpers.openFileInWorkspaceAsync(path.join('src', 'app', 'inlayHints.cs'));
+    });
+
     afterAll(async () => {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await integrationHelpers.closeAllEditorsAsync();
+    });
+
     test('OpenFiles diagnostics', async () => {
         await setBackgroundAnalysisSetting(
             /*analyzer*/ AnalysisSetting.OpenFiles,

test/integrationTests/codelens.integration.test.ts

@@ -6,16 +6,21 @@
 import * as lsp from 'vscode-languageserver-protocol';
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { describe, beforeAll, beforeEach, afterAll, test, expect } from '@jest/globals';
+import { describe, beforeAll, beforeEach, afterAll, test, expect, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
-import { activateCSharpExtension, getCodeLensesAsync, openFileInWorkspaceAsync } from './integrationHelpers';
+import {
+    activateCSharpExtension,
+    closeAllEditorsAsync,
+    getCodeLensesAsync,
+    openFileInWorkspaceAsync,
+} from './integrationHelpers';
 
-describe(`[${testAssetWorkspace.description}] Test CodeLens`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test CodeLens`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
-    beforeEach(async function () {
+    beforeEach(async () => {
         const fileName = path.join('src', 'app', 'reference.cs');
         await openFileInWorkspaceAsync(fileName);
     });
@@ -24,6 +29,10 @@ describe(`[${testAssetWorkspace.description}] Test CodeLens`, function () {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await closeAllEditorsAsync();
+    });
+
     test('CodeLens references are displayed', async () => {
         const codeLenses = await getCodeLensesAsync();
         expect(codeLenses).toHaveLength(4);

test/integrationTests/commandEnablement.integration.test.ts

@@ -9,16 +9,16 @@ import { activateCSharpExtension } from './integrationHelpers';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import { CommonCommands, OmniSharpCommands, RoslynCommands } from './expectedCommands';
 
-describe(`Command Enablement: ${testAssetWorkspace.description}`, function () {
-    beforeAll(async function () {
+describe(`Command Enablement: ${testAssetWorkspace.description}`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
     afterAll(async () => {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
-    test('Roslyn commands are available', async function () {
+    test('Roslyn commands are available', async () => {
         const commands = await vscode.commands.getCommands(true);
 
         // Ensure the standalone Roslyn commands are available.

test/integrationTests/completion.integration.test.ts

@@ -5,16 +5,16 @@
 
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { describe, beforeAll, beforeEach, afterAll, test, expect } from '@jest/globals';
+import { describe, beforeAll, beforeEach, afterAll, test, expect, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
-import { activateCSharpExtension, openFileInWorkspaceAsync } from './integrationHelpers';
+import { activateCSharpExtension, closeAllEditorsAsync, openFileInWorkspaceAsync } from './integrationHelpers';
 
-describe(`[${testAssetWorkspace.description}] Test Completion`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test Completion`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
-    beforeEach(async function () {
+    beforeEach(async () => {
         const fileName = path.join('src', 'app', 'completion.cs');
         await openFileInWorkspaceAsync(fileName);
     });
@@ -23,6 +23,10 @@ describe(`[${testAssetWorkspace.description}] Test Completion`, function () {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await closeAllEditorsAsync();
+    });
+
     test('Returns completion items', async () => {
         const completionList = await getCompletionsAsync(new vscode.Position(8, 12), undefined, 10);
         expect(completionList.items.length).toBeGreaterThan(0);

test/integrationTests/documentDiagnostics.integration.test.ts

@@ -4,14 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { describe, test, beforeAll, afterAll, expect } from '@jest/globals';
+import { describe, test, beforeAll, afterAll, expect, beforeEach, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import { AnalysisSetting } from '../../src/lsptoolshost/buildDiagnosticsService';
 import * as integrationHelpers from './integrationHelpers';
 import path = require('path');
 import { getCode, setBackgroundAnalysisScopes, waitForExpectedDiagnostics } from './diagnosticsHelpers';
-describe(`[${testAssetWorkspace.description}] Test diagnostics`, function () {
-    beforeAll(async function () {
+
+describe(`[${testAssetWorkspace.description}] Test diagnostics`, () => {
+    beforeAll(async () => {
         await integrationHelpers.activateCSharpExtension();
     });
 
@@ -21,10 +22,14 @@ describe(`[${testAssetWorkspace.description}] Test diagnostics`, function () {
 
     describe('Open document diagnostics', () => {
         let file: vscode.Uri;
-        beforeAll(async () => {
+        beforeEach(async () => {
             file = await integrationHelpers.openFileInWorkspaceAsync(path.join('src', 'app', 'diagnostics.cs'));
         });
 
+        afterEach(async () => {
+            await integrationHelpers.closeAllEditorsAsync();
+        });
+
         test('Compiler and analyzer diagnostics reported for open file when set to OpenFiles', async () => {
             await setBackgroundAnalysisScopes({
                 compiler: AnalysisSetting.OpenFiles,

test/integrationTests/documentSymbolProvider.integration.test.ts

@@ -3,17 +3,20 @@
  *  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 { expect, test, beforeAll, afterAll, describe, afterEach, beforeEach } from '@jest/globals';
 import * as vscode from 'vscode';
 import * as path from 'path';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
-import { activateCSharpExtension, openFileInWorkspaceAsync } from './integrationHelpers';
+import { activateCSharpExtension, closeAllEditorsAsync, openFileInWorkspaceAsync } from './integrationHelpers';
 
-describe(`DocumentSymbolProvider: ${testAssetWorkspace.description}`, function () {
+describe(`DocumentSymbolProvider: ${testAssetWorkspace.description}`, () => {
     let fileUri: vscode.Uri;
 
-    beforeAll(async function () {
+    beforeAll(async () => {
         await activateCSharpExtension();
+    });
+
+    beforeEach(async () => {
         const relativePath = path.join('src', 'app', 'documentSymbols.cs');
         fileUri = await openFileInWorkspaceAsync(relativePath);
     });
@@ -22,7 +25,11 @@ describe(`DocumentSymbolProvider: ${testAssetWorkspace.description}`, function (
         await testAssetWorkspace.cleanupWorkspace();
     });
 
-    test('Returns all elements', async function () {
+    afterEach(async () => {
+        await closeAllEditorsAsync();
+    });
+
+    test('Returns all elements', async () => {
         const symbols = await GetDocumentSymbols(fileUri);
 
         expect(symbols).toHaveLength(5);

test/integrationTests/gotoDefinition.integration.test.ts

@@ -6,22 +6,26 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
-import { activateCSharpExtension, openFileInWorkspaceAsync } from './integrationHelpers';
-import { describe, beforeAll, beforeEach, afterAll, test, expect } from '@jest/globals';
+import { activateCSharpExtension, closeAllEditorsAsync, openFileInWorkspaceAsync } from './integrationHelpers';
+import { describe, beforeAll, beforeEach, afterAll, test, expect, afterEach } from '@jest/globals';
 
-describe(`[${testAssetWorkspace.description}] Test Go To Definition`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test Go To Definition`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
-    beforeEach(async function () {
+    beforeEach(async () => {
         await openFileInWorkspaceAsync(path.join('src', 'app', 'definition.cs'));
     });
 
     afterAll(async () => {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await closeAllEditorsAsync();
+    });
+
     test('Navigates to definition in same file', async () => {
         const requestPosition = new vscode.Position(10, 31);
         const definitionList = <vscode.Location[]>(

test/integrationTests/integrationHelpers.ts

@@ -60,6 +60,10 @@ export async function openFileInWorkspaceAsync(relativeFilePath: string): Promis
     return uri;
 }
 
+export async function closeAllEditorsAsync(): Promise<void> {
+    await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+}
+
 /**
  * Reverts any unsaved changes to the active file.
  * Useful to reset state between tests without fully reloading everything.

test/integrationTests/lspInlayHints.integration.test.ts

@@ -5,13 +5,13 @@
 
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { describe, beforeAll, afterAll, test, expect } from '@jest/globals';
+import { describe, beforeAll, afterAll, test, expect, beforeEach, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import * as integrationHelpers from './integrationHelpers';
 import { InlayHint, InlayHintKind, Position } from 'vscode-languageserver-protocol';
 
-describe(`[${testAssetWorkspace.description}] Test LSP Inlay Hints `, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test LSP Inlay Hints `, () => {
+    beforeAll(async () => {
         const editorConfig = vscode.workspace.getConfiguration('editor');
         await editorConfig.update('inlayHints.enabled', true);
         const dotnetConfig = vscode.workspace.getConfiguration('dotnet');
@@ -30,14 +30,21 @@ describe(`[${testAssetWorkspace.description}] Test LSP Inlay Hints `, function (
         await csharpConfig.update('inlayHints.enableInlayHintsForLambdaParameterTypes', true);
         await csharpConfig.update('inlayHints.enableInlayHintsForImplicitObjectCreation', true);
 
-        await integrationHelpers.openFileInWorkspaceAsync(path.join('src', 'app', 'inlayHints.cs'));
         await integrationHelpers.activateCSharpExtension();
     });
 
+    beforeEach(async () => {
+        await integrationHelpers.openFileInWorkspaceAsync(path.join('src', 'app', 'inlayHints.cs'));
+    });
+
     afterAll(async () => {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await integrationHelpers.closeAllEditorsAsync();
+    });
+
     test('Hints retrieved for region', async () => {
         const range = new vscode.Range(new vscode.Position(4, 8), new vscode.Position(15, 85));
         const activeDocument = vscode.window.activeTextEditor?.document.uri;

test/integrationTests/onAutoInsert.integration.test.ts

@@ -8,24 +8,26 @@ import * as path from 'path';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import {
     activateCSharpExtension,
+    closeAllEditorsAsync,
     openFileInWorkspaceAsync,
     revertActiveFile,
     sleep,
     waitForExpectedResult,
 } from './integrationHelpers';
 import { describe, beforeAll, beforeEach, afterAll, test, expect, afterEach } from '@jest/globals';
 
-describe(`[${testAssetWorkspace.description}] Test OnAutoInsert`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test OnAutoInsert`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
-    beforeEach(async function () {
+    beforeEach(async () => {
         await openFileInWorkspaceAsync(path.join('src', 'app', 'DocComments.cs'));
     });
 
     afterEach(async () => {
         await revertActiveFile();
+        await closeAllEditorsAsync();
     });
 
     afterAll(async () => {

test/integrationTests/unitTests.integration.test.ts

@@ -5,17 +5,22 @@
 
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { describe, beforeAll, beforeEach, afterAll, test, expect } from '@jest/globals';
+import { describe, beforeAll, beforeEach, afterAll, test, expect, afterEach } from '@jest/globals';
 import testAssetWorkspace from './testAssets/testAssetWorkspace';
-import { activateCSharpExtension, getCodeLensesAsync, openFileInWorkspaceAsync } from './integrationHelpers';
+import {
+    activateCSharpExtension,
+    closeAllEditorsAsync,
+    getCodeLensesAsync,
+    openFileInWorkspaceAsync,
+} from './integrationHelpers';
 import { TestProgress } from '../../src/lsptoolshost/roslynProtocol';
 
-describe(`[${testAssetWorkspace.description}] Test Unit Testing`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test Unit Testing`, () => {
+    beforeAll(async () => {
         await activateCSharpExtension();
     });
 
-    beforeEach(async function () {
+    beforeEach(async () => {
         vscode.workspace
             .getConfiguration()
             .update('dotnet.unitTests.runSettingsPath', undefined, vscode.ConfigurationTarget.Workspace);
@@ -27,6 +32,10 @@ describe(`[${testAssetWorkspace.description}] Test Unit Testing`, function () {
         await testAssetWorkspace.cleanupWorkspace();
     });
 
+    afterEach(async () => {
+        await closeAllEditorsAsync();
+    });
+
     test('Unit test code lens items are displayed', async () => {
         const codeLenses = await getCodeLensesAsync();
         expect(codeLenses).toHaveLength(9);

test/integrationTests/workspaceDiagnostics.integration.test.ts

@@ -9,8 +9,8 @@ import testAssetWorkspace from './testAssets/testAssetWorkspace';
 import { AnalysisSetting } from '../../src/lsptoolshost/buildDiagnosticsService';
 import * as integrationHelpers from './integrationHelpers';
 import { getCode, setBackgroundAnalysisScopes, waitForExpectedDiagnostics } from './diagnosticsHelpers';
-describe(`[${testAssetWorkspace.description}] Test diagnostics`, function () {
-    beforeAll(async function () {
+describe(`[${testAssetWorkspace.description}] Test diagnostics`, () => {
+    beforeAll(async () => {
         await integrationHelpers.activateCSharpExtension();
     });