@lvce-editor/shared-process 0.0.2

package/test/FileSystem.test.js

@@ -0,0 +1,294 @@
+import * as fs from 'node:fs'
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { setTimeout } from 'node:timers/promises'
+import * as FileSystem from '../src/parts/FileSystem/FileSystem.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+test('copy - file', async () => {
+  const tmpDir1 = await getTmpDir()
+  const source = join(tmpDir1, 'a.txt')
+  await writeFile(source, 'a')
+  const tmpDir2 = await getTmpDir()
+  const target = join(tmpDir2, 'a.txt')
+  await FileSystem.copy(source, target)
+  expect(await fs.promises.readFile(target, 'utf-8')).toBe('a')
+})
+
+test('copy - error - source does not exist', async () => {
+  const tmpDir1 = await getTmpDir()
+  const source = join(tmpDir1, 'a.txt')
+  const tmpDir2 = await getTmpDir()
+  const target = join(tmpDir2, 'a.txt')
+  await expect(FileSystem.copy(source, target)).rejects.toThrowError(
+    new Error(
+      `Failed to copy "${source}" to "${target}": ENOENT: no such file or directory, lstat '${source}'`
+    )
+  )
+})
+
+test('copy - to self', async () => {
+  const tmpDir1 = await getTmpDir()
+  const source = join(tmpDir1, 'a.txt')
+  await writeFile(source, 'a')
+  const target = source
+  await expect(FileSystem.copy(source, target)).rejects.toThrowError(
+    new Error(
+      `Failed to copy "${source}" to "${target}": Source and destination must not be the same.`
+    )
+  )
+})
+
+test('createFile', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'a.txt')
+  await FileSystem.createFile(testFile)
+  expect(await fs.promises.readFile(testFile, 'utf-8')).toBe('')
+})
+
+test('createFile - should throw error if file already exists', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'a.txt')
+  await fs.promises.writeFile(testFile, 'abc')
+  expect(FileSystem.createFile(testFile)).rejects.toThrowError(
+    `Failed to create file "${testFile}": EEXIST: file already exists, open '${testFile}'`
+  )
+})
+
+test('create folder', async () => {
+  const tmpDir = await getTmpDir()
+  const testFolder = join(tmpDir, 'a')
+  await FileSystem.createFolder(testFolder)
+  expect(await fs.promises.readdir(tmpDir)).toEqual(['a'])
+})
+
+test('create folder - should fail if folder already exists', async () => {
+  const tmpDir = await getTmpDir()
+  const testFolder = join(tmpDir, 'a')
+  await fs.promises.mkdir(testFolder)
+  expect(FileSystem.createFolder(testFolder)).rejects.toThrowError(
+    `Failed to create folder "${testFolder}": EEXIST: file already exists, mkdir '${testFolder}'`
+  )
+})
+
+// TODO test recursive create folder
+
+test('writeFile', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'writefile.txt')
+  expect(await FileSystem.exists(testFile)).toBe(false)
+  await FileSystem.writeFile(testFile, 'Hello World')
+  expect(await fs.promises.readFile(testFile, 'utf-8')).toBe('Hello World')
+})
+
+test('writeFile - nonexistent file', async () => {
+  const tmpDir = await getTmpDir()
+  const tmpFile = join(tmpDir, 'folder', 'non-existing-file.txt')
+  await expect(FileSystem.writeFile(tmpFile, 'Hello World')).rejects.toThrow(
+    `Failed to write to file "${tmpFile}": ENOENT`
+  )
+})
+
+test.skip('writeFile - parallel write on different files works', async () => {
+  // queue would be correct but slower
+
+  const tmpDir = await getTmpDir()
+  const testFile1 = join(tmpDir, 'writefile1.txt')
+  const testFile2 = join(tmpDir, 'writefile2.txt')
+  const testFile3 = join(tmpDir, 'writefile3.txt')
+  const testFile4 = join(tmpDir, 'writefile4.txt')
+  const testFile5 = join(tmpDir, 'writefile5.txt')
+
+  await Promise.all([
+    FileSystem.writeFile(testFile1, 'Hello World 1'),
+    FileSystem.writeFile(testFile2, 'Hello World 2'),
+    FileSystem.writeFile(testFile3, 'Hello World 3'),
+    FileSystem.writeFile(testFile4, 'Hello World 4'),
+    FileSystem.writeFile(testFile5, 'Hello World 5'),
+  ])
+  expect(fs.readFileSync(testFile1, 'utf-8')).toBe('Hello World 1')
+  expect(fs.readFileSync(testFile2, 'utf-8')).toBe('Hello World 2')
+  expect(fs.readFileSync(testFile3, 'utf-8')).toBe('Hello World 3')
+  expect(fs.readFileSync(testFile4, 'utf-8')).toBe('Hello World 4')
+  expect(fs.readFileSync(testFile5, 'utf-8')).toBe('Hello World 5')
+})
+
+test.skip('writeFile - parallel write on same files works and is sequentialized', async () => {
+  // queue would be correct but slower
+
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'writefile.txt')
+  await Promise.all([
+    FileSystem.writeFile(testFile, 'Hello World 1'),
+    FileSystem.writeFile(testFile, 'Hello World 2'),
+    setTimeout(10).then(() => FileSystem.writeFile(testFile, 'Hello World 3')),
+    FileSystem.writeFile(testFile, 'Hello World 4'),
+    setTimeout(10).then(() => FileSystem.writeFile(testFile, 'Hello World 5')),
+  ])
+  expect(fs.readFileSync(testFile, 'utf-8')).toBe('Hello World 5')
+})
+
+test('writeFile (string, error handling)', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'flushed.txt')
+  fs.mkdirSync(testFile) // this will trigger an error later because testFile is now a directory!
+  let expectedError
+  try {
+    await FileSystem.writeFile(testFile, 'Hello World')
+  } catch (error) {
+    expectedError = error
+  }
+  expect(expectedError).toBeDefined()
+})
+
+test('ensureFile - created parent folders recursively', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'a', 'b', 'c', 'd', 'writefile.txt')
+  expect(await FileSystem.exists(testFile)).toBe(false)
+  await FileSystem.ensureFile(testFile, 'Hello World')
+  expect(await fs.promises.readFile(testFile, 'utf-8')).toBe('Hello World')
+})
+
+test('remove', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'file-to-be-removed.txt')
+  await fs.promises.writeFile(testFile, '')
+  await FileSystem.remove(testFile)
+  expect(fs.existsSync(testFile)).toBe(false)
+})
+
+test('remove - non-existing file', async () => {
+  const tmpDir = await getTmpDir()
+  const testFile = join(tmpDir, 'non-existing.txt')
+  await FileSystem.remove(testFile)
+})
+
+test('rename', async () => {
+  const tmpDir = await getTmpDir()
+  const oldPath = join(tmpDir, 'file-to-be-moved.txt')
+  const newPath = join(tmpDir, 'file-has-been-moved.txt')
+  await fs.promises.writeFile(oldPath, '')
+  await FileSystem.rename(oldPath, newPath)
+  expect(fs.existsSync(oldPath)).toBe(false)
+  expect(fs.existsSync(newPath)).toBe(true)
+})
+
+test('rename - non existing old path', async () => {
+  const tmpDir = await getTmpDir()
+  const oldPath = join(tmpDir, 'non-existing.txt')
+  const newPath = join(tmpDir, 'file-has-been-moved.txt')
+  await expect(FileSystem.rename(oldPath, newPath)).rejects.toThrow(
+    `Failed to rename "${oldPath}" to "${newPath}": ENOENT`
+  )
+})
+
+test('rename - new path in non-existing nested directory', async () => {
+  const tmpDir = await getTmpDir()
+  const oldPath = join(tmpDir, 'file-to-be-moved.txt')
+  const newPath = join(tmpDir, 'nested/nested/nested/file-has-been-moved.txt')
+  await fs.promises.writeFile(oldPath, '')
+  await expect(FileSystem.rename(oldPath, newPath)).rejects.toThrow(
+    `Failed to rename "${oldPath}" to "${newPath}": ENOENT:`
+  )
+})
+
+const waitForWatcherReady = async (watcher) => {
+  await new Promise((resolve) => {
+    watcher.once('ready', async () => {
+      // try to fix tests on macos through timeout :/
+      await setTimeout(100)
+      resolve(undefined)
+    })
+  })
+}
+
+// TODO all file watcher tests are very flaky on macos/windows ci
+
+test.skip('watch - add', async () => {
+  const tmpDir = await getTmpDir()
+  const watcher = FileSystem.watch(tmpDir)
+  const events = []
+  let _resolve
+  let i = 0
+  await waitForWatcherReady(watcher)
+  watcher.on('all', (...args) => {
+    events.push([args[0], args[1]])
+    i++
+    if (i === 2) {
+      _resolve()
+    }
+  })
+  const resolvePromise = new Promise((resolve) => {
+    _resolve = resolve
+  })
+  await fs.promises.writeFile(join(tmpDir, 'abc.txt'), 'sample text')
+  await fs.promises.writeFile(join(tmpDir, 'def.txt'), 'sample text')
+  await resolvePromise
+  await setTimeout(1000)
+  expect(events).toEqual([
+    ['add', join(tmpDir, 'abc.txt')],
+    ['add', join(tmpDir, 'def.txt')],
+  ])
+  watcher.close()
+})
+
+test.skip('watch - remove', async () => {
+  const tmpDir = await getTmpDir()
+  await fs.promises.writeFile(join(tmpDir, 'abc.txt'), 'sample text')
+  const watcher = FileSystem.watch(tmpDir)
+  const events = []
+  let _resolve
+  let i = 0
+  await waitForWatcherReady(watcher)
+  watcher.on('all', (...args) => {
+    events.push([args[0], args[1]])
+    i++
+    if (i === 1) {
+      _resolve()
+    }
+  })
+  const resolvePromise = new Promise((resolve) => {
+    _resolve = resolve
+  })
+  await fs.promises.rm(join(tmpDir, 'abc.txt'))
+  await resolvePromise
+  await setTimeout(1000)
+  expect(events).toEqual([['unlink', join(tmpDir, 'abc.txt')]])
+  watcher.close()
+})
+
+test.skip('watch - rename', async () => {
+  const tmpDir = await getTmpDir()
+  await fs.promises.writeFile(join(tmpDir, 'abc.txt'), 'sample text')
+  const watcher = FileSystem.watch(tmpDir)
+  const events = []
+  let _resolve
+  let i = 0
+  await waitForWatcherReady(watcher)
+  watcher.on('all', (...args) => {
+    events.push([args[0], args[1]])
+    i++
+    if (i === 2) {
+      _resolve()
+    }
+  })
+  const resolvePromise = new Promise((resolve) => {
+    _resolve = resolve
+  })
+  await fs.promises.rename(join(tmpDir, 'abc.txt'), join(tmpDir, 'def.txt'))
+  await resolvePromise
+  await setTimeout(1000)
+  expect(events).toEqual([
+    ['add', join(tmpDir, 'def.txt')],
+    ['unlink', join(tmpDir, 'abc.txt')],
+  ])
+  watcher.close()
+})
+
+test('getPathSeparator', () => {
+  expect(FileSystem.getPathSeparator()).toEqual(expect.any(String))
+})

