ui5-test-runner 5.9.1 → 5.10.0

package/index.js

@@ -99,10 +99,9 @@ async function main () {
       output.serving(url)
       serverReady()
     })
-    .on('error', error => {
-      output.serverError(error)
-      send({ msg: 'error', error })
-      serverError()
+    .on('error', ({ reason }) => {
+      send({ msg: 'error', reason })
+      serverError(reason)
     })
   await serverStarted
   if (job.preload) {

package/jest.config.json

@@ -14,6 +14,7 @@
   "coveragePathIgnorePatterns": [
     "\\.spec\\.js",
     "output\\.js",
+    "handle\\.js",
     "b\\capabilities\\b"
   ],
   "coverageThreshold": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ui5-test-runner",
-  "version": "5.9.1",
+  "version": "5.10.0",
   "description": "Standalone test runner for UI5",
   "main": "index.js",
   "bin": {
@@ -46,24 +46,24 @@
   "homepage": "https://github.com/ArnaudBuchholz/ui5-test-runner#readme",
   "dependencies": {
     "commander": "^12.1.0",
-    "ps-tree": "^1.2.0",
+    "pidtree": "^0.6.0",
     "punybind": "^1.2.1",
-    "punyexpr": "1.1.1",
+    "punyexpr": "1.2.0",
     "reserve": "2.3.3"
   },
   "devDependencies": {
-    "@openui5/types": "^1.136.1",
-    "@ui5/cli": "^4.0.19",
+    "@openui5/types": "^1.140.0",
+    "@ui5/cli": "^4.0.26",
     "@ui5/middleware-code-coverage": "^2.0.1",
     "dotenv": "^16.5.0",
     "jest": "^29.7.0",
-    "nock": "^14.0.5",
-    "npm-check-updates": "^18.0.1",
+    "nock": "^14.0.10",
+    "npm-check-updates": "^18.3.0",
     "nyc": "^17.1.0",
     "rimraf": "^6.0.1",
     "standard": "^17.1.2",
-    "typescript": "^5.8.3",
-    "ui5-tooling-transpile": "^3.8.0"
+    "typescript": "^5.9.2",
+    "ui5-tooling-transpile": "^3.9.2"
   },
   "optionalDependencies": {
     "fsevents": "^2.3.3"

package/src/browsers.js

@@ -14,8 +14,9 @@ let lastScreenshotId = 0
 const screenshots = {}
 
 async function instantiate (job, config) {
+  const output = getOutput(job)
   if (job.browserArgs.some((arg) => !arg.trim())) {
-    getOutput(job).emptyBrowserArg()
+    output.emptyBrowserArg()
     job.browserArgs = job.browserArgs.filter((arg) => arg.trim())
   }
   const { dir, url } = config
@@ -48,6 +49,9 @@ async function instantiate (job, config) {
     }
     resolve(code)
   })
+  childProcess.on('error', err => {
+    output.browserChildProcessError(url, err)
+  })
   childProcess.closed = promise
   childProcess.stdoutFilename = stdoutFilename
   childProcess.stderrFilename = stderrFilename

package/src/clean.js

@@ -1,4 +1,5 @@
 const { getOutput } = require('./output')
+const { describeHandle } = require('./handle')
 
 module.exports = {
   cleanHandles (job) {
@@ -6,22 +7,14 @@ module.exports = {
     const activeHandles = process._getActiveHandles ? process._getActiveHandles() : []
     let displayWarning = true
     for (const handle of activeHandles) {
-      const className = handle && handle.constructor && handle.constructor.name
-      output.debug('handle', 'active handle', className)
-      if (className === 'TLSSocket') {
+      const { className, label } = describeHandle(handle)
+      output.debug('handle', 'active handle', label)
+      if (className === 'TLSSocket' || className === 'Socket') {
         if (displayWarning) {
           displayWarning = false
           output.detectedLeakOfHandles()
         }
-        let info
-        if (handle._httpMessage) {
-          const { path, method, host, protocol } = handle._httpMessage
-          info = `${method} ${protocol}//${host}${path}`
-        } else {
-          const { localAddress, localPort, remoteAddress, remotePort } = handle
-          info = `from ${localAddress}:${localPort} to ${remoteAddress}:${remotePort}`
-        }
-        output.debug('handle', 'TLS socket', info)
+        output.debug('handle', className, label)
         handle.destroy()
       }
     }

package/src/cors.js

@@ -7,8 +7,8 @@ module.exports = {
       response.writeHead(200, {
         'Access-Control-Allow-Origin': origin,
         Vary: 'Origin',
-        'Access-Control-Allow-Headers': 'content-type, content-length, x-page-url',
-        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': '*',
+        'Access-Control-Allow-Methods': '*',
         'Access-Control-Allow-Credentials': 'true'
       })
       response.end()

package/src/coverage.js

@@ -169,7 +169,7 @@ async function buildAllIndex (job) {
       await writeFile(join(job.coverageTempDir, 'all-index.json'), `{${index.join(',')}}`)
     }
   } catch (e) {
-    output.genericError(e)
+    output.genericError(e, e.url)
     output.noInfoForAllCoverage()
   } finally {
     progress.done()

package/src/defaults/puppeteer.js

@@ -3,6 +3,8 @@
 let browser
 let page
 
+console.time('⏲ run      ')
+
 require('./browser')({
   metadata: {
     name: 'puppeteer',
@@ -52,7 +54,10 @@ require('./browser')({
     consoleWriter,
     networkWriter
   }) {
+    console.timeEnd('⏲ run      ')
+    console.time('⏲ require  ')
     const puppeteer = require(modules.puppeteer)
+    console.timeEnd('⏲ require  ')
 
     let args = []
     let product
@@ -62,6 +67,7 @@ require('./browser')({
       args = options.chromeArgs()
     }
 
+    console.time('⏲ launch   ')
     browser = await puppeteer.launch({
       product,
       executablePath: options.binary,
@@ -69,6 +75,7 @@ require('./browser')({
       defaultViewport: null,
       args
     })
+    console.timeEnd('⏲ launch   ')
 
     page = (await browser.pages())[0]
 
@@ -94,14 +101,18 @@ require('./browser')({
         })
       })
 
+    console.time('⏲ scripts  ')
     if (scripts && scripts.length) {
       for (const script of scripts) {
         await page.evaluateOnNewDocument(script)
       }
     }
+    console.timeEnd('⏲ scripts  ')
 
     await page.setDefaultNavigationTimeout(0)
+    console.time('⏲ navigate ')
     await page.goto(url)
+    console.timeEnd('⏲ navigate ')
   },
 
   async error ({ error: e, exit }) {

package/src/defaults/report/decompress.js

@@ -0,0 +1,19 @@
+/* global DecompressionStream */
+/* eslint-disable-next-line no-unused-vars */
+async function decompress (base64) {
+  const bin = atob(base64)
+  const uint8Array = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; ++i) {
+    uint8Array[i] = bin.charCodeAt(i)
+  }
+  const readableStream = new ReadableStream({
+    start (ctl) {
+      ctl.enqueue(uint8Array)
+      ctl.close()
+    }
+  })
+  const decompressionStream = new DecompressionStream('gzip')
+  const decompressedStream = readableStream.pipeThrough(decompressionStream)
+  const jsonString = await new Response(decompressedStream).text()
+  return JSON.parse(jsonString)
+}

package/src/defaults/report.js

@@ -1,10 +1,16 @@
 'use strict'
 
-const { join } = require('path')
+const { join, isAbsolute } = require('path')
 const { readFile, writeFile } = require('fs').promises
+const zlib = require('zlib')
 const [,, reportDir] = process.argv
+const verbose = process.argv.includes('--verbose')
 const { resolveDependencyPath } = require('../npm.js')
 
+const log = verbose ? console.log : () => {}
+
+log('🏗 Building report...')
+
 const defaultDir = join(__dirname, 'report')
 
 async function readDefault (name) {
@@ -35,30 +41,44 @@ function minifyJs (src) {
 
 async function main () {
   const html = await readDefault('default.html')
+  log('📦 default.html    :', html.length)
   const styles = (await readDefault('styles.css'))
     .replace(/\{\r?\n\s+/g, '{')
     .replace(/\}(\r?\n)+/g, '} ')
     .replace(/;\r?\n\s*/g, ';')
     .replace(/(:|,)\s*/g, (_, c) => c)
+  log('📦 styles.css      :', styles.length)
 
   const punyexpr = await readDependency('punyexpr')
+  log('📦 punyexpr        :', punyexpr.length)
   const punybind = await readDependency('punybind')
+  log('📦 punybind        :', punybind.length)
   const common = minifyJs(await readDefault('common.js'))
+  log('📦 common          :', common.length)
   const main = minifyJs(await readDefault('main.js'))
+  log('📦 main            :', main.length)
 
-  const job = (await readFile(join(reportDir, 'job.js'))).toString()
-    .replace(/(\{|,|\[)\r?\n\s*/g, (_, c) => c)
-    .replace(/\r?\n\s*(\}|\])/g, (_, c) => c)
-    .replace(/": "/g, '":"')
+  const decompress = minifyJs(await readDefault('decompress.js'))
+  log('📦 decompress      :', decompress.length)
+  const jobPath = isAbsolute(reportDir) ? reportDir : join(process.cwd(), reportDir)
+  log('📦 job path        :', jobPath)
+  const rawJob = require(join(jobPath, 'job.js'))
+  const json = JSON.stringify(rawJob)
+  log('📦 json            :', json.length)
+  const buffer = zlib.gzipSync(json)
+  const base64 = buffer.toString('base64')
+  log('📦 json (Gzip/b64) :', base64.length)
+  log('📦 compression     :', (100 * base64.length / json.length).toFixed(2) + '%')
 
-  return await writeFile(join(reportDir, 'report.html'), html
+  await writeFile(join(reportDir, 'report.html'), html
     .replace(/(>|\}\})\r?\n\s*</g, (_, c) => `${c}<`)
     .replace('<link rel="stylesheet" href="/_/report/styles.css">', `<style>${styles}</style>`)
     .replace('<script src="/_/punyexpr.js"></script>', `<script>${punyexpr}</script>`)
     .replace('<script src="/_/punybind.js"></script>', `<script>${punybind}</script>`)
     .replace('<script src="/_/report/common.js"></script>', `<script>${common}</script>`)
-    .replace('<script src="/_/report/main.js"></script>', `<script>const module={};${job};const job=module.exports;${main}</script>`)
+    .replace('<script src="/_/report/main.js"></script>', `<script>${decompress};let job={};decompress("${base64}").then(json=>{job=json;report.ready.then(update=>update({...json,elapsed:report.elapsed}))});${main}</script>`)
   )
+  log('✅ generated.')
 }
 
 main()

package/src/defaults/scan-ui5.js

@@ -2,7 +2,13 @@ module.exports = async function scanUI5 (url, onFolder, onFile) {
   if (url.match(/\/((?:test-)?resources\/.*)/)) {
     return // ignore UI5 resources
   }
-  const html = await (await fetch(url)).text()
+  let html
+  try {
+    html = await (await fetch(url)).text()
+  } catch (e) {
+    e.url = url
+    throw e
+  }
   const items = [...html.matchAll(/<a href="([^"]+)" class="icon/ig)]
     .map(([_, item]) => item)
     .filter(item => item.endsWith('/') || item.endsWith('.js') || item.endsWith('.ts'))

package/src/endpoints.js

@@ -123,6 +123,38 @@ module.exports = job => {
         match: '^/_/QUnit/done',
         custom: endpoint('QUnit/done', async (url, report) => done(job, url, report))
       }, {
+      // Fast batch endpoint for QUnit (no screenshot)
+        match: '^/_/QUnit/batch',
+        custom: async (request, response) => {
+          const url = extractPageUrl(request.headers)
+          const data = await body(request)
+          response.writeHead(200)
+          response.end()
+          try {
+            for (const [hook, hookData] of data) {
+              switch (hook) {
+                case 'QUnit/begin':
+                  await begin(job, url, hookData)
+                  break
+                case 'QUnit/testStart':
+                  await testStart(job, url, hookData)
+                  break
+                case 'QUnit/log':
+                  await log(job, url, hookData)
+                  break
+                case 'QUnit/testDone':
+                  await testDone(job, url, hookData)
+                  break
+                case 'QUnit/done':
+                  await done(job, url, hookData)
+                  break
+              }
+            }
+          } catch (error) {
+            getOutput(job).endpointError({ api: 'QUnit/batch', url, data, error })
+          }
+        }
+      }, {
       // UI to follow progress
         match: '^/_/progress.html',
         cwd: dirname(job.progressPage),

package/src/handle.js

@@ -0,0 +1,43 @@
+const { ServerResponse, ClientRequest } = require('node:http')
+
+module.exports = {
+  describeHandle (handle) {
+    const className = handle && handle.constructor && handle.constructor.name
+    let label = className
+    if (['TLSSocket', 'Socket'].includes(className)) {
+      if (handle._httpMessage instanceof ServerResponse) {
+        const { method, url } = handle._httpMessage.req
+        label += ` IncomingRequest ${method} ${url}`
+      } else if (handle._httpMessage instanceof ClientRequest) {
+        const { path, method, host, protocol } = handle._httpMessage
+        label += ` ClientRequest ${method} ${protocol}//${host}${path}`
+      } else if (handle.localAddress) {
+        const { localAddress, localPort, remoteAddress, remotePort } = handle
+        if (remoteAddress === undefined) {
+          label += ` local ${localAddress}:${localPort}`
+        } else {
+          label += ` local ${localAddress}:${localPort} remote ${remoteAddress}:${remotePort}`
+        }
+      } else if (handle._handle) {
+        const underlyingHandle = handle._handle
+        const underlyingClassName = underlyingHandle && underlyingHandle.constructor && underlyingHandle.constructor.name
+        label += ` <-> ${underlyingClassName || 'unknown'}`
+      } else {
+        label += ' unknown'
+      }
+    } else if (className === 'WriteStream') {
+      const fd = ['stdin', 'stdout', 'stderr'][handle.fd] || `fd: ${handle.fd}`
+      label += ` ${fd} ${handle.columns}x${handle.rows} isTTY: ${handle.isTTY}`
+    } else if (className === 'Server') {
+      label += ` connections: ${handle._connections} events: ${handle._eventsCount}`
+    } else if (className === 'ChildProcess') {
+      label += ` pid: ${handle.pid}`
+      if (handle.spawnargs) {
+        label += ` ${handle.spawnargs.map(value => ('' + value).replaceAll(/ /g, '␣'))}`
+      } else {
+        label += ' unknown'
+      }
+    }
+    return { className, label }
+  }
+}

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
+  })
+})()