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

package/src/browsers.js

@@ -1,319 +0,0 @@
-'use strict'
-
-const { fork } = require('child_process')
-const { join } = require('path')
-const { writeFile, readFile, open, stat, unlink } = require('fs/promises')
-const { recreateDir, filename, allocPromise } = require('./tools')
-const { getPageTimeout, pageTimedOut } = require('./timeout')
-const { getOutput, newProgress } = require('./output')
-const { resolvePackage } = require('./npm')
-const { UTRError } = require('./error')
-const { $browsers } = require('./symbols')
-
-let lastScreenshotId = 0
-const screenshots = {}
-
-async function instantiate (job, config) {
-  const output = getOutput(job)
-  if (job.browserArgs.some((arg) => !arg.trim())) {
-    output.emptyBrowserArg()
-    job.browserArgs = job.browserArgs.filter((arg) => arg.trim())
-  }
-  const { dir, url } = config
-  await recreateDir(dir)
-  const browserConfig = {
-    capabilities: job.browserCapabilities,
-    modules: job.browserModules,
-    ...config,
-    args: job.browserArgs
-  }
-  const browserConfigPath = join(dir, 'browser.json')
-  await writeFile(browserConfigPath, JSON.stringify(browserConfig, undefined, 2))
-  const stdoutFilename = join(dir, 'stdout.txt')
-  const stderrFilename = join(dir, 'stderr.txt')
-  const stdout = await open(stdoutFilename, 'w')
-  const stderr = await open(stderrFilename, 'w')
-  const childProcess = fork(job.browser, [browserConfigPath], {
-    stdio: [0, stdout, stderr, 'ipc'],
-    env: {
-      ...process.env,
-      ...job.env
-    }
-  })
-  const { promise, resolve } = allocPromise()
-  childProcess.on('close', async code => {
-    await stdout.close()
-    await stderr.close()
-    if (code !== 0) {
-      getOutput(job).browserFailed(url, code, dir)
-    }
-    resolve(code)
-  })
-  childProcess.on('error', err => {
-    output.browserChildProcessError(url, err)
-  })
-  childProcess.closed = promise
-  childProcess.stdoutFilename = stdoutFilename
-  childProcess.stderrFilename = stderrFilename
-  return childProcess
-}
-
-async function probe (job) {
-  if (job.browserCapabilities) {
-    return
-  }
-  const output = getOutput(job)
-  job.status = 'Probing browser instantiation command'
-
-  async function execute (folder) {
-    const dir = join(job.reportDir, folder)
-    const capabilities = join(dir, 'capabilities.json')
-    const childProcess = await instantiate(job, {
-      url: 'about:blank',
-      capabilities,
-      dir
-    })
-    const code = await childProcess.closed
-    if (code !== 0) {
-      throw UTRError.BROWSER_PROBE_FAILED(code.toString())
-    }
-    let browserCapabilities
-    try {
-      browserCapabilities = Object.assign({
-        modules: [],
-        screenshot: null,
-        scripts: false,
-        parallel: true,
-        traces: []
-      }, JSON.parse((await readFile(capabilities)).toString()))
-    } catch (e) {
-      throw UTRError.MISSING_OR_INVALID_BROWSER_CAPABILITIES(e.message)
-    }
-    return browserCapabilities
-  }
-
-  output.debug('browsers/probe', 'initial probing')
-  const browserCapabilities = await execute('probe')
-  output.debug('browsers/probe', 'browser capabilities', browserCapabilities)
-  job.browserCapabilities = browserCapabilities
-
-  const { modules } = browserCapabilities
-  const resolvedModules = {}
-  if (modules.length) {
-    for await (const name of browserCapabilities.modules) {
-      output.debug('browsers/probe', `resolving package ${name}...`)
-      resolvedModules[name] = await resolvePackage(job, name)
-      output.debug('browsers/probe', `package ${name} resolved`)
-    }
-  }
-  job.browserModules = resolvedModules
-  if (browserCapabilities['probe-with-modules']) {
-    output.debug('browsers/probe', 'probing with modules')
-    job.browserCapabilities = await execute('probe/with-modules')
-    output.debug('browsers/probe', 'browser capabilities', browserCapabilities)
-  }
-
-  if (job.debugCapabilitiesNoScript) {
-    job.browserCapabilities.scripts = false
-  }
-
-  output.browserCapabilities(job.browserCapabilities)
-}
-
-async function start (job, url, scripts = []) {
-  const output = getOutput(job)
-  if (!job[$browsers]) {
-    job[$browsers] = {}
-  }
-  output.browserStart(url)
-  const reportDir = join(job.reportDir, filename(url))
-  const resolvedScripts = []
-  for await (const script of scripts) {
-    if (script.endsWith('.js')) {
-      const scriptFilename = join(__dirname, 'inject', script)
-      const scriptContent = (await readFile(scriptFilename)).toString()
-      resolvedScripts.push(scriptContent)
-    } else {
-      resolvedScripts.push(script)
-    }
-  }
-  if (resolvedScripts.length) {
-    resolvedScripts.unshift(`(function () {
-  window['ui5-test-runner/base-host'] = 'http://${job.localhost}:${job.port}'
-}())`)
-  }
-  const progress = newProgress(job, url)
-  const pageBrowser = {
-    url,
-    reportDir,
-    scripts: resolvedScripts,
-    retry: 0,
-    progress
-  }
-  const { promise, resolve, reject } = allocPromise()
-  pageBrowser.done = value => {
-    delete job[$browsers][url]
-    resolve(value)
-  }
-  pageBrowser.failed = reason => {
-    delete job[$browsers][url]
-    reject(reason)
-  }
-  job[$browsers][url] = pageBrowser
-  await run(job, pageBrowser)
-  try {
-    await promise
-  } finally {
-    progress.done()
-    output.browserStopped(url)
-  }
-}
-
-async function run (job, pageBrowser) {
-  const output = getOutput(job)
-  const { url, retry, reportDir, scripts } = pageBrowser
-  let dir = reportDir
-  if (retry) {
-    output.browserRetry(url, retry)
-    dir = join(dir, retry.toString())
-    if (pageBrowser.console.count) {
-      try {
-        await pageBrowser.console.flush
-          .then(() => unlink(join(reportDir, 'console.jsonl')))
-      } catch (e) {
-        // ignore
-      }
-    }
-  }
-  pageBrowser.console = {
-    count: 0,
-    byApi: {},
-    flush: Promise.resolve()
-  }
-  await recreateDir(dir)
-  delete pageBrowser.stopped
-  const childProcess = await instantiate(job, {
-    url,
-    retry,
-    scripts,
-    dir
-  })
-  pageBrowser.childProcess = childProcess
-  const timeout = getPageTimeout(job)
-  if (timeout) {
-    pageBrowser.timeoutId = setTimeout(() => {
-      output.browserTimeout(url, dir)
-      pageTimedOut(job, url)
-      stop(job, url)
-    }, timeout)
-  }
-  childProcess.on('message', message => {
-    if (message.command === 'screenshot') {
-      const { id } = message
-      screenshots[id]()
-      delete screenshots[id]
-    } else if (message.command === 'console') {
-      ++pageBrowser.console.count
-      if (!pageBrowser.console.byApi[message.api]) {
-        pageBrowser.console.byApi[message.api] = 1
-      } else {
-        ++pageBrowser.console.byApi[message.api]
-      }
-      pageBrowser.console.flush = pageBrowser.console.flush
-        .then(() => writeFile(join(reportDir, 'console.jsonl'), JSON.stringify({
-          t: message.t,
-          api: message.api,
-          args: message.args
-        }) + '\n', {
-          flag: 'a+'
-        }))
-    }
-  })
-  childProcess.on('close', async code => {
-    if (!pageBrowser.stopped) {
-      if (code === 0) {
-        output.browserClosed(url, code, dir)
-      }
-      childProcess.closed.then(() => stop(job, url, true))
-    }
-  })
-}
-
-async function screenshot (job, url, filename) {
-  if (!job.browserCapabilities.screenshot) {
-    throw UTRError.BROWSER_SCREENSHOT_NOT_SUPPORTED()
-  }
-  const output = getOutput(job)
-  const id = ++lastScreenshotId
-  try {
-    const { childProcess, reportDir } = job[$browsers][url]
-    const absoluteFilename = join(reportDir, filename + job.browserCapabilities.screenshot)
-    if (childProcess.connected) {
-      output.debug('screenshot', id, url, absoluteFilename)
-      const { promise, resolve, reject } = allocPromise()
-      screenshots[id] = resolve
-      output.debug('screenshot', id, 'sending command')
-      childProcess.send({
-        id,
-        command: 'screenshot',
-        filename: absoluteFilename
-      })
-      const timeoutId = setTimeout(() => {
-        reject(UTRError.BROWSER_SCREENSHOT_TIMEOUT())
-      }, job.screenshotTimeout)
-      output.debug('screenshot', id, 'command sent, waiting for answer')
-      await promise
-      output.debug('screenshot', id, 'answer received')
-      clearTimeout(timeoutId)
-      const result = await stat(absoluteFilename)
-      output.debug('screenshot', id, 'file size :', result.size)
-      if (!result.isFile() || result.size === 0) {
-        throw new Error('File expected')
-      }
-      output.debug('screenshot', id, 'done')
-      return absoluteFilename
-    }
-  } catch (e) {
-    output.debug('screenshot', id, e.message)
-    if (e.code === UTRError.BROWSER_SCREENSHOT_TIMEOUT_CODE) {
-      throw e
-    }
-    throw UTRError.BROWSER_SCREENSHOT_FAILED(e.toString())
-  }
-}
-
-async function stop (job, url, retry = false) {
-  const pageBrowser = job[$browsers][url]
-  if (pageBrowser) {
-    pageBrowser.stopped = true
-    const { childProcess, done, failed, timeoutId } = pageBrowser
-    if (timeoutId) {
-      clearTimeout(timeoutId)
-    }
-    if (childProcess.connected) {
-      /* istanbul ignore else */
-      if (!job.debugKeepBrowserOpen) {
-        childProcess.send({ command: 'stop' })
-      }
-      const { promise: closeTimeout, resolve } = allocPromise()
-      const timeoutId = setTimeout(resolve, job.browserCloseTimeout)
-      await Promise.race([
-        childProcess.closed,
-        closeTimeout
-      ])
-      clearTimeout(timeoutId)
-    }
-    await pageBrowser.console.flush
-    if (retry) {
-      if (++pageBrowser.retry <= job.browserRetry) {
-        run(job, pageBrowser)
-      } else {
-        failed(UTRError.BROWSER_FAILED())
-      }
-    } else {
-      done()
-    }
-  }
-}
-
-module.exports = { probe, start, screenshot, stop }

