ui5-test-runner 5.9.0 → 5.10.0

package/src/inject/jest2qunit.js

@@ -0,0 +1,289 @@
+/* global sinon */
+(() => {
+  class Jest2QUnitError extends SyntaxError {
+    static throw (reason) {
+      throw new Jest2QUnitError(reason)
+    }
+
+    constructor (reason) {
+      super('jest2qunit failure : ' + reason)
+      this.name = 'Jest2QUnitError'
+    }
+  }
+
+  const $raw = Symbol('raw')
+  const unproxify = (value) => value && (value[$raw] ?? value)
+
+  const get = function (target, property) {
+    if (target[property] !== undefined) {
+      return target[property]
+    }
+    if (typeof property === 'symbol') {
+      return undefined // otherwise returned previously
+    }
+    if (typeof this[property] === 'function') {
+      return this[property](target)
+    }
+    Jest2QUnitError.throw(`${this._type}.${property} is missing`)
+  }
+
+  let _sinonSandbox
+  const jestSpy = (sinonStub) => new Proxy(Object.assign(sinonStub, {
+    [$raw]: sinonStub,
+    mockImplementation (callback) { sinonStub.callsFake(callback); return this },
+    mockImplementationOnce (callback) { sinonStub.onCall(0).callsFake(callback); return this },
+    mockResolvedValue (value) { sinonStub.returns(Promise.resolve(value)); return this },
+    mockResolvedValueOnce (value) { sinonStub.onCall(0).returns(Promise.resolve(value)); return this },
+    mockRejectedValue (value) { sinonStub.returns(Promise.reject(value)); return this },
+    mockRejectedValueOnce (value) { sinonStub.onCall(0).returns(Promise.reject(value)); return this },
+    mockReturnValue (value) { sinonStub.returns(value); return this },
+    mockReturnValueOnce (value) { sinonStub.onCall(0).returns(value); return this },
+    mockRestore () { sinonStub.restore() },
+    get mock () {
+      return new Proxy({}, {
+        _type: 'jestSpy.mock',
+        get,
+        calls () { return sinonStub.args },
+        results () { return sinonStub.returnValues.map(value => ({ value })) }
+      })
+    }
+  }), { _type: 'jestSpy', get })
+
+  const jest = new Proxy({
+    fn (impl) {
+      const stub = jestSpy(_sinonSandbox.stub())
+      if (impl) {
+        stub.mockImplementation(impl)
+      }
+      return stub
+    },
+    spyOn (object, property) {
+      const impl = object[property]
+      if (impl[$raw]) { // already looks like a spy
+        return impl
+      }
+      const spy = jestSpy(_sinonSandbox.stub(object, property))
+      spy.mockImplementation(impl)
+      return spy
+    },
+    clearAllMocks () { _sinonSandbox.resetHistory() }
+  }, { _type: 'jest', get })
+
+  const stringify = value => value === undefined
+    ? 'undefined'
+    : typeof value === 'function'
+      ? Function.prototype.toString.call(value)
+      : value && value instanceof RegExp
+        ? value.toString()
+        : JSON.stringify(value)
+
+  const negate = method => method.startsWith('not')
+    ? method.charAt(3).toLowerCase() + method.substring(4)
+    : 'not' + method.charAt(0).toUpperCase() + method.substring(1)
+
+  const expectQUnit = params => {
+    let { label = 'expect(result)', not, method, assert = 'ok', value, compute, expected, expectedLabel = stringify(expected) } = params
+    if (expected) {
+      expected = unproxify(expected)
+    }
+    if (not) {
+      assert = negate(assert)
+    }
+    const message = `${label}${not ? '.not' : ''}.${method}${!method.includes('(') ? '(' + expectedLabel + ')' : ''}`
+    const parameters = []
+    if ('expected' in params && !['ok', 'notOk'].includes(assert)) {
+      parameters.push(expected)
+    }
+    parameters.push(message)
+    return value && value.then
+      ? value.then(resolvedValue => QUnit.assert[assert](compute ? compute(resolvedValue) : resolvedValue, ...parameters))
+      : QUnit.assert[assert](compute ? compute(value) : value, ...parameters)
+  }
+
+  const expect = (value, label) => {
+    value = unproxify(value)
+    let not = false
+    const proxy = new Proxy({
+      toBe: (expected) => expectQUnit({ label, not, method: 'toBe', assert: 'equal', value, expected }),
+      toBeDefined: () => expectQUnit({ label, not, method: 'toBeDefined()', assert: 'notStrictEqual', value, expected: undefined }),
+      toBeUndefined: () => expectQUnit({ label, not, method: 'toBeUndefined()', assert: 'strictEqual', value, expected: undefined }),
+      toBeNull: () => expectQUnit({ label, not, method: 'toBeNull()', assert: 'strictEqual', value, expected: null }),
+      toBeNaN: () => expectQUnit({ label, not, method: 'toBeNaN()', value, compute: value => isNaN(value) }),
+      toBeTruthy: () => expectQUnit({ label, not, method: 'toBeTruthy()', value }),
+      toBeFalsy: () => expectQUnit({ label, not, method: 'toBeFalsy()', value, compute: value => !value }),
+      toEqual: (expected) => expectQUnit({ label, not, method: 'toEqual', assert: 'deepEqual', value, expected }),
+      toStrictEqual: (expected) => expectQUnit({ label, not, method: 'toStrictEqual', assert: 'deepEqual', value, expected }),
+      toBeGreaterThan: (expected) => expectQUnit({ label, not, method: 'toBeGreaterThan', value, compute: value => value > expected, expected }),
+      toBeGreaterThanOrEqual: (expected) => expectQUnit({ label, not, method: 'toBeGreaterThanOrEqual', value, compute: value => value >= expected, expected }),
+      toBeLessThan: (expected) => expectQUnit({ label, not, method: 'toBeLessThan', value, compute: value => value < expected, expected }),
+      toBeLessThanOrEqual: (expected) => expectQUnit({ label, not, method: 'toBeLessThanOrEqual', value, compute: value => value <= expected, expected }),
+      toMatch: (expected) => expectQUnit({ label, not, method: 'toMatch', value, compute: value => expected.test(value), expected }),
+      toContain: (expected) => expectQUnit({ label, not, method: 'toContain', value, compute: value => value.includes(expected), expected }),
+      // TODO: handle
+      toThrow: (expected) => expectQUnit({
+        label,
+        not,
+        method: 'toThrow',
+        value,
+        compute: value => {
+          try {
+            value()
+            return false
+          } catch (e) {
+            if (typeof expected === 'string') {
+              return e.message === expected
+            }
+            if (expected instanceof RegExp) {
+              return expected.test(e.message)
+            }
+            return true
+          }
+        },
+        expected,
+        expectedLabel: typeof expected === 'function' && expected.name ? expected.name : undefined
+      }),
+      toBeCloseTo: (expected, numDigits = 2) => {
+        const factor = 10 ** numDigits
+        const round = (x) => Math.floor(x * factor) / factor
+        return expectQUnit({ label, not, method: 'toBeCloseTo', assert: 'strictEqual', value: round(value), expected: round(expected) })
+      },
+      // Not async
+      toHaveBeenCalled: () => expectQUnit({ label, not, method: 'toHaveBeenCalled()', value, compute: value => value.called }),
+      toHaveBeenCalledTimes: (n) => expectQUnit({ label, not, method: 'toHaveBeenCalledTimes', assert: 'strictEqual', value, compute: value => value.callCount, expected: n }),
+      toHaveBeenCalledWith: (...args) => expectQUnit({ label, not, method: `toHaveBeenCalledWith(${args.map(stringify).join(', ')})`, value, compute: value => value.calledWith(...args) })
+    }, {
+      _type: 'expect',
+      get,
+      not () {
+        not = !not
+        return proxy
+      },
+      resolves () {
+        if (not) {
+          Jest2QUnitError.throw('expect.resolves cannot be negated')
+        }
+        if (typeof value.then !== 'function') {
+          Jest2QUnitError.throw('expected value must be thenable')
+        }
+        return expect(value.then(value => value, reason => QUnit.assert.ok(false, reason)), 'expect(result).resolves')
+      },
+      rejects () {
+        if (not) {
+          Jest2QUnitError.throw('expect.resolves cannot be negated')
+        }
+        if (typeof value.then !== 'function') {
+          Jest2QUnitError.throw('expected value must be thenable')
+        }
+        return expect(value.then(() => QUnit.assert.ok(false, 'Promise should not be fulfilled'), reason => reason), 'expect(result).rejects')
+      }
+    })
+    return proxy
+  }
+
+  const rootDescribe = {}
+  let currentDescribe = rootDescribe
+
+  const bddApi = (type, data) => {
+    if (!currentDescribe[type]) {
+      currentDescribe[type] = []
+    }
+    currentDescribe[type].push(data)
+  }
+
+  const beforeAll = (callback) => bddApi('beforeAll', callback)
+  const before = (callback) => bddApi('beforeAll', callback)
+  const beforeEach = (callback) => bddApi('beforeEach', callback)
+  const afterEach = (callback) => bddApi('afterEach', callback)
+  const afterAll = (callback) => bddApi('afterAll', callback)
+  const after = (callback) => bddApi('afterAll', callback)
+  const it = (label, callback) => bddApi('it', { label, callback })
+  it.only = (label, callback) => bddApi('it', { label, callback, only: true })
+  it.skip = (label, callback) => bddApi('it', { label, callback, skip: true })
+  it.todo = (label, callback) => bddApi('it', { label, callback, todo: true })
+  const test = (label, callback) => bddApi('it', { label, callback })
+  test.only = (label, callback) => bddApi('it', { label, callback, only: true })
+  test.skip = (label, callback) => bddApi('it', { label, callback, skip: true })
+  test.todo = (label, callback) => bddApi('it', { label, callback, todo: true })
+
+  const $alreadyConvertedToQUnit = Symbol('alreadyConvertedToQUnit')
+  const toQUnit = (describe) => {
+    if (describe[$alreadyConvertedToQUnit]) {
+      return
+    }
+    describe[$alreadyConvertedToQUnit] = true
+    QUnit.module(describe.label ?? '(root)', function (hooks) {
+      if (describe.beforeAll) {
+        hooks.before(async () => Promise.all(describe.beforeAll.map(callback => callback())))
+      }
+      if (describe.beforeEach) {
+        hooks.beforeEach(async () => Promise.all(describe.beforeEach.map(callback => callback())))
+      }
+      if (describe.afterEach) {
+        hooks.afterEach(async () => Promise.all(describe.afterEach.map(callback => callback())))
+      }
+      if (describe.afterAll) {
+        hooks.after(async () => Promise.all(describe.afterAll.map(callback => callback())))
+      }
+      if (describe.it) {
+        for (const { label, callback, skip, todo, only } of describe.it) {
+          if (todo) {
+            QUnit.test('[todo] ' + label, (assert) => assert.expect(0))
+          } else if (skip) {
+            QUnit.test('[skip] ' + label, (assert) => assert.expect(0))
+          } else if (only) {
+            QUnit.only(label, callback)
+          } else {
+            QUnit.test(label, callback)
+          }
+        }
+      }
+      if (describe.describe) {
+        for (const subDescribe of describe.describe) {
+          toQUnit(subDescribe)
+        }
+      }
+    })
+  }
+
+  const describe = (label, callback) => {
+    QUnit.config.reorder = false // By default in Jest
+    if (typeof sinon !== 'object') {
+      Jest2QUnitError.throw('sinon is missing')
+    }
+    if (sinon.createSandbox === undefined) {
+      Jest2QUnitError.throw('sinon 4 is expected')
+    }
+    _sinonSandbox = sinon.createSandbox()
+
+    const parentDescribe = currentDescribe
+    if (!parentDescribe.describe) {
+      parentDescribe.describe = []
+    }
+    currentDescribe = {
+      label
+    }
+    parentDescribe.describe.push(currentDescribe)
+
+    callback()
+
+    currentDescribe = parentDescribe
+    if (currentDescribe === rootDescribe) {
+      rootDescribe[$alreadyConvertedToQUnit] = false
+      toQUnit(rootDescribe)
+    }
+  }
+
+  Object.assign(globalThis, {
+    jest,
+    expect,
+    beforeAll,
+    before,
+    beforeEach,
+    afterEach,
+    afterAll,
+    after,
+    it,
+    test,
+    describe
+  })
+})()

