feat: add server url to the client

mocks/test.mocha.js

@@ -36,6 +36,10 @@ describe('Array', () => {
       equal(import.meta.env, process.env)
     })
 
+    it('should has server', async () => {
+      equal(process.env.PW_SERVER, Client.server)
+    })
+
     it('should setoffline', async () => {
       if (Client.mode === 'main' && Client.options.extension === false) {
         globalThis.addEventListener('offline', () => {

src/client/index.js

@@ -1,11 +1,30 @@
-const config = /** @type { import('../types.js').RunnerOptions} */ (
-  /** @type { unknown } */ (process.env.PW_TEST)
+const config = /** @type { import('../types.js').RunnerEnv} */ (
+  /** @type { unknown } */ (process.env)
 )
 
-export const mode = config.mode
+/**
+ * Playwright Test mode
+ */
+export const mode = config.PW_TEST.mode
 
-export const options = config
+/**
+ * Playwright Test options
+ */
+export const options = config.PW_TEST
 
+/**
+ * Playwright Test server url
+ *
+ * @type {string}
+ */
+export const server = config.PW_SERVER
+
+/**
+ * Playwright Test browser context
+ *
+ * Methods to interact with the browser context
+ *
+ */
 export const context = {
   /** @type {import('playwright-core').BrowserContext['setOffline']} */
   setOffline(offline) {

src/node/runner.js

@@ -7,7 +7,7 @@ import { nanoid } from 'nanoid'
 import { watch } from 'chokidar'
 import { execa } from 'execa'
 import { premove } from 'premove'
-import { findTests, log } from '../utils/index.js'
+import { createPolka, findTests, log } from '../utils/index.js'
 import * as DefaultRunners from '../test-runners.js'
 import { build } from './utils.js'
 
@@ -57,13 +57,18 @@ export class NodeRunner {
   constructor(options = {}, testFiles) {
     /** @type {import('../types.js').RunnerOptions} */
     this.options = merge(defaultOptions, options)
+    /** @type {import('polka').Polka["server"] | undefined} */
+    this.server = undefined
     this.dir = path.join(__dirname, '../.tmp', nanoid())
     mkdirSync(this.dir, {
       recursive: true,
     })
     this.stopped = false
     this.watching = false
     this.beforeTestsOutput = undefined
+    /**
+     * @type {import('../types.js').RunnerEnv}
+     */
     this.env = merge(JSON.parse(JSON.stringify(process.env)), {
       PW_TEST: this.options,
       NODE_ENV: 'test',
@@ -81,6 +86,17 @@ export class NodeRunner {
     }
   }
 
+  async #setupServer() {
+    // setup http server
+    const { server, url } = await createPolka(
+      this.dir,
+      this.options.cwd,
+      this.options.assets
+    )
+    this.env.PW_SERVER = url
+    this.server = server
+  }
+
   /**
    * Run the tests
    *
@@ -104,6 +120,8 @@ export class NodeRunner {
     asyncExitHook(this.#clean.bind(this), {
       wait: 1000,
     })
+
+    await this.#setupServer()
     this.beforeTestsOutput = await this.options.beforeTests(this.options)
 
     try {
@@ -148,6 +166,7 @@ export class NodeRunner {
       wait: 1000,
     })
 
+    await this.#setupServer()
     this.beforeTestsOutput = await this.options.beforeTests(this.options)
 
     const { files, outName } = await this.runTests()
@@ -191,6 +210,20 @@ export class NodeRunner {
     // Run after tests hook
     await this.options.afterTests(this.options, this.beforeTestsOutput)
     await premove(this.dir)
+    const serverClose = new Promise((resolve, reject) => {
+      if (this.server) {
+        this.server.close((err) => {
+          if (err) {
+            return reject(err)
+          }
+          resolve(true)
+        })
+      } else {
+        resolve(true)
+      }
+    })
+
+    await serverClose
   }
 
   /**

src/runner.js

@@ -56,6 +56,8 @@ export class Runner {
     this.url = ''
     this.stopped = false
     this.watching = false
+
+    /** @type {import('./types').RunnerEnv} */
     this.env = merge(JSON.parse(JSON.stringify(process.env)), {
       PW_TEST: this.options,
       NODE_ENV: 'test',
@@ -81,7 +83,14 @@ export class Runner {
     await cpy(path.join(__dirname, './../static') + '/**', this.dir)
 
     // setup http server
-    await createPolka(this)
+    const { server, url } = await createPolka(
+      this.dir,
+      this.options.cwd,
+      this.options.assets
+    )
+    this.env.PW_SERVER = url
+    this.url = url
+    this.server = server
 
     // download playwright if needed
     const pw = await getPw(this.options.browser)

src/types.d.ts

@@ -31,6 +31,12 @@ export interface RunnerOptions {
   ) => Promise<unknown>
 }
 
+export interface RunnerEnv extends NodeJS.ProcessEnv {
+  PW_SERVER: string
+  PW_TEST: RunnerOptions
+  NODE_ENV: 'test'
+}
+
 export type PwResult<TBrowser> = TBrowser extends 'webkit'
   ? WebKitBrowser
   : TBrowser extends 'firefox'

src/utils/index.js

@@ -601,17 +601,22 @@ function getPort(port = 3000, host = '127.0.0.1') {
 }
 
 /**
- * @param {import('../runner').Runner} runner
+ * Create polka server
+ *
+ * @param {string} dir - Runner directory
+ * @param {string} cwd - Current working directory
+ * @param {string} assets - Assets directory
+ * @returns {Promise<{ url: string; server: import('http').Server }>}
  */
-export async function createPolka(runner) {
+export async function createPolka(dir, cwd, assets) {
   const host = '127.0.0.1'
   const port = await getPort(0, host)
   const url = `http://${host}:${port}/`
   return new Promise((resolve, reject) => {
     const { server } = polka()
       .use(
         // @ts-ignore
-        sirv(runner.dir, {
+        sirv(dir, {
           dev: true,
           setHeaders: (
             /** @type {{ setHeader: (arg0: string, arg1: string) => void; }} */ rsp,
@@ -626,19 +631,19 @@ export async function createPolka(runner) {
       )
       .use(
         // @ts-ignore
-        sirv(path.join(runner.options.cwd, runner.options.assets), {
+        sirv(path.join(cwd, assets), {
           dev: true,
         })
       )
       .listen(port, host, (/** @type {Error} */ err) => {
         if (err) {
-          reject(err)
+          return reject(err)
+        }
 
-          return
+        if (!server) {
+          return reject(new Error('No server'))
         }
-        runner.url = url
-        runner.server = server
-        resolve(true)
+        resolve({ url, server })
       })
   })
 }