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

package/src/parallelize.js

@@ -1,63 +0,0 @@
-const { allocPromise } = require('./tools')
-
-function complete (task) {
-  ++task.completed
-  if (--task.active === 0) {
-    task.resolve()
-  }
-}
-
-async function run (task) {
-  const {
-    method,
-    list,
-    parallel,
-    started,
-    completed,
-    stop,
-    reject
-  } = task
-  const { length } = list
-  if (stop || completed === length || started === length) {
-    complete(task)
-    return
-  }
-  if (task.active < parallel && length - started > task.active) {
-    ++task.active
-    run(task)
-  }
-  const index = task.started++
-  const parameter = list[index]
-  try {
-    await method(parameter, index, list)
-  } catch (error) {
-    task.stop = true
-    reject(error)
-  }
-  let remaining = list.length - task.started
-  while (task.active < (parallel + 1) && remaining) {
-    --remaining
-    ++task.active
-    run(task)
-  }
-  complete(task)
-}
-
-function parallelize (method, list, parallel) {
-  const { promise, resolve, reject } = allocPromise()
-  const task = {
-    method,
-    list,
-    parallel,
-    started: 0,
-    completed: 0,
-    active: 1,
-    stop: false,
-    resolve,
-    reject
-  }
-  run(task)
-  return promise
-}
-
-module.exports = { parallelize }

package/src/qunit-hooks.js

