@lvce-editor/shared-process 0.0.2

package/test/ExtensionHostColorTheme.test.js

@@ -0,0 +1,141 @@
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import * as ExtensionHostColorTheme from '../src/parts/ExtensionHost/ExtensionHostColorTheme.js'
+import * as Platform from '../src/parts/Platform/Platform.js'
+import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
+import * as JsonFile from '../src/parts/JsonFile/JsonFile.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+test('getColorThemeNames - empty', async () => {
+  const tmpDir = await getTmpDir()
+  Platform.state.getExtensionsPath = () => {
+    return tmpDir
+  }
+  Platform.state.getBuiltinExtensionsPath = () => {
+    return tmpDir
+  }
+  expect(await ExtensionHostColorTheme.getColorThemes()).toEqual([])
+})
+
+test.skip('getColorThemeJson - theme id contains number', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getThemeExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.test-cobalt2',
+        colorThemes: [
+          {
+            id: 'cobalt2',
+            label: 'Cobalt2 Theme',
+            path: 'color-theme.json',
+          },
+        ],
+        path: join(tmpDir, 'builtin.theme-cobalt-2'),
+      },
+    ]
+  }
+  const colorThemePath = join(
+    tmpDir,
+    'builtin.theme-cobalt2',
+    'color-theme.json'
+  )
+  await mkdir(dirname(colorThemePath), { recursive: true })
+  await writeFile(colorThemePath, '{}')
+  expect(await ExtensionHostColorTheme.getColorThemeJson('cobalt2')).toEqual({})
+})
+
+test('getColorThemeJson - invalid json', async () => {
+  const tmpDir = await getTmpDir()
+  Platform.state.getBuiltinExtensionsPath = () => {
+    return tmpDir
+  }
+  await JsonFile.writeJson(
+    join(tmpDir, 'builtin.theme-test', 'extension.json'),
+    {
+      id: 'builtin.test-theme',
+      colorThemes: [
+        {
+          id: 'test-theme',
+          label: 'Test Theme',
+          path: 'color-theme.json',
+        },
+      ],
+      path: tmpDir,
+    }
+  )
+  const colorThemePath = join(tmpDir, 'builtin.theme-test', 'color-theme.json')
+  await writeFile(colorThemePath, '{ 1 }')
+  await expect(
+    ExtensionHostColorTheme.getColorThemeJson('test-theme')
+  ).rejects.toThrowError(
+    'Failed to load color theme "test-theme": Unexpected number in JSON at position 2 while parsing \'{ 1 }\''
+  )
+})
+
+test('getColorThemeJson - wrong/invalid path', async () => {
+  const tmpDir = await getTmpDir()
+  Platform.state.getBuiltinExtensionsPath = () => {
+    return tmpDir
+  }
+  await JsonFile.writeJson(
+    join(tmpDir, 'builtin.theme-test', 'extension.json'),
+    {
+      id: 'builtin.theme-test',
+      colorThemes: [
+        {
+          id: 'test-theme',
+          label: 'Test Theme',
+          path: 'color-theme.json',
+        },
+      ],
+      path: tmpDir,
+    }
+  )
+  const colorThemePath = join(tmpDir, 'builtin.theme-test', 'color-theme.json')
+  await expect(
+    ExtensionHostColorTheme.getColorThemeJson('test-theme')
+  ).rejects.toThrowError(
+    `Failed to load color theme "test-theme": ENOENT: no such file or directory, open '${colorThemePath}'`
+  )
+})
+
+test('getColorThemes', async () => {
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.theme-slime',
+        colorThemes: [
+          {
+            id: 'slime',
+            label: 'Slime',
+            path: 'color-theme.json',
+          },
+        ],
+        path: '/test',
+      },
+    ]
+  }
+  expect(await ExtensionHostColorTheme.getColorThemes()).toEqual([
+    {
+      id: 'slime',
+      label: 'Slime',
+      path: 'color-theme.json',
+    },
+  ])
+})
+
+test.skip('getColorThemeJson - not found', async () => {
+  ExtensionHost.state.builtinExtensions = []
+  ExtensionHost.state.installedExtensions = []
+  await expect(
+    ExtensionHost.getColorThemeJson('test-theme')
+  ).rejects.toThrowError(
+    'Color theme "test-theme" not found in extensions folder'
+  )
+})

package/test/ExtensionHostCommand.test.js

