ui5-test-runner 5.13.0 → 6.0.0-beta.1

package/src/endpoints.js

@@ -1,219 +0,0 @@
-'use strict'
-
-const { join, dirname, basename } = require('path')
-const { body } = require('reserve')
-const { extractPageUrl } = require('./tools')
-const { Request, Response } = require('reserve')
-const { getOutput } = require('./output')
-const { begin, testStart, log, testDone, done } = require('./qunit-hooks')
-const { addTestPages } = require('./add-test-pages')
-const { getJobProgress } = require('./get-job-progress')
-const { readFile } = require('fs/promises')
-const { TextEncoder } = require('util')
-const { resolveDependencyPath } = require('./npm.js')
-
-const punyexprBinPath = join(resolveDependencyPath('punyexpr'), 'dist/punyexpr.js')
-const punybindBinPath = join(resolveDependencyPath('punybind'), 'dist/punybind.js')
-
-module.exports = job => {
-  async function endpointImpl (api, implementation, request) {
-    const url = extractPageUrl(request.headers)
-    const data = await body(request)
-    try {
-      await implementation.call(this, url, data)
-    } catch (error) {
-      getOutput(job).endpointError({ api, url, data, error })
-    }
-  }
-
-  function synchronousEndpoint (api, implementation) {
-    return async function (request, response) {
-      await endpointImpl(api, implementation, request)
-      response.writeHead(200)
-      response.end()
-    }
-  }
-
-  function endpoint (api, implementation) {
-    return async function (request, response) {
-      response.writeHead(200)
-      response.end()
-      await endpointImpl(api, implementation, request)
-    }
-  }
-
-  async function getInjects (...names) {
-    return '\n;\n' + (await Promise.all(names.map(name => readFile(join(__dirname, 'inject', `${name}.js`)))))
-      .map(buffer => buffer.toString())
-      .join('\n;\n')
-  }
-
-  function contentLength (content) {
-    return new TextEncoder().encode(content).length
-  }
-
-  function sendScript (response, content) {
-    response.writeHead(200, {
-      'content-type': 'text/javascript',
-      'content-length': contentLength(content),
-      'cache-control': 'no-store'
-    })
-    response.end(content)
-  }
-
-  return job.parallel
-    ? [{
-      // Substitute qunit-redirect to extract test pages
-        match: '/resources/sap/ui/qunit/qunit-redirect.js',
-        custom: async (request, response) => {
-          sendScript(response, await getInjects('post', 'qunit-redirect'))
-        }
-      }, {
-      // Endpoint to receive test pages
-        match: '^/_/addTestPages',
-        custom: endpoint('addTestPages', (url, pages) => addTestPages(job, url, pages))
-      }, {
-      // QUnit hooks
-        match: '^/_/qunit-hooks.js',
-        cwd: __dirname,
-        file: 'inject/qunit-hooks.js',
-        static: !job.debugDevMode
-      }, {
-      // Concatenate qunit.js source with hooks
-        match: /\/thirdparty\/(qunit(?:-2)?(?:-dbg)?\.js)/,
-        custom: async function (request, response, scriptName) {
-          if (request.internal) {
-            return // ignore to avoid infinite loop
-          }
-          const ui5Request = new Request('GET', request.url)
-          ui5Request.internal = true
-          const ui5Response = new Response()
-          const [inject] = await Promise.all([
-            getInjects('post', 'qunit-hooks'),
-            this.configuration.dispatch(ui5Request, ui5Response)
-          ])
-          const hooksLength = contentLength(inject)
-          const ui5Length = parseInt(ui5Response.headers['content-length'], 10)
-          response.writeHead(ui5Response.statusCode, {
-            ...ui5Response.headers,
-            'content-length': ui5Length + hooksLength,
-            'cache-control': 'no-store' // for debugging purpose
-          })
-          response.write(ui5Response.toString())
-          response.end(inject)
-        }
-      }, {
-      // Endpoint to receive QUnit.begin
-        match: '^/_/QUnit/begin',
-        custom: endpoint('QUnit/begin', (url, details) => begin(job, url, details))
-      }, {
-      // Endpoint to receive QUnit.testStart
-        match: '^/_/QUnit/testStart',
-        custom: endpoint('QUnit/testStart', (url, details) => testStart(job, url, details))
-      }, {
-      // Endpoint to receive QUnit.log
-        match: '^/_/QUnit/log',
-        custom: synchronousEndpoint('QUnit/log', async (url, report) => log(job, url, report))
-      }, {
-      // Endpoint to receive QUnit.testDone
-        match: '^/_/QUnit/testDone',
-        custom: synchronousEndpoint('QUnit/testDone', async (url, report) => testDone(job, url, report))
-      }, {
-      // Endpoint to receive QUnit.done
-        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),
-        file: basename(job.progressPage),
-        static: !job.debugDevMode
-      }, {
-      // Report 'main' substituted for progress
-        match: '^/_/report/main.js',
-        cwd: __dirname,
-        file: 'defaults/report/progress.js',
-        static: !job.debugDevMode
-      }, {
-      // Other report resources
-        match: '^/_/report/(.*)',
-        cwd: __dirname,
-        file: 'defaults/report/$1',
-        static: !job.debugDevMode
-      }, {
-      // punybind
-        match: '^/_/punybind.js',
-        cwd: dirname(punybindBinPath),
-        file: basename(punybindBinPath),
-        static: !job.debugDevMode
-      }, {
-      // punyexpr
-        match: '^/_/punyexpr.js',
-        cwd: dirname(punyexprBinPath),
-        file: basename(punyexprBinPath),
-        static: !job.debugDevMode
-      }, {
-      // Endpoint to retry on progress
-        method: 'INFO',
-        match: '^/_/progress',
-        custom: (request, response) => {
-          response.writeHead(204)
-          response.end()
-        }
-      }, {
-      // Endpoint to follow progress
-        match: '^/_/progress(?:\\?page=([^&]*)(?:&test=([^&]*))?)?',
-        custom: (request, response, pageId, testId) => getJobProgress(job, request, response, pageId, testId)
-      }, {
-      // Endpoint to coverage files
-        match: '^/_/coverage/(.*)',
-        cwd: job.coverageReportDir,
-        file: '$1',
-        static: false
-      }, {
-      // Endpoint to report
-        match: '^/_/report.html',
-        cwd: __dirname,
-        file: 'report.html',
-        static: !job.debugDevMode
-      }, {
-      // Endpoint to report files
-        match: '^/_/(.*)',
-        cwd: job.reportDir,
-        file: '$1',
-        static: false
-      }]
-    : []
-}

