@lvce-editor/test-with-playwright-worker 0.1.0

package/index.js

@@ -0,0 +1,6 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export const testWorkerPath = join(__dirname, 'src', 'workerMain.js')

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@lvce-editor/test-with-playwright-worker",
+  "version": "0.1.0",
+  "description": "",
+  "main": "src/parts/RunAllTests/RunAllTests.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:lvce-editor/test-with-playwright.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@playwright/test": "^1.34.2",
+    "get-port": "^6.1.2",
+    "minimist": "^1.2.8",
+    "read-pkg-up": "^9.1.0",
+    "verror": "^1.10.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.1",
+    "@types/verror": "^1.10.6"
+  }
+}

package/src/parts/Assert/Assert.js

@@ -0,0 +1,59 @@
+import { AssertionError } from '../AssertionError/AssertionError.js'
+
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    default:
+      return 'unknown'
+  }
+}
+
+export const object = (value) => {
+  const type = getType(value)
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object')
+  }
+}
+
+export const number = (value) => {
+  const type = getType(value)
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number')
+  }
+}
+
+export const array = (value) => {
+  const type = getType(value)
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array')
+  }
+}
+
+export const string = (value) => {
+  const type = getType(value)
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string')
+  }
+}
+
+export const boolean = (value) => {
+  const type = getType(value)
+  if (type !== 'boolean') {
+    throw new AssertionError('expected value to be of type boolean')
+  }
+}

package/src/parts/AssertionError/AssertionError.js

@@ -0,0 +1,6 @@
+export class AssertionError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'AssertionError'
+  }
+}

package/src/parts/Callback/Callback.js

@@ -0,0 +1,39 @@
+import * as Id from '../Id/Id.js'
+
+export const state = {
+  callbacks: Object.create(null),
+  onceListeners: new Set(),
+}
+
+export const registerPromise = () => {
+  const id = Id.create()
+  const promise = new Promise((resolve, reject) => {
+    state.callbacks[id] = { resolve, reject }
+  })
+  return { id, promise }
+}
+
+// TODO merge resolve and resolveEmpty
+export const resolve = (id, args) => {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  callbacks[id].resolve(args)
+  delete callbacks[id]
+}
+
+export const reject = (id, error) => {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
+    console.warn(`callback (rejected) ${id} may already be disposed`)
+    return
+  }
+  callbacks[id].reject(error)
+  delete callbacks[id]
+}
+
+export const isAllEmpty = () => {
+  return Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
+}

package/src/parts/Character/Character.js

@@ -0,0 +1,11 @@
+export const Backslash = '\\'
+export const Dash = '-'
+export const Dot = '.'
+export const EmptyString = ''
+export const NewLine = '\n'
+export const OpenAngleBracket = '<'
+export const Slash = '/'
+export const Space = ' '
+export const Tab = '\t'
+export const Underline = '_'
+export const T = 't'

package/src/parts/CleanStack/CleanStack.js

@@ -0,0 +1,93 @@
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const RE_AT = /^\s+at/
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
+const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/
+const RE_GET_RESPONSE = /^\s*at async getResponse/
+const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/
+const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/
+const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/
+
+const isInternalLine = (line) => {
+  return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
+}
+
+const isRelevantLine = (line) => {
+  return !isInternalLine(line)
+}
+
+const isApplicationUsefulLine = (line, index) => {
+  if (index === 0) {
+    return true
+  }
+  if (RE_GET_RESPONSE.test(line)) {
+    return false
+  }
+  if (RE_WEBSOCKET_HANDLE_MESSAGE.test(line)) {
+    return false
+  }
+  if (RE_EXECUTE_COMMAND_ASYNC.test(line)) {
+    return false
+  }
+  if (RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT.test(line)) {
+    return false
+  }
+  return true
+}
+
+const isNormalStackLine = (line) => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
+}
+
+const cleanLine = (line) => {
+  if (line.startsWith('    at exports.')) {
+    return '    at ' + line.slice('    at exports.'.length)
+  }
+  if (line.startsWith('    at async exports.')) {
+    return '    at async ' + line.slice('    at async exports.'.length)
+  }
+  if (line.startsWith('    at async Module.')) {
+    return '    at async ' + line.slice('    at async Module.'.length)
+  }
+  if (line.startsWith('    at Module.')) {
+    return '    at ' + line.slice('    at Module.'.length)
+  }
+  const objectMatch = line.match(RE_OBJECT_AS)
+  if (objectMatch) {
+    const rest = line.slice(objectMatch[0].length)
+    if (objectMatch[1]) {
+      return '    at ' + objectMatch[1] + objectMatch[2] + rest
+    }
+    return '    at ' + objectMatch[2] + rest
+  }
+  return line
+}
+
+const getDetails = (lines) => {
+  const index = lines.findIndex(isNormalStackLine)
+  return {
+    custom: lines.slice(0, index),
+    actualStack: lines.slice(index).map(cleanLine),
+  }
+}
+
+const RE_PATH_1 = /^\/(.*)(\d+)$/
+
+const mergeCustom = (custom, relevantStack) => {
+  if (custom.length === 0) {
+    return relevantStack
+  }
+  const firstLine = custom[0]
+  if (RE_PATH_1.test(firstLine)) {
+    return [`    at ${firstLine}`, ...relevantStack]
+  }
+  return relevantStack
+}
+
+export const cleanStack = (stack) => {
+  const lines = SplitLines.splitLines(stack)
+  const { custom, actualStack } = getDetails(lines)
+  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine)
+  const merged = mergeCustom(custom, relevantStack)
+  return merged
+}

