ui5-test-runner 1.1.5 → 2.0.0

package/src/csv-writer.spec.js

@@ -0,0 +1,77 @@
+const { buildCsvWriter } = require('./csv-writer')
+const { writeFile } = require('fs/promises')
+
+jest.mock('fs/promises')
+
+describe('src/csv-writer', () => {
+  const now = Date.now()
+
+  beforeAll(() => {
+    jest.spyOn(Date, 'now').mockImplementation(() => now)
+  })
+
+  beforeEach(() => {
+    writeFile.mockReset()
+  })
+
+  it('allocates an object', () => {
+    const writer = buildCsvWriter('test.csv')
+    expect(writer).not.toBeUndefined()
+    expect(writeFile).not.toHaveBeenCalled()
+  })
+
+  it('starts writing the file on first record', async () => {
+    const writer = buildCsvWriter('test.csv')
+    writer.append({ text: 'test' })
+    await writer.ready
+    expect(writeFile.mock.calls).toEqual([
+      ['test.csv', 'timestamp\ttext\n', { flag: 'a+' }],
+      ['test.csv', `${now}\ttest\n`, { flag: 'a+' }]
+    ])
+  })
+
+  it('ignores any additional field not used on the first append', async () => {
+    const writer = buildCsvWriter('test.csv')
+    writer.append({ text: 'test 1' })
+    writer.append({ text: 'test 2', ignored: true })
+    await writer.ready
+    expect(writeFile.mock.calls).toEqual([
+      ['test.csv', 'timestamp\ttext\n', { flag: 'a+' }],
+      ['test.csv', `${now}\ttest 1\n`, { flag: 'a+' }],
+      ['test.csv', `${now}\ttest 2\n`, { flag: 'a+' }]
+    ])
+  })
+
+  it('escapes automatically complex values', async () => {
+    const writer = buildCsvWriter('test.csv')
+    writer.append({ number: 1, text: 'test\t1\n' })
+    await writer.ready
+    expect(writeFile.mock.calls).toEqual([
+      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
+      ['test.csv', `${now}\t1\t"test\\t1\\n"\n`, { flag: 'a+' }]
+    ])
+  })
+
+  it('handles provided timestamp', async () => {
+    const writer = buildCsvWriter('test.csv')
+    writer.append({ timestamp: 456, number: 1, text: 'test\t1\n' })
+    await writer.ready
+    expect(writeFile.mock.calls).toEqual([
+      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
+      ['test.csv', '456\t1\t"test\\t1\\n"\n', { flag: 'a+' }]
+    ])
+  })
+
+  it('handles record array', async () => {
+    const writer = buildCsvWriter('test.csv')
+    await writer.append([
+      { number: 1, text: 'test\t1\n' },
+      { number: 2, text: 'test\t2\n' }
+    ])
+    await writer.ready
+    expect(writeFile.mock.calls).toEqual([
+      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
+      ['test.csv', `${now}\t1\t"test\\t1\\n"\n${now}\t2\t"test\\t2\\n"\n`, { flag: 'a+' }]
+    ])
+  })
+})

package/src/defaults/browser.js

@@ -0,0 +1,144 @@
+const { readFile, writeFile } = require('fs/promises')
+const { join } = require('path')
+const { Command } = require('commander')
+const { buildCsvWriter } = require('../csv-writer')
+const { any, boolean, integer } = 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.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.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()
+
+    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)
+    })
+}

package/src/defaults/jsdom/compatibility.js

