ui5-test-runner 1.1.5 → 2.0.1

package/src/inject/post.spec.js

@@ -0,0 +1,147 @@
+class UI5Object {}
+global.window = {
+  sap: {
+    ui: {
+      base: {
+        Object: UI5Object
+      }
+    }
+  }
+}
+
+require('./post')
+
+describe('src/inject/post', () => {
+  describe('stringify', () => {
+    const stringify = window['ui5-test-runner/stringify']
+
+    describe('simple values', () => {
+      const simpleValues = [
+        null,
+        '',
+        'Hello World !',
+        0,
+        1,
+        false,
+        true,
+        [],
+        [1, 2],
+        { a: 'a' },
+        { a: 'a', b: { b: 'b' } },
+        [{ a: 'a' }, { a: 'a', b: { b: 'b' } }]
+      ]
+
+      simpleValues.forEach(simpleValue => {
+        it(JSON.stringify(simpleValue), () => {
+          expect(stringify(simpleValue)).toBe(JSON.stringify(simpleValue))
+        })
+      })
+    })
+
+    describe('UI5 objects', () => {
+      it('reduces UI5 objects to their simplest form (no ID)', () => {
+        const obj = new UI5Object()
+        obj.getMetadata = () => ({
+          getName: () => 'sap.m.Button'
+        })
+        expect(JSON.parse(stringify(obj))).toStrictEqual({
+          'ui5:class': 'sap.m.Button'
+        })
+      })
+
+      it('reduces UI5 objects to their simplest form (with ID)', () => {
+        const obj = new UI5Object()
+        obj.getId = () => 'test'
+        obj.getMetadata = () => ({
+          getName: () => 'sap.m.Button'
+        })
+        expect(JSON.parse(stringify(obj))).toStrictEqual({
+          'ui5:id': 'test',
+          'ui5:class': 'sap.m.Button'
+        })
+      })
+
+      it('works on a complex object', () => {
+        const obj = new UI5Object()
+        obj.getId = () => 'test'
+        obj.getMetadata = () => ({
+          getName: () => 'sap.m.Button'
+        })
+        expect(JSON.parse(stringify({
+          complex: obj
+        }))).toStrictEqual({
+          complex: {
+            'ui5:id': 'test',
+            'ui5:class': 'sap.m.Button'
+          }
+        })
+      })
+    })
+
+    describe('circular references', () => {
+      it('converts simple circular reference (object)', () => {
+        const a = { a: 'a' }
+        const b = { b: 'b' }
+        a.b = b
+        b.a = a
+        expect(JSON.parse(stringify(a))).toStrictEqual({
+          'circular:id': 0,
+          a: 'a',
+          b: {
+            b: 'b',
+            a: {
+              'circular:ref': 0
+            }
+          }
+        })
+      })
+
+      it('converts deep circular reference', () => {
+        const a = {
+          a: 'a',
+          b: {
+            b: 'b',
+            c: ['c'],
+            d: {
+              d: 'd'
+            }
+          }
+        }
+        a.b.c.push(a.b)
+        a.b.d.a = a
+        expect(JSON.parse(stringify(a))).toStrictEqual({
+          'circular:id': 0,
+          a: 'a',
+          b: {
+            'circular:id': 1,
+            b: 'b',
+            c: ['c', { 'circular:ref': 1 }],
+            d: {
+              d: 'd',
+              a: {
+                'circular:ref': 0
+              }
+            }
+          }
+        })
+      })
+
+      it('converts simple circular reference (array)', () => {
+        const a = ['a']
+        const b = ['b']
+        a.push(b)
+        b.push(a)
+        expect(JSON.parse(stringify(a))).toStrictEqual({
+          'circular:id': 0,
+          'circular:array': [
+            'a',
+            [
+              'b',
+              { 'circular:ref': 0 }
+            ]
+          ]
+        })
+      })
+    })
+  })
+})

package/src/inject/qunit-hooks.js

@@ -7,22 +7,7 @@
   }
   window['ui5-test-runner/qunit-hooks'] = true
 