package/src/parts/Cli/Cli.js

@@ -0,0 +1,8 @@
+import * as HandleCliArgs from '../HandleCliArgs/HandleCliArgs.js'
+import * as Process from '../Process/Process.js'
+
+export const main = () => {
+  HandleCliArgs.handleCliArgs({ argv: Process.argv, env: Process.env })
+}
+
+main()

package/src/parts/CliCommandType/CliCommandType.js

@@ -0,0 +1,2 @@
+export const HandleResult = 'HandleResult'
+export const HandleFinalResult = 'HandleFinalResult'

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from '../CommandState/CommandState.js'
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command)
+  if (!fn) {
+    throw new Error(`Command not found ${command}`)
+  }
+  return fn(...args)
+}

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,6 @@
+import * as RunAllTests from '../RunAllTests/RunAllTests.js'
+import * as TestWorkerCommandType from '../TestWorkerCommandType/TestWorkerCommandType.js'
+
+export const commandMap = {
+  [TestWorkerCommandType.RunAllTests]: RunAllTests.runAllTests,
+}

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -0,0 +1,9 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export class CommandNotFoundError extends Error {
+  constructor(id) {
+    super(`command ${id} not found`)
+    this.name = 'CommandNotFoundError'
+    this.code = ErrorCodes.E_COMMAND_NOT_FOUND
+  }
+}

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+export const state = {
+  commands: Object.create(null),
+}
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn
+}
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value)
+  }
+}
+
+export const getCommand = (key) => {
+  return state.commands[key]
+}

package/src/parts/EncodingType/EncodingType.js

@@ -0,0 +1 @@
+export const Utf8 = 'utf8'

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -0,0 +1,19 @@
+export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
+export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
+export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
+export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
+export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
+export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
+export const EACCES = 'EACCES'
+export const ECONNRESET = 'ECONNRESET'
+export const EEXIST = 'EEXIST'
+export const EISDIR = 'EISDIR'
+export const ELOOP = 'ELOOP'
+export const ENOENT = 'ENOENT'
+export const ENOTDIR = 'ENOTDIR'
+export const EPERM = 'EPERM'
+export const EPIPE = 'EPIPE'
+export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
+export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
+export const EXDEV = 'EXDEV'
+export const E_NO_TEST_FILES = 'E_NO_TEST_FILES'

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -0,0 +1,56 @@
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+
+const shouldLogError = (error) => {
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}
+
+export const getErrorResponse = (message, error) => {
+  if (error && error instanceof CommandNotFoundError) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.MethodNotFound,
+        message: error.message,
+        data: error.stack,
+      },
+    }
+  }
+  if (!shouldLogError(error)) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.Custom,
+        message: `${error}`,
+        data: {
+          code: error.code,
+        },
+      },
+    }
+  }
+  const prettyError = PrettyError.prepare(error)
+  PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    error: {
+      code: JsonRpcErrorCode.Custom,
+      message: prettyError.message,
+      data: {
+        stack: prettyError.stack,
+        codeFrame: prettyError.codeFrame,
+        type: prettyError.type,
+        code: prettyError.code,
+      },
+    },
+  }
+}

package/src/parts/GetPort/GetPort.js

@@ -0,0 +1,5 @@
+import _getPort from 'get-port'
+
+export const getPort = () => {
+  return _getPort()
+}

package/src/parts/GetResponse/GetResponse.js

@@ -0,0 +1,12 @@
+import * as Command from '../Command/Command.js'
+import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
+import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
+
+export const getResponse = async (message, ipc) => {
+  try {
+    const result = await Command.execute(message.method, ipc, ...message.params)
+    return GetSuccessResponse.getSuccessResponse(message, result)
+  } catch (error) {
+    return GetErrorResponse.getErrorResponse(message, error)
+  }
+}

package/src/parts/GetServerPath/GetServerPath.js

@@ -0,0 +1,4 @@
+export const getServerPath = async () => {
+  const { serverPath } = await import('@lvce-editor/server')
+  return serverPath
+}

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

@@ -0,0 +1,12 @@
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const getSuccessResponse = (message, result) => {
+  if (!message.id) {
+    return undefined
+  }
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    result: result ?? null,
+  }
+}

package/src/parts/GetTestState/GetTestState.js

@@ -0,0 +1,24 @@
+import * as TestOverlayState from '../TestOverlayState/TestOverlayState.js'
+import * as TestState from '../TestState/TestState.js'
+
+export const getTestState = (testOverlayState, text) => {
+  switch (testOverlayState) {
+    case TestOverlayState.Pass:
+      return {
+        status: TestState.Pass,
+        error: '',
+      }
+    case TestOverlayState.Skip:
+      return {
+        status: TestState.Skip,
+        error: '',
+      }
+    case TestOverlayState.Fail:
+      return {
+        status: TestState.Fail,
+        error: `${text}`,
+      }
+    default:
+      throw new Error(`unexpected test state: ${testOverlayState}`)
+  }
+}

