Add TestClient and handle various test isolation issues

Author: jdesrosiers

language-server/src/build-server.d.ts

@@ -6,6 +6,7 @@ export type Feature = {
   load: (connection: Connection, documents: TextDocuments<TextDocument>) => void;
   onInitialize: (params: InitializeParams) => ServerCapabilities;
   onInitialized: (connection: Connection, documents: TextDocuments<TextDocument>) => Promise<void>;
+  onShutdown: (connection: Connection, documents: TextDocuments<TextDocument>) => void;
 };
 
 export const buildServer: (connection: Connection, features: Feature[]) => void;

language-server/src/build-server.js

@@ -35,6 +35,12 @@ export const buildServer = (connection, features) => {
     }
   });
 
+  connection.onShutdown(() => {
+    for (const feature of features) {
+      feature.onShutdown(connection, documents);
+    }
+  });
+
   connection.listen();
   documents.listen(connection);
 };

language-server/src/features/completion.js

@@ -35,5 +35,8 @@ export default {
   },
 
   async onInitialized() {
+  },
+
+  onShutdown() {
   }
 };

language-server/src/features/completion.test.ts

@@ -1,21 +1,24 @@
-import { beforeAll, describe, expect, test } from "vitest";
-import { getTestClient, initializeServer } from "../test-utils.js";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { TestClient } from "../test-client.js";
 import completion from "./completion.js";
 
