@lvce-editor/test-with-playwright 0.0.25 → 0.0.27

package/bin/test-with-playwright.js

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

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "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,13 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@playwright/test": "^1.31.2",
+    "@playwright/test": "^1.34.3",
     "get-port": "^6.1.2",
     "minimist": "^1.2.8",
-    "read-pkg-up": "^9.1.0"
+    "read-pkg-up": "^9.1.0",
+    "verror": "^1.10.1"
+  },
+  "devDependencies": {
+    "@types/verror": "^1.10.6"
   }
 }

package/src/parts/CloseAll/CloseAll.js

@@ -0,0 +1,16 @@
+import * as TestState from '../TestState/TestState.js'
+
+export const closeAll = async () => {
+  if (TestState.state.childProcess) {
+    TestState.state.childProcess.kill('SIGTERM')
+    TestState.state.childProcess = undefined
+  }
+  if (TestState.state.page) {
+    await TestState.state.page.close()
+    TestState.state.page = undefined
+  }
+  if (TestState.state.browser) {
+    await TestState.state.browser.close()
+    TestState.state.browser = undefined
+  }
+}

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -0,0 +1,2 @@
+export const ENOENT = 'ENOENT'
+export const E_NO_TEST_FILES = 'E_NO_TEST_FILES'

package/src/parts/ExitCode/ExitCode.js

@@ -0,0 +1,2 @@
+export const Success = 0
+export const Error = 1

package/src/parts/GetPort/GetPort.js

@@ -0,0 +1,3 @@
+import getPort from 'get-port'
+
+export { getPort }

package/src/parts/GetRoot/GetRoot.js

@@ -0,0 +1,10 @@
+import { dirname } from 'node:path'
+import { readPackageUp } from 'read-pkg-up'
+
+export const getRoot = async () => {
+  const rootPackageJson = await readPackageUp()
+  if (!rootPackageJson) {
+    throw new Error('package json not found')
+  }
+  return dirname(rootPackageJson.path)
+}

package/src/parts/GetTestFiles/GetTestFiles.js

@@ -0,0 +1,21 @@
+import { readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as IsTestFile from '../IsTestFile/IsTestFile.js'
+import VError from 'verror'
+import { NoTestFilesFoundError } from '../NoTestFilesFoundError/NoTestFIlesFoundError.js'
+
+/**
+ * @param {string} root
+ */
+export const getTestFiles = async (root) => {
+  try {
+    const dirents = await readdir(root)
+    return dirents.filter(IsTestFile.isTestFile).map((x) => join(root, x))
+  } catch (error) {
+    if (error && error.code === ErrorCodes.ENOENT) {
+      throw new NoTestFilesFoundError(root)
+    }
+    throw new VError(error, `Failed to get test files`)
+  }
+}

package/src/parts/GetTmpDir/GetTmpDir.js

@@ -0,0 +1,7 @@
+import { mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+export const getTmpDir = (prefix = 'foo-') => {
+  return mkdtemp(join(tmpdir(), prefix))
+}

package/src/parts/IsTestFile/IsTestFile.js

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

package/src/parts/LaunchServer/LaunchServer.js

@@ -0,0 +1,51 @@
+import { fork } from 'node:child_process'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import * as GetRoot from '../GetRoot/GetRoot.js'
+import * as GetTmpDir from '../GetTmpDir/GetTmpDir.js'
+import * as TestState from '../TestState/TestState.js'
+
+const getExtensionFolder = async () => {
+  const root = TestState.state.root || (await GetRoot.getRoot())
+  return join(root, '..', 'extension')
+}
+
+export 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.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,
+    },
+  })
+  TestState.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)
+  })
+}

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

@@ -0,0 +1,5 @@
+export const argv = process.argv
+
+export const exit = (code) => {
+  process.exit(code)
+}

package/src/parts/RunAllTests/RunAllTests.js