@@ -0,0 +1,95 @@
+const noop = () => {}
+
+function fakeMatchMedia () {
+  return {
+    matches: false,
+    addListener: noop,
+    removeListener: noop
+  }
+}
+
+function wrapXHR (window, networkWriter) {
+  const { XMLHttpRequest } = window
+  const { open } = XMLHttpRequest.prototype
+  XMLHttpRequest.prototype.open = function (...args) {
+    const [method, url] = args
+    const log = () => {
+      const { status } = this
+      networkWriter.append({
+        method,
+        url,
+        status
+      })
+    }
+    this.addEventListener('load', log)
+    this.addEventListener('error', log)
+    return open.call(this, ...args)
+  }
+}
+
+function adjustXPathResult (window) {
+  /* https://ui5.sap.com/resources/sap/ui/model/odata/AnnotationParser-dbg.js
+     getXPath: function() {
+       xmlNodes.length = xmlNodes.snapshotLength;
+  */
+  const { Document } = window
+  const evaluate = Document.prototype.evaluate
+  Document.prototype.evaluate = function () {
+    const result = evaluate.apply(this, arguments)
+    let length = result.length
+    Object.defineProperty(result, 'length', {
+      get: () => length,
+      set: (value) => {
+        length = value
+        return true
+      }
+    })
+    return result
+  }
+}
+
+function fixMatchesDontThrow (window) {
+  // https://github.com/jsdom/jsdom/issues/3057
+  // Fix _nwsapiDontThrow which throws :-(
+  const { document } = window
+  const [impl] = Object.getOwnPropertySymbols(document)
+  const documentImpl = document[impl]
+  let _nwsapiDontThrow
+  Object.defineProperty(documentImpl, '_nwsapiDontThrow', {
+    get () {
+      return _nwsapiDontThrow
+    },
+    set (nwsapiDontThrow) {
+      _nwsapiDontThrow = nwsapiDontThrow
+      const { match } = nwsapiDontThrow
+      _nwsapiDontThrow.match = function () {
+        try {
+          return match.apply(this, arguments)
+        } catch (e) {
+          return false
+        }
+      }
+      return true
+    }
+  })
+}
+
+module.exports = ({
+  window,
+  networkWriter
+}) => {
+  window.addEventListener('error', event => {
+    const { message, filename, lineno, colno } = event
+    window.console.error(`${filename}@${lineno}:${colno}: ${message}`)
+  })
+
+  window.performance.timing = {
+    navigationStart: new Date().getTime(),
+    fetchStart: new Date().getTime()
+  }
+  window.matchMedia = window.matchMedia || fakeMatchMedia
+
+  wrapXHR(window, networkWriter)
+  adjustXPathResult(window)
+  fixMatchesDontThrow(window)
+}

package/src/defaults/jsdom/debug.js

@@ -0,0 +1,23 @@
+module.exports = window => {
+  // Proxify sap.ui to hook the loader and enable traces
+  window.sap = {
+    ui: new Proxy({}, {
+      get (obj, prop) {
+        return obj[prop]
+      },
+      set (obj, prop, value) {
+        obj[prop] = value
+        if (prop === 'loader') {
+          value._.logger = {
+            debug: (...args) => window.console.log('LOADER', ...args),
+            info: (...args) => window.console.info('LOADER', ...args),
+            warning: (...args) => window.console.warn('LOADER', ...args),
+            error: (...args) => window.console.error('LOADER', ...args),
+            isLoggable: () => true
+          }
+        }
+        return true
+      }
+    })
+  }
+}

package/src/defaults/jsdom/resource-loader.js

@@ -0,0 +1,43 @@
+module.exports = ({
+  jsdom,
+  networkWriter,
+  consoleWriter
+}) => {
+  const { ResourceLoader: JSDOMResourceLoader } = jsdom
+
+  const { readFile } = require('fs/promises')
+  const { join } = require('path')
+
+  class ResourceLoader extends JSDOMResourceLoader {
+    fetch (url, options) {
+      const request = super.fetch(url, options)
+      const log = reason => {
+        const { response } = request
+        let status
+        if (response === undefined) {
+          consoleWriter.append({
+            type: 'error',
+            message: 'NETWORK ERROR : ' + (reason ? reason.toString() : 'unknown reason')
+          })
+          status = 599
+        } else {
+          status = response.statusCode
+        }
+        networkWriter.append({
+          method: 'GET',
+          url,
+          status
+        })
+      }
+      request.then(log, log)
+      if (url.match(/sap\/ui\/test\/matchers\/Visible(-dbg)?.js/)) {
+        return request.then(() => {
+          return readFile(join(__dirname, 'sap.ui.test.matchers.visible.js'))
+        })
+      }
+      return request
+    }
+  }
+
+  return new ResourceLoader()
+}

package/src/defaults/jsdom/sap.ui.test.matchers.visible.js