@@ -1,219 +0,0 @@
-'use strict'
-
-const { screenshot, stop } = require('./browsers')
-const { collect } = require('./coverage')
-const { UTRError } = require('./error')
-const { getOutput } = require('./output')
-const { basename } = require('path')
-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)
-  job.failed = true
-  throw UTRError.QUNIT_ERROR(details)
-}
-
-function invalidTestId (job, url, testId) {
-  error(job, url, `No QUnit unit test found with id ${testId}`)
-}
-
-function merge (targetModules, modules) {
-  modules.forEach(module => {
-    const { name } = module
-    const targetModule = targetModules.filter(({ name: targetName }) => name === targetName)[0]
-    if (targetModule === undefined) {
-      targetModules.push(module)
-    } else {
-      module.tests.forEach(test => {
-        const targetTest = targetModule.tests.filter(({ testId }) => test.testId === testId)[0]
-        if (!targetTest) {
-          targetModule.tests.push(test)
-        }
-      })
-    }
-  })
-}
-
-function filterModules (modules, url) {
-  const moduleIdMatch = url.match(/\?.*\bmoduleId=([^&]+)/)
-  if (moduleIdMatch) {
-    const [, moduleId] = moduleIdMatch
-    return modules.filter(module => module.moduleId === moduleId)
-  }
-  const moduleNameMatch = url.match(/\?.*\bmodule=([^&]+)/)
-  if (moduleNameMatch) {
-    const [, escapedModuleName] = moduleNameMatch
-    const moduleName = decodeURIComponent(escapedModuleName)
-    return modules.filter(module => module.name === moduleName)
-  }
-  return modules
-}
-
-function get (job, urlWithHash, { testId, modules, isOpa } = {}) {
-  const url = stripUrlHash(urlWithHash)
-  const page = job.qunitPages && job.qunitPages[url]
-  if (!page) {
-    error(job, url, `No QUnit page found for ${urlWithHash}`)
-  }
-  const progress = (job[$browsers] && job[$browsers][url] && job[$browsers][url].progress) || { total: 0, count: 0 }
-  merge(page.modules, filterModules(modules || [], url))
-  progress.total = page.count = page.modules.reduce((total, { tests }) => total + tests.length, 0)
-  if (!page.isOpa && isOpa) {
-    page.isOpa = true
-  }
-  let testModule
-  let test
-  if (testId !== undefined) {
-    page.modules.every(module => {
-      test = module.tests.find(test => test.testId === testId)
-      if (test === undefined) {
-        return true
-      } else {
-        testModule = module
-        return false
-      }
-    })
-    if (!test) {
-      invalidTestId(job, url, testId)
-    }
-  }
-  return { url, page, testModule, test, progress }
-}
-
-async function done (job, urlWithHash, report) {
-  const { url, page } = get(job, urlWithHash)
-  if (page.count === 0) {
-    return // wait
-  }
-  const { promise, resolve } = allocPromise()
-  page[$doneResolve] = resolve
-  page[$doneTimeout] = setTimeout(async () => {
-    if (job.browserCapabilities.screenshot && job.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__
-    } else if (job.coverage) {
-      getOutput(job).coverageNotFound()
-    }
-    page.report = report
-    stop(job, url)
-    resolve()
-  }, job.pageCloseTimeout)
-  return promise
-}
-
-module.exports = {
-  get,
-
-  async begin (job, urlWithHash, details) {
-    getOutput(job).debug('qunit/begin', 'begin', urlWithHash, details)
-    const { isOpa, modules } = details
-    const url = stripUrlHash(urlWithHash)
-    if (!job.qunitPages) {
-      job.qunitPages = {}
-    }
-    const qunitPage = {
-      id: filename(url),
-      start: new Date(),
-      isOpa: !!isOpa,
-      failed: 0,
-      passed: 0,
-      count: 0,
-      modules: []
-    }
-    job.qunitPages[url] = qunitPage
-    const { page, progress } = get(job, url, { modules })
-    progress.count = 0
-    progress.total = page.count
-  },
-
-  async testStart (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', 'log', urlWithHash, details)
-    const { url, page, test } = get(job, urlWithHash, details)
-    const { isOpa, modules, module, name, testId, ...log } = details
-    if (!test) {
-      invalidTestId(job, url, testId)
-    }
-    if (!test.logs) {
-      test.logs = []
-    }
-    test.logs.push(log)
-    if (page.isOpa && job.browserCapabilities.screenshot && job.screenshot) {
-      try {
-        const absoluteName = await screenshot(job, url, `${testId}-${log.runtime}`)
-        log.screenshot = basename(absoluteName)
-      } catch (error) {
-        getOutput(job).genericError(error, url)
-      }
-    }
-  },
-
-  async testDone (job, urlWithHash, details) {
-    getOutput(job).debug('qunit/testDone', 'testDone', urlWithHash, details)
-    const { name, module, testId, assertions, ...report } = details
-    const { failed } = report
-    const { url, page, test, progress } = get(job, urlWithHash, { testId })
-    if (!test) {
-      invalidTestId(job, url, testId)
-    }
-    ++progress.count
-    if (failed) {
-      if (job.browserCapabilities.screenshot && job.screenshotOnFailure) {
-        try {
-          const absoluteName = await screenshot(job, url, testId)
-          test.screenshot = basename(absoluteName)
-        } catch (error) {
-          getOutput(job).genericError(error, url)
-        }
-      }
-      ++page.failed
-      job.failed = true
-    } else {
-      ++page.passed
-    }
-    test.end = new Date()
-    test.report = report
-    if (job.failOpaFast && failed) {
-      // skip remaining tests
-      page.modules.forEach(module => {
-        module.tests.forEach(test => {
-          if (!test.report) {
-            test.skip = true
-          }
-        })
-      })
-      await done(job, urlWithHash, {
-        failed: page.failed,
-        passed: page.passed,
-        total: page.count,
-        runtime: 0
-      })
-    }
-  },
-
-  async done (job, urlWithHash, report) {
-    getOutput(job).debug('qunit/done', 'done', urlWithHash, report)
-    await done(job, urlWithHash, report)
-  }
-}

package/src/report.js

