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

package/index.js

@@ -1,175 +0,0 @@
-#!/usr/bin/env node
-
-'use strict'
-
-const { serve } = require('reserve')
-const { watch } = require('fs')
-const { capabilities } = require('./src/capabilities')
-const { execute } = require('./src/tests')
-const { fromCmdLine } = require('./src/job')
-const { getOutput } = require('./src/output')
-const { preload } = require('./src/ui5')
-const { probe: probeBrowser } = require('./src/browsers')
-const { recreateDir, allocPromise } = require('./src/tools')
-const reserveConfigurationFactory = require('./src/reserve')
-const { start } = require('./src/start')
-const { executeIf } = require('./src/if')
-const { batch } = require('./src/batch')
-const { end } = require('./src/end')
-const { checkLatest } = require('./src/npm')
-const { cleanHandles } = require('./src/clean')
-
-function send (message) {
-  if (process.send) {
-    process.send({
-      pid: process.pid,
-      ...message
-    })
-  }
-}
-
-async function notifyAndExecuteTests (job) {
-  send({ msg: 'begin' })
-  try {
-    await execute(job)
-    let status
-    if (job.failed) {
-      status = -1
-    } else {
-      status = 0
-    }
-    send({ msg: 'end', status })
-  } catch (error) {
-    getOutput(job).genericError(error)
-    send({ msg: 'error', error })
-  }
-}
-
-let job
-let output
-
-async function main () {
-  job = fromCmdLine(process.cwd(), process.argv.slice(2))
-  output = getOutput(job)
-  await recreateDir(job.reportDir)
-  const { name, version } = output.version()
-  if (job.batchMode) {
-    output.batchMode()
-  }
-  output.reportOnJobProgress()
-  checkLatest(job, name, version)
-  if (job.if && !executeIf(job)) {
-    output.skipIf()
-    output.stop()
-    return
-  }
-  if (job.mode === 'capabilities') {
-    return capabilities(job)
-  }
-
-  let startedCommand
-  if (job.startCommand) {
-    startedCommand = await start(job)
-  }
-
-  if (job.mode === 'batch') {
-    return await batch(job)
-      .finally(async () => {
-        if (startedCommand) {
-          await startedCommand.stop()
-        }
-        cleanHandles(job)
-      })
-  }
-
-  const configuration = await reserveConfigurationFactory(job)
-  output.debug('reserve', 'configuration', configuration)
-  const server = serve(configuration)
-  if (job.logServer) {
-    server
-      .on('incoming', output.logServerIncoming)
-      .on('redirected', output.logServerRedirected)
-      .on('closed', output.logServerClosed)
-  }
-
-  const { promise: serverStarted, resolve: serverReady, reject: serverError } = allocPromise()
-  server
-    .on('ready', async ({ url, port }) => {
-      job.port = port
-      send({ msg: 'ready', port: job.port })
-      output.serving(url)
-      serverReady()
-    })
-    .on('error', ({ reason }) => {
-      send({ msg: 'error', reason })
-      serverError(reason)
-    })
-  await serverStarted
-  if (job.preload) {
-    await preload(job)
-  }
-  if (job.serveOnly) {
-    job.status = 'Serving'
-    return
-  }
-  await probeBrowser(job)
-  await notifyAndExecuteTests(job)
-  if (job.watch) {
-    if (!job.watching) {
-      job.status = 'Watching...'
-      let running = false
-      let rerun = false
-      const run = async () => {
-        running = true
-        do {
-          rerun = false
-          await recreateDir(job.reportDir)
-          await notifyAndExecuteTests(job)
-        } while (rerun)
-        running = false
-        job.status = 'Watching...'
-      }
-      output.watching(job.watchFolder)
-      watch(job.watchFolder, { recursive: true }, async (eventType, filename) => {
-        output.changeDetected(eventType, filename)
-        if (running) {
-          rerun = true
-        } else {
-          run()
-        }
-      })
-      job.watching = true
-    }
-    return
-  } else if (job.keepAlive) {
-    job.status = 'Serving'
-    return
-  } else if (job.failed) {
-    process.exitCode = -1
-  }
-  if (job.endScript) {
-    await end(job)
-  }
-  output.stop()
-  await server.close({ close: true })
-  await new Promise(resolve => setTimeout(resolve, 100)) // wait for server handles to be released
-  if (job.logServer) {
-    output.logServerSummary()
-  }
-  if (startedCommand) {
-    await startedCommand.stop()
-  }
-  output.debug('main', 'terminated')
-  cleanHandles(job)
-}
-
-main()
-  .catch(reason => {
-    if (output) {
-      output.genericError(reason)
-      output.stop()
-    } else if (reason.name !== 'CommanderError') {
-      console.error(reason)
-    }
-    process.exit(-1)
-  })

package/jest.config.json