package/src/capabilities/index.js

@@ -1,204 +0,0 @@
-'use strict'
-
-const { check, serve, body } = require('reserve')
-const { probe, start, stop } = require('../browsers')
-const { join } = require('path')
-const { getOutput } = require('../output')
-const { performance } = require('perf_hooks')
-const { cleanDir, allocPromise, filename } = require('../tools')
-const { $statusProgressTotal, $statusProgressCount } = require('../symbols')
-const tests = require('./tests')
-const { parallelize } = require('../parallelize')
-
-async function capabilities (job) {
-  const output = getOutput(job)
-
-  async function exit (code) {
-    if (job.keepAlive) {
-      job.status = 'Serving'
-    } else {
-      if (job.debugKeepReport) {
-        output.log('Report folder', job.reportDir, 'not cleaned because of --debug-keep-report.')
-      } else if (code !== 0) {
-        output.error('Report folder', job.reportDir, 'not cleaned because of errors.')
-      } else {
-        await cleanDir(job.reportDir)
-      }
-      output.stop()
-      process.exit(code)
-    }
-  }
-
-  try {
-    await probe(job)
-  } catch (e) {
-    output.error('Unable to probe')
-    exit(-1)
-  }
-
-  try {
-    const listeners = []
-    const configuration = await check({
-      port: job.port,
-      mappings: [
-        require('../cors'), {
-          custom: async (request, response) => {
-            response.setHeader('x-ui5-test-runner', 'capabilities')
-          }
-        }, {
-          match: /x-wait-time=(\d+)/,
-          custom: async (request, response, waitTime) => {
-            response.setHeader('x-wait-time', waitTime)
-            await new Promise(resolve => setTimeout(resolve, parseInt(waitTime)))
-          }
-        }, {
-          method: 'POST',
-          match: '^/_/(.*)',
-          custom: async (request, response, endpoint) => {
-            const { referer, 'x-page-url': xPageUrl } = request.headers
-            const listenerIndex = (xPageUrl || referer).match(/\blistener=(\d+)/)[1]
-            const listener = listeners[listenerIndex]
-            await listener({
-              endpoint,
-              body: await body(request).json()
-            })
-            response.writeHead(200)
-            response.end()
-          }
-        }, {
-          match: '^/inject/(.*)',
-          cwd: join(__dirname, '../inject'),
-          file: '$1',
-          static: !job.debugDevMode
-        }, {
-          match: '^/(.*)',
-          cwd: __dirname,
-          file: '$1',
-          static: !job.debugDevMode
-        }, {
-          status: 404
-        }]
-    })
-    const server = serve(configuration)
-    if (job.logServer) {
-      server
-        .on('incoming', output.logServerIncoming)
-        .on('redirected', output.logServerRedirected)
-        .on('closed', output.logServerClosed)
-    }
-    server.on('error', (error) => {
-      output.error('REserve error:', error)
-    })
-    await new Promise(resolve => server
-      .on('ready', ({ port }) => {
-        job.port = port
-        resolve()
-      })
-    )
-
-    job.status = 'Running tests'
-
-    const filteredTests = tests
-      .filter((test) => !test.for || test.for(job.browserCapabilities))
-      .filter(({ name }) => !job.debugCapabilitiesTest || name.startsWith(job.debugCapabilitiesTest))
-    output.log('Number of tests :', filteredTests.length)
-
-    let errors = 0
-
-    const task = async (test) => {
-      const { promise, resolve } = allocPromise()
-      const { label, url, args, scripts, endpoint = () => { } } = test
-
-      const listenerIndex = listeners.length
-      let pageUrl
-      if (url.startsWith('http')) {
-        pageUrl = url
-      } else {
-        pageUrl = `http://localhost:${job.port}/tests/${url}`
-      }
-      if (url.includes('?')) {
-        pageUrl += `&listener=${listenerIndex}`
-      } else {
-        pageUrl += `?listener=${listenerIndex}`
-      }
-
-      const now = performance.now()
-      let timeoutId
-      if (!job.debugCapabilitiesNoTimeout) {
-        const timeout = job.pageTimeout || 120000
-        timeoutId = setTimeout(() => done(`Timeout (${timeout})`), timeout)
-      }
-
-      async function done (error) {
-        if (done.called) {
-          return
-        }
-        ++job[$statusProgressCount]
-        done.called = true
-        if (timeoutId) {
-          clearTimeout(timeoutId)
-        }
-        await stop(job, pageUrl)
-        const timeSpent = Math.floor(performance.now() - now)
-        if (error) {
-          output.log('❌', label, `[${filename(pageUrl)}]`, error)
-          if (job.failFast) {
-            exit(1)
-          }
-          ++errors
-        } else {
-          output.log('✔️ ', label, timeSpent, 'ms')
-        }
-        resolve()
-      }
-
-      const context = {
-        job
-      }
-      listeners[listenerIndex] = async data => {
-        try {
-          if (await endpoint.call(context, data, pageUrl) !== false) {
-            done()
-          }
-        } catch (e) {
-          done(e)
-        }
-      }
-
-      if (args) {
-        // TODO replace or concat ?
-      }
-
-      start(job, pageUrl, scripts)
-        .catch(reason => done(reason))
-        .then(() => {
-          if (!context.stopExpected) {
-            done('Failed')
-          }
-        })
-
-      return promise
-    }
-
-    let parallel
-    if (!job.browserCapabilities.parallel) {
-      parallel = 1
-    } else {
-      parallel = job.parallel
-    }
-
-    job[$statusProgressTotal] = filteredTests.length
-    job[$statusProgressCount] = 0
-    await parallelize(task, filteredTests, parallel)
-
-    output.log('Done.')
-    exit(errors)
-  } catch (error) {
-    output.error(error)
-    exit(-1)
-  }
-}
-
-module.exports = {
-  capabilities
-}

