@lvce-editor/test-with-playwright 0.0.26 → 0.1.0

package/bin/test-with-playwright.js

@@ -1 +1 @@
-import '../src/all.js'
+import '../src/parts/Cli/Cli.js'

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "0.0.26",
+  "version": "0.1.0",
   "description": "",
-  "main": "src/main.js",
-  "types": "src/main.d.ts",
+  "main": "src/parts/RunAllTests/RunAllTests.js",
   "type": "module",
   "bin": "bin/test-with-playwright.js",
   "repository": {
@@ -14,9 +13,6 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@playwright/test": "^1.34.2",
-    "get-port": "^6.1.2",
-    "minimist": "^1.2.8",
-    "read-pkg-up": "^9.1.0"
+    "minimist": "^1.2.8"
   }
 }

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/Cli/Cli.js

@@ -0,0 +1,13 @@
+import * as HandleCliArgs from '../HandleCliArgs/HandleCliArgs.js'
+import * as Process from '../Process/Process.js'
+import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as CommandMap from '../CommandMap/CommandMap.js'
+
+export const main = () => {
+  Process.on('uncaughtExceptionMonitor', ProcessListeners.handleUncaughtExceptionMonitor)
+  CommandState.registerCommands(CommandMap.commandMap)
+  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,8 @@
+import * as CliCommandType from '../CliCommandType/CliCommandType.js'
+import * as HandleFinalResult from '../HandleFinalResult/HandleFinalResult.js'
+import * as HandleResult from '../HandleResult/HandleResult.js'
+
+export const commandMap = {
+  [CliCommandType.HandleResult]: HandleResult.handleResult,
+  [CliCommandType.HandleFinalResult]: HandleFinalResult.handleFinalResult,
+}

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/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -0,0 +1,5 @@
+export const Exit = 'exit'
+
+export const Error = 'error'
+
+export const Message = 'message'

package/src/parts/GetFinalResultMessage/GetFinalResultMessage.js

@@ -0,0 +1,30 @@
+export const getFinalResultMessage = (passed, skipped, failed, duration) => {
+  if (passed === 0 && skipped === 0 && failed === 0) {
+    return `no tests found`
+  }
+  if (passed === 0 && skipped === 0 && failed === 1) {
+    return `${passed} test failed in ${duration}ms`
+  }
+  if (passed === 0 && skipped === 1 && failed === 0) {
+    return `${skipped} test skipped in ${duration}ms`
+  }
+  if (passed === 0 && skipped === 1 && failed === 1) {
+    return `${skipped} test skipped, ${failed} test failed in ${duration}ms`
+  }
+  if (passed === 1 && skipped === 0 && failed === 0) {
+    return `${passed} test passed in ${duration}ms`
+  }
+  if (passed === 1 && skipped === 0 && failed === 1) {
+    return `${passed} test passed, ${failed} test failed in ${duration}ms`
+  }
+  if (passed === 1 && skipped === 1 && failed === 0) {
+    return `${passed} test passed, ${skipped} test skipped in ${duration}ms`
+  }
+  if (passed === 1 && skipped === 1 && failed === 1) {
+    return `${passed} test passed, ${skipped} test skipped, ${failed} test failed in ${duration}ms`
+  }
+  if (passed > 1 && skipped === 0 && failed === 0) {
+    return `${passed} tests passed in ${duration}ms`
+  }
+  return `${passed} tests passed, ${skipped} tests skipped, ${failed} tests failed in ${duration}ms`
+}

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -0,0 +1,28 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+
+export const getFirstNodeWorkerEvent = async (worker) => {
+  const { type, event } = await new Promise((resolve, reject) => {
+    const cleanup = (value) => {
+      worker.off('message', handleMessage)
+      worker.off('exit', handleExit)
+      worker.off('error', handleError)
+      resolve(value)
+    }
+    const handleMessage = (event) => {
+      cleanup({
+        type: FirstNodeWorkerEventType.Message,
+        event,
+      })
+    }
+    const handleExit = (event) => {
+      cleanup({ type: FirstNodeWorkerEventType.Exit, event })
+    }
+    const handleError = (event) => {
+      cleanup({ type: FirstNodeWorkerEventType.Error, event })
+    }
+    worker.on('message', handleMessage)
+    worker.on('exit', handleExit)
+    worker.on('error', handleError)
+  })
+  return { type, event }
+}

package/src/parts/GetOptions/GetOptions.js

@@ -0,0 +1,18 @@
+import * as ParseCliArgs from '../ParseCliArgs/ParseCliArgs.js'
+import * as ParseEnv from '../ParseEnv/ParseEnv.js'
+
+const defaultOptions = {
+  testPath: '',
+  extensionPath: '',
+  headless: false,
+}
+
+export const getOptions = ({ argv, env }) => {
+  const parsedEnv = ParseEnv.parseEnv(env)
+  const parsedArgs = ParseCliArgs.parseCliArgs(argv)
+  return {
+    ...defaultOptions,
+    ...parsedEnv,
+    ...parsedArgs,
+  }
+}

package/src/parts/GetPort/GetPort.js

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

package/src/parts/GetTestWorkerPath/GetTestWorkerPath.js

@@ -0,0 +1,5 @@
+import { testWorkerPath } from '@lvce-editor/test-with-playwright-worker'
+
+export const getTestWorkerPath = () => {
+  return testWorkerPath
+}

package/src/parts/GetTests/GetTests.js

@@ -0,0 +1,10 @@
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+
+/**
+ * @param {string} testSrc
+ */
+export const getTests = async (testSrc) => {
+  const dirents = await readdir(testSrc)
+  return dirents
+}

package/src/parts/HandleCliArgs/HandleCliArgs.js

@@ -0,0 +1,24 @@
+import * as GetOptions from '../GetOptions/GetOptions.js'
+import * as RunAllTests from '../RunAllTests/RunAllTests.js'
+
+/**
+ *
+ * @param {{argv:string[], env:any}} param0
+ */
+export const handleCliArgs = async ({ argv, env }) => {
+  const cwd = process.cwd()
+  const options = GetOptions.getOptions({ argv, env })
+  const onlyExtension = options.onlyExtension
+  const testPath = options.testPath
+  const headless = options.headless
+  const timeout = 30_000
+  // TODO
+  // console.log({ argv, env })
+  await RunAllTests.runAllTests({
+    onlyExtension,
+    testPath,
+    cwd,
+    headless,
+    timeout,
+  })
+}

package/src/parts/HandleFinalResult/HandleFinalResult.js

@@ -0,0 +1,8 @@
+import * as GetFinalResultMessage from '../GetFinalResultMessage/GetFinalResultMessage.js'
+
+export const handleFinalResult = (finalResult) => {
+  const { passed, failed, skipped, start, end } = finalResult
+  const duration = end - start
+  const message = GetFinalResultMessage.getFinalResultMessage(passed, skipped, failed, duration)
+  console.info(message)
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,15 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+
+export function handleIpc(ipc) {
+  const handleMessage = async (message) => {
+    if ('result' in message || 'error' in message) {
+      Callback.resolve(message.id, message)
+      return
+    }
+    if ('method' in message) {
+      await Command.execute(message.method, ...message.params)
+    }
+  }
+  ipc.on('message', handleMessage)
+}

package/src/parts/HandleResult/HandleResult.js

@@ -0,0 +1,38 @@
+import * as TestState from '../TestState/TestState.js'
+
+const getDuration = (start, end) => {
+  return end - start
+}
+
+const handleResultPassed = (result) => {
+  const { name, start, end } = result
+  const duration = getDuration(start, end)
+  console.info(`test passed ${name} in ${duration}ms`)
+}
+
+const handleResultSkipped = (result) => {
+  const { name } = result
+  console.info(`test skipped ${name}`)
+}
+
+const handleResultFailed = (result) => {
+  const { name, error } = result
+  console.error(`Test Failed ${name}: ${error}`)
+}
+
+export const handleResult = (result) => {
+  const { status } = result
+  switch (status) {
+    case TestState.Pass:
+      handleResultPassed(result)
+      break
+    case TestState.Skip:
+      handleResultSkipped(result)
+      break
+    case TestState.Fail:
+      handleResultFailed(result)
+      break
+    default:
+      throw new Error(`unexpected test state: ${status}`)
+  }
+}

package/src/parts/Id/Id.js

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

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/IpcParent/IpcParent.js

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

package/src/parts/IpcParentModule/IpcParentModule.js

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

package/src/parts/IpcParentType/IpcParentType.js

@@ -0,0 +1,2 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -0,0 +1,53 @@
+import * as Assert from '../Assert/Assert.js'
+import { fork } from 'node:child_process'
+import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import { ChildProcessError } from '../ChildProcessError/ChildProcessError.js'
+import { VError } from '../VError/VError.js'
+
+export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
+  try {
+    Assert.string(path)
+    const actualArgv = ['--ipc-type=node-forked-process', ...argv]
+    const childProcess = fork(path, actualArgv, {
+      env,
+      execArgv,
+      stdio: 'pipe',
+    })
+    const { type, event, stdout, stderr } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
+    if (type === FirstNodeWorkerEventType.Exit) {
+      throw new ChildProcessError(stderr)
+    }
+    if (type === FirstNodeWorkerEventType.Error) {
+      throw new Error(`child process had an error ${event}`)
+    }
+    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
+      childProcess.stdout.pipe(process.stdout)
+      childProcess.stderr.pipe(process.stderr)
+    }
+    return childProcess
+  } catch (error) {
+    throw new VError(error, `Failed to launch ${name}`)
+  }
+}
+
+export const wrap = (childProcess) => {
+  return {
+    childProcess,
+    on(event, listener) {
+      this.childProcess.on(event, listener)
+    },
+    off(event, listener) {
+      this.childProcess.off(event, listener)
+    },
+    send(message) {
+      this.childProcess.send(message)
+    },
+    sendAndTransfer(message, handle) {
+      this.childProcess.send(message, handle)
+    },
+    dispose() {
+      this.childProcess.kill()
+    },
+  }
+}