@@ -1,31 +0,0 @@
-{
-  "testTimeout": 15000,
-  "setupFilesAfterEnv": [
-    "./test/setup.js"
-  ],
-  "testPathIgnorePatterns": [
-    "/node_modules/",
-    "/capabilities/",
-    "/e2e/"
-  ],
-  "collectCoverage": true,
-  "collectCoverageFrom": [
-    "src/*.js",
-    "src/defaults/junit-xml-report.js"
-  ],
-  "coveragePathIgnorePatterns": [
-    "\\.spec\\.js",
-    "output\\.js",
-    "handle\\.js",
-    "coverage\\.js",
-    "b\\capabilities\\b"
-  ],
-  "coverageThreshold": {
-    "global": {
-      "branches": 80,
-      "functions": 80,
-      "lines": 80,
-      "statements": 80
-    }
-  }
-}

package/src/add-test-pages.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const { stop } = require('./browsers')
-const { URL } = require('url')
-const { getOutput } = require('./output')
-const { stripUrlHash } = require('./tools')
-
-const addUrlParam = (url, param) => {
-  if (url.includes(param)) {
-    return url
-  }
-  if (url.includes('?')) {
-    return url + '&' + param
-  }
-  return url + '?' + param
-}
-
-module.exports = {
-  async addTestPages (job, url, data) {
-    const { type, opa, module, pages, page } = data
-    getOutput(job).debug('probe', `addTestPages from ${url}`, data)
-    let testPageUrls
-    if (type === 'none') {
-      testPageUrls = []
-    } else {
-      let receivedPages
-      if (type === 'qunit') {
-        receivedPages = [page]
-        if (job.splitOpa && opa && module) {
-          if (module.ids && module.ids.length > 1) {
-            receivedPages = module.ids.map(id => addUrlParam(stripUrlHash(page), `moduleId=${id}`))
-          } else if (module.names && module.names.length > 1) {
-            receivedPages = module.names.map(name => addUrlParam(stripUrlHash(page), `module=${name}`))
-          }
-        }
-      } else {
-        receivedPages = pages
-      }
-      receivedPages = receivedPages.map(relativeUrl => {
-        const absoluteUrl = new URL(relativeUrl, url)
-        return stripUrlHash(absoluteUrl.toString())
-      })
-      if (job.pageFilter) {
-        const filter = new RegExp(job.pageFilter)
-        testPageUrls = receivedPages.filter(name => name.match(filter))
-      } else {
-        testPageUrls = receivedPages
-      }
-      if (job.pageParams) {
-        testPageUrls = testPageUrls.map(url => addUrlParam(url, job.pageParams))
-      }
-    }
-    let member
-    if (type === 'suite' && job.splitOpa) {
-      member = 'url'
-    } else {
-      member = 'testPageUrls'
-    }
-    job[member] = testPageUrls.reduce((uniques, url) => {
-      if (!uniques.includes(url)) {
-        uniques.push(url)
-      }
-      return uniques
-    }, job[member] || [])
-    stop(job, url)
-  }
-}

package/src/batch.js

