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

package/src/coverage.js

@@ -1,384 +0,0 @@
-'use strict'
-
-const { join, dirname, isAbsolute, relative, sep } = require('path')
-const { fork } = require('child_process')
-const { cleanDir, createDir, filename, download, allocPromise } = require('./tools')
-const { readdir, readFile, stat, writeFile, access, constants } = require('fs').promises
-const { Readable } = require('stream')
-const { getOutput, newProgress } = require('./output')
-const { resolvePackage } = require('./npm')
-const { promisify } = require('util')
-const { UTRError } = require('./error')
-const { $remoteOnLegacy } = require('./symbols')
-
-const $nycSettingsPath = Symbol('nycSettingsPath')
-const $coverageFileIndex = Symbol('coverageFileIndex')
-const $coverageRemote = Symbol('coverageRemote')
-
-let nycInstallationPath
-let nycScript
-
-async function setupNyc (job) {
-  if (!nycInstallationPath) {
-    nycInstallationPath = resolvePackage(job, 'nyc')
-  }
-  nycScript = join(await nycInstallationPath, 'bin/nyc.js')
-}
-
-async function nyc (job, ...args) {
-  const output = getOutput(job)
-  output.nyc(...args)
-  const childProcess = fork(nycScript, args, { stdio: 'pipe' })
-  output.monitor(childProcess)
-  const { promise, resolve } = allocPromise()
-  childProcess.on('close', resolve)
-  return promise
-}
-
-async function safeNyc (job, ...args) {
-  const code = await nyc(job, ...args)
-  if (code !== 0) {
-    const [command] = args
-    throw UTRError.NYC_FAILED(`nyc ${command} failed with code ${code}`)
-  }
-}
-
-const globalContextSearch = 'var global=new Function("return this")();'
-const globalContextReplace = 'var global=window.top;'
-
-const customFileSystem = {
-  stat: path => stat(path)
-    .then(stats => {
-      stats.size -= globalContextSearch.length + globalContextReplace.length
-      return stats
-    }),
-  readdir,
-  createReadStream: async (path) => {
-    const buffer = (await readFile(path))
-      .toString()
-      .replace(globalContextSearch, globalContextReplace)
-    return Readable.from(buffer)
-  }
-}
-
-async function instrument (job) {
-  await setupNyc(job)
-  job[$nycSettingsPath] = join(job.coverageTempDir, 'settings/.nycrc.json')
-  await cleanDir(job.coverageTempDir)
-  await createDir(join(job.coverageTempDir, 'settings'))
-  const settings = JSON.parse((await readFile(job.coverageSettings)).toString())
-  settings.cwd = job.webapp
-  if (!settings.exclude) {
-    settings.exclude = []
-  }
-  settings.exclude.push(join(job.coverageTempDir, '**'))
-  if (job.cache) {
-    settings.exclude.push(join(job.cache, '**'))
-  }
-  settings.exclude.push(join(job.reportDir, '**'))
-  settings.exclude.push(join(job.coverageReportDir, '**'))
-  await writeFile(job[$nycSettingsPath], JSON.stringify(settings))
-  job.nycSettings = settings
-  if (job.mode === 'url') {
-    if (!job[$remoteOnLegacy]) {
-      job[$coverageRemote] = true
-      getOutput(job).instrumentationSkipped()
-      return
-    }
-  }
-  job.status = 'Instrumenting'
-  await safeNyc(job, 'instrument', job.webapp, join(job.coverageTempDir, 'instrumented'), '--nycrc-path', job[$nycSettingsPath])
-}
-
-function getUrlOrigin (job) {
-  const { origin } = new URL(job.url[0])
-  if (job.url.some(url => new URL(url).origin !== origin)) {
-    getOutput(job).assumingOneOrigin()
-  }
-  return origin
-}
-
-async function buildAllIndex (job) {
-  async function scanFs (path, onFolder, onFile) {
-    const items = await readdir(path)
-    await onFolder(items.length)
-    for (const item of items) {
-      const itemPath = join(path, item)
-      const itemStat = await stat(itemPath)
-      if (itemStat.isDirectory()) {
-        await scanFs(itemPath, onFolder, onFile)
-      } else {
-        await onFile(itemPath, (await readFile(itemPath)).toString())
-      }
-    }
-  }
-
-  const output = getOutput(job)
-  output.debug('coverage', 'Build index for all files...')
-  const progress = newProgress(job, 'Build index for all files', 1, 0)
-
-  try {
-    const index = []
-    let scan
-    let start
-    if (job.mode === 'legacy' || job[$remoteOnLegacy]) {
-      scan = scanFs
-      start = join(job.coverageTempDir, 'instrumented')
-    } else {
-      scan = require(job.coverageRemoteScanner)
-      start = getUrlOrigin(job)
-    }
-
-    await scan(
-      start,
-      count => {
-        progress.total += count
-        ++progress.count
-      },
-      async (file, source) => {
-        if (file.endsWith('.js') || file.endsWith('.ts')) {
-          output.debug('coverage', file)
-          try {
-            const coverageData = source
-              .match(/coverageData\s*=\s*({[^;]*});/)[1]
-              .replace(/([^"])(\w+):/g, (_, before, name) => `${before}"${name}":`)
-            const [, coveragePath] = coverageData.match(/"path"\s*:\s*"([^"]+)"/)
-            const UNDEFINED = '__undefined__'
-            const validatedCoverageData = JSON.stringify(
-              JSON.parse(coverageData.replace(/\bundefined\b/g, `"${UNDEFINED}"`)),
-              (key, value) => {
-                if (value === UNDEFINED) {
-                  return undefined
-                }
-                return value
-              }
-            )
-            index.push(`"${coveragePath}": ${validatedCoverageData}`)
-          } catch (e) {
-            output.debug('coverage', `Error when extracting all coverage for ${file}`, e)
-          }
-        } else {
-          output.debug('coverage', `Ignore all coverage for ${file}`)
-        }
-        ++progress.count
-      }
-    )
-    if (index.length === 0) {
-      output.noInfoForAllCoverage()
-    } else {
-      await writeFile(join(job.coverageTempDir, 'all-index.json'), `{${index.join(',')}}`)
-    }
-  } catch (e) {
-    output.genericError(e, e.url)
-    output.noInfoForAllCoverage()
-  } finally {
-    progress.done()
-  }
-}
-
-async function getReadableSource (job, pathOrUrl) {
-  if (isAbsolute(pathOrUrl)) {
-    try {
-      await access(pathOrUrl, constants.R_OK)
-      return pathOrUrl
-    } catch (e) {}
-  }
-  try {
-    const filePath = join(job.webapp, pathOrUrl)
-    await access(filePath, constants.R_OK)
-    return filePath
-  } catch (e) {}
-  try {
-    const origin = getUrlOrigin(job)
-    if (!job.coverageSourceDir) {
-      job.coverageSourceDir = join(job.coverageTempDir, 'sources')
-    }
-    const filePath = join(job.coverageSourceDir, pathOrUrl)
-    await download(origin + pathOrUrl, filePath)
-    return filePath
-  } catch (e) {}
-}
-
-async function checkAllSourcesAreAvailable (job, coverageFilename) {
-  const output = getOutput(job)
-  job.status = 'Checking remote source files'
-  output.debug('coverage', 'Checking remote source files...')
-  const coverageData = require(coverageFilename)
-  const filenames = Object.keys(coverageData)
-  let changes = false
-  let basePath
-  for (const filename of filenames) {
-    const fileData = coverageData[filename]
-    const filePath = await getReadableSource(job, fileData.path)
-    if (!filePath) {
-      // TODO this will compromise coverage report generation
-      continue
-    }
-    if (filePath && filePath !== fileData.path) {
-      fileData.path = filePath
-      changes = true
-    }
-    if (filename !== filePath) {
-      delete coverageData[filename]
-      coverageData[filePath] = fileData
-      changes = true
-    }
-    const fileFolder = dirname(filePath)
-    if (basePath === undefined) {
-      basePath = fileFolder
-    } else {
-      const diff = relative(basePath, fileFolder).split(sep)
-      while (diff.shift() === '..') {
-        basePath = dirname(basePath)
-      }
-    }
-  }
-  if (basePath !== job.nycSettings.cwd) {
-    job.nycSettings.cwd = basePath
-    await writeFile(job[$nycSettingsPath], JSON.stringify(job.nycSettings))
-  }
-  if (changes) {
-    await writeFile(coverageFilename, JSON.stringify(coverageData))
-  }
-}
-
-async function generateCoverageReport (job) {
-  job.status = 'Generating coverage report'
-  if (job.nycSettings.all) {
-    await buildAllIndex(job)
-  }
-  const output = getOutput(job)
-  output.debug('coverage', 'Generating coverage report...')
-  await cleanDir(job.coverageReportDir)
-  const coverageMergedDir = join(job.coverageTempDir, 'merged')
-  await createDir(coverageMergedDir)
-  const coverageFilename = join(coverageMergedDir, 'coverage.json')
-  await safeNyc(job, 'merge', job.coverageTempDir, coverageFilename)
-  if (job[$coverageRemote]) {
-    await checkAllSourcesAreAvailable(job, coverageFilename)
-  }
-  const reporters = job.coverageReporters.map(reporter => `--reporter=${reporter}`)
-  if (!job.coverageReporters.includes('text')) {
-    reporters.push('--reporter=text')
-  }
-  const checks = []
-  if (job.coverageCheckBranches || job.coverageCheckFunctions || job.coverageCheckLines || job.coverageCheckStatements) {
-    if (!job.coverageReporters.includes('lcov')) {
-      reporters.push('--reporter=lcov')
-    }
-    checks.push(
-      `--branches=${job.coverageCheckBranches}`,
-      `--functions=${job.coverageCheckFunctions}`,
-      `--lines=${job.coverageCheckLines}`,
-      `--statements=${job.coverageCheckStatements}`,
-      '--check-coverage'
-    )
-  }
-  const returnCode = await nyc(job, 'report', ...reporters, ...checks, '--temp-dir', coverageMergedDir, '--report-dir', job.coverageReportDir, '--nycrc-path', job[$nycSettingsPath])
-  if (checks.length) {
-    // The checks are not triggered if the coverage is empty
-    const lcov = await stat(join(job.coverageReportDir, 'lcov.info'))
-    if (lcov.size === 0) {
-      throw UTRError.NYC_FAILED('No coverage information extracted')
-    }
-    if (returnCode === 1) {
-      // Assuming coverage report shows the error
-      output.debug('coverage', `nyc report failed with code ${returnCode}`)
-      job.failed = true
-    }
-  } else if (returnCode !== 0) {
-    throw UTRError.NYC_FAILED(`nyc report failed with code ${returnCode}`)
-  }
-}
-
-module.exports = {
-  instrument: job => job.coverage && instrument(job),
-  async collect (job, url, coverageData) {
-    if (!job.coverage) {
-      return
-    }
-    job[$coverageFileIndex] = (job[$coverageFileIndex] || 0) + 1
-    const coverageFileName = join(job.coverageTempDir, `${filename(url)}_${job[$coverageFileIndex]}.json`)
-    getOutput(job).debug('coverage', `saved coverage in '${coverageFileName}'`)
-    await writeFile(coverageFileName, JSON.stringify(coverageData))
-  },
-  generateCoverageReport: job => job.coverage ? generateCoverageReport(job) : Promise.resolve(),
-  mappings: async job => {
-    if (!job.coverage) {
-      return []
-    }
-    const instrumentedBasePath = join(job.coverageTempDir, 'instrumented')
-    const instrumentedMapping = {
-      match: /(.*\.js)(\?.*)?$/,
-      cwd: instrumentedBasePath,
-      file: '$1'
-    }
-    if (job.mode === 'legacy' || job[$remoteOnLegacy]) {
-      return [{
-        ...instrumentedMapping,
-        'custom-file-system': job.debugCoverageNoCustomFs ? undefined : customFileSystem
-      }]
-    }
-    if (job.mode === 'url' && job.coverageProxy) {
-      await setupNyc(job)
-      // Assuming all files are coming from the same server
-      const { origin } = new URL(job.url[0])
-      let instrument
-      try {
-        const { createInstrumenter } = require(join(await nycInstallationPath, 'node_modules/istanbul-lib-instrument'))
-        const instrumenter = createInstrumenter({
-          produceSourceMap: true,
-          coverageGlobalScope: 'window.top',
-          coverageGlobalScopeFunc: false
-        })
-        instrument = promisify(instrumenter.instrument.bind(instrumenter))
-      } catch (e) {
-        // Recent version of nyc offers a different interface
-        const createInstrumenter = require(join(await nycInstallationPath, 'lib/instrumenters/istanbul.js'))
-        const instrumenter = createInstrumenter({
-          produceSourceMap: true
-        })
-        instrument = async function (code, sourcePath) {
-          return instrumenter.instrumentSync(code, sourcePath, { registerMap: () => {} })
-            // TODO use regular expression !
-            .replace(globalContextSearch, globalContextReplace)
-        }
-      }
-      const sources = {}
-      return [{
-        match: /(.*\.js)(\?.*)?$/,
-        custom: async (request, response, url) => {
-          if (!url.match(job.coverageProxyInclude) || url.match(job.coverageProxyExclude)) {
-            getOutput(job).debug('coverage', 'coverage_proxy ignore', url)
-            return
-          }
-          const instrumentedSourcePath = join(instrumentedBasePath, url)
-          try {
-            await access(instrumentedSourcePath, constants.R_OK)
-            return
-          } catch (e) {}
-          if (!sources[url]) {
-            sources[url] = (async () => {
-              const sourcePath = await getReadableSource(job, url)
-              getOutput(job).debug('coverage', 'coverage_proxy instrument', url, sourcePath)
-              if (sourcePath) {
-                const source = (await readFile(sourcePath)).toString()
-                const instrumentedSource = await instrument(source, sourcePath)
-                await createDir(dirname(instrumentedSourcePath))
-                await writeFile(instrumentedSourcePath, instrumentedSource)
-                delete sources[url]
-              }
-            })()
-          }
-          await sources[url]
-        }
-      },
-      instrumentedMapping,
-      {
-        match: /(.*)$/,
-        url: `${origin}$1`
-      }]
-    }
-    return []
-  }
-}

package/src/csv-reader.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const { createReadStream } = require('fs')
-const readline = require('readline')
-
-const unescape = value => {
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return JSON.parse(value)
-  }
-  return value
-}
-
-async function * buildCsvReader (fileName) {
-  const fileStream = createReadStream(fileName)
-  const rl = readline.createInterface({
-    input: fileStream,
-    crlfDelay: Infinity
-  })
-  let headers
-  for await (const line of rl) {
-    const fields = line.split('\t')
-    if (headers === undefined) {
-      headers = fields
-      continue
-    }
-    const record = {}
-    headers.forEach((field, index) => {
-      record[field] = unescape(fields[index])
-    })
-    yield record
-  }
-}
-
-module.exports = {
-  buildCsvReader
-}

package/src/csv-writer.js

@@ -1,55 +0,0 @@
-'use strict'
-
-const { writeFile } = require('fs/promises')
-
-const append = (fileName, line) => writeFile(fileName, line + '\n', { flag: 'a+' })
-const escape = value => {
-  if (value === undefined) {
-    return '❓'
-  }
-  const stringValue = value.toString()
-  if (stringValue.match(/\r|\n|\t|"/)) {
-    return JSON.stringify(stringValue)
-  }
-  return stringValue
-}
-
-class CsvWriter {
-  #fileName
-  #ready
-  #fields
-
-  constructor (fileName) {
-    this.#fileName = fileName
-    this.#ready = Promise.resolve()
-    this.#fields = []
-  }
-
-  get ready () {
-    return this.#ready
-  }
-
-  append (records) {
-    if (!Array.isArray(records)) {
-      records = [records]
-    }
-    if (this.#fields.length === 0) {
-      this.#fields = Object.keys(records[0]).filter(name => name !== 'timestamp')
-      this.#ready = this.#ready.then(() => append(this.#fileName, `timestamp\t${this.#fields.join('\t')}`))
-    }
-    const lines = records.map(record => {
-      const { timestamp = Date.now() } = record
-      return [
-        timestamp,
-        ...this.#fields.map(name => escape(record[name]))
-      ].join('\t')
-    }).join('\n')
-    this.#ready = this.#ready.then(() => append(this.#fileName, lines))
-  }
-}
-
-module.exports = {
-  buildCsvWriter (fileName) {
-    return new CsvWriter(fileName)
-  }
-}

package/src/defaults/.nycrc.json

@@ -1,4 +0,0 @@
-{
-  "all": true,
-  "sourceMap": false
-}

package/src/defaults/browser.js

@@ -1,217 +0,0 @@
-const { readFile, writeFile } = require('fs/promises')
-const { join } = require('path')
-const { Command, InvalidArgumentError } = require('commander')
-const { buildCsvWriter } = require('../csv-writer')
-const { any, arrayOf, boolean, integer, string } = require('../options')
-
-const noop = () => { }
-
-module.exports = ({
-  metadata,
-  flush = noop,
-  beforeExit = noop,
-  screenshot,
-  capabilities: computeCapabilities,
-  run,
-  error = noop
-}) => {
-  const command = new Command()
-  command
-    .name(`ui5-test-runner/@/${metadata.name}`)
-    .description(`Browser instantiation command for ${metadata.name}`)
-    .helpOption(false)
-  metadata.options
-    .map(option => {
-      if (option[0] === 'browser') {
-        const [, ...browsers] = option
-        return [[
-          '-b, --browser <name>', 'Browser driver',
-          function (value) {
-            if (value === undefined) {
-              return browsers[0]
-            }
-            if (!browsers.includes(value)) {
-              throw new InvalidArgumentError('Browser name')
-            }
-            return value
-          },
-          browsers[0]
-        ]]
-      }
-      if (option === 'binary') {
-        return [['--binary <binary>', 'Binary path']]
-      }
-      if (option === 'visible') {
-        return [['--visible [flag]', 'Show the browser', false]]
-      }
-      if (option === 'viewport') {
-        return [
-          ['-w, --viewport-width <width>', 'Viewport width', 1920],
-          ['-h, --viewport-height <height>', 'Viewport height', 1080]
-        ]
-      }
-      if (option === 'language') {
-        return [['-l, --language <lang...>', 'Language(s) (see rfc5646)', arrayOf(string, true), ['en-US']]]
-      }
-      if (option === 'unsecure') {
-        return [['-u, --unsecure', 'Disable security features', false]]
-      }
-      return [option]
-    })
-    .flat()
-    .forEach(([label, description, parser, defaultValue]) => {
-      if (defaultValue === undefined && typeof parser !== 'function') {
-        defaultValue = parser
-        if (typeof defaultValue === 'number') {
-          parser = integer
-        } else if (typeof defaultValue === 'boolean') {
-          parser = boolean
-        } else {
-          parser = any
-        }
-      }
-      command.option(label, description, parser, defaultValue)
-    })
-
-  const append = () => { }
-  let consoleWriter = { ready: Promise.resolve(), append }
-  let networkWriter = { ready: Promise.resolve(), append }
-
-  let stopping = false
-  let settings
-  let options
-
-  async function exit (code) {
-    if (stopping) {
-      return
-    }
-    stopping = true
-    if (settings && typeof settings.capabilities !== 'string' && settings.capabilities.traces.length) {
-      try {
-        await flush({
-          settings,
-          options,
-          consoleWriter,
-          networkWriter
-        })
-      } catch (e) {
-        console.error('[exit:flush]', e)
-        code = -3
-      }
-      await Promise.all([consoleWriter.ready, networkWriter.ready])
-    }
-    try {
-      await beforeExit({
-        settings,
-        options
-      })
-    } catch (e) {
-      console.error('[exit:beforeExit]', e)
-      // but ignore
-    }
-    process.exit(code)
-  }
-
-  process.on('message', async message => {
-    const { command } = message
-    try {
-      if (command === 'stop') {
-        await exit(0)
-      } else if (command === 'screenshot') {
-        if (settings.capabilities.screenshot && screenshot && await screenshot({
-          settings,
-          options,
-          filename: message.filename
-        })) {
-          process.send(message)
-        } else {
-          throw new Error('screenshot command failed')
-        }
-      }
-    } catch (e) {
-      console.error(e)
-      exit(-2)
-    }
-  })
-
-  if (process.argv[2] === 'test') {
-    command.parse(process.argv.slice(3), { from: 'user' })
-    console.log(command.opts(), command.args)
-    return exit(0)
-  }
-
-  if (process.argv.length !== 3) {
-    command.outputHelp()
-    return exit(0)
-  }
-
-  async function main () {
-    settings = JSON.parse((await readFile(process.argv[2])).toString())
-    command.parse(settings.args, { from: 'user' })
-    options = command.opts()
-
-    options.chromeArgs = function () {
-      const args = [
-        'true', // Not sure why but this changes the behavior of the browser
-        '--start-maximized',
-        '--no-sandbox',
-        '--disable-gpu',
-        '--disable-extensions',
-        '--log-level=3',
-        `--window-size=${options.viewportWidth},${options.viewportHeight}`
-      ]
-      if (options.language) {
-        args.push(`--lang=${options.language.join(',')}`)
-      }
-      if (!options.visible) {
-        args.push('--headless=new')
-      }
-      if (options.unsecure) {
-        args.push(
-          '--ignore-certificate-errors',
-          '--disable-web-security',
-          '--disable-features=IsolateOrigins',
-          '--disable-features=BlockInsecurePrivateNetworkRequests',
-          '--disable-site-isolation-trials'
-        )
-      }
-      return args.concat(command.args)
-    }
-
-    if (typeof settings.capabilities === 'string') {
-      let capabilities
-      if (computeCapabilities !== undefined) {
-        capabilities = await computeCapabilities({ settings, options })
-      } else {
-        capabilities = metadata.capabilities
-      }
-      await writeFile(settings.capabilities, JSON.stringify(capabilities, undefined, 2))
-      return exit(0)
-    }
-
-    consoleWriter = buildCsvWriter(join(settings.dir, 'console.csv'))
-    networkWriter = buildCsvWriter(join(settings.dir, 'network.csv'))
-
-    await run({
-      settings,
-      options,
-      consoleWriter,
-      networkWriter,
-      exit
-    })
-  }
-
-  main()
-    .catch(async e => {
-      if (!stopping) {
-        await error({
-          settings,
-          options,
-          error: e,
-          exit
-        })
-        console.error(e)
-      }
-      exit(-1)
-    })
-}