package/test/Json.test.js

@@ -0,0 +1,25 @@
+import * as Json from '../src/parts/Json/Json.js'
+
+test('parse', async () => {
+  expect(await Json.parse('{ "x": 42 }')).toEqual({ x: 42 })
+})
+
+test('parse - syntax error', async () => {
+  await expect(
+    Json.parse('{ "x" 42 }', '/test/some-file.txt')
+  ).rejects.toThrowError(
+    /^Unexpected number in JSON at position 6 while parsing/
+  )
+})
+
+test('stringify', () => {
+  expect(Json.stringify({ x: 42 })).toBe(`{
+  "x": 42
+}
+`)
+})
+
+test('stringify - invalid parameter', () => {
+  expect(Json.stringify(Symbol('a'))).toBe(`undefined
+`)
+})

package/test/Native.test.js

@@ -0,0 +1,31 @@
+import { jest } from '@jest/globals'
+
+jest.unstable_mockModule('open', () => {
+  return {
+    default: jest.fn(() => {
+      throw new Error('not implemented')
+    }),
+  }
+})
+
+const open = await import('open')
+const Native = await import('../src/parts/Native/Native.js')
+
+test('openFolder', async () => {
+  // @ts-ignore
+  open.default.mockImplementation(() => {})
+  await Native.openFolder('/test')
+  expect(open.default).toHaveBeenCalledTimes(1)
+  expect(open.default).toHaveBeenCalledWith('/test')
+})
+
+test('openFolder - error', async () => {
+  // @ts-ignore
+  open.default.mockImplementation(() => {
+    throw new TypeError('x is not a function')
+  })
+  // TODO should say that is is a TypeError
+  await expect(Native.openFolder('/test')).rejects.toThrowError(
+    new Error('Failed to open /test: x is not a function')
+  )
+})

