ui5-test-runner 1.1.5 → 2.0.0

package/src/tests.js

@@ -1,106 +1,149 @@
 'use strict'
 
-const { start } = require('./browsers')
-const { instrument, generateCoverageReport } = require('./coverage')
-const { filename, recreateDir } = require('./tools')
-const { join } = require('path')
-const { copyFile, writeFile } = require('fs').promises
+const { probe, start } = require('./browsers')
+const { instrument } = require('./coverage')
+const { recreateDir } = require('./tools')
 const { globallyTimedOut } = require('./timeout')
-const output = require('./output')
+const { save, generate } = require('./report')
+const { getOutput } = require('./output')
+const {
+  $probeUrlsStarted,
+  $probeUrlsCompleted,
+  $testPagesStarted,
+  $testPagesCompleted
+} = require('./symbols')
+const { UTRError } = require('./error')
 
-async function saveJob (job) {
-  await writeFile(join(job.tstReportDir, 'job.json'), JSON.stringify({
-    ...job,
-    // Following members are useless because already serialized or not relevant
-    status: undefined,
-    testPageUrls: undefined,
-    browsers: undefined,
-    testPages: undefined
-  }))
-}
-
-async function extractTestPages (job) {
-  job.start = new Date()
-  await instrument(job)
-  await recreateDir(job.tstReportDir)
-  await saveJob(job)
-  job.status = 'Extracting test pages'
-  job.testPageUrls = []
-  await start(job, '/' + job.testsuite)
-  if (job.testPageUrls.length === 0) {
-    output.noTestPageFound()
-    job.failed = true
-    return Promise.resolve()
-  }
-  job.testPagesStarted = 0
-  job.testPagesCompleted = 0
-  job.testPages = {}
-  job.status = 'Executing test pages'
-  delete job.failed
-  const promises = []
-  for (let i = 0; i < Math.min(job.parallel, job.testPageUrls.length); ++i) {
-    promises.push(runTestPage(job))
-  }
-  return Promise.all(promises)
-}
-
-async function runTestPage (job) {
-  const { length } = job.testPageUrls
-  if (job.testPagesCompleted === length) {
-    return generateReport(job)
+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.testPagesStarted === length) {
+  if (job[startedMember] === length) {
     return
   }
-  const index = job.testPagesStarted++
-  const url = job.testPageUrls[index]
+  const index = job[startedMember]++
+  const url = urls[index]
   if (globallyTimedOut(job)) {
     output.globalTimeout(url)
+    job.failed = true
   } else if (job.failFast && job.failed) {
     output.failFast(url)
   } else {
-    await start(job, url)
-    const page = job.testPages[url]
-    if (page) {
-      const reportFileName = join(job.tstReportDir, `${filename(url)}.json`)
-      await writeFile(reportFileName, JSON.stringify(page))
+    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.mode === 'url' && job.browserCapabilities.scripts) {
+      scripts = [
+        'post.js',
+        'qunit-intercept.js',
+        'qunit-hooks.js'
+      ]
     }
+    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))
   }
-  ++job.testPagesCompleted
-  return runTestPage(job)
+  return Promise.all(promises)
 }
 
-async function generateReport (job) {
-  job.status = 'Finalizing'
-  // Simple report
-  job.failed = 0
-  const pages = []
-  for (const url of job.testPageUrls) {
-    const page = job.testPages[url]
-    if (page && page.report) {
-      pages.push({
-        url,
-        failed: page.report.failed
-      })
-      job.failed += page.report.failed
-    } else {
-      pages.push({
-        url,
-        failed: -1
-      })
-      job.failed += 1
+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
     }
   }
-  output.results(pages)
-  await saveJob(job)
-  await copyFile(join(__dirname, 'report.html'), join(job.tstReportDir, 'report.html'))
-  await generateCoverageReport(job)
-  output.timeSpent(job.start)
-  job.status = 'Done'
+
+  await generate(job)
 }
 
-module.exports = job => {
-  if (job.parallel) {
-    return extractTestPages(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)
   }
 }

