@lvce-editor/shared-process 0.0.2

package/test/ExtensionHostRename.test.js

@@ -0,0 +1,59 @@
+import * as ExtensionHostRename from '../src/parts/ExtensionHost/ExtensionHostRename.js'
+
+test('executePrepareRename', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return {
+        canRename: true,
+      }
+    },
+  }
+  expect(
+    await ExtensionHostRename.executePrepareRename(fakeExtensionHost, 0, 0)
+  ).toEqual({
+    canRename: true,
+  })
+})
+
+test('executePrepareRename - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostRename.executePrepareRename(fakeExtensionHost, 0, 0)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})
+
+test('executeRename', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return [
+        {
+          file: '/test/file.txt',
+          edits: [],
+        },
+      ]
+    },
+  }
+  expect(
+    await ExtensionHostRename.executeRename(fakeExtensionHost, 0, 0, '')
+  ).toEqual([
+    {
+      file: '/test/file.txt',
+      edits: [],
+    },
+  ])
+})
+
+test('executeRename - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostRename.executeRename(fakeExtensionHost, 0, 0, '')
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostSemanticTokens.test.js

@@ -0,0 +1,26 @@
+import * as ExtensionHostSemanticTokens from '../src/parts/ExtensionHost/ExtensionHostSemanticTokens.js'
+
+test('executeSemanticTokenProvider', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return [1, 2, 3, 4, 5]
+    },
+  }
+  expect(
+    await ExtensionHostSemanticTokens.executeSemanticTokenProvider(
+      fakeExtensionHost,
+      0
+    )
+  ).toEqual([1, 2, 3, 4, 5])
+})
+
+test('executeCompletionProvider - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostSemanticTokens.executeSemanticTokenProvider(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostTabCompletion.test.js

@@ -0,0 +1,35 @@
+import * as ExtensionHostTabCompletion from '../src/parts/ExtensionHost/ExtensionHostTabCompletion.js'
+
+test('executeTabCompletionProvider', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return {
+        inserted: '<div></div>',
+        deleted: 0,
+        type: /* Snippet */ 2,
+      }
+    },
+  }
+  expect(
+    await ExtensionHostTabCompletion.executeTabCompletionProvider(
+      fakeExtensionHost,
+      0,
+      0
+    )
+  ).toEqual({
+    inserted: '<div></div>',
+    deleted: 0,
+    type: /* Snippet */ 2,
+  })
+})
+
+test('executeTabCompletionProvider - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostTabCompletion.executeTabCompletionProvider(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostTextDocument.test.js

@@ -0,0 +1,61 @@
+import * as ExtensionHostTextDocument from '../src/parts/ExtensionHost/ExtensionHostTextDocument.js'
+
+test('textDocumentSyncInitial', async () => {
+  const fakeExtensionHost = {
+    invoke() {},
+  }
+  expect(
+    await ExtensionHostTextDocument.textDocumentSyncInitial(
+      fakeExtensionHost,
+      '/test/file.txt',
+      0,
+      '',
+      ''
+    )
+  ).toEqual(undefined)
+})
+
+test('textDocumentSyncInitial - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostTextDocument.textDocumentSyncInitial(
+      fakeExtensionHost,
+      '/test/file.txt',
+      0,
+      '',
+      ''
+    )
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})
+
+test('textDocumentSyncIncremental', async () => {
+  const fakeExtensionHost = {
+    invoke() {},
+  }
+  expect(
+    await ExtensionHostTextDocument.textDocumentSyncIncremental(
+      fakeExtensionHost,
+      0,
+      []
+    )
+  ).toEqual(undefined)
+})
+
+test('textDocumentSyncInitial - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostTextDocument.textDocumentSyncIncremental(
+      fakeExtensionHost,
+      0,
+      []
+    )
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostTypeDefinition.test.js

@@ -0,0 +1,35 @@
+import * as ExtensionHostTypeDefinition from '../src/parts/ExtensionHost/ExtensionHostTypeDefinition.js'
+
+test('executeTypeDefinitionProvider', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return {
+        uri: '/test/file.txt',
+        startOffset: 0,
+        endOffset: 0,
+      }
+    },
+  }
+  expect(
+    await ExtensionHostTypeDefinition.executeTypeDefinitionProvider(
+      fakeExtensionHost,
+      0,
+      0
+    )
+  ).toEqual({
+    uri: '/test/file.txt',
+    startOffset: 0,
+    endOffset: 0,
+  })
+})
+
+test('executeTypeDefinitionProvider - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostTypeDefinition.executeTypeDefinitionProvider(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostWorkspace.test.js

@@ -0,0 +1,21 @@
+import * as ExtensionHostWorkspace from '../src/parts/ExtensionHost/ExtensionHostWorkspace.js'
+
+test('setWorkspacePath', async () => {
+  const fakeExtensionHost = {
+    invoke() {},
+  }
+  expect(
+    await ExtensionHostWorkspace.setWorkspacePath(fakeExtensionHost, '/test')
+  ).toEqual(undefined)
+})
+
+test('setWorkspacePath - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostWorkspace.setWorkspacePath(fakeExtensionHost, '/test')
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionManagement.test.js

@@ -0,0 +1,408 @@
+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'),
+    },
+  ])
+})