package/src/parts/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -0,0 +1,41 @@
+import { Worker } from 'node:worker_threads'
+import * as Assert from '../Assert/Assert.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstNodeWorkerEvent from '../GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js'
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const create = async ({ path, argv, env, execArgv }) => {
+  Assert.string(path)
+  const actualArgv = ['--ipc-type=node-worker', ...argv]
+  const worker = new Worker(path, {
+    argv: actualArgv,
+    env,
+    execArgv,
+  })
+  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw event
+  }
+  if (type === FirstNodeWorkerEventType.Exit) {
+    throw new IpcError('worker exited unexpectedly')
+  }
+  return worker
+}
+
+export const wrap = (worker) => {
+  return {
+    worker,
+    on(event, listener) {
+      this.worker.on(event, listener)
+    },
+    send(message) {
+      this.worker.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      this.worker.postMessage(message, transfer)
+    },
+    dispose() {
+      this.worker.terminate()
+    },
+  }
+}

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/JsonRpcVersion/JsonRpcVersion.js

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

package/src/parts/ParseCliArgs/ParseCliArgs.js

@@ -0,0 +1,16 @@
+import parseArgv from 'minimist'
+
+export const parseCliArgs = (argv) => {
+  const parsed = parseArgv(argv)
+  const result = Object.create(null)
+  if (parsed.headless) {
+    result.headless = true
+  }
+  if (parsed['only-extension']) {
+    result.onlyExtension = parsed['only-extension']
+  }
+  if (parsed['test-path']) {
+    result.testPath = parsed['test-path']
+  }
+  return result
+}

