@lvce-editor/shared-process 0.0.2

package/test/Callback.test.js

@@ -0,0 +1,42 @@
+import { jest } from '@jest/globals'
+import * as Callback from '../src/parts/Callback/Callback.js'
+
+beforeEach(() => {
+  Callback.state.id = 0
+})
+
+test('register / resolve', () => {
+  const resolve = jest.fn()
+  const reject = jest.fn()
+  const id = Callback.register(resolve, reject)
+  Callback.resolve(id)
+  expect(resolve).toHaveBeenCalledTimes(1)
+  Callback.resolve(id)
+  expect(resolve).toHaveBeenCalledTimes(2)
+  Callback.unregister(id)
+})
+
+test('register / resolve - nonexisting id', () => {
+  console.warn = jest.fn()
+  Callback.resolve(-1)
+  expect(console.warn).toHaveBeenCalledWith(
+    'callback -1 may already be disposed'
+  )
+})
+
+test('register / reject', () => {
+  const resolve = jest.fn()
+  const reject = jest.fn()
+  const id = Callback.register(resolve, reject)
+  Callback.reject(id)
+  expect(reject).toHaveBeenCalledTimes(1)
+  Callback.unregister(id)
+})
+
+test('register / reject - nonexisting id', () => {
+  console.warn = jest.fn()
+  Callback.reject(-1)
+  expect(console.warn).toHaveBeenCalledWith(
+    'callback (rejected) -1 may already be disposed'
+  )
+})

package/test/ClipBoard.test.js

@@ -0,0 +1,105 @@
+import { jest } from '@jest/globals'
+
+jest.unstable_mockModule('../src/parts/Exec/Exec.js', () => ({
+  exec: jest.fn(() => {
+    throw new Error('not implemented')
+  }),
+}))
+
+jest.unstable_mockModule('../src/parts/Platform/Platform.js', () => ({
+  getDesktop: jest.fn(() => {
+    throw new Error('not implemented')
+  }),
+}))
+
+const Exec = await import('../src/parts/Exec/Exec.js')
+const Platform = await import('../src/parts/Platform/Platform.js')
+const ClipBoard = await import('../src/parts/ClipBoard/ClipBoard.js')
+
+afterEach(() => {
+  jest.resetAllMocks()
+})
+
+test('readFiles - gnome - copied files', async () => {
+  // @ts-ignore
+  Platform.getDesktop.mockImplementation(() => 'gnome')
+  // @ts-ignore
+  Exec.exec.mockImplementation(() => {
+    return {
+      stdout: `copy
+file:///test/my-folder`,
+      stderr: '',
+    }
+  })
+
+  expect(await ClipBoard.readFiles()).toEqual({
+    source: 'gnomeCopiedFiles',
+    type: 'copy',
+    files: ['/test/my-folder'],
+  })
+})
+
+test('readFiles - gnome - target not available', async () => {
+  // @ts-ignore
+  Platform.getDesktop.mockImplementation(() => 'gnome')
+  // @ts-ignore
+  Exec.exec.mockImplementation(() => {
+    const error = new Error('command failed with exit code 1')
+    // @ts-ignore
+    error.stderr = 'Error: target x-special/gnome-copied-files not available'
+    throw error
+  })
+  expect(await ClipBoard.readFiles()).toBe(undefined)
+})
+
+test('writeFiles - gnome - copied files', async () => {
+  // @ts-ignore
+  Platform.getDesktop.mockImplementation(() => 'gnome')
+  // @ts-ignore
+  Exec.exec.mockImplementation(async () => {
+    return { stdout: '', stderr: '' }
+  })
+  await ClipBoard.writeFiles('copy', ['/test/my-folder'])
+  expect(Exec.exec).toHaveBeenCalledTimes(3)
+  expect(Exec.exec).toHaveBeenNthCalledWith(
+    1,
+    'xclip',
+    ['-i', '-selection', 'clipboard', '-t', 'x-special/gnome-copied-files'],
+    {
+      input: `copy
+file:///test/my-folder`,
+    }
+  )
+  expect(Exec.exec).toHaveBeenNthCalledWith(
+    2,
+    'xclip',
+    ['-i', '-selection', 'clipboard', '-t', 'text/uri-list'],
+    {
+      input: 'file:///test/my-folder',
+    }
+  )
+  expect(Exec.exec).toHaveBeenNthCalledWith(
+    3,
+    'xclip',
+    ['-i', '-selection', 'clipboard', '-t', 'text/plain'],
+    {
+      input: '/test/my-folder',
+    }
+  )
+})
+
+test('writeFiles - unsupported desktop', async () => {
+  // @ts-ignore
+  Platform.getDesktop.mockImplementation(() => 'test-desktop')
+  // @ts-ignore
+  Exec.exec.mockImplementation(async () => {
+    return { stdout: '', stderr: '' }
+  })
+  const consoleSpy = jest.spyOn(console, 'info')
+  await ClipBoard.writeFiles('copy', ['/test/my-folder'])
+  expect(Exec.exec).not.toHaveBeenCalled()
+  expect(consoleSpy).toHaveBeenCalledTimes(1)
+  expect(consoleSpy).toHaveBeenCalledWith(
+    'writing files to clipboard is not yet supported on test-desktop'
+  )
+})

