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

package/src/parts/JsonError/JsonError.js

@@ -0,0 +1,64 @@
+import { codeFrameColumns } from '@babel/code-frame'
+import { LinesAndColumns } from 'lines-and-columns'
+
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+const emptyError = {
+  message: '',
+  stack: '',
+  codeFrame: '',
+}
+
+export const getErrorPropsFromError = (error, string, filePath) => {
+  const indexMatch = error.message.match(/in JSON at position (\d+)/)
+  if (indexMatch && indexMatch.length > 0) {
+    const lines = new LinesAndColumns(string)
+    const index = Number(indexMatch[1])
+    const location = lines.locationForIndex(index)
+    if (location) {
+      const line = location.line + 1
+      const column = location.column + 1
+      const codeFrame = codeFrameColumns(string, { start: { line, column } }, { highlightCode: false })
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `    at ${filePath}:${line}:${column}`,
+      }
+    }
+  }
+  if (string.length === 0) {
+    return {
+      codeFrame: ``,
+      message: 'Json Parsing Error: Cannot parse empty string',
+      stack: `    at ${filePath}`,
+    }
+  }
+
+  if (error.message === 'Unexpected end of JSON input') {
+    const lines = new LinesAndColumns(string)
+    const index = string.length - 1
+    const location = lines.locationForIndex(index)
+    if (location) {
+      const codeFrame = codeFrameColumns(string, { start: { line: location.line + 1, column: location.column + 1 } }, { highlightCode: false })
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `    at ${filePath}`,
+      }
+    }
+  }
+  return {
+    codeFrame: ``,
+    message: 'Json Parsing Error',
+    stack: `    at ${filePath}`,
+  }
+}
+
+export const getErrorProps = (string, filePath) => {
+  try {
+    JSON.parse(string)
+    return emptyError
+  } catch (error) {
+    return getErrorPropsFromError(error, string, filePath)
+  }
+}

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -0,0 +1,17 @@
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+export class JsonParsingError extends Error {
+  constructor(message, codeFrame, stack) {
+    super(message)
+    this.name = 'JsonParsingError'
+    if (codeFrame) {
+      this.codeFrame = codeFrame
+    }
+
+    if (stack) {
+      const parentStack = JoinLines.joinLines(SplitLines.splitLines(this.stack).slice(1))
+      this.stack = this.name + ': ' + this.message + '\n' + stack + '\n' + parentStack
+    }
+  }
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1,35 @@
+import * as Callback from '../Callback/Callback.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const send = (transport, method, ...params) => {
+  transport.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+  })
+}
+
+export const invoke = (ipc, method, ...params) => {
+  const { id, promise } = Callback.registerPromise()
+  ipc.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
+  })
+  return promise
+}
+
+export const invokeAndTransfer = (ipc, handle, method, ...params) => {
+  const { id, promise } = Callback.registerPromise()
+  ipc.sendAndTransfer(
+    {
+      jsonrpc: JsonRpcVersion.Two,
+      method,
+      params,
+      id,
+    },
+    handle
+  )
+  return promise
+}

package/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

@@ -0,0 +1,2 @@
+export const MethodNotFound = -32601
+export const Custom = -32001

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

@@ -0,0 +1 @@
+export const Two = '2.0'

package/src/parts/Logger/Logger.js

@@ -0,0 +1,43 @@
+// TODO mock this module when used in unit tests
+
+const state = {
+  /**
+   * @type {Console|undefined}
+   */
+  console: undefined,
+}
+
+const createConsole = () => {
+  return console
+}
+
+const getOrCreateLogger = () => {
+  if (!state.console) {
+    state.console = createConsole()
+  }
+  return state.console
+}
+
+export const log = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.log(...args)
+  console.log(...args)
+}
+
+export const info = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.info(...args)
+  console.info(...args)
+}
+
+export const warn = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.warn(...args)
+  console.warn(...args)
+}
+
+export const error = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.error(...args)
+  console.error(...args)
+}

package/src/parts/Main/Main.js

@@ -0,0 +1,36 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as Process from '../Process/Process.js'
+import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
+
+const handleDisconnect = () => {
+  console.log('[test-worker] disconnected')
+}
+
+const handleExit = () => {
+  console.log('[test-worker] exiting')
+}
+
+const handleSigint = () => {
+  console.log('[test-worker] sigint')
+}
+
+const handleSigTerm = () => {
+  console.log('[test-worker] sigterm')
+}
+
+export const main = async () => {
+  Process.on('disconnect', handleDisconnect)
+  Process.on('exit', handleExit)
+  Process.on('SIGINT', handleSigint)
+  Process.on('SIGTERM', handleSigTerm)
+  Process.on('uncaughtExceptionMonitor', ProcessListeners.handleUncaughtExceptionMonitor)
+  CommandState.registerCommands(CommandMap.commandMap)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.Auto(),
+  })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/NoTestFilesFoundError/NoTestFilesFoundError.js