package/src/capabilities/tests/basic/iframe.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>iframe</H1>
-    <p>Checks if the browser can load UI5 in an iframe</p>
-    <iframe src="ui5.html"></iframe>
-  </body>
-</html>

package/src/capabilities/tests/basic/index.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>basic</H1>
-    <p>Checks if the browser can load a page</p>
-    <script>
-      const xhr = new XMLHttpRequest()
-      xhr.open('POST', '/_/log')
-      xhr.send('{}')
-    </script>
-  </body>
-</html>

package/src/capabilities/tests/basic/index.js

@@ -1,20 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-
-module.exports = [{
-  label: 'Loads a page',
-  url: 'basic/index.html'
-}, {
-  label: 'Loads a UI5 example',
-  url: 'basic/ui5.html',
-  endpoint: ({ body }) => {
-    assert.strictEqual(body['sap.m.Button'], true)
-  }
-}, {
-  label: 'Loads a UI5 inside an iframe',
-  url: 'basic/iframe.html',
-  endpoint: ({ body }) => {
-    assert.strictEqual(body['sap.m.Button'], true)
-  }
-}]

package/src/capabilities/tests/basic/ui5.html

@@ -1,24 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>UI5 example</H1>
-    <p>Checks if the browser can load a page</p>
-    <script
-        src="https://ui5.sap.com/resources/sap-ui-core.js"
-        id="sap-ui-bootstrap"
-        data-sap-ui-libs="sap.m"
-        data-sap-ui-theme="sap_fiori_3"
-        data-sap-ui-compatVersion="edge">
-    </script>
-    <script>
-        sap.ui.getCore().attachInit(function() {
-            const xhr = new XMLHttpRequest()
-            xhr.open('POST', '/_/log')
-            if (parent !== window && parent.document.location.toString() !== 'about:blank') {
-              xhr.setRequestHeader('x-page-url', parent.document.location.toString())
-            }
-            xhr.send('{"sap.m.Button":' + !!sap.m.Button + '}')
-        });
-    </script>
-  </body>
-</html>