@@ -0,0 +1,56 @@
+import parseArgv from 'minimist'
+import { join } from 'node:path'
+import * as CloseAll from '../CloseAll/CloseAll.js'
+import * as ExitCode from '../ExitCode/ExitCode.js'
+import * as GetRoot from '../GetRoot/GetRoot.js'
+import * as GetTestFiles from '../GetTestFiles/GetTestFiles.js'
+import * as Process from '../Process/Process.js'
+import * as RunTests from '../RunTests/RunTests.js'
+import * as ShouldLogErrorWithStack from '../ShouldLogErrorWithStack/ShouldLogErrorWithStack.js'
+import * as StartAll from '../StartAll/StartAll.js'
+
+/**
+ *
+ * @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)
+    const env = getEnv(options)
+    const { page, port } = await StartAll.startAll(env)
+    const root = await GetRoot.getRoot()
+    const testFiles = await GetTestFiles.getTestFiles(join(root, 'src'))
+    console.log({ testFiles })
+    await RunTests.runTests({
+      testFiles,
+      options,
+      page,
+      port,
+    })
+  } catch (error) {
+    console.info('tests failed')
+    if (ShouldLogErrorWithStack.shouldLogErrorWithStack(error)) {
+      console.error(error)
+    } else {
+      // @ts-ignore
+      console.error(error.message)
+    }
+    Process.exit(ExitCode.Error)
+  } finally {
+    await CloseAll.closeAll()
+  }
+}
+
+main()

package/src/parts/RunTest/RunTest.js

@@ -0,0 +1,10 @@
+import { performance } from 'node:perf_hooks'
+
+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`)
+}

package/src/parts/RunTests/RunTests.js

@@ -0,0 +1,83 @@
+import { expect } from '@playwright/test'
+import { basename } from 'node:path'
+import { performance } from 'node:perf_hooks'
+import * as TestOverlayTimeout from '../TestOverlayTimeout/TestOverlayTimeout.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}`
+}
+
+/**
+ *
+ * @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: TestOverlayTimeout.testOverlayTimeout,
+  })
+  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 {{testFiles:any[], options:any, port:number, page: import('@playwright/test').Page}} param0
+ */
+export const runTests = async ({ testFiles, options, port, page }) => {
+  let skipped = 0
+  let passed = 0
+  const start = performance.now()
+  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`)
+  }
+}

package/src/parts/ShouldLogErrorWithStack/ShouldLogErrorWithStack.js

@@ -0,0 +1,13 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+/**
+ *
+ * @param {any} error
+ * @returns
+ */
+export const shouldLogErrorWithStack = (error) => {
+  if (error && error.code === ErrorCodes.E_NO_TEST_FILES) {
+    return false
+  }
+  return true
+}

package/src/parts/StartAll/StartAll.js

@@ -0,0 +1,18 @@
+import * as GetPort from '../GetPort/GetPort.js'
+import * as LaunchServer from '../LaunchServer/LaunchServer.js'
+import * as StartBrowser from '../StartBrowser/StartBrowser.js'
+import * as TestState from '../TestState/TestState.js'
+import * as Process from '../Process/Process.js'
+
+export const startAll = async (env) => {
+  const port = await GetPort.getPort()
+  await LaunchServer.launchServer({
+    port,
+    env,
+    folder: '',
+  })
+  TestState.state.port = port
+  const headless = Process.argv.includes('--headless')
+  const page = await StartBrowser.startBrowser({ headless })
+  return { page, port }
+}

package/src/parts/StartBrowser/StartBrowser.js

@@ -0,0 +1,15 @@
+import { chromium } from '@playwright/test'
+import assert from 'node:assert'
+import * as TestState from '../TestState/TestState.js'
+
+export const startBrowser = async ({ headless = false }) => {
+  assert(!TestState.state.browser, 'Browser should not be defined')
+  console.info('START BROWSER')
+  const browser = await chromium.launch({
+    headless,
+  })
+  TestState.state.browser = browser
+  const page = await browser.newPage({})
+  TestState.state.page = page
+  return page
+}

package/src/parts/TestOverlayTimeout/TestOverlayTimeout.js

@@ -0,0 +1 @@
+export const testOverlayTimeout = 25_000

package/src/parts/TestResultType/TestResultType.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,23 @@
+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,
+}

package/src/all.js

@@ -1,126 +0,0 @@
-import { expect } from '@playwright/test'
-import { readdirSync } from 'node:fs'
-import { basename, join } from 'node:path'
-import { performance } from 'node:perf_hooks'
-import { closeAll, getRoot, runTest, startAll, state } from './main.js'
-import parseArgv from 'minimist'
-
-/**
- * @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 'assert'
-import { fork } from 'child_process'
-import { mkdir, mkdtemp, writeFile } from 'fs/promises'
-import getPort from 'get-port'
-import { join } from 'node:path'
-import { performance } from 'node:perf_hooks'
-import { tmpdir } from 'os'
-import { dirname } from '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
-  }
-}