@lvce-editor/shared-process 0.0.2 → 0.0.8

package/test/ExtensionManagement.test.js

@@ -1,408 +0,0 @@
-import { createReadStream, createWriteStream } from 'node:fs'
-import {
-  access,
-  mkdir,
-  mkdtemp,
-  readdir,
-  readFile,
-  rm,
-  writeFile,
-} from 'node:fs/promises'
-import http from 'node:http'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { pipeline } from 'node:stream/promises'
-import { constants, createBrotliCompress } from 'node:zlib'
-import getPort from 'get-port'
-import { jest } from '@jest/globals'
-import tar from 'tar-fs'
-import VError from 'verror'
-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-'))
-}
-
-const exists = async (path) => {
-  try {
-    await access(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * @param {string} inDir
- * @param {string} outFile
- */
-export const compress = async (inDir, outFile) => {
-  await mkdir(dirname(outFile), { recursive: true })
-  await pipeline(
-    tar.pack(inDir),
-    createBrotliCompress({
-      params: {
-        [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MIN_QUALITY,
-      },
-    }),
-    createWriteStream(outFile)
-  )
-}
-
-const createExtensionTarBr = async (files) => {
-  const folder = '/tmp/extension-test/test-author.test-extension'
-  await rm(folder, { force: true, recursive: true })
-  await mkdir(folder, { recursive: true })
-  for (const [filePath, content] of Object.entries(files)) {
-    await writeFile(`${folder}/${filePath}`, content)
-  }
-  await compress(folder, `${folder}.tar.br`)
-}
-
-let server
-let handler
-
-beforeAll(async () => {
-  const port = await getPort()
-  server = http.createServer((request, response) => {
-    handler(request, response)
-  })
-  await new Promise((resolve) => {
-    server.listen(port, () => {
-      resolve(undefined)
-    })
-  })
-  process.env.LVCE_MARKETPLACE_URL = `http://localhost:${port}`
-})
-
-afterAll(() => {
-  server.close()
-})
-
-afterEach(() => {
-  jest.restoreAllMocks()
-})
-
-// TODO this test is flaky sometimes: Jest has detected the following 1 open handle potentially keeping Jest from exiting: ●  JSSTREAM
-test.skip('install', async () => {
-  await createExtensionTarBr({
-    'extension.json': `{
-  "id": "test-author.test-extension",
-  "name": "test-extension",
-  "publisher": "test-author",
-  "version": "0.0.1",
-  "main": "main.js"
-}
-`,
-    'main.js': 'export const activate = () => { console.info("hello world") }',
-    'package.json': '{ "type" : "module" }',
-  })
-  handler = async (request, response) => {
-    switch (request.url) {
-      case '/download/test-author.test-extension':
-        response.statusCode = 200
-        await pipeline(
-          createReadStream(
-            '/tmp/extension-test/test-author.test-extension.tar.br'
-          ),
-          response
-        )
-        break
-      default:
-        response.statusCode = 404
-        response.end()
-        break
-    }
-  }
-  const tmpDir = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir
-  await ExtensionManagement.install('test-author.test-extension')
-  expect(
-    await readFile(
-      join(tmpDir, 'test-author.test-extension/extension.json'),
-      'utf-8'
-    )
-  ).toBe(`{
-  "id": "test-author.test-extension",
-  "name": "test-extension",
-  "publisher": "test-author",
-  "version": "0.0.1",
-  "main": "main.js"
-}
-`)
-  expect(
-    await readFile(join(tmpDir, 'test-author.test-extension/main.js'), 'utf-8')
-  ).toBe('export const activate = () => { console.info("hello world") }')
-  expect(
-    await readFile(
-      join(tmpDir, 'test-author.test-extension/package.json'),
-      'utf-8'
-    )
-  ).toBe('{ "type" : "module" }')
-})
-
-test('install should fail when the server sends a bad status code', async () => {
-  handler = (request, response) => {
-    switch (request.url) {
-      default:
-        response.statusCode = 404
-        return response.end()
-    }
-  }
-  const tmpDir = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir
-  await expect(
-    ExtensionManagement.install('test-author.test-extension')
-  ).rejects.toThrowError(
-    /Failed to install extension "test-author.test-extension": Failed to download "http:\/\/localhost:\d+\/download\/test-author.test-extension": Response code 404 \(Not Found\)/
-  )
-})
-
-test('install should fail when the server sends an invalid compressed object', async () => {
-  // TODO avoid side effect in tests, use createServer
-  handler = (request, res) => {
-    switch (request.url) {
-      case '/download/test-author.test-extension':
-        res.statusCode = 200
-        return res.end('abc')
-      default:
-        res.statusCode = 404
-        return res.end()
-    }
-  }
-  const tmpDir = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir
-  await expect(
-    ExtensionManagement.install('test-author.test-extension')
-  ).rejects.toThrowError(
-    /^Failed to install extension "test-author.test-extension": unexpected end of file/
-  )
-})
-
-test('uninstall', async () => {
-  const tmpDir = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir
-  await mkdir(join(tmpDir, 'test-author.test-extension'))
-  expect(await exists(join(tmpDir, 'test-author.test-extension'))).toBe(true)
-  await ExtensionManagement.uninstall('test-author.test-extension')
-  expect(await exists(join(tmpDir, 'test-author.test-extension'))).toBe(false)
-})
-
-test("uninstall should fail when extension doesn't exist", async () => {
-  const tmpDir = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir
-  await expect(
-    ExtensionManagement.uninstall('test-author.test-extension')
-  ).rejects.toThrowError(
-    /^Failed to uninstall extension "test-author.test-extension": ENOENT: no such file or directory/
-  )
-})
-
-// TODO test for extension main not found (extension host)
-
-// TODO test for extension json not found (extension host)
-
-// TODO test for extension code import fails (extension host)
-// TODO test for extension activation fails (in extension host)
-// TODO test for extension deactivation fails (in extension host)
-// TODO test for global unhandlederror/unhandledrejection (in extension host)
-
-test('getAllExtensions', async () => {
-  const tmpDir1 = await getTmpDir()
-  const manifestPath1 = join(tmpDir1, 'test-extension', 'extension.json')
-  await mkdir(dirname(manifestPath1))
-  await writeFile(manifestPath1, JSON.stringify({ id: 'test-extension' }))
-  const tmpDir2 = await getTmpDir()
-  const manifestPath2 = join(tmpDir2, 'builtin-extension', 'extension.json')
-  await mkdir(dirname(manifestPath2))
-  await writeFile(manifestPath2, JSON.stringify({ id: 'builtin-extension' }))
-  const tmpDir3 = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir1
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir2
-  Platform.state.getDisabledExtensionsPath = () => tmpDir3
-  expect(await ExtensionManagement.getAllExtensions()).toEqual([
-    {
-      status: 'fulfilled',
-      id: 'builtin-extension',
-      path: join(tmpDir2, 'builtin-extension'),
-    },
-    {
-      status: 'fulfilled',
-      id: 'test-extension',
-      path: join(tmpDir1, 'test-extension'),
-    },
-  ])
-})
-
-test('getAllExtensions - invalid extension.json', async () => {
-  const spy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-  const tmpDir1 = await getTmpDir()
-  const manifestPath = join(tmpDir1, 'test-extension', 'extension.json')
-  await mkdir(dirname(manifestPath))
-  await writeFile(manifestPath, '{invalid json}')
-  const tmpDir2 = await getTmpDir()
-  const tmpDir3 = await getTmpDir()
-  Platform.state.getExtensionsPath = () => tmpDir1
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir2
-  Platform.state.getDisabledExtensionsPath = () => tmpDir3
-  expect(await ExtensionManagement.getAllExtensions()).toEqual([
-    {
-      path: join(tmpDir1, 'test-extension'),
-      reason: new VError(
-        'Failed to load extension "test-extension": Failed to load extension manifest: JSON parsing error:'
-      ),
-      status: 'rejected',
-    },
-  ])
-})
-
-test('disable', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension'))
-  await writeFile(join(tmpDir1, 'test-extension', 'extension.json'), '{}')
-  Platform.state.getExtensionsPath = () => tmpDir1
-  Platform.state.getDisabledExtensionsPath = () => tmpDir2
-  await ExtensionManagement.disable('test-extension')
-  expect(await readdir(tmpDir1)).toEqual([])
-  expect(await readdir(tmpDir2)).toEqual(['test-extension'])
-})
-
-test('disable should fail if enabled extension path does not exist', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension'))
-  await writeFile(join(tmpDir1, 'test-extension', 'extension.json'), '{}')
-  Platform.state.getExtensionsPath = () => tmpDir1
-  Platform.state.getDisabledExtensionsPath = () => tmpDir2
-  const nonExistentPath1 = join(tmpDir1, 'non-existent-extension')
-  const nonExistentPath2 = join(tmpDir2, 'non-existent-extension')
-  await expect(
-    ExtensionManagement.disable('non-existent-extension')
-  ).rejects.toThrowError(
-    `Failed to disable extension non-existent-extension: ENOENT: no such file or directory, rename '${nonExistentPath1}' -> '${nonExistentPath2}'`
-  )
-})
-
-test('getExtensions - empty object', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), '{}')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'fulfilled',
-      path: join(tmpDir1, '/test-extension-1'),
-    },
-  ])
-})
-
-test.skip('getExtensions - error - invalid value - empty array', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), '[]')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'fulfilled',
-
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})
-
-test('getExtensions - error - invalid value - null', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), 'null')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'rejected',
-      reason: new VError(
-        'Failed to load extension "test-extension-1": Failed to load extension manifest: Invalid manifest file: Not an JSON object.'
-      ),
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})
-
-test('getExtensions - error - invalid value - string', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), '""')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'rejected',
-      reason: new VError(
-        'Failed to load extension "test-extension-1": Failed to load extension manifest: Invalid manifest file: Not an JSON object.'
-      ),
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})
-
-test('getExtensions - error - invalid value - number', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), '42')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'rejected',
-      reason: new VError(
-        'Failed to load extension "test-extension-1": Failed to load extension manifest: Invalid manifest file: Not an JSON object.'
-      ),
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})
-
-test('getExtensions - error - invalid value - boolean', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), 'true')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      status: 'rejected',
-      reason: new VError(
-        'Failed to load extension "test-extension-1": Failed to load extension manifest: Invalid manifest file: Not an JSON object.'
-      ),
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})
-
-// TODO should have better error message here and also stack
-test('getExtensions - error - invalid json', async () => {
-  const tmpDir1 = await getTmpDir()
-  const tmpDir2 = await getTmpDir()
-  await mkdir(join(tmpDir1, 'test-extension-1'))
-  await writeFile(join(tmpDir1, 'test-extension-1', 'extension.json'), '{')
-  Platform.state.getBuiltinExtensionsPath = () => tmpDir1
-  Platform.state.getExtensionsPath = () => tmpDir2
-  expect(await ExtensionManagement.getExtensions()).toEqual([
-    {
-      reason: new VError(
-        'Failed to load extension "test-extension-1": Failed to load extension manifest: Unexpected end of JSON input while parsing "{"'
-      ),
-      status: 'rejected',
-      path: join(tmpDir1, 'test-extension-1'),
-    },
-  ])
-})

package/test/FileSystem.test.js

@@ -1,294 +0,0 @@
-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))
-})