fix: fix tests

Author: Loïc Mangeonjean

FixJSDOMEnvironment.js

@@ -0,0 +1,14 @@
+const JSDOMEnvironment = require('jest-environment-jsdom').default
+
+
+class FixJSDOMEnvironment extends JSDOMEnvironment {
+  constructor(...args) {
+    super(...args);
+
+    // FIXME https://github.com/jsdom/jsdom/issues/3363
+    this.global.structuredClone = structuredClone;
+  }
+}
+
+// https://github.com/facebook/jest/blob/v29.4.3/website/versioned_docs/version-29.4/Configuration.md#testenvironment-string
+module.exports = FixJSDOMEnvironment

babel.test.config.js

@@ -2,7 +2,8 @@ module.exports = {
   plugins: [
     ["@babel/plugin-transform-modules-commonjs", {
       importInterop: 'babel'
-    }]
+    }],
+    "babel-plugin-transform-import-meta"
   ],
   presets: [
     "@babel/preset-env",

browserMock.js

@@ -1,4 +1,6 @@
 const fs = require('fs/promises')
+const { performance } = require('perf_hooks')
+const path = require('path')
 
 Object.defineProperty(document, 'queryCommandSupported', {
   value: jest.fn().mockImplementation(() => true),
@@ -19,20 +21,19 @@ Object.defineProperty(window, 'matchMedia', {
 });
 
 Object.defineProperty(window, 'fetch', {
-  value: jest.fn(async (path) => {
-
-    const content = await fs.readFile(path)
+  value: jest.fn(async (url) => {
+    const content = await fs.readFile(new URL(url).pathname)
     return {
       json: async () => JSON.stringify(JSON.parse(content.toString())),
-      arrayBuffer: async () => content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength)
+      arrayBuffer: async () => content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength),
+      status: 200
     }
   })
 })
 
 Object.defineProperty(URL, 'createObjectURL', {
   value: jest.fn((blob) => {
-
-    return null
+    return 'blob:not-working'
   })
 })
 
@@ -90,6 +91,9 @@ Object.defineProperty(window, 'TextEncoder', {
 Object.defineProperty(window, 'TextDecoder', {
   value: class TextDecoder {
     decode (octets) {
+      if (octets == null) {
+        return ''
+      }
       var string = "";
       var i = 0;
       while (i < octets.length) {
@@ -130,4 +134,19 @@ Object.defineProperty(window, 'TextDecoder', {
 
 Object.defineProperty(window, 'Buffer', {
   value: undefined
-})
+})
+
+// Force override performance, for some reason the implementation is empty otherwise
+let _performance = performance
+Object.defineProperty(global, 'performance', {
+  get () { return _performance },
+  set (v) {
+    // ignore
+  }
+})
+
+global.CSS = {
+  escape: v => v
+}
+
+Element.prototype.scrollIntoView = jest.fn();

jest/onig.js

@@ -1 +1 @@
-module.exports = "vscode-oniguruma/release/onig.wasm"
+module.exports = "node_modules/vscode-oniguruma/release/onig.wasm"

src/tests/infrastructure.test.ts

@@ -1,16 +1,19 @@
-
-import { createEditor, monaco, registerEditorOpenHandler } from '@codingame/monaco-editor-wrapper'
+import { createEditor, initializePromise, monaco, registerEditorOpenHandler } from '@codingame/monaco-editor-wrapper'
 import { CompletionTriggerKind, ServerCapabilities, TextDocumentSyncKind, Range } from 'vscode-languageserver-protocol'
 import {
   _Connection,
   _
 } from 'vscode-languageserver/lib/common/api'
+import { createModelReference } from 'vscode/monaco'
+import * as vscode from 'vscode'
+import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override'
+import { ExtensionHostKind, registerExtension } from 'vscode/extensions'
 import pDefer, { TestInfrastructure, waitClientNotification, waitClientRequest } from './tools'
-import { GetTextDocumentParams, getTextDocumentRequestType, GetTextDocumentResult, SaveTextDocumentParams, saveTextDocumentRequestType } from '../customRequests'
-import { createLanguageClientManager, LanguageClientId, LanguageClientManager, getLanguageClientOptions } from '..'
+import { GetTextDocumentParams, getTextDocumentRequestType, GetTextDocumentResult, saveTextDocumentRequestType } from '../customRequests'
+import { createLanguageClientManager, LanguageClientManager, getLanguageClientOptions, StaticLanguageClientId } from '..'
 
 async function initializeLanguageClientAndGetConnection (
-  languageClientId: LanguageClientId,
+  languageClientId: StaticLanguageClientId,
   capabilities: ServerCapabilities<unknown>,
   automaticTextDocumentUpdate: boolean = false,
   useMutualizedProxy: boolean = false
@@ -73,16 +76,26 @@ async function testLanguageClient (
   await initializedNotifPromise
 
   // Creating a java model which will be open in the language client
-  const model = monaco.editor.createModel('public class Toto {}', 'java', monaco.Uri.file('/tmp/project/src/main/Toto.java'))
+  const mainFileUri = monaco.Uri.file('/tmp/project/src/main/Toto.java')
+  const fs = new RegisteredFileSystemProvider(false)
+  const fileContent = 'public class Toto {}'
+
+  fs.registerFile(new RegisteredMemoryFile(mainFileUri, fileContent))
+  const fileSystemDisposable = registerFileSystemOverlay(1, fs)
 
-  const editor = createEditor(document.createElement('div'), {
+  const modelRef = await createModelReference(mainFileUri)
+  const model = modelRef.object.textEditorModel!
+
+  const el = document.createElement('div')
+  document.body.append(el)
+  const editor = createEditor(el, {
     model
   })
 
   // Expect the model to be open
   expect(await waitClientNotification(connection.onDidOpenTextDocument)).toEqual({
     textDocument: {
-      uri: 'file:///tmp/project/src/main/Toto.java',
+      uri: mainFileUri.toString(),
       languageId: 'java',
       version: 1,
       text: 'public class Toto {}'
@@ -103,7 +116,7 @@ async function testLanguageClient (
   // ... and expect the changed to be sent to the server
   expect(await waitClientNotification(connection.onDidChangeTextDocument)).toEqual({
     textDocument: {
-      uri: 'file:///tmp/project/src/main/Toto.java',
+      uri: mainFileUri.toString(),
       version: 2
     },
     contentChanges: [{
@@ -116,29 +129,18 @@ async function testLanguageClient (
     }]
   })
 
-  if (!automaticTextDocumentUpdate) {
-    // expect the document to being saved after 500ms
-    await Promise.all([
-      waitClientNotification(connection.onWillSaveTextDocument),
-      waitClientRequest<SaveTextDocumentParams, void, never>(handler => connection.onRequest(saveTextDocumentRequestType, handler)).then(([params, sendResponse]) => {
-        sendResponse()
-        return params
-      }),
-      waitClientNotification(connection.onDidSaveTextDocument)
-    ])
-  } else {
-    // wait 1sec to be sure no request is sent during this interval
-    await new Promise(resolve => setTimeout(resolve, 1000))
-  }
+  // wait 1sec to be sure no request is sent during this interval
+  await new Promise(resolve => setTimeout(resolve, 1000))
 
   // Test a completion request
   const completionRequestPromise = waitClientRequest(connection.onCompletion)
   editor.setPosition(new monaco.Position(1, 20))
   editor.trigger('me', 'editor.action.triggerSuggest', {})
+  editor.focus()
 
   const [completionRequest, sendCompletionRequestResponse] = await completionRequestPromise
   expect(completionRequest).toEqual({
-    textDocument: { uri: 'file:///tmp/project/src/main/Toto.java' },
+    textDocument: { uri: mainFileUri.toString() },
     position: { line: 0, character: 19 },
     context: {
       triggerKind: CompletionTriggerKind.Invoked,
@@ -149,13 +151,14 @@ async function testLanguageClient (
 
   // Test a hover request
   const hoverRequestPromise = waitClientRequest(connection.onHover)
-  await editor.getAction('editor.action.showHover').run()
+  await editor.getAction('editor.action.showHover')!.run()
   const [, sendHoverRequestResponse] = await hoverRequestPromise
   sendHoverRequestResponse(null)
 
   // Test go to declaration + getTextDocument
   const definitionRequestPromise = waitClientRequest(connection.onDefinition)
-  editor.getAction('editor.action.revealDefinition').run().catch(console.error)
+
+  void vscode.commands.executeCommand('editor.action.revealDefinition')
 
   const [, sendDefinitionRequestResponse] = await definitionRequestPromise
   sendDefinitionRequestResponse({
@@ -164,13 +167,13 @@ async function testLanguageClient (
   })
 
   const editorOpenDeferred = pDefer<monaco.editor.IStandaloneCodeEditor>()
-  const editorHandlerDisposable = registerEditorOpenHandler(async (model) => {
+  const editorHandlerDisposable = registerEditorOpenHandler(async (modelRef) => {
     // do nothing
     const editor = createEditor(document.createElement('div'), {
-      model
+      model: modelRef.object.textEditorModel
     })
     editor.onDidDispose(() => {
-      model.dispose()
+      modelRef.dispose()
     })
     setTimeout(() => {
       editorOpenDeferred.resolve(editor)
@@ -185,12 +188,15 @@ async function testLanguageClient (
       uri: 'file:///tmp/project/src/main/Otherfile.java'
     }
   })
+
+  const openNotificationPromise = waitClientNotification(connection.onDidOpenTextDocument)
+
   sendGetDocumentRequestResponse({
     text: 'other file content'
   })
 
   // Expect the model to be open
-  expect(await waitClientNotification(connection.onDidOpenTextDocument)).toEqual({
+  expect(await openNotificationPromise).toEqual({
     textDocument: {
       uri: 'file:///tmp/project/src/main/Otherfile.java',
       languageId: 'java',
@@ -209,16 +215,48 @@ async function testLanguageClient (
     }
   })
 
+  const savePromise = modelRef.object.save()
+
+  // Expect the model to be saved
+  const willSavePromise = waitClientNotification(connection.onWillSaveTextDocument)
+  const saveRequestPromise = waitClientRequest(handler => connection.onRequest(saveTextDocumentRequestType, handler))
+  const didSavePromise = waitClientNotification(connection.onDidSaveTextDocument)
+
+  expect(await willSavePromise).toEqual({
+    textDocument: {
+      uri: mainFileUri.toString()
+    },
+    reason: vscode.TextDocumentSaveReason.Manual
+  })
+  const [saveRequest, sendSaveRequestResponse] = await saveRequestPromise
+  expect(await saveRequest).toEqual({
+    textDocument: {
+      uri: mainFileUri.toString(),
+      text: modelRef.object.textEditorModel!.getValue()
+    }
+  })
+  sendSaveRequestResponse(null)
+
+  expect(await didSavePromise).toEqual({
+    textDocument: {
+      uri: mainFileUri.toString()
+    }
+  })
+
+  await savePromise
+
   editor.dispose()
-  model.dispose()
+  modelRef.dispose()
 
   // Expect the model to be closed
   expect(await waitClientNotification(connection.onDidCloseTextDocument)).toEqual({
     textDocument: {
-      uri: 'file:///tmp/project/src/main/Toto.java'
+      uri: mainFileUri.toString()
     }
   })
 
+  fileSystemDisposable.dispose()
+
   const disposePromise = languageClient.dispose()
 
   const [, sendShutdownResponse] = await waitClientRequest<void, void, void>((handler) => connection.onShutdown((token) => handler(undefined, token)))
@@ -232,6 +270,31 @@ async function testLanguageClient (
   expect(onRemainingNotification).not.toHaveBeenCalled()
 }
 
+beforeAll(async () => {
+  await initializePromise
+
+  // wait for java vscode extension to be ready as we use it to test the configuration update
+  const { getApi } = registerExtension({
+    name: 'test',
+    publisher: 'codingame',
+    version: '1.0.0',
+    engines: {
+      vscode: '*'
+    },
+    enabledApiProposals: ['extensionsAny']
+  }, ExtensionHostKind.LocalProcess)
+  const api = await getApi()
+
+  await new Promise<void>((resolve) => {
+    const disposable = vscode.extensions.onDidChange(() => {
+      if (api.extensions.allAcrossExtensionHosts.some(ext => ext.id === 'redhat.java')) {
+        disposable.dispose()
+        resolve()
+      }
+    })
+  })
+})
+
 describe('Infrastructure', () => {
   test('Codingame behavior without mutualization', async () => {
     await testLanguageClient(false, false)

src/tests/lifecycle.test.ts

@@ -1,10 +1,11 @@
-
+import { whenReady } from '@codingame/monaco-vscode-java-default-extension'
 import { TestInfrastructure } from './tools'
 import { createLanguageClientManager, getLanguageClientOptions } from '..'
 
 describe('Lifecycle', () => {
   test('Can dispose the language client manager immediately', async () => {
     const infrastructure = new TestInfrastructure(false, false, 2000)
+    await whenReady()
 
     const languageClient = createLanguageClientManager('java', infrastructure, {
       ...getLanguageClientOptions('java'),