package/test/OutputChannel.test.js

@@ -0,0 +1,68 @@
+import { createWriteStream } from 'node:fs'
+import * as fs from 'node:fs/promises'
+import { mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { jest } from '@jest/globals'
+import waitForExpect from 'wait-for-expect'
+import * as OutputChannel from '../src/parts/OutputChannel/OutputChannel.js'
+import * as Platform from '../src/parts/Platform/Platform.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+if (Platform.isWindows()) {
+  test.todo('output channel test')
+} else {
+  test('writing to channel via stream', async () => {
+    const tmpDir = await getTmpDir()
+    await fs.writeFile(join(tmpDir, 'log.txt'), '')
+    const onData = jest.fn()
+    const state = OutputChannel.open(join(tmpDir, 'log.txt'), onData)
+    const writeStream = createWriteStream(join(tmpDir, 'log.txt'))
+    writeStream.write('a')
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenNthCalledWith(1, 'a')
+    })
+    writeStream.write('b')
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenNthCalledWith(2, 'b')
+    })
+    writeStream.write('c')
+    writeStream.close()
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenNthCalledWith(3, 'c')
+    })
+    OutputChannel.dispose(state)
+  })
+
+  test('writing to channel', async () => {
+    const tmpDir = await getTmpDir()
+    await fs.writeFile(join(tmpDir, 'log.txt'), '')
+    const onData = jest.fn()
+    const state = OutputChannel.open(join(tmpDir, 'log.txt'), onData)
+    await fs.writeFile(join(tmpDir, 'log.txt'), 'abc\n')
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith('abc\n')
+    })
+    OutputChannel.dispose(state)
+  })
+
+  test('non-existing file', async () => {
+    const tmpDir = await getTmpDir()
+    const onData = jest.fn()
+    const onError = jest.fn()
+    const state = OutputChannel.open(
+      join(tmpDir, 'non-existing-file.txt'),
+      onData,
+      onError
+    )
+    expect(onError).toHaveBeenCalledWith(
+      expect.stringMatching(
+        /^Error: ENOENT: no such file or directory, access /
+      )
+    )
+    OutputChannel.dispose(state)
+  })
+}