package/src/timeout.spec.js

@@ -0,0 +1,39 @@
+const { getPageTimeout, globallyTimedOut } = require('./timeout')
+
+describe('src/timeout', () => {
+  describe('getPageTimeout', () => {
+    it('returns 0 when no timeout is defined', () => {
+      expect(getPageTimeout({})).toStrictEqual(0)
+    })
+
+    it('returns pageTimeout when no globalTimeout is defined', () => {
+      expect(getPageTimeout({ pageTimeout: 123 })).toStrictEqual(123)
+    })
+
+    it('returns pageTimeout if smaller than globalTimeout', () => {
+      expect(getPageTimeout({ pageTimeout: 123, globalTimeout: 1000, start: new Date() })).toStrictEqual(123)
+    })
+
+    it('returns reminder of the globalTimeout', () => {
+      expect(getPageTimeout({ globalTimeout: 10, start: new Date() })).not.toStrictEqual(0)
+    })
+
+    it('returns reminder of the globalTimeout if smaller than pageTimeout', () => {
+      expect(getPageTimeout({ pageTimeout: 123, globalTimeout: 10, start: new Date() })).not.toStrictEqual(123)
+    })
+  })
+
+  describe('globallyTimedOut', () => {
+    it('returns false if no globalTimeout', () => {
+      expect(globallyTimedOut({})).toStrictEqual(false)
+    })
+
+    it('returns false if not globally timed out', () => {
+      expect(globallyTimedOut({ globalTimeout: 1000, start: new Date() })).toStrictEqual(false)
+    })
+
+    it('returns true if globally timed out', () => {
+      expect(globallyTimedOut({ globalTimeout: 10, start: new Date(Date.now() - 1000) })).toStrictEqual(true)
+    })
+  })
+})

package/src/tools.js

@@ -2,6 +2,7 @@
 
 const fsPromises = require('fs').promises
 const { mkdir, stat } = fsPromises
+const { createHash } = require('crypto')
 
 let rm
 /* istanbul ignore next */ // Hard to test both in the same run