@@ -1,89 +0,0 @@
-'use strict'
-
-const { join } = require('path')
-const { writeFile } = require('fs').promises
-const { generateCoverageReport } = require('./coverage')
-const { filename, allocPromise } = require('./tools')
-const { fork } = require('child_process')
-const { getOutput } = require('./output')
-
-async function save (job) {
-  // Ensure the file is treated as CommonJS
-  await writeFile(join(job.reportDir, 'package.json'), '{"type": "commonjs"}')
-  await writeFile(join(job.reportDir, 'job.js'), `module.exports = ${JSON.stringify(job, (key, value) => {
-    if (value && value instanceof RegExp) {
-      return value.toString()
-    }
-    return value
-  }, 2)}`)
-}
-
-function generateTextReport (job) {
-  const { promise, resolve } = allocPromise()
-  const childProcess = fork(
-    join(__dirname, 'defaults/text-report.js'),
-    [job.reportDir, process.stdout.columns || ''],
-    {
-      stdio: 'pipe',
-      env: {
-        ...process.env,
-        ...job.env
-      }
-    }
-  )
-  getOutput(job).monitor(childProcess, true)
-  childProcess.on('close', resolve)
-  return promise
-}
-
-module.exports = {
-  save,
-
-  async generate (job) {
-    const output = getOutput(job)
-    try {
-      await generateCoverageReport(job)
-    } catch (e) {
-      output.genericError(e)
-      job.failed = true
-    }
-    job.status = 'Generating reports'
-    job.end = new Date()
-    job.failed = !!job.failed
-    job.testPageHashes = job.testPageUrls.map(url => filename(url))
-    output.debug('report', 'saving job...')
-    await save(job)
-    output.debug('report', 'job saved.')
-    output.debug('report', 'generating text report...')
-    await generateTextReport(job)
-    output.debug('report', 'text report generated.')
-    const promises = job.reportGenerator.map(generator => {
-      output.debug('report', 'launching', generator, '...')
-      const { promise, resolve } = allocPromise()
-      const childProcess = fork(
-        generator,
-        [job.reportDir],
-        {
-          stdio: 'pipe',
-          env: {
-            ...process.env,
-            ...job.env
-          }
-        }
-      )
-      const buffers = output.monitor(childProcess, false)
-      childProcess.on('close', exitCode => {
-        output.debug('report', generator, 'ended with exit code', exitCode)
-        if (exitCode !== 0) {
-          output.reportGeneratorFailed(generator, exitCode, buffers)
-        }
-        resolve()
-        output.debug('report', generator, 'resolved')
-      })
-      return promise
-    })
-    output.debug('report', 'generators count:', promises.length)
-    await Promise.all(promises)
-    job.status = 'Reports generated'
-  }
-}

package/src/reserve.js

@@ -1,25 +0,0 @@
-const cors = require('./cors')
-const endpoints = require('./endpoints')
-const { mappings: coverage } = require('./coverage')
-const { mappings: ui5 } = require('./ui5')
-const { check } = require('reserve')
-const unhandled = require('./unhandled')
-
-module.exports = async job => check({
-  port: job.port,
-  mappings: [
-    cors,
-    ...job.mappings ?? [],
-    ...job.serveOnly ? [] : endpoints(job),
-    ...await ui5(job),
-    ...job.serveOnly ? [] : await coverage(job),
-    {
-      // Project mapping
-      match: /^\/(.*)/,
-      cwd: job.webapp,
-      file: '$1',
-      static: !job.watch && !job.debugDevMode
-    },
-    ...job.serveOnly ? [{ status: 404 }] : unhandled(job)
-  ]
-})

package/src/start.js

