ui5-test-runner 5.13.1 → 6.0.0-beta.2

package/src/tests.js

@@ -1,183 +0,0 @@
-'use strict'
-
-const { start } = require('./browsers')
-const { instrument } = require('./coverage')
-const { globallyTimedOut } = require('./timeout')
-const { save, generate } = require('./report')
-const { getOutput } = require('./output')
-const {
-  $statusProgressTotal,
-  $statusProgressCount,
-  $proxifiedUrls
-} = require('./symbols')
-const { UTRError } = require('./error')
-const { parallelize } = require('./parallelize')
-
-function task (job, method) {
-  return async (url, index, { length }) => {
-    if (job[$statusProgressCount] === undefined) {
-      job[$statusProgressCount] = 0
-    }
-    job[$statusProgressTotal] = length
-    const output = getOutput(job)
-    if (globallyTimedOut(job)) {
-      output.globalTimeout(url)
-      job.failed = true
-      job.timedOut = true
-    } else if (job.failFast && job.failed) {
-      output.failFast(url)
-    } else {
-      try {
-        await method(job, url)
-      } catch (error) {
-        job.failed = true
-      }
-    }
-    ++job[$statusProgressCount]
-  }
-}
-
-async function probeUrl (job, url) {
-  const parsedUrl = new URL(url)
-  if (parsedUrl.port === '0') {
-    parsedUrl.port = job.port
-    url = parsedUrl.toString()
-  }
-  const output = getOutput(job)
-  try {
-    let scripts
-    if (job.browserCapabilities.scripts) {
-      scripts = [
-        '(function () { window[\'ui5-test-runner/probe\'] = true }())',
-        'post.js',
-        'qunit-redirect.js'
-      ]
-      if (job.jest) {
-        scripts.push('jest2qunit.js')
-      }
-    }
-    await start(job, url, scripts)
-  } catch (error) {
-    output.startFailed(url, error)
-    throw error
-  }
-}
-
-async function runTestPage (job, url) {
-  const output = getOutput(job)
-  try {
-    let scripts
-    if (job.browserCapabilities.scripts) {
-      scripts = []
-      if (job.qunitBatchSize) {
-        scripts.push(
-          `(function () { window['ui5-test-runner/batch'] = ${job.qunitBatchSize} }())`
-        )
-      }
-      scripts.push(
-        'post.js',
-        'qunit-hooks.js'
-      )
-      if (job.jest) {
-        scripts.push('jest2qunit.js')
-      }
-      if (job.coverage && !job.coverageProxy) {
-        scripts.push(
-          'opa-iframe-coverage.js',
-          'ui5-coverage.js' // TODO detect if middleware exists before injecting this
-        )
-      }
-    }
-    if (job.coverageProxy) {
-      const { origin } = new URL(url)
-      const proxifiedUrl = url.replace(origin, `http://localhost:${job.port}`)
-      if (!job[$proxifiedUrls]) {
-        job[$proxifiedUrls] = {}
-      }
-      job[$proxifiedUrls][proxifiedUrl] = url
-      await start(job, proxifiedUrl, scripts)
-      job.qunitPages[url] = job.qunitPages[proxifiedUrl]
-      delete job.qunitPages[proxifiedUrl]
-    } else {
-      await start(job, url, scripts)
-    }
-  } catch (error) {
-    output.startFailed(url, error)
-    throw error
-  }
-}
-
-async function process (job) {
-  const output = getOutput(job)
-  job.start = new Date()
-  job.failed = false
-  await instrument(job)
-  await save(job)
-  job.testPageUrls = []
-
-  let probingRound = 0
-  const parallel = job.probeParallel || job.parallel
-  const confirmedTestPageUrls = []
-  job.status = 'Probing urls'
-  do {
-    ++probingRound
-    if (probingRound >= 2) {
-      if (job.testPageUrls.length === 0) {
-        break
-      }
-      job.status = `Probing urls (${probingRound})`
-      job.url = job.testPageUrls.filter(url => !confirmedTestPageUrls.includes(url))
-      if (job.url.length) {
-        job.testPageUrls = []
-      } else {
-        job.testPageUrls = confirmedTestPageUrls
-        break
-      }
-    }
-    try {
-      await parallelize(task(job, probeUrl), job.url, parallel)
-    } catch (e) {
-      output.genericError(e)
-      job.failed = true
-      break
-    }
-    job.testPageUrls.forEach(url => {
-      if ((job.url.includes(url) && !confirmedTestPageUrls.includes(url)) ||
-        (url.includes('/resources/sap/ui/test/starter/Test.qunit.html?testsuite=') && url.includes('&test='))
-      ) {
-        confirmedTestPageUrls.push(url)
-        getOutput(job).debug('probe', 'confirmed:', url)
-      }
-    })
-    getOutput(job).debug('probe', 'from', job.url.length, 'to', job.testPageUrls.length, 'confirmed', confirmedTestPageUrls.length)
-  } while (job.deepProbe)
-
-  /* istanbul ignore else */
-  if (!job.debugProbeOnly && !job.failed) {
-    if (job.testPageUrls.length !== 0) {
-      job.status = 'Executing test pages'
-      try {
-        await parallelize(task(job, runTestPage), job.testPageUrls, job.parallel)
-      } catch (e) {
-        output.genericError(e)
-        job.failed = true
-      }
-    } else if (Object.keys(job.qunitPages || []).length === 0) {
-      output.noTestPageFound()
-      job.failed = true
-    }
-  }
-
-  await generate(job)
-}
-
-module.exports = {
-  async execute (job) {
-    if (job.mode !== 'url') {
-      job.url = [`http://${job.localhost}:${job.port}/${job.testsuite}`]
-    } else if (!job.browserCapabilities.scripts) {
-      throw UTRError.BROWSER_MISS_SCRIPTS_CAPABILITY()
-    }
-    return process(job)
-  }
-}