package/src/parts/ParseEnv/ParseEnv.js

@@ -0,0 +1,10 @@
+export const parseEnv = (env) => {
+  const options = Object.create(null)
+  if (env['ONLY_EXTENSION']) {
+    options['onlyExtension'] = env['ONLY_EXTENSION']
+  }
+  if (env['TEST_PATH']) {
+    options['testPath'] = env['TEST_PATH']
+  }
+  return options
+}

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] uncaught exception ${error}`)
+}

package/src/parts/Root/Root.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 root = join(__dirname, '..', '..', '..', '..', '..')

package/src/parts/RunAllTests/RunAllTests.js

@@ -0,0 +1,22 @@
+import * as GetTestWorkerPath from '../GetTestWorkerPath/GetTestWorkerPath.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as TestWorkerCommandType from '../TestWorkerCommandType/TestWorkerCommandType.js'
+
+/**
+ *
+ * @param {{onlyExtension:string, testPath:string, cwd:string, headless:boolean, timeout:number}} param0
+ */
+export const runAllTests = async ({ onlyExtension, testPath, cwd, headless, timeout }) => {
+  const path = GetTestWorkerPath.getTestWorkerPath()
+  const ipc = await IpcParent.create({
+    method: IpcParentType.NodeWorker,
+    path,
+    argv: [],
+  })
+  HandleIpc.handleIpc(ipc)
+  await JsonRpc.invoke(ipc, TestWorkerCommandType.RunAllTests, onlyExtension, testPath, cwd, headless, timeout)
+  ipc.dispose()
+}

package/src/parts/Signal/Signal.js

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

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/all.js

@@ -1,126 +0,0 @@
-import { expect } from '@playwright/test'
-import parseArgv from 'minimist'
-import { readdirSync } from 'node:fs'
-import { basename, join } from 'node:path'
-import { performance } from 'node:perf_hooks'
-import { closeAll, getRoot, startAll } from './main.js'
-
-/**
- * @param {string} name
- */
-const isTestFile = (name) => {
-  return !name.startsWith('_')
-}
-
-/**
- * @param {string} root
- */
-const getTestFiles = async (root) => {
-  return readdirSync(root)
-    .filter(isTestFile)
-    .map((x) => join(root, x))
-}
-
-/**
- * @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}`
-}
-
-/**
- *
- * @param {import('@playwright/test').Page} page
- * @param {string} url
- */
-const executeSingleTest = async (page, url) => {
-  await page.goto(url)
-  const testOverlay = page.locator('#TestOverlay')
-  await expect(testOverlay).toBeVisible({ timeout: 25_000 })
-  const text = await testOverlay.textContent()
-  const state = await testOverlay.getAttribute('data-state')
-  switch (state) {
-    case 'pass':
-      return {
-        status: 'pass',
-      }
-    case 'skip':
-      return {
-        status: 'skip',
-      }
-    case 'fail':
-      return {
-        status: 'fail',
-        error: `${text}`,
-      }
-    default:
-      throw new Error(`unexpected test state: ${state}`)
-  }
-}
-
-/**
- *
- * @param {any} options
- */
-const getEnv = (options) => {
-  const env = Object.create(null)
-  if (options['only-extension']) {
-    env['ONLY_EXTENSION'] = options['only-extension']
-  }
-  if (options['test-path']) {
-    env['TEST_PATH'] = options['test-path']
-  }
-  return env
-}
-
-const main = async () => {
-  try {
-    const argv = process.argv.slice(2)
-    const options = parseArgv(argv)
-    let skipped = 0
-    let passed = 0
-    const env = getEnv(options)
-    const start = performance.now()
-    const { page, port } = await startAll(env)
-    const root = await getRoot()
-    const testFiles = await getTestFiles(join(root, 'src'))
-    console.log({ testFiles })
-    for (const testFile of testFiles) {
-      const url = getUrlFromTestFile(testFile, port)
-      const name = basename(testFile)
-      const result = await executeSingleTest(page, url)
-      switch (result.status) {
-        case 'pass':
-          console.info(`test passed ${name}`)
-          passed++
-          break
-        case 'skip':
-          console.info(`test skipped ${name}`)
-          skipped++
-          break
-        case 'fail':
-          throw new Error(`Test Failed ${name}: ${result.error}`)
-      }
-    }
-    const end = performance.now()
-    const duration = end - start
-    if (skipped) {
-      console.info(
-        `${passed} tests passed, ${skipped} tests skipped in ${duration}ms`
-      )
-    } else {
-      console.info(`${passed} tests passed in ${duration}ms`)
-    }
-  } catch (error) {
-    console.info('tests failed')
-    console.error(error)
-    process.exit(1)
-  } finally {
-    await closeAll()
-  }
-}
-
-main()