@@ -13,6 +14,19 @@ if (process.version > 'v14.14') {
 
 const recursive = { recursive: true }
 
+const stripUrlHash = url => url.split('#')[0]
+
+const filename = url => {
+  const hash = createHash('shake256', {
+    outputLength: 8
+  })
+  hash.update(stripUrlHash(url))
+  return hash.digest('base64')
+    .replace(/=/g, '')
+    .replace(/\+/g, '_')
+    .replace(/\//g, '$')
+}
+
 const cleanDir = async dir => {
   try {
     await stat(dir)
@@ -22,12 +36,105 @@ const cleanDir = async dir => {
   }
 }
 
+const $op = Symbol('pad.op')
+const $x = Symbol('pad.x')
+const $lt = Symbol('pad.lt')
+const $w = Symbol('pad.w')
+function pad (width) {
+  if (!width) {
+    width = process.stdout.columns || 80
+  }
+  const ops = {
+    [$x] (widthLeft) {
+      return ''.padStart(widthLeft, this.text)
+    },
+    [$lt] (widthLeft) {
+      const { text, padding } = this
+      if (text.length <= widthLeft) {
+        return text.padEnd(widthLeft, padding)
+      }
+      return '...' + text.substring(text.length - widthLeft + 3)
+    },
+    [$w] (widthLeft, result, opIndex) {
+      const { text } = this
+      if (text.length < widthLeft && !text.includes('\n')) {
+        return text.padEnd(widthLeft, ' ')
+      }
+      const lines = []
+      text.split(/\r?\n/).forEach(line => {
+        if (line.length <= widthLeft) {
+          lines.push(line.padEnd(widthLeft, ' '))
+        } else {
+          for (let offset = 0; offset < line.length; offset += widthLeft - 1) {
+            const part = line.slice(offset, offset + widthLeft - 1)
+            if (part.length < widthLeft - 1) {
+              lines.push(part.padEnd(widthLeft, ' '))
+            } else {
+              lines.push(`${part}↵`)
+            }
+          }
+        }
+      })
+      const before = result.slice(0, opIndex).join('')
+      const after = result.slice(opIndex + 1).join('')
+      return lines.join(after + '\n' + before)
+    }
+  }
+  return (strings, ...values) => {
+    const result = []
+    let op
+    let opIndex
+    const length = strings.reduce((total, string, index) => {
+      result.push(string)
+      total += string.length
+      let value = values[index]
+      if (value === null || value === undefined) {
+        return total
+      }
+      if (value[$op]) {
+        if (opIndex !== undefined) {
+          throw new Error('Only one operator is allowed')
+        }
+        op = value
+        opIndex = result.length
+        result.push(value)
+      } else {
+        if (typeof value !== 'string') {
+          value = value.toString()
+        }
+        result.push(value)
+        total += value.length
+      }
+      return total
+    }, 0)
+    if (op !== undefined) {
+      const widthLeft = width - length
+      result[opIndex] = ops[op[$op]].call(op, widthLeft, result, opIndex)
+    }
+    return result.join('')
+  }
+}
+
+pad.x = (text) => ({ [$op]: $x, text })
+pad.lt = (text, padding = ' ') => ({ [$op]: $lt, text, padding })
+pad.w = (text) => ({ [$op]: $w, text })
+
 module.exports = {
-  filename: url => escape(url)
-    .replace(/\//g, '_')
-    .replace(/%([0-9a-z]{2})/ig, (match, hexa) => `_${hexa}_`),
+  stripUrlHash,
+  filename,
   cleanDir,
   createDir: dir => mkdir(dir, recursive),
   recreateDir: dir => cleanDir(dir).then(() => mkdir(dir, recursive)),
-  extractUrl: headers => headers.referer.match(/http:\/\/[^/]+(?::\d+)?(\/.*)/)[1]
+  extractPageUrl: headers => headers['x-page-url'],
+  allocPromise () {
+    let resolve
+    let reject
+    const promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve
+      reject = _reject
+    })
+    return { promise, resolve, reject }
+  },
+  noop () {},
+  pad
 }

package/src/tools.spec.js

@@ -0,0 +1,90 @@
+const { filename, noop, pad } = require('./tools')
+
+describe('src/tools', () => {
+  describe('filename', () => {
+    const baseUrl = 'http://localhost:8085/test.html'
+
+    it('generates unique IDs for different search param', () => {
+      const id1 = filename(baseUrl + '?param1')
+      const id2 = filename(baseUrl + '?param2')
+      expect(id1).not.toBe(id2)
+    })
+
+    it('generates similar IDs for different hashes', () => {
+      const id1 = filename(baseUrl + '#param1')
+      const id2 = filename(baseUrl + '#param2')
+      expect(id1).toBe(id2)
+    })
+  })
+
+  describe('noop', () => {
+    it('is an empty function', () => {
+      expect(noop()).toBeUndefined()
+      expect(() => noop()).not.toThrow()
+    })
+  })
+
+  describe('pad', () => {
+    it('works if no operator is given', () => {
+      expect(pad(20)`abc`).toStrictEqual('abc')
+    })
+
+    it('fails if several operators are given', () => {
+      expect(() => pad()`${pad.x('-')}${pad.x('+')}`).toThrow()
+    })
+
+    it('extends a string (begin)', () => {
+      expect(pad(20)`${pad.x('-')}12`).toStrictEqual('------------------12')
+    })
+
+    it('extends a string (middle)', () => {
+      expect(pad(20)`1${pad.x('-')}2`).toStrictEqual('1------------------2')
+    })
+
+    it('extends a string (multiple interpolation)', () => {
+      expect(pad(20)`1${'3'}${pad.x('-')}${'4'}2`).toStrictEqual('13----------------42')
+    })
+
+    it('extends a string (end)', () => {
+      expect(pad(20)`12${pad.x('-')}`).toStrictEqual('12------------------')
+    })
+
+    it('extends a string (multiple chars)', () => {
+      expect(pad(20)`1${pad.x('-+')}2`).toStrictEqual('1-+-+-+-+-+-+-+-+-+2')
+    })
+
+    it('left trims a string', () => {
+      expect(pad(20)`1${pad.lt('abcdefghijklmnopqrstuvwxyz')}2`).toStrictEqual('1...lmnopqrstuvwxyz2')
+    })
+
+    it('left trims a small string', () => {
+      expect(pad(20)`1${pad.lt('abcdef')}2`).toStrictEqual('1abcdef            2')
+    })
+
+    it('wraps text (small enough)', () => {
+      expect(pad(20)`1${pad.w('abcdef')}2`).toStrictEqual('1abcdef            2')
+    })
+
+    it('wraps multiline', () => {
+      expect(pad(20)`1${pad.w('a\nb')}2`)
+        .toStrictEqual(`1a                 2
+1b                 2`)
+    })
+
+    it('wraps multiline / long text', () => {
+      expect(pad(20)`1${pad.w('first line\nsecond longer line to wrap\nfits exactly width')}2`)
+        .toStrictEqual(`1first line        2
+1second longer lin↵2
+1e to wrap         2
+1fits exactly width2`)
+    })
+
+    it('wraps multiline / long text (DOS carriage return)', () => {
+      expect(pad(20)`1${pad.w('first line\r\nsecond longer line to wrap\r\nfits exactly width')}2`)
+        .toStrictEqual(`1first line        2
+1second longer lin↵2
+1e to wrap         2
+1fits exactly width2`)
+    })
+  })
+})

package/src/ui5.js

@@ -4,12 +4,12 @@ const { dirname, join } = require('path')
 const { createWriteStream } = require('fs')
 const { mkdir, unlink } = require('fs').promises
 const { capture } = require('reserve')
-const output = require('./output')
+const { getOutput } = require('./output')
 
 module.exports = job => {
   const [, hostName] = /https?:\/\/([^/]*)/.exec(job.ui5)
   const [, version] = /(\d+\.\d+\.\d+)?$/.exec(job.ui5)
-  const cacheBase = join(job.cwd, job.cache, hostName.replace(':', '_'), version || '')
+  const cacheBase = join(job.cache || '', hostName.replace(':', '_'), version || '')
   const match = /\/((?:test-)?resources\/.*)/
   const ifCacheEnabled = (request, url, match) => job.cache ? match : false
   const uncachable = {}
@@ -59,7 +59,7 @@ module.exports = job => {
           file.end()
           uncachable[path] = true
           if (response.statusCode !== 404) {
-            output.failedToCacheUI5resource(path, response.statusCode)
+            getOutput(job).failedToCacheUI5resource(path, response.statusCode)
           }
           return unlink(cachePath)
         })

package/src/unhandled.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const { extractUrl } = require('./tools')
+const { extractPageUrl, noop } = require('./tools')
 const { join } = require('path')
 const { writeFile } = require('fs')
-const output = require('./output')
+const { getOutput } = require('./output')
 
 module.exports = job => {
-  const unhandled = join(job.tstReportDir, 'unhandled.txt')
+  const unhandled = join(job.reportDir, 'unhandled.txt')
   let outputUnhandled = true
   return [{
     custom: ({ headers, method, url }) => {
@@ -20,12 +20,12 @@ module.exports = job => {
         status = 500
       }
       if (outputUnhandled) {
-        output.unhandled()
+        getOutput(job).unhandled()
         outputUnhandled = false
       }
-      writeFile(unhandled, `${extractUrl(headers)} ${status} ${method} ${url}\n`, {
+      writeFile(unhandled, `${extractPageUrl(headers)} ${status} ${method} ${url}\n`, {
         flag: 'a'
-      }, () => {})
+      }, noop)
       return status
     }
   }]

package/src/unhandled.spec.js

@@ -0,0 +1,63 @@
+const { join } = require('path')
+const { getOutput } = require('./output')
+const jobFactory = require('./job')
+const mappingFactory = require('./unhandled')
+
+const cwd = join(__dirname, '../test/project')
+
+describe('src/unhandled', () => {
+  let unhandled
+  let output
+  let unhandledCall
+
+  beforeEach(() => {
+    const job = jobFactory.fromCmdLine(cwd, [])
+    output = getOutput(job)
+    unhandledCall = 0
+    output.unhandled = () => {
+      ++unhandledCall
+    }
+    unhandled = mappingFactory(job)[0].custom
+  })
+
+  const expectedIgnores = [
+    'favicon.ico',
+    'component-preload.js',
+    'button-dbg.js',
+    'i18n_en.properties'
+  ]
+  expectedIgnores.forEach(url => {
+    it(`does not log known GET patterns (${url})`, () => {
+      expect(unhandled({ method: 'GET', url })).toStrictEqual(404)
+      expect(unhandledCall).toStrictEqual(0)
+    })
+  })
+
+  const expectedWarnings = [
+    'any-mock-data-file.json',
+    'sourceFile.js'
+  ]
+  expectedWarnings.forEach(url => {
+    it(`warns about 404 GET (${url})`, () => {
+      expect(unhandled({ method: 'GET', url, headers: { referer: 'http://localhost:3475/test.html' } })).toStrictEqual(404)
+      expect(unhandledCall).toStrictEqual(1)
+    })
+  })
+  it('Warns only once', () => {
+    expectedWarnings.forEach(url => {
+      expect(unhandled({ method: 'GET', url, headers: { referer: 'http://localhost:3475/test.html' } })).toStrictEqual(404)
+    })
+    expect(unhandledCall).toStrictEqual(1)
+  })
+
+  it('logs errors for any other verb', () => {
+    expect(unhandled({ method: 'POST', url: '/any_url', headers: { referer: 'http://localhost:3475/test.html' } })).toStrictEqual(500)
+    expect(unhandledCall).toStrictEqual(1)
+  })
+
+  it('logs errors only once', () => {
+    expect(unhandled({ method: 'POST', url: '/any_url', headers: { referer: 'http://localhost:3475/test.html' } })).toStrictEqual(500)
+    expect(unhandled({ method: 'POST', url: '/any_other_url', headers: { referer: 'http://localhost:3475/test.html' } })).toStrictEqual(500)
+    expect(unhandledCall).toStrictEqual(1)
+  })
+})

package/defaults/chromium.js

@@ -1,62 +0,0 @@
-'use strict'
-
-const puppeteer = require('puppeteer')
-const { join } = require('path')
-const { createWriteStream } = require('fs')
-
-const [url, reportDir] = process.argv.slice(2).filter(arg => !arg.startsWith('--'))
-const headless = !process.argv.some(arg => arg === '--visible')
-
-let browser
-let page
-let consoleStream
-
-if (reportDir) {
-  consoleStream = createWriteStream(join(reportDir, 'console.txt'), 'utf-8')
-}
-
-process.on('message', async message => {
-  try {
-    if (message.command === 'stop') {
-      await browser.close()
-      process.exit(0)
-    } else if (message.command === 'screenshot') {
-      if (reportDir && page) {
-        await page.screenshot({ path: join(reportDir, message.filename) })
-        process.send(message)
-      }
-    } else if (message.command === 'capabilities') {
-      process.send({
-        command: 'capabilities',
-        screenshot: true,
-        consoleLog: true
-      })
-    }
-  } catch (e) {
-    console.error(e)
-    process.exit(-2)
-  }
-})
-
-async function main () {
-  browser = await puppeteer.launch({
-    headless,
-    defaultViewport: null,
-    args: [
-      url,
-      '--start-maximized',
-      '--no-sandbox',
-      '--disable-gpu',
-      '--disable-extensions'
-    ]
-  })
-  page = (await browser.pages())[0]
-  if (consoleStream) {
-    page.on('console', message => consoleStream.write(`${message.type().substr(0, 3).toUpperCase()} ${message.text()}\n`))
-  }
-}
-
-main().catch(e => {
-  console.error(e)
-  process.exit(-1)
-})