@@ -1,214 +0,0 @@
-const { open, readdir, stat, unlink } = require('fs/promises')
-const { extname, isAbsolute, join } = require('path')
-const { allocPromise, filename } = require('./tools')
-const { fork } = require('child_process')
-const { getOutput, newProgress } = require('./output')
-const { parallelize } = require('./parallelize')
-const { $statusProgressCount } = require('./symbols')
-const { $valueSources } = require('./symbols')
-const { getCommand, toLongName } = require('./job')
-const { save } = require('./report')
-const { end } = require('./end')
-
-const batchParameters = getCommand('.').options
-  .filter(option => option.description.includes('📡'))
-  .reduce((dictionary, option) => {
-    dictionary[option.long.substring(2)] = option
-    return dictionary
-  }, {})
-
-const root = join(__dirname, '..')
-
-const folder = (job, folderPath) => {
-  getOutput(job).debug('batch', `adding folder: ${folderPath}`)
-  job.batchItems.push({
-    path: folderPath,
-    id: filename(folderPath),
-    label: folderPath,
-    args: ['--cwd', folderPath]
-  })
-}
-
-const configurationFile = (job, configurationFilePath) => {
-  getOutput(job).debug('batch', `adding configuration file: ${configurationFilePath}`)
-  try {
-    const {
-      batchId: id = filename(configurationFilePath),
-      batchLabel: label = configurationFilePath
-    } = require(configurationFilePath)
-    job.batchItems.push({
-      path: configurationFilePath,
-      id,
-      label,
-      args: ['--config', configurationFilePath]
-    })
-  } catch (e) {
-    getOutput(job).batchFailed(configurationFilePath, 'invalid JSON configuration file')
-  }
-}
-
-const task = async function (batchItem) {
-  const { id, label, args } = batchItem
-  batchItem.start = new Date()
-  const job = this
-  const output = getOutput(job)
-  const progress = newProgress(job)
-  const reportDir = join(job.reportDir, id)
-  progress.label = `${label} (${id})`
-  progress.count = 1
-  output.batchStartingTask(label)
-  const { promise, resolve, reject } = allocPromise()
-  const parameters = [
-    ...args,
-    '--batch-mode'
-  ]
-  if (job[$valueSources]) {
-    if (job[$valueSources].reportDir === 'cli') {
-      parameters.push('--report-dir', reportDir)
-    }
-    Object.keys(job[$valueSources])
-      .filter(name => job[$valueSources][name] === 'cli')
-      .forEach(name => {
-        const longName = toLongName(name)
-        const option = batchParameters[longName] || batchParameters['no-' + longName]
-        if (option) {
-          parameters.push(option.long)
-          if (!option.negate) {
-            if (name === 'env') {
-              Object.keys(job.env).forEach(key => {
-                parameters.push(`${key}=${job.env[key]}`)
-              })
-            } else if (option.variadic) {
-              parameters.push(...job[name].map(value => value.toString()))
-            } else {
-              parameters.push(job[name].toString())
-            }
-          }
-        }
-      })
-  }
-
-  const stdoutFilename = join(job.reportDir, `${id}.stdout.txt`)
-  const stdout = await open(stdoutFilename, 'w')
-  const stderrFilename = join(job.reportDir, `${id}.stderr.txt`)
-  const stderr = await open(stderrFilename, 'w')
-  const childProcess = fork(
-    join(root, 'index.js'),
-    parameters,
-    {
-      stdio: [0, stdout, stderr, 'ipc']
-    }
-  )
-  childProcess.on('message', data => {
-    if (data.type === 'progress') {
-      const { count, total } = data
-      progress.count = count
-      progress.total = total
-    }
-  })
-  childProcess.on('close', async code => {
-    await stdout.close()
-    await stderr.close()
-    batchItem.statusCode = code
-    batchItem.end = new Date()
-    if (code !== 0) {
-      reject(code)
-    } else {
-      await unlink(stdoutFilename)
-      await unlink(stderrFilename)
-      resolve()
-    }
-  })
-  return promise
-    .then(() => {
-      output.log('✔️ ', progress.label)
-    }, (reason) => {
-      ++job.failed
-      output.log('❌', progress.label, reason)
-    })
-    .finally(() => {
-      ++job[$statusProgressCount]
-      progress.done()
-    })
-}
-
-async function batch (job) {
-  /**
-   * job
-   * path: full path
-   * id: batchId | hash (using filename)
-   * label: batchLabel | configuration file path | path
-   * args: []
-   *   --report-dir is always passed to aggregate reports under one root folder
-   */
-  const output = getOutput(job)
-  job.start = new Date()
-  job.failed = 0
-  job.batchItems = []
-  for (const batch of job.batch) {
-    output.debug('batch', `processing: ${batch}`)
-    // check if path
-    try {
-      let path = batch
-      if (!isAbsolute(path)) {
-        path = join(job.cwd, path)
-      }
-      const pathStat = await stat(path)
-      if (pathStat.isDirectory()) {
-        folder(job, path)
-      } else if (pathStat.isFile() && extname(path) === '.json') {
-        configurationFile(job, path)
-      } else {
-        output.batchFailed(batch, 'only folders and JSON configuration files are supported')
-      }
-      continue
-    } catch (e) {
-      // ignore
-    }
-    // Try using regular expression match
-    let re
-    try {
-      re = new RegExp(batch)
-    } catch (e) {
-      getOutput(job).batchFailed(batch, 'invalid regular expression')
-      continue
-    }
-    const scan = async (cwd) => {
-      const names = await readdir(cwd)
-      for (const name of names) {
-        const path = join(cwd, name)
-        const pathStat = await stat(path)
-        if (pathStat.isDirectory()) {
-          if (re.test(path) || re.test(path.replaceAll('\\', '/'))) {
-            folder(job, path)
-            continue
-          }
-          await scan(path)
-        } else if (pathStat.isFile() && (re.test(path) || re.test(path.replaceAll('\\', '/')))) {
-          configurationFile(job, path)
-        }
-      }
-    }
-    await scan(job.cwd)
-  }
-  if (job.batchItems.length) {
-    job.status = 'Running batch items...'
-    await parallelize(task.bind(job), job.batchItems, job.parallel)
-  } else {
-    output.batchFailed(job.batch, 'no match')
-  }
-
-  job.end = new Date()
-  job.failed = !!job.failed
-  if (job.failed) {
-    process.exitCode = -1
-  }
-  await save(job)
-  if (job.endScript) {
-    await end(job)
-  }
-  output.stop()
-  return 0
-}
-
-module.exports = { batch, task }