package/test/Path.test.js

@@ -0,0 +1,17 @@
+import * as Path from '../src/parts/Path/Path.js'
+
+test('join', () => {
+  if (process.platform === 'win32') {
+    expect(Path.join('test', 'my-file.txt')).toBe('test\\my-file.txt')
+  } else {
+    expect(Path.join('test', 'my-file.txt')).toBe('test/my-file.txt')
+  }
+})
+
+test('dirname', () => {
+  if (process.platform === 'win32') {
+    expect(Path.dirname('test\\my-file.txt')).toBe('test')
+  } else {
+    expect(Path.dirname('test/my-file.txt')).toBe('test')
+  }
+})

package/test/Platform.test.js

@@ -0,0 +1,61 @@
+import * as Platform from '../src/parts/Platform/Platform.js'
+
+test('isWindows', () => {
+  expect(Platform.isWindows()).toEqual(expect.any(Boolean))
+})
+
+test('isMacOs', () => {
+  expect(Platform.isMacOs()).toEqual(expect.any(Boolean))
+})
+
+test('getDataDir', () => {
+  expect(Platform.getDataDir()).toEqual(expect.any(String))
+})
+
+test('getConfigDir', () => {
+  expect(Platform.getConfigDir()).toEqual(expect.any(String))
+})
+
+test('getCacheDir', () => {
+  expect(Platform.getCacheDir()).toEqual(expect.any(String))
+})
+
+test('getHomeDir', () => {
+  expect(Platform.getHomeDir()).toEqual(expect.any(String))
+})
+
+test('getCachedExtensionsPath', () => {
+  expect(Platform.getCachedExtensionsPath()).toEqual(expect.any(String))
+})
+
+test('getBuiltinExtensionsPath', () => {
+  expect(Platform.getBuiltinExtensionsPath()).toEqual(expect.any(String))
+})
+
+test('getDisabledExtensionsPath', () => {
+  expect(Platform.getDisabledExtensionsPath()).toEqual(expect.any(String))
+})
+
+test('getMarketplaceUrl', () => {
+  expect(Platform.getMarketplaceUrl()).toEqual(expect.any(String))
+})
+
+test('getDesktop', () => {
+  expect(Platform.getDesktop()).toEqual(expect.any(String))
+})
+
+test('getPathSeparator', () => {
+  expect(Platform.getPathSeparator()).toEqual(expect.any(String))
+})
+
+test('getLogsDir', () => {
+  expect(Platform.getLogsDir()).toEqual(expect.any(String))
+})
+
+test('getUserSettingsPath', () => {
+  expect(Platform.getUserSettingsPath()).toEqual(expect.any(String))
+})
+
+test('getRecentlyOpenedPath', () => {
+  expect(Platform.getRecentlyOpenedPath()).toEqual(expect.any(String))
+})

package/test/Preferences.test.js