package/src/error.js

@@ -1,54 +0,0 @@
-class UTRError extends Error {
-  get code () { return this._code }
-
-  constructor (error, details) {
-    super()
-    this.name = `UTRError:${error.name}`
-    this._code = error.code
-    if (details) {
-      this.message = details
-    } else {
-      this.message = error.name
-    }
-  }
-}
-
-const errors = [{
-  name: 'GENERIC'
-}, {
-  name: 'NPM_FAILED'
-}, {
-  name: 'MISSING_OR_INVALID_BROWSER_CAPABILITIES'
-}, {
-  name: 'BROWSER_PROBE_FAILED'
-}, {
-  name: 'BROWSER_FAILED'
-}, {
-  name: 'BROWSER_SCREENSHOT_FAILED'
-}, {
-  name: 'BROWSER_SCREENSHOT_TIMEOUT'
-}, {
-  name: 'BROWSER_SCREENSHOT_NOT_SUPPORTED'
-}, {
-  name: 'QUNIT_ERROR'
-}, {
-  name: 'MODE_INCOMPATIBLE_OPTION'
-}, {
-  name: 'BROWSER_MISS_SCRIPTS_CAPABILITY'
-}, {
-  name: 'NPM_DEPENDENCY_NOT_FOUND'
-}, {
-  name: 'NYC_FAILED'
-}]
-
-errors.forEach((error, index) => {
-  error.code = -1 - index
-  UTRError[`${error.name}_CODE`] = error.code
-  UTRError[error.name] = function (details = '') {
-    return new UTRError(error, details)
-  }
-})
-
-module.exports = {
-  UTRError
-}

package/src/get-job-progress.js

@@ -1,78 +0,0 @@
-'use strict'
-
-const { $proxifiedUrls } = require('./symbols')
-
-const send = (response, obj) => {
-  let json
-  if (typeof obj !== 'string') {
-    json = JSON.stringify(obj, undefined, 2)
-  } else {
-    json = obj
-  }
-  const length = (new TextEncoder().encode(json)).length
-  response.writeHead(200, {
-    'Content-Type': 'application/json',
-    'Content-Length': length
-  })
-  response.end(json)
-}
-
-const notFound = response => {
-  response.writeHead(404)
-  response.end()
-}
-
-module.exports = {
-  async getJobProgress (job, request, response, pageId, testId) {
-    if (pageId) {
-      const url = Object.keys(job.qunitPages).find(pageUrl => job.qunitPages[pageUrl].id === pageId)
-      if (!url) {
-        return notFound(response)
-      }
-      const qunitPage = { url, ...job.qunitPages[url] }
-      if (!testId) {
-        return send(response, JSON.stringify(qunitPage, (key, value) => {
-          if (key === 'logs') {
-            return undefined
-          }
-          return value
-        }, 2))
-      }
-      let test
-      let moduleName
-      qunitPage.modules.every(module => module.tests.every(candidate => {
-        if (candidate.testId === testId) {
-          moduleName = module.name
-          test = candidate
-          return false
-        }
-        return true
-      }))
-      if (!test) {
-        return notFound(response)
-      }
-      return send(response, {
-        url,
-        pageId,
-        module: moduleName,
-        ...test
-      })
-    }
-    send(response, JSON.stringify({
-      ...job,
-      status: job.status
-    }, (key, value) => {
-      if (key === 'qunitPages' && job[$proxifiedUrls]) {
-        const unproxifiedQunitPages = {}
-        for (const url of Object.keys(job.qunitPages)) {
-          unproxifiedQunitPages[job[$proxifiedUrls][url] || url] = job.qunitPages[url]
-        }
-        return unproxifiedQunitPages
-      }
-      if (key === 'modules') {
-        return undefined
-      }
-      return value
-    }, 2))
-  }
-}

package/src/handle.js

@@ -1,43 +0,0 @@
-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/if.js

@@ -1,10 +0,0 @@
-const { punyexpr } = require('punyexpr')
-
-function executeIf (job) {
-  return punyexpr(job.if)({
-    ...process.env,
-    NODE_MAJOR_VERSION: parseInt(parseInt(process.version.match(/v(\d+)\./)[1]))
-  })
-}
-
-module.exports = { executeIf }

package/src/inject/jest2qunit.js

@@ -1,289 +0,0 @@
-/* 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
-  })
-})()