-import type { Connection, ServerCapabilities } from "vscode-languageserver";
+import type { DocumentSettings } from "./document-settings.js";
 
 
 describe("Feature - Completion", () => {
-  let client: Connection;
-  let capabilities: ServerCapabilities;
+  let client: TestClient<DocumentSettings>;
 
   beforeAll(async () => {
-    client = getTestClient([completion]);
-    capabilities = await initializeServer(client);
+    client = new TestClient([completion]);
+    await client.start();
+  });
+
+  afterAll(async () => {
+    await client.stop();
   });
 
   test("completion provider capabilities", async () => {
-    expect(capabilities.completionProvider).to.eql({
+    expect(client.serverCapabilities?.completionProvider).to.eql({
       resolveProvider: false,
       triggerCharacters: ["\"", ":", " "]
     });

language-server/src/features/deprecated.js

@@ -31,5 +31,8 @@ export default {
   },
 
   async onInitialized() {
+  },
+
+  onShutdown() {
   }
 };

language-server/src/features/document-settings.js

@@ -1,5 +1,5 @@
 import { DidChangeConfigurationNotification } from "vscode-languageserver";
-import { publish } from "../pubsub.js";
+import { publishAsync } from "../pubsub.js";
 import { clearSchemaDocuments } from "./schema-registry.js";
 
 /**
@@ -14,13 +14,13 @@ let hasDidChangeConfigurationCapability = false;
 /** @type Feature */
 export default {
   load(connection, documents) {
-    connection.onDidChangeConfiguration(() => {
+    connection.onDidChangeConfiguration(async () => {
       if (hasConfigurationCapability) {
         documentSettings.clear();
         clearSchemaDocuments();
       }
 
-      publish("workspaceChanged", { changes: [] });
+      await publishAsync("workspaceChanged", { changes: [] });
     });
 
     documents.onDidClose(({ document }) => {
@@ -37,11 +37,13 @@ export default {
 
   async onInitialized(connection) {
     if (hasDidChangeConfigurationCapability) {
-      connection.client.register(DidChangeConfigurationNotification.type, {
+      await connection.client.register(DidChangeConfigurationNotification.type, {
         section: "jsonSchemaLanguageServer"
       });
     }
-  }
+  },
+
+  onShutdown() {}
 };
 
 const documentSettings = new Map();

language-server/src/features/document-settings.test.ts

@@ -1,119 +1,103 @@
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
-import {
-  ConfigurationRequest,
-  DidChangeTextDocumentNotification,
-  PublishDiagnosticsNotification
-} from "vscode-languageserver";
-import { getTestClient, closeDocument, initializeServer, openDocument } from "../test-utils.js";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { PublishDiagnosticsNotification } from "vscode-languageserver";
+import { TestClient } from "../test-client.js";
 import documentSettings from "./document-settings.js";
+import semanticTokens from "./semantic-tokens.js";
 import schemaRegistry from "./schema-registry.js";
 import workspace from "./workspace.js";
 import validationErrorsFeature from "./validation-errors.js";
 
-import type { Connection, Diagnostic } from "vscode-languageserver";
+import type { Diagnostic } from "vscode-languageserver";
+import type { DocumentSettings } from "./document-settings.js";
 
 
 describe("Feature - Document Settings", () => {
-  let client: Connection;
-  let documentUri: string;
+  let client: TestClient<DocumentSettings>;
 
-  beforeAll(async () => {
-    client = getTestClient([
+  beforeEach(async () => {
+    client = new TestClient([
       workspace,
       documentSettings,
+      semanticTokens,
       schemaRegistry,
       validationErrorsFeature
     ]);
-    const init = {};
-    const settings = { "defaultDialect": "https://json-schema.org/draft/2020-12/schema" };
-    await initializeServer(client, init, settings);
+    await client.start();
   });
 
-  afterAll(async () => {
-    await closeDocument(client, documentUri);
+  afterEach(async () => {
+    await client.stop();
   });
 
   test("test default dialect", async () => {
-    documentUri = await openDocument(client, "./subject.schema.json", `{}`);
+    await client.changeConfiguration({ defaultDialect: "https://json-schema.org/draft/2020-12/schema" });
 
     const diagnosticsPromise = new Promise<Diagnostic[]>((resolve) => {
       client.onNotification(PublishDiagnosticsNotification.type, (params) => {
         resolve(params.diagnostics);
       });
     });
 
-    await client.sendNotification(DidChangeTextDocumentNotification.type, {
-      textDocument: { uri: documentUri, version: 1 },
-      contentChanges: []
-    });
+    await client.openDocument("./subject.schema.json", `{}`);
 
     const diagnostics = await diagnosticsPromise;
     expect(diagnostics).to.eql([]);
   });
 
   test("test no dialect", async () => {
-    documentUri = await openDocument(client, "./subject.schema.json", `{}`);
-
-    client.onRequest(ConfigurationRequest.type, () => {
-      return [{}];
-    });
-
     const diagnosticsPromise = new Promise<Diagnostic[]>((resolve) => {
       client.onNotification(PublishDiagnosticsNotification.type, (params) => {
         resolve(params.diagnostics);
       });
     });
 
-    await client.sendNotification(DidChangeTextDocumentNotification.type, {
-      textDocument: { uri: documentUri, version: 1 },
-      contentChanges: []
-    });
+    await client.openDocument("./subject.schema.json", `{}`);
 
     const diagnostics = await diagnosticsPromise;
     expect(diagnostics[0].message).to.eql("No dialect");
   });
 
   test("test unknown dialect", async () => {
-    documentUri = await openDocument(client, "./subject.schema.json", `{ "$schema": "" }`);
-
-    client.onRequest(ConfigurationRequest.type, () => {
-      return [{}];
-    });
-
     const diagnosticsPromise = new Promise<Diagnostic[]>((resolve) => {
       client.onNotification(PublishDiagnosticsNotification.type, (params) => {
         resolve(params.diagnostics);
       });
     });
 
-    await client.sendNotification(DidChangeTextDocumentNotification.type, {
-      textDocument: { uri: documentUri, version: 1 },
-      contentChanges: []
-    });
+    await client.openDocument("./subject.schema.json", `{ "$schema": "" }`);
 
     const diagnostics = await diagnosticsPromise;
     expect(diagnostics[0].message).to.eql("Unknown dialect");
   });
 
   test("test unknown dialect when default dialect is unknown", async () => {
-    documentUri = await openDocument(client, "./subject.schema.json", `{}`);
-
-    client.onRequest(ConfigurationRequest.type, () => {
-      return [{ "defaultDialect": "" }];
-    });
+    await client.changeConfiguration({ defaultDialect: "https://example.com/unknown-dialect" });
 
     const diagnosticsPromise = new Promise<Diagnostic[]>((resolve) => {
       client.onNotification(PublishDiagnosticsNotification.type, (params) => {
         resolve(params.diagnostics);
       });
     });
 
-    await client.sendNotification(DidChangeTextDocumentNotification.type, {
-      textDocument: { uri: documentUri, version: 1 },
-      contentChanges: []
-    });
+    await client.openDocument("./subject.schema.json", `{}`);
 
     const diagnostics = await diagnosticsPromise;
     expect(diagnostics[0].message).to.eql("Unknown dialect");
   });
+
+  test("watches only specified files", async () => {
+    await client.changeConfiguration({ "schemaFilePatterns": ["**/subjectB.schema.json"] });
+
+    const diagnosticsPromise = new Promise<string>((resolve) => {
+      client.onNotification(PublishDiagnosticsNotification.type, (params) => {
+        resolve(params.uri);
+      });
+    });
+
+    await client.openDocument("./subject.schema.json", "{}");
+    const documentUriB = await client.openDocument("./subjectB.schema.json", "{}");
+
+    const diagnostics = await diagnosticsPromise;
+    expect(diagnostics).to.equal(documentUriB);
+  });
 });