@lvce-editor/test-with-playwright 0.0.14 → 0.0.18

package/bin/test-with-playwright.js

@@ -0,0 +1 @@
+import '../src/all.js'

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "0.0.14",
+  "version": "0.0.18",
   "description": "",
   "main": "src/main.js",
   "types": "src/main.d.ts",
   "type": "module",
+  "bin": "bin/test-with-playwright.js",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/test-with-playwright.git"
@@ -15,6 +16,7 @@
   "dependencies": {
     "@playwright/test": "^1.25.0",
     "get-port": "^6.1.2",
+    "minimist": "^1.2.6",
     "read-pkg-up": "^9.1.0"
   }
 }

package/src/all.js

@@ -1,36 +1,108 @@
+import { expect } from '@playwright/test'
 import { readdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { basename, join } from 'node:path'
 import { performance } from 'node:perf_hooks'
-import { pathToFileURL } from 'node:url'
 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).map((x) => join(root, x))
+  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.replace('.js', '.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()
-    state.runImmediately = false
-    await startAll()
-    console.info('SETUP COMPLETE')
+    const { page, port } = await startAll(env)
     const root = await getRoot()
-    state.root = root
     const testFiles = await getTestFiles(join(root, 'src'))
     console.log({ testFiles })
     for (const testFile of testFiles) {
-      state.tests = []
-      const testUri = pathToFileURL(testFile).toString()
-      await import(testUri)
-      for (const test of state.tests) {
-        if (test.status === 'skipped') {
-          skipped++
-        } else {
-          await runTest(test)
+      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()

package/src/main.js

@@ -29,7 +29,6 @@ export const state = {
   /**
    * @type{any}
    */
-  tests: [],
   port: 0,
   root: undefined,
 }
@@ -47,7 +46,7 @@ const getExtensionFolder = async () => {
   return join(root, '..', 'extension')
 }
 
-export const getTmpDir = (prefix='foo-') => {
+export const getTmpDir = (prefix = 'foo-') => {
   return mkdtemp(join(tmpdir(), prefix))
 }
 
@@ -103,34 +102,6 @@ const startBrowser = async ({ port, headless = false }) => {
   return page
 }
 
-export const runWithExtension = async ({ folder = '', env = {} }) => {
-  folder ||= await getTmpDir()
-  if (state.page && state.childProcess) {
-    console.info('recycle page')
-    state.childProcess.send({
-      jsonrpc: '2.0',
-      method: 'Platform.setEnvironmentVariables',
-      params: [
-        {
-          FOLDER: folder,
-          ...env,
-        },
-      ],
-      id: 999999999999,
-    })
-    await state.page.goto(`http://localhost:${state.port}`)
-    return state.page
-  }
-  const port = await getPort()
-  const server = await launchServer({ port, folder, env })
-  const page = await startBrowser({
-    headless: false,
-    port,
-  })
-  await page.goto(`http://localhost:${port}`)
-  return page
-}
-
 export const runTest = async ({ name, fn }) => {
   const start = performance.now()
   console.info(`[test] running ${name}`)
@@ -140,29 +111,17 @@ export const runTest = async ({ name, fn }) => {
   console.info(`[test] passed ${name} in ${duration}ms`)
 }
 
-export const test = async (name, fn) => {
-  if (state.runImmediately) {
-    await runTest({ name, fn })
-  } else {
-    state.tests.push({ name, fn })
-  }
-}
-
-test.skip = (name, fn) => {
-  state.tests.push({ name, fn, status: 'skipped' })
-}
-
-export const startAll = async () => {
+export const startAll = async (env) => {
   const port = await getPort()
   await launchServer({
     port,
-    env: {},
+    env,
     folder: '',
   })
   state.port = port
   const headless = process.argv.includes('--headless')
   const page = await startBrowser({ port, headless })
-  return page
+  return { page, port }
 }
 
 export const closeAll = async () => {
@@ -179,5 +138,3 @@ export const closeAll = async () => {
     state.browser = undefined
   }
 }
-
-export { expect } from '@playwright/test'

package/src/main.d.ts

@@ -1,18 +0,0 @@
-import type { Page } from '@playwright/test'
-
-export const runWithExtension: ({
-  folder,
-  env,
-}: {
-  folder?: string
-  env?: any
-}) => Promise<Page>
-
-export const test: {
-  (name: string, fn: () => Promise<void>): void
-  skip: (name: string, fn: () => Promise<void>) => void
-}
-
-export { expect } from '@playwright/test'
-
-export const getTmpDir: (prefix = 'foo-') => Promise<string>