package/src/capabilities/tests/dynamic-include/index.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-
-const endpoint = ({ body }) => {
-  assert.strictEqual(body.test, true)
-}
-
-module.exports = [{
-  label: 'Dynamic include',
-  url: 'dynamic-include/one.html',
-  endpoint
-}, {
-  label: 'Dynamic includes',
-  url: 'dynamic-include/two.html',
-  endpoint
-}, {
-  label: 'Dynamic include mixed with a static one',
-  url: 'dynamic-include/mix.html',
-  endpoint
-}]

package/src/capabilities/tests/dynamic-include/mix.html

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>basic</H1>
-    <p>Checks if the browser can mix static script with a dynamic script inserted with document.write</p>
-    <script>
-      document.write('<script src="test.js?x-wait-time=1000"><' + '/script>'); // wait 1s before delivering
-    </script>
-    <script src="post.js"></script>
-  </body>
-</html>

package/src/capabilities/tests/dynamic-include/one.html

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>basic</H1>
-    <p>Checks if the browser can load a script inserted with document.write</p>
-    <script>
-      window.test = true
-      document.write('<script src="post.js"><' + '/script>');
-    </script>
-  </body>
-</html>

package/src/capabilities/tests/dynamic-include/post.js

@@ -1,3 +0,0 @@
-const xhr = new XMLHttpRequest()
-xhr.open('POST', '/_/log')
-xhr.send('{"test":' + window.test + '}')