package/src/parts/GetTests/GetTests.js

@@ -0,0 +1,22 @@
+import { readdir } from 'fs/promises'
+import VError from 'verror'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as IsTestFile from '../IsTestFile/IsTestFile.js'
+import { NoTestFilesFoundError } from '../NoTestFilesFoundError/NoTestFilesFoundError.js'
+
+/**
+ * @param {string} testSrc
+ */
+export const getTests = async (testSrc) => {
+  try {
+    const dirents = await readdir(testSrc)
+    return dirents.filter(IsTestFile.isTestFile)
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.code === ErrorCodes.ENOENT) {
+      throw new NoTestFilesFoundError(testSrc)
+    }
+    // @ts-ignore
+    throw new VError(error, `Failed to get test files`)
+  }
+}

package/src/parts/HandleCliArgs/HandleCliArgs.js

@@ -0,0 +1,19 @@
+import * as RunAllTests from '../RunAllTests/RunAllTests.js'
+
+/**
+ *
+ * @param {{argv:string[], env:any}} param0
+ */
+export const handleCliArgs = async ({ argv, env }) => {
+  const cwd = process.cwd()
+  const extensionPath = env.ONLY_EXTENSION
+  const testPath = env.TEST_PATH || ''
+  const headless = argv.includes('--headless')
+  // TODO
+  await RunAllTests.runAllTests({
+    extensionPath,
+    testPath,
+    cwd,
+    headless,
+  })
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,13 @@
+import * as Assert from '../Assert/Assert.js'
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+export const handleIpc = (ipc) => {
+  Assert.object(ipc)
+  const handleMessage = async (message) => {
+    const response = await GetResponse.getResponse(message, ipc)
+    if (response) {
+      ipc.send(response)
+    }
+  }
+  ipc.on('message', handleMessage)
+}

package/src/parts/Id/Id.js

@@ -0,0 +1,7 @@
+export const state = {
+  id: 0,
+}
+
+export const create = () => {
+  return ++state.id
+}

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,9 @@
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.listen(params)
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,12 @@
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
+    case IpcChildType.NodeWorker:
+      return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,13 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+
+export const Auto = () => {
+  const { argv } = process
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  throw new Error(`[test-worker] unknown ipc type`)
+}

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -0,0 +1,41 @@
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const listen = async () => {
+  if (!process.send) {
+    throw new IpcError('process ipc is not available')
+  }
+  process.send('ready')
+  return process
+}
+
+const getActualData = (message, handle) => {
+  if (handle) {
+    return {
+      ...message,
+      params: [...message.params, handle],
+    }
+  }
+  return message
+}
+
+export const wrap = (process) => {
+  return {
+    process,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (message, handle) => {
+          const actualData = getActualData(message, handle)
+          listener(actualData)
+        }
+        this.process.on(event, wrappedListener)
+      }
+    },
+    off(event, listener) {
+      this.process.off(event, listener)
+    },
+    send(message) {
+      this.process.send(message)
+    },
+    dispose() {},
+  }
+}

package/src/parts/IpcChildWithNodeWorker/IpcChildWithNodeWorker.js

@@ -0,0 +1,27 @@
+import { parentPort } from 'node:worker_threads'
+
+export const listen = async () => {
+  if (!parentPort) {
+    throw new Error('parentPort is required')
+  }
+  parentPort.postMessage('ready')
+  return parentPort
+}
+
+export const wrap = (parentPort) => {
+  return {
+    parentPort,
+    on(event, listener) {
+      this.parentPort.on(event, listener)
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/src/parts/IpcError/IpcError.js

@@ -0,0 +1,6 @@
+export class IpcError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'IpcError'
+  }
+}

package/src/parts/IsTestFile/IsTestFile.js

@@ -0,0 +1,6 @@
+/**
+ * @param {string} name
+ */
+export const isTestFile = (name) => {
+  return !name.startsWith('_')
+}

package/src/parts/JoinLines/JoinLines.js

@@ -0,0 +1,5 @@
+import * as Character from '../Character/Character.js'
+
+export const joinLines = (lines) => {
+  return lines.join(Character.NewLine)
+}

package/src/parts/Json/Json.js

@@ -0,0 +1,17 @@
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+import { JsonParsingError } from '../JsonParsingError/JsonParsingError.js'
+
+export const parse = async (string, filePath) => {
+  try {
+    return JSON.parse(string)
+  } catch (error) {
+    const JsonError = await import('../JsonError/JsonError.js')
+    const errorProps = JsonError.getErrorPropsFromError(error, string, filePath)
+    throw new JsonParsingError(errorProps.message, errorProps.codeFrame, errorProps.stack)
+  }
+}
+
+export const stringify = (value) => {
+  return JSON.stringify(value, null, 2) + '\n'
+}