package/src/timeout.js

@@ -1,53 +0,0 @@
-'use strict'
-
-module.exports = {
-  getPageTimeout (job) {
-    if (job.pageTimeout || job.globalTimeout) {
-      if (job.globalTimeout) {
-        return Math.min(job.globalTimeout - (new Date() - job.start), job.pageTimeout || Number.MAX_SAFE_INTEGER)
-      }
-      return job.pageTimeout
-    }
-    return 0
-  },
-
-  globallyTimedOut (job) {
-    if (job.globalTimeout) {
-      return new Date() - job.start > job.globalTimeout
-    }
-    return false
-  },
-
-  pageTimedOut (job, url) {
-    const page = job.qunitPages && job.qunitPages[url]
-    if (page) {
-      const now = new Date()
-      page.end = now
-      page.timedOut = true
-      page.modules.forEach(module => {
-        module.tests.forEach(test => {
-          if (!test.report) {
-            ++page.failed
-            if (test.start && !test.end) {
-              test.end = now
-            }
-            test.logs ??= []
-            test.logs.push({
-              result: false,
-              message: 'Page timed out'
-            })
-            test.report = {
-              skipped: false,
-              todo: false,
-              failed: 1,
-              passed: 0,
-              total: 1
-            }
-          }
-        })
-      })
-    }
-    job.failed = true
-    job.timedOut = true
-  }
-}

package/src/tools.js