@@ -0,0 +1,8 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export class NoTestFilesFoundError extends Error {
+  constructor(root) {
+    super(`No test files found at ${root}`)
+    this.code = ErrorCodes.E_NO_TEST_FILES
+  }
+}

package/src/parts/PrettyError/PrettyError.js

@@ -0,0 +1,139 @@
+import { codeFrameColumns } from '@babel/code-frame'
+import { LinesAndColumns } from 'lines-and-columns'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { AssertionError } from '../AssertionError/AssertionError.js'
+import * as CleanStack from '../CleanStack/CleanStack.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as Json from '../Json/Json.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const getActualPath = (fileUri) => {
+  if (fileUri.startsWith('file://')) {
+    return fileURLToPath(fileUri)
+  }
+  return fileUri
+}
+
+const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/
+
+const prepareModuleNotFoundError = (error) => {
+  const { message } = error
+  const match = message.match(RE_MODULE_NOT_FOUND_STACK)
+  if (!match) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: '',
+    }
+  }
+  const notFoundModule = match[1]
+  const importedFrom = match[2]
+  const rawLines = readFileSync(importedFrom, EncodingType.Utf8)
+  let line = 0
+  let column = 0
+  const splittedLines = SplitLines.splitLines(rawLines)
+  for (let i = 0; i < splittedLines.length; i++) {
+    const splittedLine = splittedLines[i]
+    const index = splittedLine.indexOf(notFoundModule)
+    if (index !== -1) {
+      line = i + 1
+      column = index
+      break
+    }
+  }
+  const location = {
+    start: {
+      line,
+      column,
+    },
+  }
+  const codeFrame = codeFrameColumns(rawLines, location)
+  const stackLines = SplitLines.splitLines(error.stack)
+  const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)]
+  const newStack = JoinLines.joinLines(newStackLines)
+  return {
+    message,
+    stack: newStack,
+    codeFrame,
+  }
+}
+
+const getStackLinesToCut = (error) => {
+  if (error instanceof AssertionError) {
+    return 1
+  }
+  return 0
+}
+
+export const prepare = (error) => {
+  if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
+    return prepareModuleNotFoundError(error)
+  }
+  const { message } = error
+  if (error && error.cause) {
+    const cause = error.cause()
+    if (cause) {
+      error = cause
+    }
+  }
+  const linesToCut = getStackLinesToCut(error)
+  const lines = CleanStack.cleanStack(error.stack).slice(linesToCut)
+  const file = lines[0]
+  let codeFrame = ''
+  if (error.codeFrame) {
+    codeFrame = error.codeFrame
+  } else if (file) {
+    let match = file.match(/\((.*):(\d+):(\d+)\)$/)
+    if (!match) {
+      match = file.match(/at (.*):(\d+):(\d+)$/)
+    }
+    if (match) {
+      const [_, path, line, column] = match
+      const actualPath = getActualPath(path)
+      const rawLines = readFileSync(actualPath, EncodingType.Utf8)
+      const location = {
+        start: {
+          line: Number.parseInt(line),
+          column: Number.parseInt(column),
+        },
+      }
+      codeFrame = codeFrameColumns(rawLines, location)
+    }
+  }
+  const relevantStack = JoinLines.joinLines(lines)
+  return {
+    message,
+    stack: relevantStack,
+    codeFrame,
+    type: error.constructor.name,
+    code: error.code,
+  }
+}
+
+const fixBackslashes = (string) => {
+  return string.replaceAll('\\\\', '\\')
+}
+
+export const prepareJsonError = (json, property, message) => {
+  const string = fixBackslashes(Json.stringify(json))
+  const stringifiedPropertyName = `"${property}"`
+  const index = string.indexOf(stringifiedPropertyName) // TODO this could be wrong in some cases, find a better way
+  console.log({ string, index })
+  const jsonError = {
+    stack: '',
+  }
+  if (index !== -1) {
+    const lines = new LinesAndColumns(string)
+    const location = lines.locationForIndex(index + stringifiedPropertyName.length + 1)
+    const codeFrame = codeFrameColumns(string, {
+      // @ts-ignore
+      start: { line: location.line + 1, column: location.column + 1 },
+    })
+    jsonError.codeFrame = codeFrame
+  }
+  // jsonError.stack = `${bottomMessage}\n    at ${filePath}`
+  return jsonError
+}

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -0,0 +1,5 @@
+import * as Logger from '../Logger/Logger.js'
+
+export const printPrettyError = (prettyError, prefix = '') => {
+  Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
+}

