ui5-test-runner 1.1.4 → 2.0.0

package/src/endpoints.js

@@ -2,86 +2,72 @@
 
 const { join } = require('path')
 const { body } = require('reserve')
-const { screenshot, stop } = require('./browsers')
-const { writeFile } = require('fs').promises
-const { extractUrl, filename } = require('./tools')
+const { extractPageUrl } = require('./tools')
 const { Request, Response } = require('reserve')
-const output = require('./output')
+const { getOutput } = require('./output')
+const { begin, testStart, log, testDone, done } = require('./qunit-hooks')
+const { addTestPages } = require('./add-test-pages')
+const { getJobProgress } = require('./get-job-progress')
+const { readFile } = require('fs/promises')
+const { TextEncoder } = require('util')
 
 module.exports = job => {
-  async function endpointImpl (implementation, request) {
-    const url = extractUrl(request.headers)
+  async function endpointImpl (api, implementation, request) {
+    const url = extractPageUrl(request.headers)
     const data = JSON.parse(await body(request))
-    if (job.parallel === -1) {
-      output.endpoint(url, data)
-    }
     try {
       await implementation.call(this, url, data)
-    } catch (e) {
-      output.endpointError(url, data, e)
+    } catch (error) {
+      getOutput(job).endpointError({ api, url, data, error })
     }
   }
 
-  function synchronousEndpoint (implementation) {
+  function synchronousEndpoint (api, implementation) {
     return async function (request, response) {
-      await endpointImpl(implementation, request)
+      await endpointImpl(api, implementation, request)
       response.writeHead(200)
       response.end()
     }
   }
 
-  function endpoint (implementation) {
+  function endpoint (api, implementation) {
     return async function (request, response) {
       response.writeHead(200)
       response.end()
-      await endpointImpl(implementation, request)
+      await endpointImpl(api, implementation, request)
     }
   }
 
-  function getPageTest (page, testId) {
-    const { tests, order } = page
-    if (!tests[testId]) {
-      tests[testId] = {
-        timestamps: []
-      }
-      order.push(testId)
-    }
-    return tests[testId]
+  async function getInjects (...names) {
+    return '\n;\n' + (await Promise.all(names.map(name => readFile(join(__dirname, 'inject', `${name}.js`)))))
+      .map(buffer => buffer.toString())
+      .join('\n;\n')
+  }
+
+  function contentLength (content) {
+    return new TextEncoder().encode(content).length
+  }
+
+  function sendScript (response, content) {
+    response.writeHead(200, {
+      'content-type': 'text/javascript',
+      'content-length': contentLength(content),
+      'cache-control': 'no-store'
+    })
+    response.end(content)
   }
 
   return job.parallel
     ? [{
       // Substitute qunit-redirect to extract test pages
         match: '/resources/sap/ui/qunit/qunit-redirect.js',
-        file: join(__dirname, './inject/qunit-redirect.js')
+        custom: async (request, response) => {
+          sendScript(response, await getInjects('post', 'qunit-redirect'))
+        }
       }, {
       // Endpoint to receive test pages
         match: '^/_/addTestPages',
-        custom: endpoint(async (url, data) => {
-          let testPageUrls
-          if (job.pageFilter) {
-            const filter = new RegExp(job.pageFilter)
-            testPageUrls = data.filter(name => name.match(filter))
-          } else {
-            testPageUrls = data
-          }
-          if (job.pageParams) {
-            testPageUrls = testPageUrls.map(url => {
-              if (url.includes('?')) {
-                return url + '&' + job.pageParams
-              }
-              return url + '?' + job.pageParams
-            })
-          }
-          const pages = testPageUrls.reduce((mapping, page) => {
-            mapping[page] = filename(page)
-            return mapping
-          }, {})
-          const pagesFileName = join(job.tstReportDir, 'pages.json')
-          await writeFile(pagesFileName, JSON.stringify(pages))
-          job.testPageUrls = Object.keys(pages) // filter out duplicates
-          stop(job, url)
-        })
+        custom: endpoint('addTestPages', (url, pages) => addTestPages(job, url, pages))
       }, {
       // QUnit hooks
         match: '^/_/qunit-hooks.js',
@@ -96,13 +82,11 @@ module.exports = job => {
           const ui5Request = new Request('GET', request.url)
           ui5Request.internal = true
           const ui5Response = new Response()
-          const hooksRequest = new Request('GET', '/_/qunit-hooks.js')
-          const hooksResponse = new Response()
-          await Promise.all([
-            this.configuration.dispatch(ui5Request, ui5Response),
-            this.configuration.dispatch(hooksRequest, hooksResponse)
+          const [inject] = await Promise.all([
+            getInjects('post', 'qunit-hooks'),
+            this.configuration.dispatch(ui5Request, ui5Response)
           ])
-          const hooksLength = parseInt(hooksResponse.headers['content-length'], 10)
+          const hooksLength = contentLength(inject)
           const ui5Length = parseInt(ui5Response.headers['content-length'], 10)
           response.writeHead(ui5Response.statusCode, {
             ...ui5Response.headers,
@@ -110,94 +94,56 @@ module.exports = job => {
             'cache-control': 'no-store' // for debugging purpose
           })
           response.write(ui5Response.toString())
-          response.end(hooksResponse.toString())
+          response.end(inject)
         }
       }, {
       // Endpoint to receive QUnit.begin
         match: '^/_/QUnit/begin',
-        custom: endpoint((url, details) => {
-          const page = {
-            isOpa: details.isOpa,
-            total: details.totalTests,
-            failed: 0,
-            passed: 0,
-            tests: {},
-            order: []
-          }
-          details.modules.forEach(module => {
-            module.tests.forEach(test => getPageTest(page, test.testId))
-          })
-          job.testPages[url] = page
-        })
+        custom: endpoint('QUnit/begin', (url, details) => begin(job, url, details))
+      }, {
+      // Endpoint to receive QUnit.testStart
+        match: '^/_/QUnit/testStart',
+        custom: endpoint('QUnit/testStart', (url, details) => testStart(job, url, details))
       }, {
       // Endpoint to receive QUnit.log
         match: '^/_/QUnit/log',
-        custom: synchronousEndpoint(async (url, report) => {
-          const page = job.testPages[url]
-          if (page.isOpa) {
-            const { testId, runtime } = report
-            getPageTest(page, testId).timestamps.push(runtime)
-            await screenshot(job, url, `${testId}-${runtime}.png`)
-          }
-        })
+        custom: synchronousEndpoint('QUnit/log', async (url, report) => log(job, url, report))
       }, {
       // Endpoint to receive QUnit.testDone
         match: '^/_/QUnit/testDone',
-        custom: synchronousEndpoint(async (url, report) => {
-          const page = job.testPages[url]
-          const { testId } = report
-          if (report.failed) {
-            await screenshot(job, url, `${testId}.png`)
-            job.failed = true
-            ++page.failed
-          } else {
-            ++page.passed
-          }
-          getPageTest(page, testId).report = report
-        })
+        custom: synchronousEndpoint('QUnit/testDone', async (url, report) => testDone(job, url, report))
       }, {
       // Endpoint to receive QUnit.done
         match: '^/_/QUnit/done',
-        custom: endpoint(async (url, report) => {
-          const page = job.testPages[url]
-          if (page) {
-            await screenshot(job, url, 'screenshot.png')
-            if (report.__coverage__) {
-              const coverageFileName = join(job.covTempDir, `${filename(url)}.json`)
-              await writeFile(coverageFileName, JSON.stringify(report.__coverage__))
-              delete report.__coverage__
-            }
-            page.report = report
-          }
-          stop(job, url)
-        })
+        custom: endpoint('QUnit/done', async (url, report) => done(job, url, report))
       }, {
       // UI to follow progress
         match: '^/_/progress.html',
-        file: join(__dirname, 'progress.html')
+        file: job.progressPage
+      }, {
+      // Report 'main' substituted for progress
+        match: '^/_/report/main.js',
+        file: join(__dirname, 'defaults/report/progress.js')
+      }, {
+      // Other report resources
+        match: '^/_/report/(.*)',
+        file: join(__dirname, 'defaults/report/$1')
+      }, {
+      // punybind
+        match: '^/_/punybind.js',
+        file: join(__dirname, '../node_modules/punybind/dist/punybind.js')
+      }, {
+      // punyexpr
+        match: '^/_/punyexpr.js',
+        file: join(__dirname, '../node_modules/punyexpr/dist/punyexpr.js')
       }, {
       // Endpoint to follow progress
-        match: '^/_/progress',
-        custom: async (request, response) => {
-          const json = JSON.stringify(job, (key, value) => {
-            if (((key === 'tests' || key === 'browsers') && typeof value === 'object') ||
-                (key === 'order' && Array.isArray(value))
-            ) {
-              return undefined // Filter out
-            }
-            return value
-          })
-          const length = (new TextEncoder().encode(json)).length
-          response.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Content-Length': length
-          })
-          response.end(json)
-        }
+        match: '^/_/progress(?:\\?page=([^&]*)(?:&test=([^&]*))?)?',
+        custom: (request, response, pageId, testId) => getJobProgress(job, request, response, pageId, testId)
       }, {
       // Endpoint to coverage files
         match: '^/_/coverage/(.*)',
-        file: join(job.covReportDir, '$1')
+        file: join(job.coverageReportDir, '$1')
       }, {
       // Endpoint to report
         match: '^/_/report.html',
@@ -205,7 +151,7 @@ module.exports = job => {
       }, {
       // Endpoint to report files
         match: '^/_/(.*)',
-        file: join(job.tstReportDir, '$1')
+        file: join(job.reportDir, '$1')
       }]
     : []
 }

package/src/error.js

@@ -0,0 +1,52 @@
+class UTRError extends Error {
+  get code () { return this._code }
+
+  constructor (error, details) {
+    super()
+    this.name = `UTRError:${error.name}`
+    this._code = error.code
+    if (details) {
+      this.message = details
+    } else {
+      this.message = error.name
+    }
+  }
+}
+
+const errors = [{
+  name: 'GENERIC'
+}, {
+  name: 'NPM_FAILED'
+}, {
+  name: 'MISSING_OR_INVALID_BROWSER_CAPABILITIES'
+}, {
+  name: 'BROWSER_PROBE_FAILED'
+}, {
+  name: 'BROWSER_FAILED'
+}, {
+  name: 'BROWSER_SCREENSHOT_FAILED'
+}, {
+  name: 'BROWSER_SCREENSHOT_TIMEOUT'
+}, {
+  name: 'BROWSER_SCREENSHOT_NOT_SUPPORTED'
+}, {
+  name: 'QUNIT_ERROR'
+}, {
+  name: 'MODE_INCOMPATIBLE_OPTION'
+}, {
+  name: 'BROWSER_MISS_SCRIPTS_CAPABILITY'
+}, {
+  name: 'NPM_DEPENDENCY_NOT_FOUND'
+}]
+
+errors.forEach((error, index) => {
+  error.code = -1 - index
+  UTRError[`${error.name}_CODE`] = error.code
+  UTRError[error.name] = function (details = '') {
+    return new UTRError(error, details)
+  }
+})
+
+module.exports = {
+  UTRError
+}

package/src/error.spec.js

@@ -0,0 +1,17 @@
+const { UTRError } = require('./error')
+
+describe('src/errors', () => {
+  it('generates a fully documented error', () => {
+    const error = UTRError.NPM_FAILED('test')
+    expect(error.name).toStrictEqual('UTRError:NPM_FAILED')
+    expect(error.code).toBeLessThan(0)
+    expect(error.message).toStrictEqual('test')
+  })
+
+  it('generates a generic error', () => {
+    const error = UTRError.NPM_FAILED()
+    expect(error.name).toStrictEqual('UTRError:NPM_FAILED')
+    expect(error.code).toBeLessThan(0)
+    expect(error.message).toStrictEqual('NPM_FAILED')
+  })
+})

package/src/get-job-progress.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const send = (response, obj) => {
+  let json
+  if (typeof obj !== 'string') {
+    json = JSON.stringify(obj, undefined, 2)
+  } else {
+    json = obj
+  }
+  const length = (new TextEncoder().encode(json)).length
+  response.writeHead(200, {
+    'Content-Type': 'application/json',
+    'Content-Length': length
+  })
+  response.end(json)
+}
+
+const notFound = response => {
+  response.writeHead(404)
+  response.end()
+}
+
+module.exports = {
+  async getJobProgress (job, request, response, pageId, testId) {
+    if (pageId) {
+      const url = Object.keys(job.qunitPages).find(pageUrl => job.qunitPages[pageUrl].id === pageId)
+      if (!url) {
+        return notFound(response)
+      }
+      const qunitPage = { url, ...job.qunitPages[url] }
+      if (!testId) {
+        return send(response, JSON.stringify(qunitPage, (key, value) => {
+          if (key === 'logs') {
+            return undefined
+          }
+          return value
+        }, 2))
+      }
+      let test
+      let moduleName
+      qunitPage.modules.every(module => module.tests.every(candidate => {
+        if (candidate.testId === testId) {
+          moduleName = module.name
+          test = candidate
+          return false
+        }
+        return true
+      }))
+      if (!test) {
+        return notFound(response)
+      }
+      return send(response, {
+        url,
+        pageId,
+        module: moduleName,
+        ...test
+      })
+    }
+    send(response, JSON.stringify({
+      ...job,
+      status: job.status
+    }, (key, value) => {
+      if (key === 'modules') {
+        return undefined
+      }
+      return value
+    }, 2))
+  }
+}

package/src/get-job-progress.spec.js

@@ -0,0 +1,175 @@
+const { getJobProgress } = require('./get-job-progress')
+const { Response } = require('reserve')
+
+describe('src/get-job-progress', () => {
+  const url = 'https://localhost:8080/tests/unitTests.qunit.html'
+  const id = 'abcdef'
+  const firstTestId = '8ef4ee8b'
+
+  const job = {
+    cwd: '.',
+    port: 8080,
+    ui5: 'https://ui5.sap.com',
+    testPageUrls: [url],
+    qunitPages: {
+      [url]: {
+        id,
+        start: '2023-01-09T12:49:34.255Z',
+        failed: 0,
+        passed: 2,
+        count: 3,
+        modules: [{
+          name: 'module',
+          tests: [{
+            name: 'First test',
+            testId: firstTestId,
+            logs: ['whatever it contains'],
+            report: {
+              skipped: false,
+              todo: false,
+              failed: 0,
+              passed: 1,
+              total: 1,
+              runtime: 3
+            }
+          }, {
+            name: 'Second test',
+            testId: '35d36b9d',
+            logs: [],
+            report: {
+              skipped: false,
+              todo: false,
+              failed: 0,
+              passed: 1,
+              total: 1,
+              runtime: 5
+            }
+          }, {
+            name: 'Third test',
+            testId: 'e32c4c98',
+            logs: [],
+            report: {
+              skipped: false,
+              todo: false,
+              failed: 1,
+              passed: 0,
+              total: 1,
+              runtime: 3
+            }
+          }]
+        }]
+      }
+    }
+  }
+
+  it('returns job without modules', async () => {
+    const response = new Response()
+    await getJobProgress(job, {}, response)
+    await response.waitForFinish()
+    const json = JSON.parse(response.toString())
+    expect(json).toStrictEqual({
+      cwd: '.',
+      port: 8080,
+      ui5: 'https://ui5.sap.com',
+      testPageUrls: [url],
+      qunitPages: {
+        [url]: {
+          id,
+          start: '2023-01-09T12:49:34.255Z',
+          failed: 0,
+          passed: 2,
+          count: 3
+        }
+      }
+    })
+  })
+
+  it('returns page without logs from page id', async () => {
+    const response = new Response()
+    await getJobProgress(job, {}, response, id)
+    await response.waitForFinish()
+    const json = JSON.parse(response.toString())
+    expect(json).toStrictEqual({
+      url,
+      id,
+      start: '2023-01-09T12:49:34.255Z',
+      failed: 0,
+      passed: 2,
+      count: 3,
+      modules: [{
+        name: 'module',
+        tests: [{
+          name: 'First test',
+          testId: '8ef4ee8b',
+          report: {
+            skipped: false,
+            todo: false,
+            failed: 0,
+            passed: 1,
+            total: 1,
+            runtime: 3
+          }
+        }, {
+          name: 'Second test',
+          testId: '35d36b9d',
+          report: {
+            skipped: false,
+            todo: false,
+            failed: 0,
+            passed: 1,
+            total: 1,
+            runtime: 5
+          }
+        }, {
+          name: 'Third test',
+          testId: 'e32c4c98',
+          report: {
+            skipped: false,
+            todo: false,
+            failed: 1,
+            passed: 0,
+            total: 1,
+            runtime: 3
+          }
+        }]
+      }]
+    })
+  })
+
+  it('returns 404 if page id is unknown', async () => {
+    const response = new Response()
+    await getJobProgress(job, {}, response, 'unknown')
+    await response.waitForFinish()
+    expect(response.statusCode).toBe(404)
+  })
+
+  it('returns test page and test id', async () => {
+    const response = new Response()
+    await getJobProgress(job, {}, response, id, firstTestId)
+    await response.waitForFinish()
+    const json = JSON.parse(response.toString())
+    expect(json).toStrictEqual({
+      url,
+      pageId: id,
+      module: 'module',
+      name: 'First test',
+      testId: firstTestId,
+      logs: ['whatever it contains'],
+      report: {
+        skipped: false,
+        todo: false,
+        failed: 0,
+        passed: 1,
+        total: 1,
+        runtime: 3
+      }
+    })
+  })
+
+  it('returns 404 if test id is unknown', async () => {
+    const response = new Response()
+    await getJobProgress(job, {}, response, id, 'unknown')
+    await response.waitForFinish()
+    expect(response.statusCode).toBe(404)
+  })
+})

package/src/inject/post.js

@@ -0,0 +1,96 @@
+(function () {
+  'use strict'
+
+  if (window['ui5-test-runner/post']) {
+    return
+  }
+
+  const base = window['ui5-test-runner/base-host'] || ''
+
+  let lastPost = Promise.resolve()
+  let UI5Object
+
+  function stringify (data) {
+    const objects = []
+    const referenced = []
+    if (!UI5Object && window.sap && window.sap.ui && window.sap.ui.base) {
+      UI5Object = window.sap.ui.base.Object
+    }
+    const ui5Summary = obj => {
+      const id = obj.getId && obj.getId()
+      const className = obj.getMetadata().getName()
+      return {
+        'ui5:class': className,
+        'ui5:id': id
+      }
+    }
+    const simple = JSON.stringify(data, function (key, value) {
+      if (typeof value === 'object' && value) {
+        if (UI5Object && value instanceof UI5Object) {
+          return ui5Summary(value)
+        }
+        const id = objects.indexOf(value)
+        if (id !== -1) {
+          referenced[id] = true
+          return null // Skip error and check all references
+        }
+        objects.push(value)
+      }
+      return value
+    })
+    if (referenced.length === 0) {
+      return simple
+    }
+    const stringified = []
+    return JSON.stringify(data, function (key, value) {
+      if (typeof value === 'object' && value) {
+        if (UI5Object && value instanceof UI5Object) {
+          return ui5Summary(value)
+        }
+        const id = objects.indexOf(value)
+        if (referenced[id]) {
+          if (stringified[id]) {
+            return { 'circular:ref': id }
+          }
+          stringified[id] = true
+          if (Array.isArray(value)) {
+            return {
+              'circular:id': id,
+              'circular:array': [].concat(value) // 'new' object
+            }
+          }
+          return Object.assign({
+            'circular:id': id
+          }, value)
+        }
+      }
+      return value
+    })
+  }
+
+  window['ui5-test-runner/stringify'] = stringify
+
+  window['ui5-test-runner/post'] = function post (url, data) {
+    function request () {
+      return new Promise(function (resolve, reject) {
+        const xhr = new XMLHttpRequest()
+        xhr.addEventListener('load', () => {
+          resolve(xhr.responseText)
+        })
+        xhr.addEventListener('error', () => {
+          reject(xhr.statusText)
+        })
+        xhr.open('POST', base + '/_/' + url)
+        xhr.setRequestHeader('x-page-url', location)
+        xhr.send(stringify(data))
+      })
+    }
+    lastPost = lastPost
+      .then(undefined, function (reason) {
+        console.error('Failed to POST to ' + url + '\nreason: ' + reason.toString())
+        throw new Error('failed')
+      })
+      .then(request)
+    return lastPost
+  }
+}())