package/test/Credentials.test.js

@@ -0,0 +1,147 @@
+import { jest } from '@jest/globals'
+
+// TODO actual keytar tests are failing in ci due to dbus error
+// would be better to have tests using actual keytar
+
+const serviceName = `Test 123`
+
+jest.unstable_mockModule('keytar', () => {
+  return {
+    default: {
+      deletePassword: jest.fn(() => {
+        throw new Error('not implemented')
+      }),
+      findCredentials: jest.fn(() => {
+        throw new Error('not implemented')
+      }),
+      findPassword: jest.fn(() => {
+        throw new Error('not implemented')
+      }),
+      getPassword: jest.fn(() => {
+        throw new Error('not implemented')
+      }),
+      setPassword: jest.fn(() => {
+        throw new Error('not implemented')
+      }),
+    },
+  }
+})
+
+const KeyTar = await import('keytar')
+const Credentials = await import('../src/parts/Credentials/Credentials.js')
+
+test('deletePassword', async () => {
+  // @ts-ignore
+  KeyTar.default.deletePassword.mockImplementation(() => {})
+  await Credentials.deletePassword(serviceName, 'foo')
+  expect(KeyTar.default.deletePassword).toHaveBeenCalledTimes(1)
+  expect(KeyTar.default.deletePassword).toHaveBeenCalledWith(serviceName, 'foo')
+})
+
+test('deletePassword - error', async () => {
+  // @ts-ignore
+  KeyTar.default.deletePassword.mockImplementation(() => {
+    throw new Error('"dbus-launch" (No such file or directory)')
+  })
+
+  await expect(
+    Credentials.deletePassword(serviceName, 'foo')
+  ).rejects.toThrowError(
+    new Error(
+      `Failed to delete password from service ${serviceName}: "dbus-launch" (No such file or directory)`
+    )
+  )
+})
+
+test('findCredentials', async () => {
+  // @ts-ignore
+  KeyTar.default.findCredentials.mockImplementation(() => {
+    return [{ account: 'abc', password: 'abc' }]
+  })
+  expect(await Credentials.findCredentials(serviceName)).toEqual([
+    {
+      account: 'abc',
+      password: 'abc',
+    },
+  ])
+})
+
+test('findCredentials - error', async () => {
+  // @ts-ignore
+  KeyTar.default.findCredentials.mockImplementation(() => {
+    throw new Error('"dbus-launch" (No such file or directory)')
+  })
+  await expect(Credentials.findCredentials(serviceName)).rejects.toThrowError(
+    new Error(
+      `Failed to find credentials from service ${serviceName}: "dbus-launch" (No such file or directory)`
+    )
+  )
+})
+
+test('findPassword', async () => {
+  // @ts-ignore
+  KeyTar.default.findPassword.mockImplementation(() => {
+    return 'bar'
+  })
+  expect(await Credentials.findPassword(serviceName)).toBe('bar')
+})
+
+test('findPassword - error', async () => {
+  // @ts-ignore
+  KeyTar.default.findPassword.mockImplementation(() => {
+    throw new Error('"dbus-launch" (No such file or directory)')
+  })
+  await expect(Credentials.findPassword(serviceName)).rejects.toThrowError(
+    new Error(
+      `Failed to find password from service ${serviceName}: "dbus-launch" (No such file or directory)`
+    )
+  )
+})
+
+test('getPassword', async () => {
+  // @ts-ignore
+  KeyTar.default.getPassword.mockImplementation(() => {
+    return 'bar'
+  })
+  expect(await Credentials.getPassword(serviceName, 'foo')).toBe('bar')
+})
+
+test('getPassword - error', async () => {
+  // @ts-ignore
+  KeyTar.default.getPassword.mockImplementation(() => {
+    throw new Error('"dbus-launch" (No such file or directory)')
+  })
+  await expect(
+    Credentials.getPassword(serviceName, 'foo')
+  ).rejects.toThrowError(
+    new Error(
+      `Failed to get password from service ${serviceName}: "dbus-launch" (No such file or directory)`
+    )
+  )
+})
+
+test('setPassword', async () => {
+  // @ts-ignore
+  KeyTar.default.setPassword.mockImplementation(() => {})
+  await Credentials.setPassword(serviceName, 'foo', 'bar')
+  expect(KeyTar.default.setPassword).toHaveBeenCalledTimes(1)
+  expect(KeyTar.default.setPassword).toHaveBeenCalledWith(
+    serviceName,
+    'foo',
+    'bar'
+  )
+})
+
+test('setPassword - error', async () => {
+  // @ts-ignore
+  KeyTar.default.setPassword.mockImplementation(() => {
+    throw new Error('"dbus-launch" (No such file or directory)')
+  })
+  await expect(
+    Credentials.setPassword(serviceName, 'foo', 'bar')
+  ).rejects.toThrowError(
+    new Error(
+      `Failed to set password for service ${serviceName}: "dbus-launch" (No such file or directory)`
+    )
+  )
+})