package/src/parts/Process/Process.js

@@ -0,0 +1,20 @@
+export const argv = process.argv
+
+export const env = process.env
+
+/**
+ *
+ * @param {number} code
+ */
+export const exit = (code) => {
+  process.exit(code)
+}
+
+/**
+ *
+ * @param {string} event
+ * @param {any} listener
+ */
+export const on = (event, listener) => {
+  process.on(event, listener)
+}

package/src/parts/ProcessListeners/ProcessListeners.js

@@ -0,0 +1,3 @@
+export const handleUncaughtExceptionMonitor = (error) => {
+  console.log(`[test-worker] uncaught exception ${error}`)
+}

package/src/parts/RunAllTests/RunAllTests.js

@@ -0,0 +1,45 @@
+import { join } from 'path'
+import * as Assert from '../Assert/Assert.js'
+import * as GetTests from '../GetTests/GetTests.js'
+import * as RunTests from '../RunTests/RunTests.js'
+import * as SetupTests from '../SetupTests/SetupTests.js'
+import * as TearDownTests from '../TearDownTests/TearDownTests.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as CliCommandType from '../CliCommandType/CliCommandType.js'
+
+/**
+ * @param {any} ipc
+ * @param {string} extensionPath
+ * @param {string} testPath
+ * @param {string} cwd
+ * @param {boolean} headless
+ * @param {number} headless
+ */
+export const runAllTests = async (ipc, extensionPath, testPath, cwd, headless, timeout) => {
+  Assert.string(extensionPath)
+  Assert.string(testPath)
+  Assert.string(cwd)
+  Assert.boolean(headless)
+  Assert.number(timeout)
+  const controller = new AbortController()
+  const signal = controller.signal
+  const { browser, page, child, port } = await SetupTests.setupTests({
+    signal,
+    headless,
+    onlyExtension: extensionPath,
+    testPath,
+  })
+  const testSrc = join(testPath, 'src')
+  const tests = await GetTests.getTests(testSrc)
+  const onResult = (result) => {
+    JsonRpc.send(ipc, CliCommandType.HandleResult, result)
+  }
+  const onFinalResult = (finalResult) => {
+    JsonRpc.send(ipc, CliCommandType.HandleFinalResult, finalResult)
+  }
+  await RunTests.runTests({ testSrc, tests, headless, port, page, timeout, onResult, onFinalResult })
+  await TearDownTests.tearDownTests({
+    controller,
+    child,
+  })
+}

package/src/parts/RunTest/RunTest.js

@@ -0,0 +1,37 @@
+import { expect } from '@playwright/test'
+import { basename } from 'node:path'
+import { join } from 'path'
+import * as GetTestState from '../GetTestState/GetTestState.js'
+
+/**
+ * @param {string} absolutePath
+ * @param {number} port
+ */
+const getUrlFromTestFile = (absolutePath, port) => {
+  const baseName = basename(absolutePath)
+  const htmlFileName = baseName.slice(0, -'.js'.length) + '.html'
+  return `http://localhost:${port}/tests/${htmlFileName}`
+}
+
+export const runTest = async ({ test, page, testSrc, port, timeout }) => {
+  const start = performance.now()
+  const url = getUrlFromTestFile(test, port)
+  await page.goto(url, {
+    waitUntil: 'networkidle',
+  })
+  const testOverlay = page.locator('#TestOverlay')
+  await expect(testOverlay).toBeVisible({
+    timeout,
+  })
+  const text = await testOverlay.textContent()
+  const testOverlayState = await testOverlay.getAttribute('data-state')
+  const testState = GetTestState.getTestState(testOverlayState)
+  const end = performance.now()
+  return {
+    ...testState,
+    name: test,
+    start,
+    end,
+    error: text,
+  }
+}

package/src/parts/RunTests/RunTests.js