@@ -1,129 +0,0 @@
-const { spawn } = require('child_process')
-const { readFile, access, constants } = require('fs/promises')
-const { join } = require('path')
-const { getOutput } = require('./output')
-const { platform } = require('os')
-const { allocPromise } = require('./tools')
-
-async function start (job) {
-  const { startWaitUrl: url, startWaitMethod: method } = job
-  const { startCommand: start } = job
-  const output = getOutput(job)
-  let [command, ...parameters] = start.split(' ')
-
-  job.status = 'Executing start command'
-
-  // check if existing NPM script
-  if (command !== 'node' && parameters.length === 0) {
-    const packagePath = join(job.cwd, 'package.json')
-    try {
-      await access(packagePath, constants.F_OK)
-      output.debug('start', 'Found package.json in cwd')
-      const packageFile = JSON.parse(await readFile(packagePath, 'utf-8'))
-      if (packageFile.scripts[command]) {
-        output.debug('start', 'Found matching script in package.json')
-        // grab npm-cli path
-        const { promise, resolve } = allocPromise()
-        const npmChildProcess = spawn('npm', {
-          shell: true,
-          encoding: 'utf8'
-        })
-        npmChildProcess.on('close', resolve)
-        const npmOutput = []
-        npmChildProcess.stdout.on('data', (data) => npmOutput.push(data.toString()))
-        await promise
-        const [, version, path] = /^npm@([^ ]+) (.*)$/gm.exec(npmOutput.join(''))
-        output.debug('start', `npm@${version} ${path}`)
-        parameters = [join(path, 'bin/npm-cli.js'), 'run', command]
-        command = 'node'
-      }
-    } catch (e) {
-      output.debug('start', 'Missing or invalid package.json in cwd', e)
-    }
-  }
-
-  if (command === 'node') {
-    const [node] = process.argv
-    output.debug('start', `Replacing node with ${node}`)
-    command = node
-  }
-
-  let startProcessExited = false
-  output.debug('start', 'Spawning', [command, ...parameters])
-  const startProcess = spawn(command, parameters, {
-    cwd: job.cwd,
-    windowsHide: true,
-    detached: true
-  })
-  startProcess.on('close', () => {
-    output.debug('start', 'Start command process exited')
-    startProcessExited = true
-  })
-  output.monitor(startProcess)
-  output.debug('start', `Spawned process id ${startProcess.pid}`)
-
-  job.status = 'Waiting for URL to be reachable'
-
-  const begin = Date.now()
-  let lastError
-  // eslint-disable-next-line no-unmodified-loop-condition
-  while (!startProcessExited && Date.now() - begin <= job.startTimeout) {
-    try {
-      const response = await fetch(url, { method })
-      output.debug('start', url, response.status)
-      if (response.status === 200) {
-        break
-      }
-    } catch (e) {
-      if (e.toString() !== lastError) {
-        output.debug('start', url, e)
-        lastError = e.toString()
-      }
-      await new Promise(resolve => setTimeout(resolve, 250))
-    }
-  }
-
-  if (startProcessExited) {
-    throw new Error(`Start command failed with exit code ${startProcess.exitCode}`)
-  }
-
-  const stop = async () => {
-    job.status = 'Terminating start command'
-    if (platform() === 'win32') {
-      const killProcess = spawn('taskkill', ['/F', '/T', '/PID', startProcess.pid], {
-        windowsHide: true
-      })
-      const { promise, resolve } = allocPromise()
-      killProcess.on('close', resolve)
-      output.monitor(killProcess)
-      await promise
-    } else {
-      try {
-        process.kill(-startProcess.pid)
-      } catch (error) {
-        output.genericError(error)
-        return
-      }
-    }
-    const begin = Date.now()
-    // eslint-disable-next-line no-unmodified-loop-condition
-    while (!startProcessExited && Date.now() - begin <= job.startTimeout) {
-      await new Promise(resolve => setTimeout(resolve, 250))
-    }
-    if (startProcessExited) {
-      // Additional waiting time to release handles
-      await new Promise(resolve => setTimeout(resolve, 250))
-    }
-  }
-
-  if (Date.now() - begin > job.startTimeout) {
-    await stop()
-    throw new Error(`Timeout while waiting for ${url}`)
-  }
-
-  return {
-    stop
-  }
-}
-
-module.exports = { start }

package/src/symbols.js

@@ -1,8 +0,0 @@
-module.exports = {
-  $browsers: Symbol('browsers'),
-  $valueSources: Symbol('valueSources'),
-  $remoteOnLegacy: Symbol('remoteOnLegacy'),
-  $proxifiedUrls: Symbol('proxifiedUrls'),
-  $statusProgressCount: Symbol('statusProgressCount'),
-  $statusProgressTotal: Symbol('statusProgressTotal')
-}