@@ -0,0 +1,27 @@
+import * as ExtensionHostCommand from '../src/parts/ExtensionHost/ExtensionHostCommand.js'
+
+test('executeCommand', async () => {
+  const fakeExtensionHost = {
+    invoke(method, ...params) {
+      return {
+        params,
+      }
+    },
+  }
+  expect(
+    await ExtensionHostCommand.executeCommand(fakeExtensionHost, 1, 2, 3)
+  ).toEqual({
+    params: [1, 2, 3],
+  })
+})
+
+test('executeCommand - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostCommand.executeCommand(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostCompletion.test.js

@@ -0,0 +1,45 @@
+import * as ExtensionHostCompletion from '../src/parts/ExtensionHost/ExtensionHostCompletion.js'
+
+test('executeCompletionProvider', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return [
+        {
+          label: 'Option A',
+          snippet: 'Option A',
+        },
+        {
+          label: 'Option B',
+          snippet: 'Option B',
+        },
+      ]
+    },
+  }
+  expect(
+    await ExtensionHostCompletion.executeCompletionProvider(
+      fakeExtensionHost,
+      0,
+      0
+    )
+  ).toEqual([
+    {
+      label: 'Option A',
+      snippet: 'Option A',
+    },
+    {
+      label: 'Option B',
+      snippet: 'Option B',
+    },
+  ])
+})
+
+test('executeCompletionProvider - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostCompletion.executeCompletionProvider(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostDefinition.test.js

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

package/test/ExtensionHostDiagnostic.test.js

@@ -0,0 +1,23 @@
+import * as ExtensionHostDiagnostic from '../src/parts/ExtensionHost/ExtensionHostDiagnostic.js'
+
+test('executeDiagnosticProvider - empty', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      return []
+    },
+  }
+  expect(
+    await ExtensionHostDiagnostic.executeDiagnosticProvider(fakeExtensionHost)
+  ).toEqual([])
+})
+
+test('executeDiagnosticProvider - error', async () => {
+  const fakeExtensionHost = {
+    invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostDiagnostic.executeDiagnosticProvider(fakeExtensionHost, 0)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostFileSystem.test.js

@@ -0,0 +1,91 @@
+import * as ExtensionHostFileSystem from '../src/parts/ExtensionHost/ExtensionHostFileSystem.js'
+
+test('readFile', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      return ''
+    },
+  }
+  expect(
+    await ExtensionHostFileSystem.readFile(
+      fakeExtensionHost,
+      '/test',
+      '/test/file.txt'
+    )
+  ).toBe('')
+})
+
+test('readFile - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostFileSystem.readFile(
+      fakeExtensionHost,
+      'test',
+      '/test/file.txt'
+    )
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})
+
+test('writeFile', async () => {
+  const fakeExtensionHost = {
+    async invoke() {},
+  }
+  expect(
+    await ExtensionHostFileSystem.writeFile(
+      fakeExtensionHost,
+      '/test',
+      '/test/file.txt',
+      ''
+    )
+  ).toBeUndefined()
+})
+
+test('writeFile - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostFileSystem.writeFile(
+      fakeExtensionHost,
+      'test',
+      '/test/file.txt',
+      ''
+    )
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})
+
+test('readDirWithFileTypes', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      return []
+    },
+  }
+  expect(
+    await ExtensionHostFileSystem.readDirWithFileTypes(
+      fakeExtensionHost,
+      'test',
+      '/test'
+    )
+  ).toEqual([])
+})
+
+test('readDirWithFileTypes - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostFileSystem.readDirWithFileTypes(
+      fakeExtensionHost,
+      'test',
+      '/test'
+    )
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})

package/test/ExtensionHostFormatting.test.js

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

package/test/ExtensionHostIconTheme.test.js