@@ -0,0 +1,44 @@
+import * as RunTest from '../RunTest/RunTest.js'
+import * as TestState from '../TestState/TestState.js'
+
+/**
+ *
+ * @param {{testSrc:string, tests:string[], headless:boolean, page: import('@playwright/test').Page, port:number, timeout:number, onResult:any, onFinalResult:any}} param0
+ */
+export const runTests = async ({ testSrc, tests, headless, page, port, timeout, onResult, onFinalResult }) => {
+  let failed = 0
+  let skipped = 0
+  let passed = 0
+  const start = performance.now()
+  for (const test of tests) {
+    const result = await RunTest.runTest({
+      test,
+      page,
+      testSrc,
+      port,
+      timeout,
+    })
+    onResult(result)
+    switch (result.status) {
+      case TestState.Fail:
+        failed++
+        break
+      case TestState.Skip:
+        skipped++
+        break
+      case TestState.Pass:
+        passed++
+        break
+      default:
+        break
+    }
+  }
+  const end = performance.now()
+  onFinalResult({
+    passed,
+    failed,
+    skipped,
+    start,
+    end,
+  })
+}

package/src/parts/SetupTests/SetupTests.js

@@ -0,0 +1,25 @@
+import * as StartBrowser from '../StartBrowser/StartBrowser.js'
+import * as StartServer from '../StartServer/StartServer.js'
+import * as GetPort from '../GetPort/GetPort.js'
+import * as GetServerPath from '../GetServerPath/GetServerPath.js'
+
+/**
+ *
+ * @param {{signal:AbortSignal, headless: boolean, onlyExtension:string, testPath:string}} options
+ * @returns
+ */
+export const setupTests = async ({ signal, headless, onlyExtension, testPath }) => {
+  const port = await GetPort.getPort()
+  const { browser, page } = await StartBrowser.startBrowser({
+    signal,
+    headless,
+  })
+  const serverPath = await GetServerPath.getServerPath()
+  const child = await StartServer.startServer({ signal, port, serverPath, onlyExtension, testPath })
+  return {
+    port,
+    browser,
+    page,
+    child,
+  }
+}

package/src/parts/Signal/Signal.js

@@ -0,0 +1 @@
+export const SIGINT = 'SIGINT'

package/src/parts/SplitLines/SplitLines.js

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

package/src/parts/StartBrowser/StartBrowser.js

@@ -0,0 +1,21 @@
+import { chromium } from '@playwright/test'
+
+/**
+ *
+ * @param {{signal:AbortSignal, headless:boolean}} options
+ * @returns
+ */
+export const startBrowser = async ({ signal, headless }) => {
+  const browser = await chromium.launch({
+    headless,
+  })
+  const page = await browser.newPage()
+  signal.addEventListener('abort', async () => {
+    await page.close()
+    await browser.close()
+  })
+  return {
+    browser,
+    page,
+  }
+}

package/src/parts/StartServer/StartServer.js

@@ -0,0 +1,29 @@
+import { fork } from 'child_process'
+
+/**
+ *
+ * @param {{signal:AbortSignal, port:number, serverPath:string, onlyExtension:string, testPath:string}} param0
+ * @returns
+ */
+export const startServer = async ({ signal, port, serverPath, onlyExtension, testPath }) => {
+  const child = fork(serverPath, {
+    stdio: 'inherit',
+    // signal,
+    env: {
+      ...process.env,
+      PORT: String(port),
+      ONLY_EXTENSION: onlyExtension,
+      TEST_PATH: testPath,
+    },
+  })
+  child.on('error', (x) => {
+    if (x.name === 'AbortError') {
+      return
+    }
+    console.log('child error', x)
+  })
+  await new Promise((resolve) => {
+    child.on('message', resolve)
+  })
+  return child
+}

package/src/parts/TearDownTests/TearDownTests.js

@@ -0,0 +1,6 @@
+import * as Signal from '../Signal/Signal.js'
+
+export const tearDownTests = ({ controller, child }) => {
+  controller.abort()
+  child.kill(Signal.SIGINT)
+}

package/src/parts/TestOverlayState/TestOverlayState.js

@@ -0,0 +1,3 @@
+export const Pass = 'pass'
+export const Skip = 'skip'
+export const Fail = 'fail'

package/src/parts/TestState/TestState.js

@@ -0,0 +1,3 @@
+export const Pass = 1
+export const Skip = 2
+export const Fail = 3

package/src/parts/TestWorkerCommandType/TestWorkerCommandType.js

@@ -0,0 +1 @@
+export const RunAllTests = 'RunAllTests'

package/src/workerMain.js

@@ -0,0 +1,3 @@
+import * as Main from './parts/Main/Main.js'
+
+Main.main()