@@ -0,0 +1,39 @@
+/* Modified version of https://ui5.sap.com/resources/sap/ui/test/matchers/Visible-dbg.js */
+/* see https://github.com/jsdom/jsdom/issues/1048 */
+/* global sap, jQuery */
+sap.ui.define(['sap/ui/test/matchers/Matcher'], function (Matcher) {
+  'use strict'
+
+  /**
+   * @class Checks if a controls domref is visible.
+   * @private
+   * @extends sap.ui.test.matchers.Matcher
+   * @name sap.ui.test.matchers.Visible
+   * @author SAP SE
+   * @since 1.34
+   */
+  return Matcher.extend('sap.ui.test.matchers.Visible', /** @lends sap.ui.test.matchers.Visible.prototype */ {
+    isMatching: function (oControl) {
+      const oDomRef = oControl.$()
+
+      if (oDomRef.length) {
+        const isVisible = ref => ref.css('display') !== 'none' && ref.css('visibility') !== 'hidden'
+        if (!isVisible(oDomRef)) {
+          this._oLogger.debug("Control '" + oControl + "' is not visible")
+          return false
+        }
+        const parents = oDomRef.parents()
+        for (const parent of parents) {
+          if (!isVisible(jQuery(parent))) {
+            this._oLogger.debug("Control '" + oControl + "' is not visible (because of hidden parent)")
+            return false
+          }
+        }
+        return true
+      }
+
+      this._oLogger.debug("Control '" + oControl + "'' is not rendered")
+      return false
+    }
+  })
+})

package/src/defaults/jsdom.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { join } = require('path')
+
+require('./browser')({
+  metadata: {
+    name: 'jsdom',
+    options: [
+      ['--debug [flag]', 'Enable more traces', false]
+    ],
+    capabilities: {
+      modules: ['jsdom'],
+      scripts: true,
+      traces: ['console', 'network']
+    }
+  },
+
+  async run ({
+    settings: { url, scripts, modules },
+    options,
+    consoleWriter,
+    networkWriter
+  }) {
+    const jsdom = require(modules.jsdom)
+    const { JSDOM, VirtualConsole } = jsdom
+
+    const virtualConsole = new VirtualConsole()
+    virtualConsole.on('error', (...args) => consoleWriter.append({ type: 'error', text: args.join(' ') }))
+    virtualConsole.on('warn', (...args) => consoleWriter.append({ type: 'warning', text: args.join(' ') }))
+    virtualConsole.on('info', (...args) => consoleWriter.append({ type: 'info', text: args.join(' ') }))
+    virtualConsole.on('log', (...args) => consoleWriter.append({ type: 'log', text: args.join(' ') }))
+
+    const beforeParse = (window) => {
+      require('./jsdom/compatibility')({ window, networkWriter })
+      if (options.debug) {
+        require('./jsdom/debug')(window)
+      }
+      scripts.forEach(script => window.eval(script))
+    }
+
+    // https://github.com/jsdom/jsdom/issues/2920
+    const Window = require(join(modules.jsdom, 'lib/jsdom/browser/Window.js'))
+    const origCreate = Window.createWindow.bind(Window)
+    Window.createWindow = (...args) => {
+      const window = origCreate(...args)
+      beforeParse(window)
+      return window
+    }
+
+    JSDOM.fromURL(url, {
+      includeNodeLocations: true,
+      storageQuota: 10000000,
+      runScripts: 'dangerously',
+      pretendToBeVisual: true,
+      virtualConsole,
+      resources: require('./jsdom/resource-loader')({
+        jsdom,
+        networkWriter,
+        consoleWriter
+      }),
+      beforeParse
+    })
+  }
+})

package/src/defaults/junit-xml-report.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { join } = require('path')
+const { writeFile } = require('fs').promises
+const [,, reportDir] = process.argv
+
+const output = []
+function o (text) {
+  output.push(text)
+}
+
+function xmlEscape (text) {
+  return text.replace(/<|>|&|"/g, match => ({
+    '<': '&lt;',
+    '>': '&gt;',
+    '&': '&amp;',
+    '"': '&quot;'
+  }[match]))
+}
+
+async function main () {
+  const job = require(join(reportDir, 'job.js'))
+  o('<?xml version="1.0" encoding="UTF-8"?>')
+  o('<testsuites>')
+  const urls = Object.keys(job.qunitPages)
+  for (const url of urls) {
+    const qunitPage = job.qunitPages[url]
+    for (const module of qunitPage.modules) {
+      o(`  <testsuite
+    name="${xmlEscape(url)}"
+    package="${xmlEscape(module.name)}"
+    tests="${module.tests.length}"
+  >`)
+      for (const test of module.tests) {
+        o(`    <testcase
+      name="${xmlEscape(test.name)}"
+    >`)
+        if (test.skip) {
+          o('      <skipped></skipped>')
+        } else if (test.report.failed) {
+          const log = test.logs.filter(({ result }) => !result)[0]
+          o(`      <failure
+        message="${xmlEscape(log.message)}"
+      >`)
+          o(xmlEscape(log.source))
+          o('      </failure>')
+        }
+        o('    </testcase>')
+      }
+      o('  </testsuite>')
+    }
+  }
+  o('</testsuites>')
+  await writeFile(join(reportDir, 'junit.xml'), output.join('\n'))
+}
+
+main()
+  .catch(reason => {
+    console.error(reason)
+    return -1
+  })
+  .then((code = 0) => {
+    process.exit(code)
+  })