@@ -0,0 +1,73 @@
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import * as ExtensionHostIconTheme from '../src/parts/ExtensionHost/ExtensionHostIconTheme.js'
+import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+test('getIconTheme - not found', async () => {
+  ExtensionManagement.state.getExtensions = async () => {
+    return []
+  }
+  await expect(
+    ExtensionHostIconTheme.getIconTheme('test-theme')
+  ).rejects.toThrowError(
+    'Icon theme "test-theme" not found in extensions folder'
+  )
+})
+
+test('getIconTheme - wrong/invalid path', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.theme-test',
+        iconThemes: [
+          {
+            id: 'test',
+            label: 'Test',
+            path: 'icon-theme.json',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  const iconThemeJsonPath = join(tmpDir, 'icon-theme.json')
+  await expect(
+    ExtensionHostIconTheme.getIconTheme('test')
+  ).rejects.toThrowError(
+    `Failed to load icon theme "test": ENOENT: no such file or directory, open '${iconThemeJsonPath}'`
+  )
+})
+
+test('getIconTheme - invalid json', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.icon-theme-test',
+        iconThemes: [
+          {
+            id: 'test',
+            label: 'Test',
+            path: 'icon-theme.json',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  const iconThemeJsonPath = join(tmpDir, 'icon-theme.json')
+  await writeFile(iconThemeJsonPath, '{ 2 }')
+  await expect(
+    ExtensionHostIconTheme.getIconTheme('test')
+  ).rejects.toThrowError(
+    'Failed to load icon theme "test": Unexpected number in JSON at position 2 while parsing \'{ 2 }\''
+  )
+})

package/test/ExtensionHostLanguages.test.js

@@ -0,0 +1,212 @@
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import * as ExtensionHostLanguages from '../src/parts/ExtensionHost/ExtensionHostLanguages.js'
+import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
+
+const getTmpDir = () => {
+  return mkdtemp(join(tmpdir(), 'foo-'))
+}
+
+test('getLanguages', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.plaintext',
+        languages: [
+          {
+            id: 'plaintext',
+            label: 'Plaintext',
+            tokenize: 'src/tokenizePlainText.js',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
+    {
+      id: 'plaintext',
+      label: 'Plaintext',
+      tokenize: `/remote/${pathToFileURL(
+        join(tmpDir, 'src/tokenizePlainText.js')
+      )
+        .toString()
+        .slice(8)}`,
+    },
+  ])
+})
+
+// TODO
+test('getLanguages - error - property languages is not of type array', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.plaintext',
+        languages: {},
+        path: tmpDir,
+      },
+    ]
+  }
+  // TODO should handle error gracefully
+  await expect(ExtensionHostLanguages.getLanguages()).rejects.toThrowError(
+    new TypeError('extension.languages.map is not a function')
+  )
+})
+
+test('getLanguages - language without tokenize property', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.icon-theme-test',
+        languages: [
+          {
+            id: 'plaintext',
+            label: 'Plaintext',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
+    {
+      id: 'plaintext',
+      label: 'Plaintext',
+    },
+  ])
+})
+
+test('getLanguages - error - property tokenize is of type array', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.test',
+        languages: [
+          {
+            id: 'python',
+            extensions: ['.py'],
+            configuration: './languageConfiguration.json',
+            tokenize: ['src/tokenizePython.js'],
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
+    {
+      configuration: './languageConfiguration.json',
+      extensions: ['.py'],
+      id: 'python',
+      tokenize: '',
+    },
+  ])
+})
+
+test('getLanguageConfiguration', async () => {
+  const tmpDir = await getTmpDir()
+  await writeFile(
+    join(tmpDir, 'languageConfiguration.json'),
+    `{
+    "comments": {
+      "lineComment": "//",
+      "blockComment": ["/*", "*/"]
+    }
+}
+`
+  )
+
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.javascript',
+        languages: [
+          {
+            id: 'javascript',
+            extensions: ['.js'],
+            tokenize: 'src/tokenizeJavaScript.js',
+            configuration: './languageConfiguration.json',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  expect(
+    await ExtensionHostLanguages.getLanguageConfiguration('javascript')
+  ).toEqual({
+    comments: {
+      blockComment: ['/*', '*/'],
+      lineComment: '//',
+    },
+  })
+})
+test('getLanguageConfiguration - error - language configuration not found', async () => {
+  const tmpDir = await getTmpDir()
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.javascript',
+        languages: [
+          {
+            id: 'javascript',
+            extensions: ['.js'],
+            tokenize: 'src/tokenizeJavaScript.js',
+            configuration: './languageConfiguration.json',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  const languageConfigurationPath = join(tmpDir, 'languageConfiguration.json')
+  await expect(
+    ExtensionHostLanguages.getLanguageConfiguration('javascript')
+  ).rejects.toThrowError(
+    new Error(
+      `Failed to load language configuration for javascript: ENOENT: no such file or directory, open '${languageConfigurationPath}'`
+    )
+  )
+})
+
+test('getLanguageConfiguration - error - language configuration has invalid json', async () => {
+  const tmpDir = await getTmpDir()
+  await writeFile(join(tmpDir, 'languageConfiguration.json'), '{')
+  ExtensionManagement.state.getExtensions = async () => {
+    return [
+      {
+        status: 'fulfilled',
+        id: 'builtin.javascript',
+        languages: [
+          {
+            id: 'javascript',
+            extensions: ['.js'],
+            tokenize: 'src/tokenizeJavaScript.js',
+            configuration: './languageConfiguration.json',
+          },
+        ],
+        path: tmpDir,
+      },
+    ]
+  }
+  // TODO should display path as well
+  await expect(
+    ExtensionHostLanguages.getLanguageConfiguration('javascript')
+  ).rejects.toThrowError(
+    new Error(
+      'Failed to load language configuration for javascript: Unexpected end of JSON input while parsing "{"'
+    )
+  )
+})

package/test/ExtensionHostOutput.test.js

@@ -0,0 +1,23 @@
+import * as ExtensionHostOutput from '../src/parts/ExtensionHost/ExtensionHostOutput.js'
+
+test('getOutputChannels - empty', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      return []
+    },
+  }
+  expect(
+    await ExtensionHostOutput.getOutputChannels(fakeExtensionHost)
+  ).toEqual([])
+})
+
+test('getOutputChannels - error', async () => {
+  const fakeExtensionHost = {
+    async invoke() {
+      throw new TypeError('x is not a function')
+    },
+  }
+  await expect(
+    ExtensionHostOutput.getOutputChannels(fakeExtensionHost)
+  ).rejects.toThrowError(new TypeError('x is not a function'))
+})