package/test/Developer.test.js

@@ -0,0 +1,34 @@
+import { access } from 'node:fs/promises'
+import { jest } from '@jest/globals'
+import * as Developer from '../src/parts/Developer/Developer.js'
+
+const exists = async (path) => {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+test.skip('createHeapSnapshot', async () => {
+  Date.now = () => 123456
+  // TODO jest esm mock not working https://github.com/facebook/jest/issues/10025
+  jest.mock('v8', () => ({
+    getHeapSnapshot() {
+      return ''
+    },
+  }))
+  await Developer.createHeapSnapshot()
+  expect(await exists('/tmp/vscode-123456.heapsnapshot')).toBe(true)
+})
+
+test('sharedProcessMemoryUsage', () => {
+  expect(Developer.sharedProcessMemoryUsage()).toEqual({
+    arrayBuffers: expect.any(Number),
+    external: expect.any(Number),
+    heapTotal: expect.any(Number),
+    heapUsed: expect.any(Number),
+    rss: expect.any(Number),
+  })
+})

package/test/Electron.test.js

@@ -0,0 +1,93 @@
+import { jest } from '@jest/globals'
+import * as Electron from '../src/parts/Electron/Electron.js'
+
+test('toggleDevtools', () => {
+  Electron.state.send = jest.fn()
+  Electron.toggleDevtools()
+  expect(Electron.state.send).toHaveBeenCalledWith({
+    jsonrpc: '2.0',
+    method: 6523,
+    params: [],
+  })
+})
+
+test('windowMinimize', () => {
+  Electron.state.send = jest.fn()
+  Electron.windowMinimize()
+  expect(Electron.state.send).toHaveBeenCalledWith({
+    jsonrpc: '2.0',
+    method: 6521,
+    params: [],
+  })
+})
+
+test('windowMaximize', () => {
+  Electron.state.send = jest.fn()
+  Electron.windowMaximize()
+  expect(Electron.state.send).toHaveBeenCalledWith({
+    jsonrpc: '2.0',
+    method: 6522,
+    params: [],
+  })
+})
+
+test('windowUnmaximize', () => {
+  Electron.state.send = jest.fn()
+  Electron.windowUnmaximize()
+  expect(Electron.state.send).toHaveBeenCalledWith({
+    jsonrpc: '2.0',
+    method: 6524,
+    params: [],
+  })
+})
+
+test('windowClose', () => {
+  Electron.state.send = jest.fn()
+  Electron.windowClose()
+  expect(Electron.state.send).toBeCalledWith({
+    jsonrpc: '2.0',
+    method: 6525,
+    params: [],
+  })
+})
+
+test('windowReload', () => {
+  Electron.state.send = jest.fn()
+  Electron.windowReload()
+  expect(Electron.state.send).toBeCalledWith({
+    jsonrpc: '2.0',
+    method: 6526,
+    params: [],
+  })
+})
+
+test('about', () => {
+  Electron.state.send = jest.fn()
+  Electron.about()
+  expect(Electron.state.send).toBeCalledWith({
+    jsonrpc: '2.0',
+    method: 20001,
+    params: [],
+  })
+})
+
+test('showOpenDialog', () => {
+  Electron.state.send = jest.fn()
+  Electron.showOpenDialog()
+  expect(Electron.state.send).toBeCalledWith({
+    jsonrpc: '2.0',
+    method: 20100,
+    params: [],
+    id: expect.any(Number),
+  })
+})
+
+test('crashMainProcess', () => {
+  Electron.state.send = jest.fn()
+  Electron.crashMainProcess()
+  expect(Electron.state.send).toBeCalledWith({
+    jsonrpc: '2.0',
+    method: 7723,
+    params: [],
+  })
+})

package/test/Error.test.js

@@ -0,0 +1,16 @@
+import * as Error from '../src/parts/Error/Error.js'
+
+// TODO don't shim global Error object
+
+// TODO
+test('OperationalError', () => {
+  const error = globalThis.Error('enoent: no such file')
+  const operationalError = new Error.OperationalError({
+    cause: error,
+    code: 'E_FAILED_TO_READ_FILE',
+    message: 'Failed to read file',
+  })
+  expect(operationalError.toString()).toBe(
+    'OperationalError: Failed to read file: enoent: no such file'
+  )
+})

package/test/Exec.test.js

@@ -0,0 +1,25 @@
+import * as Exec from '../src/parts/Exec/Exec.js'
+
+test('exec - stdout', async () => {
+  expect(
+    await Exec.exec('node', ['-e', "process.stdout.write('a')"], {})
+  ).toEqual({
+    stderr: '',
+    stdout: 'a',
+  })
+})
+
+test('exec - stderr', async () => {
+  expect(
+    await Exec.exec('node', ['-e', "process.stderr.write('b')"], {})
+  ).toEqual({
+    stderr: 'b',
+    stdout: '',
+  })
+})
+
+test('exec - error', async () => {
+  await expect(Exec.exec('node', ['-e', 'oops'], {})).rejects.toThrowError(
+    'Command failed with exit code 1: node -e oops'
+  )
+})

package/test/ExtensionHost.test.js

@@ -0,0 +1,127 @@
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import * as ExtensionHost from '../src/parts/ExtensionHost/ExtensionHost.js'
+import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
+import * as Platform from '../src/parts/Platform/Platform.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+test.skip('start / stop', async () => {
+  await ExtensionHost.start()
+  ExtensionHost.stop()
+})
+
+// TODO test with mock extensions
+test.skip('activateAll', async () => {
+  const tmpDir1 = await getTmpDir()
+  const tmpDir2 = await getTmpDir()
+  ExtensionManagement.state.builtinExtensionsPath = tmpDir1
+  ExtensionManagement.state.extensionPath = tmpDir2
+  await ExtensionHost.start()
+  await ExtensionHost.activateAll()
+  await ExtensionHost.stop()
+})
+
+test('start - error - path not found', async () => {
+  Platform.state.getExtensionHostPath = () => {
+    return '/test'
+  }
+  const socket = {
+    on() {},
+  }
+  await expect(ExtensionHost.start(socket)).rejects.toThrowError(
+    new Error(
+      'Failed to start extension host: Extension Host exited with code 1'
+    )
+  )
+})
+
+test('start - error - path is a directory', async () => {
+  const tmpDir = await getTmpDir()
+  Platform.state.getExtensionHostPath = () => {
+    return tmpDir
+  }
+  const socket = {
+    on() {},
+  }
+  await mkdir(tmpDir, { recursive: true })
+  // TODO error message should include stderr of extension host
+  await expect(ExtensionHost.start(socket)).rejects.toThrowError(
+    new Error(
+      'Failed to start extension host: Extension Host exited with code 1'
+    )
+  )
+})
+
+test('start - error - syntax error', async () => {
+  const tmpDir = await getTmpDir()
+  const extensionHostPath = join(tmpDir, 'extensionHost.js')
+  await writeFile(extensionHostPath, '...')
+  Platform.state.getExtensionHostPath = () => {
+    return extensionHostPath
+  }
+  const socket = {
+    on() {},
+  }
+  // TODO error message should include stderr of extension host: SyntaxError: Unexpected end of input
+  await expect(ExtensionHost.start(socket)).rejects.toThrowError(
+    new Error(
+      'Failed to start extension host: Extension Host exited with code 1'
+    )
+  )
+})
+
+test('start - error - uncaught exception', async () => {
+  const tmpDir = await getTmpDir()
+  const extensionHostPath = join(tmpDir, 'extensionHost.js')
+  await writeFile(extensionHostPath, "throw new Error('oops')")
+  Platform.state.getExtensionHostPath = () => {
+    return extensionHostPath
+  }
+  const socket = {
+    on() {},
+  }
+  // TODO error message should include stderr of extension host: SyntaxError: Unexpected end of input
+  await expect(ExtensionHost.start(socket)).rejects.toThrowError(
+    new Error(
+      'Failed to start extension host: Extension Host exited with code 1'
+    )
+  )
+})
+
+test('start - error - custom exit code', async () => {
+  const tmpDir = await getTmpDir()
+  const extensionHostPath = join(tmpDir, 'extensionHost.js')
+  await writeFile(extensionHostPath, 'process.exit(123)')
+  Platform.state.getExtensionHostPath = () => {
+    return extensionHostPath
+  }
+  const socket = {
+    on() {},
+  }
+  await expect(ExtensionHost.start(socket)).rejects.toThrowError(
+    new Error(
+      'Failed to start extension host: Extension Host exited with code 123'
+    )
+  )
+})
+
+test('start - child process should be closed when socket immediately is closed', async () => {
+  const tmpDir = await getTmpDir()
+  const extensionHostPath = join(tmpDir, 'extensionHost.js')
+  await writeFile(extensionHostPath, 'process.on(`message`, ()=>{})')
+  Platform.state.getExtensionHostPath = () => {
+    return extensionHostPath
+  }
+  const socket = {
+    on(event, listener) {
+      if (event === 'close') {
+        listener()
+      }
+    },
+  }
+  await ExtensionHost.start(socket)
+})