@@ -1,179 +0,0 @@
-'use strict'
-
-const { dirname } = require('path')
-const { mkdir, rm, stat } = require('fs').promises
-const { createHash } = require('crypto')
-const { createWriteStream } = require('fs')
-const http = require('http')
-const https = require('https')
-const { unlink } = require('fs/promises')
-
-const recursive = { recursive: true }
-
-const stripUrlHash = url => url.split('#')[0]
-
-const filename = url => {
-  const hash = createHash('shake256', {
-    outputLength: 8
-  })
-  hash.update(stripUrlHash(url))
-  return hash.digest('base64')
-    .replace(/=/g, '')
-    .replace(/\+/g, '_')
-    .replace(/\//g, '$')
-}
-
-const cleanDir = async dir => {
-  try {
-    await stat(dir)
-    await rm(dir, recursive)
-  } catch (err) {
-    // Ignore
-  }
-}
-
-const $op = Symbol('pad.op')
-const $x = Symbol('pad.x')
-const $lt = Symbol('pad.lt')
-const $w = Symbol('pad.w')
-function pad (width) {
-  if (!width) {
-    width = process.stdout.columns || 80
-  }
-  const ops = {
-    [$x] (widthLeft) {
-      return ''.padStart(widthLeft, this.text)
-    },
-    [$lt] (widthLeft) {
-      const { text, padding } = this
-      if (text.length <= widthLeft) {
-        return text.padEnd(widthLeft, padding)
-      }
-      return '...' + text.substring(text.length - widthLeft + 3)
-    },
-    [$w] (widthLeft, result, opIndex) {
-      const { text } = this
-      if (text.length < widthLeft && !text.includes('\n')) {
-        return text.padEnd(widthLeft, ' ')
-      }
-      const lines = []
-      text.split(/\r?\n/).forEach(line => {
-        if (line.length <= widthLeft) {
-          lines.push(line.padEnd(widthLeft, ' '))
-        } else {
-          for (let offset = 0; offset < line.length; offset += widthLeft - 1) {
-            const part = line.slice(offset, offset + widthLeft - 1)
-            if (part.length < widthLeft - 1) {
-              lines.push(part.padEnd(widthLeft, ' '))
-            } else {
-              lines.push(`${part}↵`)
-            }
-          }
-        }
-      })
-      const before = result.slice(0, opIndex).join('')
-      const after = result.slice(opIndex + 1).join('')
-      return lines.join(after + '\n' + before)
-    }
-  }
-  return (strings, ...values) => {
-    const result = []
-    let op
-    let opIndex
-    const length = strings.reduce((total, string, index) => {
-      result.push(string)
-      total += string.length
-      let value = values[index]
-      if (value === null || value === undefined) {
-        return total
-      }
-      if (value[$op]) {
-        if (opIndex !== undefined) {
-          throw new Error('Only one operator is allowed')
-        }
-        op = value
-        opIndex = result.length
-        result.push(value)
-      } else {
-        if (typeof value !== 'string') {
-          value = value.toString()
-        }
-        result.push(value)
-        total += value.length
-      }
-      return total
-    }, 0)
-    if (op !== undefined) {
-      const widthLeft = width - length
-      result[opIndex] = ops[op[$op]].call(op, widthLeft, result, opIndex)
-    }
-    return result.join('')
-  }
-}
-
-pad.x = (text) => ({ [$op]: $x, text })
-pad.lt = (text, padding = ' ') => ({ [$op]: $lt, text, padding })
-pad.w = (text) => ({ [$op]: $w, text })
-
-function allocPromise () {
-  let resolve
-  let reject
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-  return { promise, resolve, reject }
-}
-
-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,
-    path: url.substring(origin.length),
-    method: 'GET'
-  }
-  const protocol = url.startsWith('https:') ? https : http
-  await mkdir(dirname(filename), recursive)
-  const output = createWriteStream(filename)
-  const { promise, resolve, reject } = allocPromise()
-  const request = protocol.request(options, async response => {
-    if (response.statusCode !== 200) {
-      reject(error(`server responded with ${response.statusCode}`))
-      output.end()
-      try {
-        await unlink(filename)
-      } catch (e) {
-        // ignore
-      }
-      return
-    }
-    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.end()
-  return promise
-}
-
-module.exports = {
-  stripUrlHash,
-  filename,
-  cleanDir,
-  createDir: dir => mkdir(dir, recursive),
-  recreateDir: dir => cleanDir(dir).then(() => mkdir(dir, recursive)),
-  extractPageUrl: headers => headers['x-page-url'],
-  allocPromise,
-  noop () {},
-  pad,
-  download
-}

package/src/ui5.js

@@ -1,199 +0,0 @@
-'use strict'
-
-const { dirname, join } = require('path')
-const { createWriteStream } = require('fs')
-const { mkdir, unlink, stat } = require('fs').promises
-const { capture } = require('reserve')
-const { getOutput, newProgress } = require('./output')
-const { download } = require('./tools')
-const { $statusProgressCount, $statusProgressTotal } = require('./symbols')
-const { parallelize } = require('./parallelize')
-const { relative: relativePath } = require('path')
-
-const buildCacheBase = job => {
-  const [, hostName] = /https?:\/\/([^/]*)/.exec(job.ui5)
-  const [, version] = /(\d+\.\d+\.\d+)?$/.exec(job.ui5)
-  return join(job.cache || '', hostName.replace(':', '_'), version || '')
-}
-
-const ui5mappings = async job => {
-  const output = getOutput(job)
-  const cacheBase = buildCacheBase(job)
-  const match = /\/((?:test-)?resources\/.*)/ // Captured value never starts with /
-  const ifCacheEnabled = () => job.cache
-  const uncachable = {}
-  const cachingInProgress = {}
-
-  let { ui5 } = job
-  if (!ui5.endsWith('/')) {
-    ui5 += '/'
-  }
-  const mappingUrl = new URL('$1', ui5).toString()
-
-  const inJest = typeof jest !== 'undefined'
-  /* istanbul ignore next */
-  if (!inJest) {
-    const versionUrl = mappingUrl.replace('$1', 'resources/sap-ui-version.json')
-    const versionResponse = await fetch(versionUrl)
-    if (versionResponse.status !== 200) {
-      output.log('Unable to fetch UI5 version: ' + versionResponse.status + ' ' + versionResponse.statusText)
-      throw new Error('Unable to fetch UI5 version')
-    }
-    const version = await versionResponse.json()
-    const { version: coreVersion } = version.libraries.find(({ name }) => name === 'sap.ui.core')
-    output.log('UI5 version used by the local server: ' + coreVersion)
-  }
-
-  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,
-    cwd: cacheBase,
-    file: '$1',
-    static: !job.debugDevMode
-  }, { // 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) {
-            output.failedToCacheUI5resource(path, response.statusCode)
-          }
-          return unlink(cachePath)
-        })
-        .then(() => {
-          delete cachingInProgress[path]
-        })
-    }
-  }, { // UI5 from url
-    method: ['GET', 'HEAD'],
-    match,
-    url: mappingUrl,
-    'ignore-unverifiable-certificate': true
-  }]
-
-  for (let { relative, source } of job.libs) {
-    if (source.endsWith('/') || source.endsWith('\\')) {
-      source = source.substring(0, source.length - 1)
-    }
-    const relativeUrl = relative.replace(/\//g, '\\/')
-    if (source.startsWith(job.webapp)) {
-      if (relative === '*') {
-        // Special handling to support webapp/resources folder (/!\ coverage won't be extracted for those files)
-        output.debug('libs', '* map to webapp sub directory (expected resources), use file access')
-        mappings.unshift({
-          match: /\/resources\/(.*)/,
-          cwd: source,
-          file: '$1',
-          static: !job.watch && !job.debugDevMode
-        })
-      } else {
-        // Use redirection to support local coverage instrumentation
-        const relativeAbsoluteUrl = '/' + relativePath(job.webapp, source).replace(/\\/g, '/')
-        output.debug('libs', `${relative} maps to webapp sub directory, use internal redirection to ${relativeAbsoluteUrl}`)
-        mappings.unshift({
-          match: new RegExp(`\\/resources\\/${relativeUrl}(.*)`),
-          custom: (request, response, $1) => `${relativeAbsoluteUrl}${$1}`
-        })
-      }
-    } else {
-      mappings.unshift({
-        match: new RegExp(`\\/resources\\/${relativeUrl}(.*)`),
-        cwd: source,
-        file: '$1',
-        static: !job.watch && !job.debugDevMode
-      }, {
-        match: new RegExp(`\\/resources\\/${relativeUrl}(.*)`),
-        custom: (request, response, $1) => {
-          if ($1 === undefined) {
-            output.debug('libs', `Unable to map ${relative} : $1 is undefined`)
-          } else {
-            output.debug('libs', `Unable to map ${relative}/${$1} to ${join(source, $1)}`)
-          }
-          return 404
-        }
-      })
-    }
-  }
-
-  return mappings
-}
-
-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)
-    }
-
-    const lib = async name => {
-      progress.label = name
-      progress.count = 0
-      const libPath = name.replace(/\./g, '/') + '/'
-      const { resources } = require(await get(libPath + 'resources.json'))
-      progress.total = resources.length
-      progress.label = `${name} (${resources.length} files)`
-      await parallelize(async ({ name, size }) => {
-        await get(libPath + name, size)
-        ++progress.count
-      }, resources, 8)
-      ++job[$statusProgressCount]
-    }
-
-    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 parallelize(lib, ['sap.ui.core', ...job.preload], 1)
-    progress.done()
-  },
-
-  mappings: async job => {
-    if (job.disableUi5) {
-      return []
-    }
-    return ui5mappings(job)
-  }
-}

package/src/unhandled.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const { extractPageUrl, noop } = require('./tools')
-const { join } = require('path')
-const { writeFile } = require('fs')
-const { getOutput } = require('./output')
-
-module.exports = job => {
-  const unhandled = join(job.reportDir, 'unhandled.txt')
-  let outputUnhandled = true
-  return [{
-    custom: ({ headers, method, url }) => {
-      if (method === 'GET' && url.match(/favicon\.ico$|-preload\.js$|-dbg(\.[^.]+)*\.js$|i18n_\w+\.properties$/)) {
-        return 404 // expected
-      }
-      let status
-      if (method === 'GET') {
-        status = 404
-      } else {
-        status = 500
-      }
-      if (outputUnhandled) {
-        getOutput(job).unhandled()
-        outputUnhandled = false
-      }
-      writeFile(unhandled, `${extractPageUrl(headers) || headers.referer} ${status} ${method} ${url}\n`, {
-        flag: 'a'
-      }, noop)
-      return status
-    }
-  }]
-}