ui5-test-runner 4.2.0 → 4.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ui5-test-runner",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Standalone test runner for UI5",
   "main": "index.js",
   "bin": {
@@ -66,19 +66,19 @@
     "mime": "^3.0.0",
     "punybind": "^1.2.1",
     "punyexpr": "^1.0.4",
-    "reserve": "^1.15.6"
+    "reserve": "^1.15.8"
   },
   "devDependencies": {
     "@openui5/types": "^1.121.0",
     "@ui5/cli": "^3.9.1",
     "@ui5/middleware-code-coverage": "^1.1.1",
     "jest": "^29.7.0",
-    "nock": "^13.5.3",
+    "nock": "^13.5.4",
     "nyc": "^15.1.0",
     "standard": "^17.1.0",
     "start-server-and-test": "^2.0.3",
-    "typescript": "^5.3.3",
-    "ui5-tooling-transpile": "^3.3.5"
+    "typescript": "^5.4.2",
+    "ui5-tooling-transpile": "^3.3.7"
   },
   "optionalDependencies": {
     "fsevents": "^2.3.3"

package/src/add-test-pages.js

@@ -2,9 +2,11 @@
 
 const { stop } = require('./browsers')
 const { URL } = require('url')
+const { getOutput } = require('./output')
 
 module.exports = {
   async addTestPages (job, url, pages) {
+    getOutput(job).debug('probe', `addTestPages from ${url}`, pages)
     let testPageUrls
     pages = pages.map(relativeUrl => {
       const absoluteUrl = new URL(relativeUrl, url)

package/src/browsers.js

@@ -5,7 +5,7 @@ const { join } = require('path')
 const { writeFile, readFile, open, stat, unlink } = require('fs/promises')
 const { recreateDir, filename, allocPromise } = require('./tools')
 const { getPageTimeout, pageTimedOut } = require('./timeout')
-const { getOutput } = require('./output')
+const { getOutput, newProgress } = require('./output')
 const { resolvePackage } = require('./npm')
 const { UTRError } = require('./error')
 const { $browsers } = require('./symbols')
@@ -119,11 +119,14 @@ async function start (job, url, scripts = []) {
     resolvedScripts.unshift(`window['ui5-test-runner/base-host'] = 'http://localhost:${job.port}'
 `)
   }
+  const progress = newProgress(job)
+  progress.label = url
   const pageBrowser = {
     url,
     reportDir,
     scripts: resolvedScripts,
-    retry: 0
+    retry: 0,
+    progress
   }
   const { promise, resolve, reject } = allocPromise()
   pageBrowser.done = value => {
@@ -136,8 +139,12 @@ async function start (job, url, scripts = []) {
   }
   job[$browsers][url] = pageBrowser
   await run(job, pageBrowser)
-  await promise
-  output.browserStopped(url)
+  try {
+    await promise
+  } finally {
+    progress.done()
+    output.browserStopped(url)
+  }
 }
 
 async function run (job, pageBrowser) {

package/src/job.js

@@ -112,6 +112,7 @@ function getCommand (cwd) {
     .option('--webapp <path>', '[💻🔗] Base folder of the web application (relative to cwd)', 'webapp')
     .option('-pf, --page-filter <regexp>', '[💻🔗] Filter out pages not matching the regexp')
     .option('-pp, --page-params <params>', '[💻🔗] Add parameters to page URL')
+    .option('--page-close-timeout <timeout>', '[💻🔗] Maximum waiting time for page close', timeout, 250)
     .option('-t, --global-timeout <timeout>', '[💻🔗] Limit the pages execution time, fail the page if it takes longer than the timeout (0 means no timeout)', timeout, 0)
     .option('--screenshot [flag]', '[💻🔗] Take screenshots during the tests execution (if supported by the browser)', boolean, true)
     .option('--no-screenshot', '[💻🔗] Disable screenshots')
@@ -137,6 +138,7 @@ function getCommand (cwd) {
     .option('--libs <lib...>', '[💻] Library mapping (<relative>=<path> or <path>)', arrayOf(lib))
     .option('--mappings <mapping...>', '[💻] Custom mapping (<match>=<file|url>(<config>))', arrayOf(mapping))
     .option('--cache <path>', '[💻] Cache UI5 resources locally in the given folder (empty to disable)')
+    .option('--preload <library...>', '[💻] Preload UI5 libraries in the cache folder (only if --cache is used)', arrayOf(string))
     .option('--testsuite <path>', '[💻] Path of the testsuite file (relative to webapp, URL parameters are supported)', 'test/testsuite.qunit.html')
     .option('-w, --watch [flag]', '[💻] Monitor the webapp folder and re-execute tests on change', boolean, false)
 
@@ -224,6 +226,8 @@ function finalize (job) {
     .forEach(setting => updateToAbsolute(setting))
   if (job.cache) {
     updateToAbsolute('cache')
+  } else if (job.preload) {
+    throw new Error('--preload cannot be used without --cache')
   }
   if (job.alternateNpmPath) {
     checkAccess({ path: job.alternateNpmPath, label: 'Alternate NPM path' })

package/src/output.js

@@ -5,9 +5,8 @@ const { join } = require('path')
 const { memoryUsage } = require('process')
 const {
   $browsers,
-  $probeUrlsStarted,
-  $probeUrlsCompleted,
-  $testPagesCompleted
+  $statusProgressCount,
+  $statusProgressTotal
 } = require('./symbols')
 const { filename, noop, pad } = require('./tools')
 
@@ -15,6 +14,7 @@ const inJest = typeof jest !== 'undefined'
 const interactive = process.stdout.columns !== undefined && !inJest
 const $output = Symbol('output')
 const $outputStart = Symbol('output-start')
+const $outputProgress = Symbol('output-progress')
 
 if (!interactive) {
   const UTF8_BOM_CODE = '\ufeff'
@@ -41,66 +41,90 @@ const formatTime = duration => {
 
 const getElapsed = job => formatTime(Date.now() - job[$outputStart])
 
-const write = (...parts) => parts.forEach(part => process.stdout.write(part))
-
-function clean (job) {
+function * buildCleanSequence (job) {
   const { lines } = job[$output]
   if (!lines) {
     return
   }
-  write('\x1b[?12l')
-  write(`\x1b[${lines.toString()}F`)
+  yield '\x1b[?12l'
+  yield `\x1b[${lines.toString()}F`
   for (let line = 0; line < lines; ++line) {
     if (line > 1) {
-      write('\x1b[1E')
+      yield '\x1b[1E'
     }
-    write(''.padEnd(process.stdout.columns, ' '))
+    yield ''.padEnd(process.stdout.columns, ' ')
   }
   if (lines > 1) {
-    write(`\x1b[${(lines - 1).toString()}F`)
+    yield `\x1b[${(lines - 1).toString()}F`
   } else {
-    write('\x1b[1G')
+    yield '\x1b[1G'
   }
 }
 
+function clean (job) {
+  process.stdout.write([...buildCleanSequence(job)].join(''))
+}
+
 const BAR_WIDTH = 10
 
-function bar (ratio, msg) {
-  write('[')
+function * bar (ratio, msg) {
+  yield '['
   if (typeof ratio === 'string') {
     if (ratio.length > BAR_WIDTH) {
-      write(ratio.substring(0, BAR_WIDTH - 3), '...')
+      yield ratio.substring(0, BAR_WIDTH - 3)
+      yield '...'
     } else {
       const padded = ratio.padStart(BAR_WIDTH - Math.floor((BAR_WIDTH - ratio.length) / 2), '-').padEnd(BAR_WIDTH, '-')
-      write(padded)
+      yield padded
     }
-    write(']     ')
+    yield ']     '
   } else {
     const filled = Math.floor(BAR_WIDTH * ratio)
-    write(''.padEnd(filled, '\u2588'), ''.padEnd(BAR_WIDTH - filled, '\u2591'))
-    const percent = Math.floor(100 * ratio).toString().padStart(3, ' ')
-    write('] ', percent, '%')
+    yield ''.padEnd(filled, '\u2588')
+    yield ''.padEnd(BAR_WIDTH - filled, '\u2591')
+    yield '] '
+    yield Math.floor(100 * ratio).toString().padStart(3, ' ').toString()
+    yield '%'
   }
-  write(' ')
+  yield ' '
   const spaceLeft = process.stdout.columns - BAR_WIDTH - 14
   if (msg.length > spaceLeft) {
-    write('...', msg.substring(msg.length - spaceLeft - 3))
+    yield '...'
+    yield msg.substring(msg.length - spaceLeft - 3)
   } else {
-    write(msg)
+    yield msg
   }
-  write('\n')
+  yield '\n'
 }
 
 const TICKS = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f']
 
+class Progress {
+  #job = undefined
+
+  constructor (job) {
+    this.#job = job
+    if (!job[$outputProgress]) {
+      job[$outputProgress] = []
+    }
+    job[$outputProgress].push(this)
+  }
+
+  done () {
+    const pos = this.#job[$outputProgress].indexOf(this)
+    this.#job[$outputProgress].splice(pos, 1)
+  }
+}
+
 function progress (job, cleanFirst = true) {
+  const sequence = []
   if (interactive) {
     if (cleanFirst) {
-      clean(job)
+      sequence.push(...buildCleanSequence(job))
     }
   } else {
     if (job[$browsers]) {
-      write(`${getElapsed(job)} │ Progress\n──────┴──────────\n`)
+      sequence.push(`${getElapsed(job)} │ Progress\n──────┴──────────\n`)
     } else {
       return
     }
@@ -112,41 +136,28 @@ function progress (job, cleanFirst = true) {
     ++output.lines
     const { rss, heapTotal, heapUsed, external, arrayBuffers } = memoryUsage()
     const fmt = size => `${(size / (1024 * 1024)).toFixed(2)}M`
-    write(`MEM r:${fmt(rss)}, h:${fmt(heapUsed)}/${fmt(heapTotal)}, x:${fmt(external)}, a:${fmt(arrayBuffers)}\n`)
-  }
-  if (job[$probeUrlsStarted]) {
-    const total = job.url.length + job.testPageUrls.length
-    if (job[$testPagesCompleted] !== total) {
-      progressRatio = (job[$probeUrlsCompleted] + (job[$testPagesCompleted] || 0)) / total
-    }
+    sequence.push(`MEM r:${fmt(rss)}, h:${fmt(heapUsed)}/${fmt(heapTotal)}, x:${fmt(external)}, a:${fmt(arrayBuffers)}\n`)
   }
-  if (job[$browsers]) {
-    const runningPages = Object.keys(job[$browsers])
-    output.lines += runningPages.length
-    runningPages.forEach(pageUrl => {
-      let starting = true
-      if (job.qunitPages) {
-        const page = job.qunitPages[pageUrl]
-        if (page) {
-          const { count, passed, failed } = page
-          if (count) {
-            const progress = passed + failed
-            bar(progress / count, pageUrl)
-            starting = false
-          }
-        }
-      }
-      if (starting) {
-        bar('starting', pageUrl)
+  if (job[$outputProgress]) {
+    output.lines += job[$outputProgress].length
+    job[$outputProgress].forEach(({ count, total, label }) => {
+      if (total !== undefined) {
+        sequence.push(...bar((count || 0) / (total || 1), label))
+      } else {
+        sequence.push(...bar('starting', label))
       }
     })
   }
+  if (job[$statusProgressTotal]) {
+    progressRatio = (job[$statusProgressCount] || 0) / job[$statusProgressTotal]
+  }
   const status = `${TICKS[++output.lastTick % TICKS.length]} ${job.status}`
   if (progressRatio !== undefined) {
-    bar(progressRatio, status)
+    sequence.push(...bar(progressRatio, status))
   } else {
-    write(status, '\n')
+    sequence.push(status, '\n')
   }
+  process.stdout.write(sequence.join(''))
 }
 
 function output (job, ...args) {
@@ -250,12 +261,15 @@ function build (job) {
       log(job, p80()`Server running at ${pad.lt(url)}`)
     },
 
-    debug: wrap((module, ...args) => {
-      if (job.debugVerbose && job.debugVerbose.includes(module)) {
-        console.log(`🐞${module}`, ...args)
-        output(job, `🐞${module}`, ...args)
+    debug: (moduleSpecifier, ...args) => {
+      const [mainModule] = moduleSpecifier.split('/')
+      if (job.debugVerbose && (job.debugVerbose.includes(moduleSpecifier) || job.debugVerbose.includes(mainModule))) {
+        wrap(() => {
+          console.log(`🐞${moduleSpecifier}`, ...args)
+          output(job, `🐞${moduleSpecifier}`, ...args)
+        })()
       }
-    }),
+    },
 
     redirected: wrap(({ method, url, statusCode, timeSpent }) => {
       if (url.startsWith('/_/progress')) {
@@ -281,6 +295,8 @@ function build (job) {
       method(job, '')
       method(job, text)
       method(job, '──────┴'.padEnd(text.length, '─'))
+      delete job[$statusProgressCount]
+      delete job[$statusProgressTotal]
     },
 
     watching: wrap(path => {
@@ -552,5 +568,9 @@ module.exports = {
       job[$output] = build(job)
     }
     return job[$output]
+  },
+
+  newProgress (job) {
+    return new Progress(job)
   }
 }

package/src/qunit-hooks.js

@@ -5,7 +5,10 @@ const { collect } = require('./coverage')
 const { UTRError } = require('./error')
 const { getOutput } = require('./output')
 const { basename } = require('path')
-const { filename, stripUrlHash } = require('./tools')
+const { filename, stripUrlHash, allocPromise } = require('./tools')
+const { $browsers } = require('./symbols')
+const $doneResolve = Symbol('doneResolve')
+const $doneTimeout = Symbol('doneTimeout')
 
 function error (job, url, details = '') {
   stop(job, url)
@@ -40,11 +43,12 @@ function merge (targetModules, modules) {
 function get (job, urlWithHash, { testId, modules, isOpa } = {}) {
   const url = stripUrlHash(urlWithHash)
   const page = job.qunitPages && job.qunitPages[url]
+  const progress = (job[$browsers] && job[$browsers][url] && job[$browsers][url].progress) || { total: 0, count: 0 }
   if (!page) {
     error(job, url, `No QUnit page found for ${urlWithHash}`)
   }
   if (modules && modules.length) {
-    page.count = merge(page.modules, modules)
+    progress.total = page.count = merge(page.modules, modules)
   }
   if (!page.isOpa && isOpa) {
     page.isOpa = true
@@ -65,7 +69,7 @@ function get (job, urlWithHash, { testId, modules, isOpa } = {}) {
       invalidTestId(job, url, testId)
     }
   }
-  return { url, page, testModule, test }
+  return { url, page, testModule, test, progress }
 }
 
 async function done (job, urlWithHash, report) {
@@ -73,27 +77,33 @@ async function done (job, urlWithHash, report) {
   if (page.count === 0) {
     return // wait
   }
-  if (job.browserCapabilities.screenshot) {
-    try {
-      await screenshot(job, url, 'done')
-    } catch (error) {
-      getOutput(job).genericError(error, url)
+  const { promise, resolve } = allocPromise()
+  page[$doneResolve] = resolve
+  page[$doneTimeout] = setTimeout(async () => {
+    if (job.browserCapabilities.screenshot) {
+      try {
+        await screenshot(job, url, 'done')
+      } catch (error) {
+        getOutput(job).genericError(error, url)
+      }
     }
-  }
-  page.end = new Date()
-  if (report.__coverage__) {
-    await collect(job, url, report.__coverage__)
-    delete report.__coverage__
-  }
-  page.report = report
-  stop(job, url)
+    page.end = new Date()
+    if (report.__coverage__) {
+      await collect(job, url, report.__coverage__)
+      delete report.__coverage__
+    }
+    page.report = report
+    stop(job, url)
+    resolve()
+  }, job.pageCloseTimeout)
+  return promise
 }
 
 module.exports = {
   get,
 
   async begin (job, urlWithHash, details) {
-    getOutput(job).debug('qunit', 'begin', urlWithHash, details)
+    getOutput(job).debug('qunit/begin', 'begin', urlWithHash, details)
     const { isOpa, totalTests, modules } = details
     const url = stripUrlHash(urlWithHash)
     if (!job.qunitPages) {
@@ -109,16 +119,24 @@ module.exports = {
       modules
     }
     job.qunitPages[url] = qunitPage
+    const { progress } = get(job, url)
+    progress.count = 0
+    progress.total = totalTests
   },
 
   async testStart (job, urlWithHash, details) {
-    getOutput(job).debug('qunit', 'testStart', urlWithHash, details)
-    const { test } = get(job, urlWithHash, details)
+    getOutput(job).debug('qunit/testStart', 'testStart', urlWithHash, details)
+    const { page, test } = get(job, urlWithHash, details)
+    const { [$doneTimeout]: doneTimeout, [$doneResolve]: doneResolve } = page
+    if (doneTimeout) {
+      clearTimeout(doneTimeout)
+      doneResolve()
+    }
     test.start = new Date()
   },
 
   async log (job, urlWithHash, details) {
-    getOutput(job).debug('qunit', 'log', urlWithHash, details)
+    getOutput(job).debug('qunit/log', 'log', urlWithHash, details)
     const { url, page, test } = get(job, urlWithHash, details)
     const { isOpa, modules, module, name, testId, ...log } = details
     if (!test) {
@@ -139,13 +157,14 @@ module.exports = {
   },
 
   async testDone (job, urlWithHash, details) {
-    getOutput(job).debug('qunit', 'testDone', urlWithHash, details)
+    getOutput(job).debug('qunit/testDone', 'testDone', urlWithHash, details)
     const { name, module, testId, assertions, ...report } = details
     const { failed } = report
-    const { url, page, test } = get(job, urlWithHash, { testId })
+    const { url, page, test, progress } = get(job, urlWithHash, { testId })
     if (!test) {
       invalidTestId(job, url, testId)
     }
+    ++progress.count
     if (failed) {
       if (job.browserCapabilities.screenshot) {
         try {
@@ -180,5 +199,8 @@ module.exports = {
     }
   },
 
-  done
+  async done (job, urlWithHash, report) {
+    getOutput(job).debug('qunit/done', 'done', urlWithHash, report)
+    await done(job, urlWithHash, report)
+  }
 }

package/src/reserve.js

@@ -2,7 +2,7 @@ const { join } = require('path')
 const cors = require('./cors')
 const endpoints = require('./endpoints')
 const { mappings: coverage } = require('./coverage')
-const ui5 = require('./ui5')
+const { mappings: ui5 } = require('./ui5')
 const { check } = require('reserve')
 const unhandled = require('./unhandled')
 

package/src/symbols.js

@@ -6,5 +6,7 @@ module.exports = {
   $testPagesCompleted: Symbol('testPagesCompleted'),
   $valueSources: Symbol('valueSources'),
   $remoteOnLegacy: Symbol('remoteOnLegacy'),
-  $proxifiedUrls: Symbol('proxifiedUrls')
+  $proxifiedUrls: Symbol('proxifiedUrls'),
+  $statusProgressCount: Symbol('statusProgressCount'),
+  $statusProgressTotal: Symbol('statusProgressTotal')
 }

package/src/tests.js

@@ -10,10 +10,13 @@ const {
   $probeUrlsStarted,
   $probeUrlsCompleted,
   $testPagesStarted,
-  $testPagesCompleted
+  $testPagesCompleted,
+  $statusProgressTotal,
+  $statusProgressCount
 } = require('./symbols')
 const { UTRError } = require('./error')
 const { $proxifiedUrls } = require('./symbols')
+const { preload } = require('./ui5')
 
 async function run (task, job) {
   const {
@@ -25,6 +28,10 @@ async function run (task, job) {
   const output = getOutput(job)
   const urls = job[urlsMember]
   const { length } = urls
+  if (job[$statusProgressTotal] === undefined) {
+    job[$statusProgressTotal] = length
+    job[$statusProgressCount] = 0
+  }
   if (job[completedMember] === length) {
     return
   }
@@ -47,6 +54,7 @@ async function run (task, job) {
     }
   }
   ++job[completedMember]
+  ++job[$statusProgressCount]
   return run(task, job)
 }
 
@@ -158,6 +166,9 @@ module.exports = {
   async execute (job) {
     await recreateDir(job.reportDir)
     getOutput(job).version()
+    if (job.preload) {
+      await preload(job)
+    }
     await probe(job)
     if (job.mode !== 'url') {
       job.url = [`http://localhost:${job.port}/${job.testsuite}`]

package/src/tools.js

@@ -127,6 +127,7 @@ function allocPromise () {
 
 async function download (url, filename) {
   const { hostname, port, origin } = new URL(url)
+  const error = reason => new Error(`Error downloading ${url} to ${filename}, ${reason}`)
   const options = {
     hostname,
     port,
@@ -139,16 +140,27 @@ async function download (url, filename) {
   const { promise, resolve, reject } = allocPromise()
   const request = protocol.request(options, async response => {
     if (response.statusCode !== 200) {
-      reject(response.statusCode)
+      reject(error(`server responded with ${response.statusCode}`))
       output.end()
-      await unlink(filename)
+      try {
+        await unlink(filename)
+      } catch (e) {
+        // ignore
+      }
       return
     }
-    response.on('error', reject)
-    response.on('end', resolve)
-    response.pipe(output)
+    response.on('error', reason => {
+      reject(error(`response failed : ${reason.toString()}`))
+    })
+    response
+      .pipe(output)
+      .on('finish', () => {
+        resolve(filename)
+      })
+  })
+  request.on('error', reason => {
+    reject(error(`request failed : ${reason.toString()}`))
   })
-  request.on('error', reject)
   request.end()
   return promise
 }

package/src/ui5.js

@@ -2,90 +2,158 @@
 
 const { dirname, join } = require('path')
 const { createWriteStream } = require('fs')
-const { mkdir, unlink } = require('fs').promises
+const { mkdir, unlink, stat } = require('fs').promises
 const { capture } = require('reserve')
-const { getOutput } = require('./output')
-
-module.exports = job => {
-  if (job.disableUi5) {
-    return []
-  }
+const { getOutput, newProgress } = require('./output')
+const { download, allocPromise } = require('./tools')
+const { $statusProgressCount, $statusProgressTotal } = require('./symbols')
 
+const buildCacheBase = job => {
   const [, hostName] = /https?:\/\/([^/]*)/.exec(job.ui5)
   const [, version] = /(\d+\.\d+\.\d+)?$/.exec(job.ui5)
-  const cacheBase = join(job.cache || '', hostName.replace(':', '_'), version || '')
-  const match = /\/((?:test-)?resources\/.*)/
-  const ifCacheEnabled = (request, url, match) => job.cache ? match : false
-  const uncachable = {}
-  const cachingInProgress = {}
+  return join(job.cache || '', hostName.replace(':', '_'), version || '')
+}
 
-  const mappings = [{
-    /* Prevent caching issues :
-     * - Caching was not possible (99% URL does not exist)
-     * - Caching is in progress (must wait for the end of the writing stream)
-     */
-    match,
-    'if-match': ifCacheEnabled,
-    custom: async (request, response, path) => {
-      if (uncachable[path]) {
-        response.writeHead(404)
-        response.end()
-        return
-      }
-      const cachingPromise = cachingInProgress[path]
-      /* istanbul ignore next */ // Hard to reproduce
-      if (cachingPromise) {
-        await cachingPromise
+module.exports = {
+  preload: async job => {
+    const cacheBase = buildCacheBase(job)
+
+    const get = async (path, expectedSize) => {
+      const filePath = join(cacheBase, 'resources/' + path)
+      try {
+        const info = await stat(filePath)
+        if (expectedSize !== undefined && info.isFile() && info.size === expectedSize) {
+          return filePath
+        }
+      } catch (e) {
+        // ignore
       }
+      return download((new URL('resources/' + path, job.ui5)).toString(), filePath)
     }
-  }, {
-    // UI5 from cache
-    match,
-    'if-match': ifCacheEnabled,
-    file: join(cacheBase, '$1'),
-    'ignore-if-not-found': true
-  }, {
-    // UI5 caching
-    method: 'GET',
-    match,
-    'if-match': ifCacheEnabled,
-    custom: async (request, response, path) => {
-      const filePath = /([^?#]+)/.exec(unescape(path))[1] // filter URL parameters & hash (assuming resources are static)
-      const cachePath = join(cacheBase, filePath)
-      const cacheFolder = dirname(cachePath)
-      await mkdir(cacheFolder, { recursive: true })
-      if (cachingInProgress[path]) {
-        return request.url // loop back to use cached result
+
+    const lib = async name => {
+      progress.label = name
+      progress.count = 0
+      const { promise, resolve/*, reject */ } = allocPromise()
+      const libPath = name.replace(/\./g, '/') + '/'
+      const { resources } = require(await get(libPath + 'resources.json'))
+      progress.total = resources.length
+      let index = 0
+      let active = 0
+
+      const task = async () => {
+        ++active
+        const { name, size } = resources[index++]
+        await get(libPath + name, size)
+        ++progress.count
+        if (index < resources.length) {
+          task()
+        }
+        if (--active === 0) {
+          resolve()
+        }
       }
-      const file = createWriteStream(cachePath)
-      cachingInProgress[path] = capture(response, file)
-        .catch(reason => {
-          file.end()
-          uncachable[path] = true
-          if (response.statusCode !== 404) {
-            getOutput(job).failedToCacheUI5resource(path, response.statusCode)
-          }
-          return unlink(cachePath)
-        })
-        .then(() => {
-          delete cachingInProgress[path]
-        })
+
+      for (let parallel = 0; parallel < 8; ++parallel) {
+        task()
+      }
+
+      return promise
     }
-  }, {
-    // UI5 from url
-    method: ['GET', 'HEAD'],
-    match,
-    url: `${job.ui5}/$1`,
-    'ignore-unverifiable-certificate': true
-  }]
 
-  job.libs.forEach(({ relative, source }) => {
-    mappings.unshift({
-      match: new RegExp(`\\/resources\\/${relative.replace(/\//g, '\\/')}(.*)`),
-      file: join(source, '$1'),
+    job.status = 'Preloading UI5'
+    job[$statusProgressCount] = 0
+    job[$statusProgressTotal] = job.preload.length + 1
+    await get('sap-ui-version.json')
+    await get('sap-ui-core.js')
+    const progress = newProgress(job)
+    await lib('sap.ui.core')
+    for (const name of job.preload) {
+      ++job[$statusProgressCount]
+      await lib(name)
+    }
+    progress.done()
+  },
+
+  mappings: job => {
+    if (job.disableUi5) {
+      return []
+    }
+
+    const cacheBase = buildCacheBase(job)
+    const match = /\/((?:test-)?resources\/.*)/
+    const ifCacheEnabled = (request, url, match) => job.cache ? match : false
+    const uncachable = {}
+    const cachingInProgress = {}
+
+    const mappings = [{
+      /* Prevent caching issues :
+      * - Caching was not possible (99% URL does not exist)
+      * - Caching is in progress (must wait for the end of the writing stream)
+      */
+      match,
+      'if-match': ifCacheEnabled,
+      custom: async (request, response, path) => {
+        if (uncachable[path]) {
+          response.writeHead(404)
+          response.end()
+          return
+        }
+        const cachingPromise = cachingInProgress[path]
+        /* istanbul ignore next */ // Hard to reproduce
+        if (cachingPromise) {
+          await cachingPromise
+        }
+      }
+    }, {
+      // UI5 from cache
+      match,
+      'if-match': ifCacheEnabled,
+      file: join(cacheBase, '$1'),
       'ignore-if-not-found': true
+    }, {
+      // UI5 caching
+      method: 'GET',
+      match,
+      'if-match': ifCacheEnabled,
+      custom: async (request, response, path) => {
+        const filePath = /([^?#]+)/.exec(unescape(path))[1] // filter URL parameters & hash (assuming resources are static)
+        const cachePath = join(cacheBase, filePath)
+        const cacheFolder = dirname(cachePath)
+        await mkdir(cacheFolder, { recursive: true })
+        if (cachingInProgress[path]) {
+          return request.url // loop back to use cached result
+        }
+        const file = createWriteStream(cachePath)
+        cachingInProgress[path] = capture(response, file)
+          .catch(reason => {
+            file.end()
+            uncachable[path] = true
+            if (response.statusCode !== 404) {
+              getOutput(job).failedToCacheUI5resource(path, response.statusCode)
+            }
+            return unlink(cachePath)
+          })
+          .then(() => {
+            delete cachingInProgress[path]
+          })
+      }
+    }, {
+      // UI5 from url
+      method: ['GET', 'HEAD'],
+      match,
+      url: `${job.ui5}/$1`,
+      'ignore-unverifiable-certificate': true
+    }]
+
+    job.libs.forEach(({ relative, source }) => {
+      mappings.unshift({
+        match: new RegExp(`\\/resources\\/${relative.replace(/\//g, '\\/')}(.*)`),
+        file: join(source, '$1'),
+        'ignore-if-not-found': true
+      })
     })
-  })
 
-  return mappings
+    return mappings
+  }
 }