-  function post (url, data) {
-    return new Promise(function (resolve, reject) {
-      const xhr = new XMLHttpRequest()
-      xhr.open('POST', '/_/' + url)
-      xhr.send(JSON.stringify(data))
-      xhr.onreadystatechange = function () {
-        if (xhr.readyState === 4) {
-          if (xhr.status === 200) {
-            resolve(xhr.responseText)
-          } else {
-            reject(xhr.statusText)
-          }
-        }
-      }
-    })
-  }
+  const post = window['ui5-test-runner/post']
 
   function isOpa () {
     try {
@@ -37,12 +22,12 @@
     return post('QUnit/begin', details)
   })
 
-  QUnit.log(function (report) {
+  QUnit.testStart(function (details) {
+    return post('QUnit/testStart', details)
+  })
+
+  QUnit.log(function (log) {
     let ready = false
-    const log = {
-      testId: report.testId,
-      runtime: report.runtime
-    }
     post('QUnit/log', log)
       .then(undefined, function () {
         console.error('Failed to POST to QUnit/log (no timestamp)', log)

package/src/inject/qunit-intercept.js

@@ -0,0 +1,30 @@
+/* Injected QUnit hooks */
+(function () {
+  'use strict'
+
+  const callbacks = {}
+  const mock = new Proxy({}, {
+    get: function (instance, property) {
+      if (property !== 'version') {
+        return function (callback) {
+          callbacks[property] = callback
+        }
+      }
+    }
+  })
+
+  let QUnit = mock
+
+  Object.defineProperty(window, 'QUnit', {
+    get: function () {
+      return QUnit
+    },
+
+    set: function (value) {
+      QUnit = value
+      Object.keys(callbacks).forEach(property => {
+        QUnit[property](callbacks[property])
+      })
+    }
+  })
+}())

package/src/inject/qunit-redirect.js

@@ -1,25 +1,33 @@
 (function () {
   'use strict'
 
+  if (window['ui5-test-runner/qunit-redirect']) {
+    return // already installed
+  }
+  window['ui5-test-runner/qunit-redirect'] = true
+
   /* global suite */
 
+  const post = window['ui5-test-runner/post']
+
   const pages = []
 
   function jsUnitTestSuite () {}
 
   jsUnitTestSuite.prototype.addTestPage = function (url) {
-    if (!url.startsWith('/')) {
-      url = '/' + url
-    }
     pages.push(url)
   }
 
   window.jsUnitTestSuite = jsUnitTestSuite
 
   window.addEventListener('load', function () {
-    suite()
-    const xhr = new XMLHttpRequest()
-    xhr.open('POST', '/_/addTestPages')
-    xhr.send(JSON.stringify(pages))
+    if (typeof suite === 'function') {
+      suite()
+      post('addTestPages', pages)
+    } else if (typeof QUnit === 'object') {
+      post('addTestPages', [location.toString()])
+    } else {
+      post('addTestPages', []) // No page
+    }
   })
 }())

package/src/job-mode.js

@@ -0,0 +1,45 @@
+const { UTRError } = require('./error')
+const { $valueSources } = require('./symbols')
+
+function check (job, allowed, forbidden) {
+  const valueSources = job[$valueSources]
+  const incompatible = Object.keys(valueSources).filter(option => {
+    const source = valueSources[option]
+    return source === 'cli' && !option.startsWith('debug') &&
+    (
+      (allowed && !allowed.includes(option)) ||
+      (forbidden && forbidden.includes(option))
+    )
+  })
+  if (incompatible.length) {
+    throw UTRError.MODE_INCOMPATIBLE_OPTION(incompatible.join(','))
+  }
+}
+
+function buildAndCheckMode (job) {
+  if (job.capabilities) {
+    check(job, [
+      'capabilities',
+      'cwd',
+      'port',
+      'logServer',
+      'browser',
+      'parallel',
+      'reportDir',
+      'pageTimeout',
+      'browserCloseTimeout',
+      'failFast',
+      'keepAlive'
+    ])
+    return 'capabilities'
+  }
+  if (job.url && job.url.length) {
+    check(job, undefined, ['testsuite'])
+    return 'url'
+  }
+  return 'legacy'
+}
+
+module.exports = {
+  buildAndCheckMode
+}