package/src/main.js

@@ -1,140 +0,0 @@
-import { chromium } from '@playwright/test'
-import assert from 'node:assert'
-import { fork } from 'node:child_process'
-import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
-import getPort from 'get-port'
-import { join } from 'node:path'
-import { performance } from 'node:perf_hooks'
-import { tmpdir } from 'node:os'
-import { dirname } from 'node:path'
-import { readPackageUp } from 'read-pkg-up'
-
-export const state = {
-  /**
-   * @type {import('@playwright/test').Page|undefined}
-   */
-  page: undefined,
-  /**
-   * @type {import('@playwright/test').Browser|undefined}
-   */
-  browser: undefined,
-  /**
-   * @type {import('child_process').ChildProcess|undefined}
-   */
-  childProcess: undefined,
-  /**
-   * @type{boolean}
-   */
-  runImmediately: true,
-  /**
-   * @type{any}
-   */
-  port: 0,
-  root: undefined,
-}
-
-export const getRoot = async () => {
-  const rootPackageJson = await readPackageUp()
-  if (!rootPackageJson) {
-    throw new Error('package json not found')
-  }
-  return dirname(rootPackageJson.path)
-}
-
-const getExtensionFolder = async () => {
-  const root = state.root || (await getRoot())
-  return join(root, '..', 'extension')
-}
-
-export const getTmpDir = (prefix = 'foo-') => {
-  return mkdtemp(join(tmpdir(), prefix))
-}
-
-const launchServer = async ({ port, folder, env }) => {
-  const { serverPath } = await import('@lvce-editor/server')
-  // TODO disable saving state between tests in settings
-  const configDir = await getTmpDir()
-  await mkdir(join(configDir, 'lvce-oss'), { recursive: true })
-  await writeFile(
-    join(configDir, 'lvce-oss', 'settings.json'),
-    JSON.stringify(
-      {
-        'workbench.saveStateOnVisibilityChange': false,
-      },
-      null,
-      2
-    )
-  )
-  const extensionFolder = await getExtensionFolder()
-  const childProcess = fork(serverPath, {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      PORT: port,
-      FOLDER: folder,
-      ONLY_EXTENSION: extensionFolder,
-      XDG_CONFIG_HOME: configDir,
-      ...env,
-    },
-  })
-  state.childProcess = childProcess
-  return new Promise((resolve, reject) => {
-    const handleMessage = (message) => {
-      if (message === 'ready') {
-        resolve(undefined)
-      } else {
-        reject(new Error('expected ready message'))
-      }
-    }
-    childProcess.once('message', handleMessage)
-  })
-}
-
-const startBrowser = async ({ port, headless = false }) => {
-  assert(!state.browser, 'Browser should not be defined')
-  console.info('START BROWSER')
-  const browser = await chromium.launch({
-    headless,
-  })
-  state.browser = browser
-  const page = await browser.newPage({})
-  state.page = page
-  return page
-}
-
-export const runTest = async ({ name, fn }) => {
-  const start = performance.now()
-  console.info(`[test] running ${name}`)
-  await fn()
-  const end = performance.now()
-  const duration = end - start
-  console.info(`[test] passed ${name} in ${duration}ms`)
-}
-
-export const startAll = async (env) => {
-  const port = await getPort()
-  await launchServer({
-    port,
-    env,
-    folder: '',
-  })
-  state.port = port
-  const headless = process.argv.includes('--headless')
-  const page = await startBrowser({ port, headless })
-  return { page, port }
-}
-
-export const closeAll = async () => {
-  if (state.childProcess) {
-    state.childProcess.kill('SIGTERM')
-    state.childProcess = undefined
-  }
-  if (state.page) {
-    await state.page.close()
-    state.page = undefined
-  }
-  if (state.browser) {
-    await state.browser.close()
-    state.browser = undefined
-  }
-}