package/src/inject/post.js

@@ -7,7 +7,8 @@
   }
 
   const base = window['ui5-test-runner/base-host'] || ''
-  const XHR = window.XMLHttpRequest
+  const probe = window['ui5-test-runner/probe'] || false
+  const batchSize = !probe && (window['ui5-test-runner/batch'] || 0)
 
   let lastPost = Promise.resolve()
 
@@ -64,9 +65,10 @@
               'circular:array': [].concat(value) // 'new' object
             }
           }
-          return Object.assign({
-            'circular:id': id
-          }, value)
+          return {
+            'circular:id': id,
+            ...value
+          }
         }
       }
       return value
@@ -77,8 +79,26 @@
 
   const xPageUrl = top.location.toString()
 
-  window[MODULE] = function post (url, data) {
-    function request () {
+  const nativeFetch = window.fetch
+  let request
+  if (nativeFetch) {
+    request = async function (url, data) {
+      const response = await nativeFetch(base + '/_/' + url, {
+        method: 'POST',
+        headers: {
+          'x-page-url': xPageUrl,
+          'content-type': 'application/json'
+        },
+        body: stringify(data)
+      })
+      if (response.status !== 200) {
+        throw response.statusText
+      }
+      return response.text()
+    }
+  } else {
+    const XHR = window.XMLHttpRequest
+    request = function (url, data) {
       return new Promise(function (resolve, reject) {
         const xhr = new XHR()
         xhr.addEventListener('load', () => {
@@ -94,7 +114,10 @@
         xhr.send(json)
       })
     }
-    lastPost = lastPost.then(request)
+  }
+
+  function post (url, data) {
+    lastPost = lastPost.then(() => request(url, data))
     if (!window.__unsafe__) {
       lastPost = lastPost
         .then(undefined, function (reason) {
@@ -103,4 +126,16 @@
     }
     return lastPost
   }
+
+  const aggregatedData = []
+
+  function batch (url, data) {
+    aggregatedData.push([url, data])
+    if (url === 'QUnit/done' || aggregatedData.length === batchSize) {
+      post('QUnit/batch', [...aggregatedData])
+      aggregatedData.length = 0
+    }
+  }
+
+  window[MODULE] = batchSize ? batch : post
 }())

package/src/inject/qunit-hooks.js

@@ -36,6 +36,10 @@
   }
 
   function installQUnitHooks () {
+    if (window !== window.top || window !== window.parent) {
+      return // Do not install in iframe
+    }
+
     QUnit.begin(function (details) {
       details.isOpa = isOpa()
       return post('QUnit/begin', details)
@@ -47,21 +51,24 @@
 
     QUnit.log(function (log) {
       let ready = false
-      post('QUnit/log', extend(log))
-        .then(undefined, function () {
-          console.error('Failed to POST to QUnit/log (no timestamp)', log)
-        })
-        .then(function () {
-          ready = true
-        })
-      if (isOpa()) {
-        window.sap.ui.test.Opa5.prototype.waitFor({
-          timeout: 10,
-          autoWait: false, // Ignore interactable constraint
-          check: function () {
-            return ready
-          }
-        })
+      const result = post('QUnit/log', extend(log))
+      if (result && result.then) {
+        result
+          .then(undefined, function () {
+            console.error('Failed to POST to QUnit/log (no timestamp)', log)
+          })
+          .then(function () {
+            ready = true
+          })
+        if (isOpa()) {
+          window.sap.ui.test.Opa5.prototype.waitFor({
+            timeout: 10,
+            autoWait: false, // Ignore interactable constraint
+            check: function () {
+              return ready
+            }
+          })
+        }
       }
     })
 

package/src/job.js

@@ -114,6 +114,8 @@ function getCommand (cwd) {
     .option('--env <name=value...>', '[💻🔗🧪📡] Set environment variable', arrayOf(string))
     .option('--localhost <host>', `[💻🔗🧪📡] ${DANGEROUS_OPTION} Hostname for legacy URLs and callbacks`, string, 'localhost')
     .option('--ci [flag]', '[💻🔗🧪📡] CI mode (no interactive output)', boolean, false)
+    .option('--deep-probe [flag]', '[💻🔗🧪📡] Deep probe (recursive, slower)', boolean, false)
+    .option('--probe-parallel <count>', '[💻🔗🧪📡] Number of parallel probes (0 to use --parallel)', integer, 0)
 
     // Common to legacy and url
     .option('--webapp <path>', '[💻🔗] Base folder of the web application (relative to cwd)', 'webapp')
@@ -128,6 +130,8 @@ function getCommand (cwd) {
     .option('-so, --split-opa [flag]', '[💻🔗📡] Split OPA tests using QUnit modules', boolean, false)
     .option('-rg, --report-generator <path...>', '[💻🔗📡] Report generator paths (relative to cwd or use $/ for provided ones)', ['$/report.js'])
     .option('--progress-page <path>', '[💻🔗📡] Progress page path (relative to cwd or use $/ for provided ones)', '$/report/default.html')
+    .option('--jest [flag]', `[💻🔗📡] ${EXPERIMENTAL_OPTION} Simulate jest environment`)
+    .option('--qunit-batch-size <size>', `[💻🔗📡] ${EXPERIMENTAL_OPTION} QUnit hooks batch size (disables screenshots)`, integer, 0)
 
     .option('--coverage [flag]', '[💻🔗📡] Enable or disable code coverage', boolean)
     .option('--no-coverage', '[💻🔗📡] Disable code coverage')
@@ -145,10 +149,11 @@ function getCommand (cwd) {
     .option('-w, --watch [flag]', '[💻🔗] Monitor the webapp folder (or the one specified with --watch-folder) and re-execute tests on change', boolean, false)
     .option('--watch-folder <path>', '[💻🔗] Folder to monitor with watch (enables --watch if not specified)', string)
 
-    .option('--start <command>', '[💻🔗] Start command (might be an NPM script or a shell command)', string)
+    .option('--start <command>', '[💻🔗] Start command (might be an NPM script or a shell command) ⚠️ the command is killed on tests completion', string)
     .option('--start-wait-url <command>', '[💻🔗] URL to wait for (🔗 defaulted to first url)', url)
     .option('--start-wait-method <method>', '[💻🔗] HTTP method to check the waited URL', 'GET')
-    .option('--start-timeout <timeout>', '[💻🔗] Maximum waiting time for the start command (based on when the first URL becomes available)', timeout, 5000)
+
+    .option('--start-timeout <timeout>', '[💻🔗] Maximum waiting time for the start command (based on when the first URL becomes available, also used for termination)', timeout, 5000)
 
     .option('--end <script>', '[💻🔗] End script (will receive path to `job.js`)', string)
     .option('--end-timeout <timeout>', '[💻🔗] Maximum waiting time for the end script', timeout, 15000)
@@ -178,6 +183,7 @@ function getCommand (cwd) {
     .addOption(new Option('--debug-probe-only', DEBUG_OPTION, boolean).hideHelp())
     .addOption(new Option('--debug-keep-browser-open', DEBUG_OPTION, boolean).hideHelp())
     .addOption(new Option('--debug-memory', DEBUG_OPTION, boolean).hideHelp())
+    .addOption(new Option('--debug-handles', DEBUG_OPTION, boolean).hideHelp())
     .addOption(new Option('--debug-keep-report', DEBUG_OPTION, boolean).hideHelp())
     .addOption(new Option('--debug-capabilities-test <name>', DEBUG_OPTION).hideHelp())
     .addOption(new Option('--debug-capabilities-no-timeout', DEBUG_OPTION, boolean).hideHelp())
@@ -214,7 +220,7 @@ function checkAccess ({ path, label, file /*, write */ }) {
     // }
     accessSync(path, mode)
   } catch (error) {
-    throw new Error(`Unable to access ${label}, check your settings`)
+    throw new Error(`Unable to access ${label || path}, check your settings`)
   }
   const stat = statSync(path)
   if (file) {
@@ -361,13 +367,18 @@ function finalize (job) {
 
   if (job.mode === 'url') {
     const port = job.port.toString()
-    job[$remoteOnLegacy] = job.url.every(url => {
+    job[$remoteOnLegacy] = job.url && job.url.every(url => {
       // ignore host name since the machine might be exposed with any name
       const parsedUrl = new URL(url)
       return parsedUrl.port === port
     })
   }
 
+  if (job.qunitBatchSize) {
+    job.screenshot = false
+    job.screenshotOnFailure = false
+  }
+
   job[$status] = 'Starting'
   Object.defineProperty(job, 'status', {
     get () {

package/src/npm.js

@@ -80,7 +80,9 @@ function getSafeJobAndOutput (nullableJob) {
     return { job: nullableJob, output: getOutput(nullableJob) }
   }
   return {
-    job: {},
+    job: {
+      offline: true
+    },
     output: {
       debug: noop,
       resolvedPackage: noop,

package/src/output.js

@@ -9,6 +9,8 @@ const {
   $statusProgressTotal
 } = require('./symbols')
 const { filename, noop, pad } = require('./tools')
+const os = require('os')
+const { describeHandle } = require('./handle')
 
 const $output = Symbol('output')
 const $outputStart = Symbol('output-start')
@@ -134,6 +136,22 @@ function progress (job, cleanFirst = true) {
     const fmt = size => `${(size / (1024 * 1024)).toFixed(2)}M`
     sequence.push(`MEM r:${fmt(rss)}, h:${fmt(heapUsed)}/${fmt(heapTotal)}, x:${fmt(external)}, a:${fmt(arrayBuffers)}\n`)
   }
+  if (job.debugHandles) {
+    ++output.lines
+    const activeHandles = process._getActiveHandles ? process._getActiveHandles() : []
+    sequence.push(`HANDLES ${activeHandles.length}\n`)
+    for (let index = 0; index < activeHandles.length; ++index) {
+      const handle = activeHandles[index]
+      const bullet = index === activeHandles.length - 1 ? '└' : '├'
+      ++output.lines
+      const handleDescription = describeHandle(handle).label
+      if (handleDescription.length > process.stdout.columns - 4) {
+        sequence.push(`${bullet}─ ${handleDescription.slice(0, process.stdout.columns - 4)}\n`)
+      } else {
+        sequence.push(`${bullet}─ ${handleDescription}\n`)
+      }
+    }
+  }
   if (job[$outputProgress]) {
     output.lines += job[$outputProgress].length
     job[$outputProgress].forEach(({ count, total, label }) => {
@@ -270,7 +288,24 @@ function build (job) {
 
     version: wrap(() => {
       const { name, version = 'dev' } = require(join(__dirname, '../package.json'))
-      log(job, p80()`${name}@${version}`)
+      log(job, p80()`       _ ____        _            _                                         
+ _   _(_) ___|      | |_ ___  ___| |_      _ __ _   _ _ __  _ __   ___ _ __ 
+| | | | |___ \\ _____| __/ _ \\/ __| __|____| '__| | | | '_ \\| '_ \\ / _ \\ '__|
+| |_| | |___) |_____| ||  __/\\__ \\ ||_____| |  | |_| | | | | | | |  __/ |   
+ \\__,_|_|____/       \\__\\___||___/\\__|    |_|   \\__,_|_| |_|_| |_|\\___|_|   `)
+      const now = new Date()
+      log(job, p80()`${name}@${version} / Node.js ${process.version} / ${now.toISOString()} (${now.getTimezoneOffset()})`)
+      const cpus = {}
+      for (const { model } of os.cpus()) {
+        if (cpus[model]) {
+          ++cpus[model]
+        } else {
+          cpus[model] = 1
+        }
+      }
+      for (const [model, count] of Object.entries(cpus)) {
+        log(job, p80()`${os.machine()} / ${count}x ${model}`)
+      }
       if (job.debugDevMode) {
         log(job, p80()`⚠️  Development mode ⚠️`)
       }
@@ -422,7 +457,7 @@ function build (job) {
     },
 
     packageNotLatest (name, latestVersion) {
-      wrap(() => log(job, `⚠️ [PKGVRS] latest version of ${name} is ${latestVersion}`))()
+      wrap(() => log(job, `⚠️ [PKGVRS] Latest version of ${name} is ${latestVersion}`))()
     },
 
     emptyBrowserArg () {
@@ -430,7 +465,11 @@ function build (job) {
     },
 
     detectedLeakOfHandles () {
-      wrap(() => log(job, '⚠️ [HDLEAK] leaking Node.js handle(s) detected. This may cause issues with the shutdown'))()
+      wrap(() => log(job, '⚠️ [HDLEAK] Leaking Node.js handle(s) detected. This may cause issues with the shutdown'))()
+    },
+
+    failedToTerminateStartCommand () {
+      wrap(() => log(job, '⚠️ [STRTCT] Failed to terminate start command. This may cause issues with the shutdown'))()
     },
 
     browserStart (url) {
@@ -476,6 +515,10 @@ function build (job) {
       browserIssue(job, { type: 'failed', url, code, dir })
     }),
 
+    browserChildProcessError: wrap((url, { code }) => {
+      log(job, p80()`⚠️ [BRWCPE] Child process error ${code}: ${pad.lt(url)}`)
+    }),
+
     skipIf: wrap(() => {
       log(job, p80()`⚠️ [SKIPIF] Skipping execution (--if)`)
     }),
@@ -640,6 +683,15 @@ function build (job) {
       } else {
         log(job, p`│ ${pad.w(error.toString())} │`)
       }
+      if (error.cause) {
+        log(job, p`├────────${pad.x('─')}──┤`)
+        log(job, p`│ Cause : ${pad.x(' ')} │`)
+        if (error.cause.stack) {
+          log(job, p`│ ${pad.w(error.cause.stack)} │`)
+        } else {
+          log(job, p`│ ${pad.w(error.cause.toString())} │`)
+        }
+      }
       log(job, p`└──────────${pad.x('─')}┘`)
     }),
 

package/src/reserve.js

@@ -11,7 +11,7 @@ module.exports = async job => check({
     cors,
     ...job.mappings ?? [],
     ...job.serveOnly ? [] : endpoints(job),
-    ...ui5(job),
+    ...await ui5(job),
     ...job.serveOnly ? [] : await coverage(job),
     {
       // Project mapping