package/src/capabilities/tests/dynamic-include/test.js

@@ -1 +0,0 @@
-window.test = true

package/src/capabilities/tests/dynamic-include/two.html

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>basic</H1>
-    <p>Checks if the browser can load sequentially scripts inserted with document.write</p>
-    <script>
-      document.write('<script src="test.js?x-wait-time=1000"><' + '/script>'); // wait 1s before delivering
-      document.write('<script src="post.js"><' + '/script>');
-    </script>
-  </body>
-</html>

package/src/capabilities/tests/index.js

@@ -1,16 +0,0 @@
-const { readdirSync } = require('fs')
-
-module.exports = readdirSync(__dirname)
-  .filter(name => !name.endsWith('.js'))
-  .map(name => {
-    const tests = require(`./${name}`)
-    if (Array.isArray(tests)) {
-      tests.forEach((test, index) => {
-        test.name = `${name}:${index}`
-      })
-    } else {
-      tests.name = name
-    }
-    return tests
-  })
-  .flat()

package/src/capabilities/tests/local-storage/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <H1>localStorage</H1>
-    <p>Check if the localStorage is isolated</p>
-    <script>
-      const initial = localStorage.value
-      const parameters = new URLSearchParams(location.search)
-      localStorage.value = parameters.get('value')
-      const modified = localStorage.value
-      const xhr = new XMLHttpRequest()
-      xhr.open('POST', '/_/log')
-      xhr.send(JSON.stringify({initial, modified}))
-    </script>
-  </body>
-</html>