ui5-test-runner/src/tests.js

'use strict'

const { probe, start } = require('./browsers')
const { instrument } = require('./coverage')
const { recreateDir } = require('./tools')
const { globallyTimedOut } = require('./timeout')
const { save, generate } = require('./report')
const { getOutput } = require('./output')
const {
  $probeUrlsStarted,
  $probeUrlsCompleted,
  $testPagesStarted,
  $testPagesCompleted
} = require('./symbols')
const { UTRError } = require('./error')
const { $proxifiedUrls } = require('./symbols')

async function run (task, job) {
  const {
    urlsMember,
    startedMember,
    completedMember,
    method
  } = task
  const output = getOutput(job)
  const urls = job[urlsMember]
  const { length } = urls
  if (job[completedMember] === length) {
    return
  }
  if (job[startedMember] === length) {
    return
  }
  const index = job[startedMember]++
  const url = urls[index]
  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[completedMember]
  return run(task, job)
}

async function probeUrl (job, url) {
  const output = getOutput(job)
  try {
    let scripts
    if (job.mode === 'url' && job.browserCapabilities.scripts) {
      scripts = [
        'post.js',
        'qunit-redirect.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 = [
        'post.js',
        'qunit-intercept.js',
        'qunit-hooks.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
  }
}

function parallelize (task, job) {
  const {
    urlsMember,
    completedMember,
    startedMember
  } = task
  job[startedMember] = 0
  job[completedMember] = 0
  const max = Math.min(job.parallel, job[urlsMember].length)
  const promises = []
  for (let i = 0; i < max; ++i) {
    promises.push(run(task, job))
  }
  return Promise.all(promises)
}

async function process (job) {
  const output = getOutput(job)
  job.start = new Date()
  delete job.failed
  await instrument(job)
  await save(job)
  job.testPageUrls = []

  job.status = 'Probing urls'
  await parallelize({
    urlsMember: 'url',
    startedMember: $probeUrlsStarted,
    completedMember: $probeUrlsCompleted,
    method: probeUrl
  }, job)

  /* istanbul ignore else */
  if (!job.debugProbeOnly) {
    if (job.testPageUrls.length !== 0) {
      job.status = 'Executing test pages'
      await parallelize({
        urlsMember: 'testPageUrls',
        startedMember: $testPagesStarted,
        completedMember: $testPagesCompleted,
        method: runTestPage
      }, job)
    } else if (Object.keys(job.qunitPages || []).length === 0) {
      output.noTestPageFound()
      job.failed = true
    }
  }

  await generate(job)
}

module.exports = {
  async execute (job) {
    await recreateDir(job.reportDir)
    getOutput(job).version()
    await probe(job)
    if (job.mode !== 'url') {
      job.url = [`http://localhost:${job.port}/${job.testsuite}`]
    } else if (!job.browserCapabilities.scripts) {
      throw UTRError.BROWSER_MISS_SCRIPTS_CAPABILITY()
    }
    return process(job)
  }
}