@@ -0,0 +1,140 @@
+import { mkdtemp, readFile, writeFile, mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import * as Platform from '../src/parts/Platform/Platform.js'
+import * as Preferences from '../src/parts/Preferences/Preferences.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+// test.skip('getAll - no preferences exist', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   expect(await Preferences.getAll()).toEqual({
+//     'editor.fontFamily': "'Fira Code'",
+//     'editor.fontSize': 14,
+//     'extensions.autoUpdate': true,
+//     'workbench.activityBar.visible': true,
+//     'workbench.colorTheme': 'slime',
+//     'workbench.iconTheme': 'vscode-icons',
+//     'workbench.sideBar.visible': true,
+//   })
+// })
+
+// test('set - no preferences exist', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   await Preferences.set('sample-key', 'sample-value')
+//   expect(await readFile(join(tmpDir, 'settings.json'), 'utf-8')).toBe(`{
+//   \"sample-key\": \"sample-value\"
+// }
+// `)
+// })
+
+// test('set - no preferences exist in nested folder', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getConfigDir = () => {
+//     return join(tmpDir, 'my-app', 'nested')
+//   }
+//   await Preferences.set('sample-key', 'sample-value')
+//   expect(
+//     await readFile(join(tmpDir, 'my-app', 'nested', 'settings.json'), 'utf-8')
+//   ).toBe(`{
+//   \"sample-key\": \"sample-value\"
+// }
+// `)
+// })
+
+// test('set - preferences exist', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   await writeFile(
+//     join(tmpDir, 'settings.json'),
+//     JSON.stringify({
+//       'key-0': '0',
+//     }) + '\n'
+//   )
+//   await Preferences.set('sample-key', 'sample-value')
+//   expect(await readFile(join(tmpDir, 'settings.json'), 'utf-8')).toBe(`{
+//   \"key-0\": \"0\",
+//   \"sample-key\": \"sample-value\"
+// }
+// `)
+// })
+
+// test.skip('set - preferences exist but are invalid json', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   const settingsPath = join(tmpDir, 'settings.json')
+//   await writeFile(settingsPath, `"`)
+//   // TODO should handle error gracefully
+//   await expect(
+//     Preferences.set('sample-key', 'sample-value')
+//   ).rejects.toThrowError(
+//     new Error(
+//       `Unexpected end of JSON input while parsing "\\"" in ${settingsPath}`
+//     )
+//   )
+// })
+
+test('getAll - error', async () => {
+  const tmpDir = await getTmpDir()
+  Platform.state.getAppDir = () => {
+    return tmpDir
+  }
+  await expect(Preferences.getAll()).rejects.toThrowError(
+    /^Failed to get all preferences: Failed to load default preferences: ENOENT/
+  )
+})
+
+// test('getDefaultPreferences - error', async () => {
+//   const tmpDir = await getTmpDir()
+//   Platform.state.getAppDir = () => {
+//     return tmpDir
+//   }
+//   await expect(Preferences.getDefaultPreferences()).rejects.toThrowError(
+//     /^Failed to load default preferences: ENOENT/
+//   )
+// })
+
+// test('set - error', async () => {
+//   const tmpDir = await getTmpDir()
+//   await mkdir(join(tmpDir, 'settings.json'))
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   await expect(Preferences.set('x', 42)).rejects.toThrowError(
+//     /^Failed to set key in user settings: failed to get user preferences: EISDIR/
+//   )
+// })
+
+// test('getUserSettingsContent - error', async () => {
+//   const tmpDir = await getTmpDir()
+//   await mkdir(join(tmpDir, 'settings.json'))
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   await expect(Preferences.getUserSettingsContent()).rejects.toThrowError(
+//     /^Failed to load user settings: EISDIR/
+//   )
+// })
+
+// test('setUserSettingsContent - error', async () => {
+//   const tmpDir = await getTmpDir()
+//   await mkdir(join(tmpDir, 'settings.json'))
+//   Platform.state.getConfigDir = () => {
+//     return tmpDir
+//   }
+//   await expect(Preferences.setUserSettingsContent('')).rejects.toThrowError(
+//     /^Failed to write to user settings file: EISDIR/
+//   )
+// })

package/test/Process.test.js

@@ -0,0 +1,9 @@
+import * as Process from '../src/parts/Process/Process.js'
+
+test('crash', () => {
+  expect(Process.crash).toThrow()
+})
+
+test('crashAsync', () => {
+  expect(Process.crashAsync).rejects.toThrow()
+})

package/test/RgPath.test.js

@@ -0,0 +1,5 @@
+import * as RgPath from '../src/parts/RgPath/RgPath.js'
+
+test('rgPath', () => {
+  expect(RgPath.rgPath).toEqual(expect.any(String))
+})