package/src/defaults/puppeteer.js

@@ -0,0 +1,111 @@
+'use strict'
+
+let browser
+let page
+
+require('./browser')({
+  metadata: {
+    name: 'puppeteer',
+    options: [
+      ['--visible [flag]', 'Show the browser', false],
+      ['-w, --viewport-width <width>', 'Viewport width', 1920],
+      ['-h, --viewport-height <height>', 'Viewport height', 1080],
+      ['-l, --language <lang...>', 'Language(s)', ['en-US']],
+      ['-u, --unsecure', 'Disable security features', false]
+    ],
+    capabilities: {
+      modules: ['puppeteer'],
+      screenshot: '.png',
+      scripts: true,
+      traces: ['console', 'network']
+    }
+  },
+
+  async screenshot ({ filename }) {
+    if (page) {
+      await page.screenshot({
+        path: filename,
+        fullPage: true
+      })
+      return true
+    }
+  },
+
+  async beforeExit () {
+    if (page) {
+      await page.close()
+    }
+    if (browser) {
+      await browser.close()
+    }
+  },
+
+  async run ({
+    settings: { url, scripts, modules },
+    options,
+    consoleWriter,
+    networkWriter
+  }) {
+    const puppeteer = require(modules.puppeteer)
+
+    const args = [
+      '--start-maximized',
+      '--no-sandbox',
+      '--disable-gpu',
+      '--disable-extensions',
+      `--window-size=${options.viewportWidth},${options.viewportHeight}`,
+      `--lang=${options.language.join(',')}`
+    ]
+
+    if (options.unsecure) {
+      args.push(
+        '--disable-web-security',
+        '--disable-features=IsolateOrigins',
+        '--disable-features=BlockInsecurePrivateNetworkRequests',
+        '--disable-site-isolation-trials'
+      )
+    }
+
+    browser = await puppeteer.launch({
+      headless: !options.visible,
+      defaultViewport: null,
+      args
+    })
+
+    page = (await browser.pages())[0]
+
+    if (options.unsecure) {
+      await page.setBypassCSP(true)
+    }
+
+    page
+      .on('console', message => consoleWriter.append({
+        type: message.type(),
+        text: message.text()
+      }))
+      .on('response', response => {
+        const request = response.request()
+        networkWriter.append({
+          method: request.method(),
+          url: response.url(),
+          status: response.status()
+        })
+      })
+
+    if (scripts && scripts.length) {
+      for await (const script of scripts) {
+        await page.evaluateOnNewDocument(script)
+      }
+    }
+
+    await page.setDefaultNavigationTimeout(0)
+    await page.goto(url)
+  },
+
+  async error ({ error: e, exit }) {
+    // Lots of threads on this message but no clear solution
+    if (e.message === 'Navigation failed because browser has disconnected!') {
+      await exit(0)
+    }
+  }
+})

package/src/defaults/report/common.js

@@ -0,0 +1,38 @@
+(function () {
+  /* global punybind, punyexpr */
+
+  const report = {}
+
+  report.elapsed = function (start, end = Date.now()) {
+    if (typeof end === 'string') {
+      end = new Date(end).getTime()
+    }
+    if (typeof start === 'string') {
+      start = new Date(start).getTime()
+    }
+    const ms = end - start
+    if (isNaN(ms)) {
+      return '-'
+    }
+    if (ms > 5000) {
+      const mins = Math.floor(ms / 60000)
+      const secs = Math.floor((ms % 60000) / 1000)
+      return `${mins.toString().padStart(2, 0)}:${secs.toString().padStart(2, 0)}`
+    }
+    return `${ms} ms`
+  }
+
+  let setReady
+  report.ready = new Promise(resolve => {
+    setReady = resolve
+  })
+
+  window.addEventListener('load', () => {
+    const safebind = punybind.use({
+      compiler: punyexpr
+    })
+    safebind(document.body).then(setReady)
+  })
+
+  window.report = report
+}())