polendina 1.0.1 → 2.0.0-alpha2

package/test/fixtures/tape-failure/build/common-run.js

@@ -0,0 +1,108 @@
+/* globals WorkerGlobalScope ServiceWorkerGlobalScope clients */
+
+import { registry } from './test-registry.js'
+
+const inPage =
+  typeof window !== 'undefined' &&
+  window.location &&
+  typeof WorkerGlobalScope === 'undefined'
+const inServiceWorker = !inPage &&
+  typeof ServiceWorkerGlobalScope !== 'undefined' &&
+  globalThis instanceof ServiceWorkerGlobalScope
+const inWorker = !inPage && !inServiceWorker &&
+  typeof WorkerGlobalScope !== 'undefined' &&
+  globalThis instanceof WorkerGlobalScope
+let _executionQueue = Promise.resolve()
+
+export { registry }
+export function executionQueue (fn) {
+  _executionQueue = _executionQueue.then(fn)
+  return _executionQueue
+}
+
+export const log = {
+  info: (...args) => {
+    executionQueue(() => globalThis.polendinaLog(['info'].concat(args)))
+    return executionQueue
+  },
+  // TODO
+  warn: (...args) => {
+    executionQueue(() => globalThis.polendinaLog(['warn'].concat(args)))
+    return executionQueue
+  },
+  // TODO
+  error: (...args) => {
+    executionQueue(() => globalThis.polendinaLog(['error'].concat(args)))
+    return executionQueue
+  }
+}
+
+function setupWorkerGlobals () {
+  globalThis.polendinaLog = async function (...args) {
+    globalThis.postMessage(['polendinaLog'].concat(args))
+  }
+
+  globalThis.polendinaWrite = async function (...args) {
+    globalThis.postMessage(['polendinaWrite'].concat(args))
+  }
+
+  globalThis.polendinaEnd = async function (...args) {
+    globalThis.postMessage(['polendinaEnd'].concat(args))
+  }
+}
+
+function setupServiceWorkerGlobals () {
+  async function _postMessage (msg) {
+    for (const client of await clients.matchAll()) {
+      client.postMessage(msg)
+    }
+  }
+
+  globalThis.polendinaLog = async function (...args) {
+    _postMessage(['polendinaLog'].concat(args))
+  }
+
+  globalThis.polendinaWrite = async function (...args) {
+    _postMessage(['polendinaWrite'].concat(args))
+  }
+
+  globalThis.polendinaEnd = async function (...args) {
+    _postMessage(['polendinaEnd'].concat(args))
+  }
+}
+
+function setupLogging () {
+  console.log = function (...args) {
+    try {
+      if (/BrowserStdout.*write/.test(new Error().stack)) {
+        // the BrowserStdout polyfill (Mocha ships with among others) that converts
+        // process.stdout.write() to console.log()
+        // so we strip out the extra \n that necessarily inserts
+        // args[0] = args[0].replace(/\n$/, '')
+        executionQueue(() => globalThis.polendinaWrite(args))
+        return
+      }
+    } catch (err) {}
+    log.info.apply(null, args)
+  }
+
+  // TODO: differentiate
+  console.warn = log.warn
+  console.error = log.error
+}
+
+export async function setup () {
+  if (inWorker) {
+    setupWorkerGlobals()
+  } else if (inServiceWorker) {
+    await new Promise((resolve, reject) => {
+      globalThis.addEventListener('activate', (event) => {
+        event.waitUntil(globalThis.clients.claim())
+        setupServiceWorkerGlobals()
+        resolve()
+      })
+    })
+  }
+
+  setupLogging()
+}

package/test/fixtures/tape-failure/build/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Tests</title>
+  </head>
+  <body>
+    <script src="page-run.js"></script>
+  </body>
+</html>

package/test/fixtures/tape-failure/build/page-run.js

@@ -0,0 +1,46 @@
+/* globals self Worker */
+
+// loaded as script file in index.html, determines how to load the bundle
+
+const isWorkerMode = /mode=worker/.test(window.location.search)
+const isServiceWorkerMode = /mode=serviceworker/.test(window.location.search)
+const _consoleLog = console ? console.log : () => {}
+
+function runPage () {
+  const script = document.createElement('script')
+  script.type = 'text/javascript'
+  script.src = 'bundle.js'
+  document.head.appendChild(script)
+}
+
+function onWorkerMessage (msg) {
+  if (!Array.isArray(msg.data)) {
+    return
+  }
+
+  if (!self[msg.data[0]]) {
+    _consoleLog.apply(console, msg.data)
+  } else {
+    self[msg.data[0]].apply(null, msg.data.slice(1))
+  }
+}
+
+function runWorker () {
+  const worker = new Worker('bundle.js')
+  worker.addEventListener('message', onWorkerMessage, false)
+}
+
+function runServiceWorker () {
+  navigator.serviceWorker.register('bundle.js', { scope: './' })
+  navigator.serviceWorker.addEventListener('message', onWorkerMessage, false)
+}
+
+window.addEventListener('load', () => {
+  if (isWorkerMode) {
+    runWorker()
+  } else if (isServiceWorkerMode) {
+    runServiceWorker()
+  } else {
+    runPage()
+  }
+})

package/test/fixtures/tape-failure/build/tape-run.js

@@ -0,0 +1,39 @@
+// in-browser setup and runner for Tape, at end of bundle
+
+import tape from 'tape'
+import { registry, setup, executionQueue } from './common-run.js'
+import { Transform } from 'stream'
+
+function runTape () {
+  let failures = 0
+
+  const stream = new Transform({
+    transform (chunk, encoding, callback) {
+      executionQueue(() => {
+        globalThis.polendinaWrite(chunk.toString())
+          .catch(callback)
+          .then(callback)
+      })
+    },
+
+    flush (callback) {
+      executionQueue(() => {
+        globalThis.polendinaEnd(failures)
+          .catch(callback)
+          .then(callback)
+      })
+    }
+  })
+
+  tape.getHarness({ stream })
+
+  tape.getHarness().onFailure((...args) => {
+    failures = 1
+  })
+
+  for (const mod of registry.tests) {
+    mod.load()
+  }
+}
+
+setup().then(runTape)

package/test/fixtures/tape-failure/build/test-registry.js

@@ -0,0 +1,6 @@
+// see wrap-loader.js
+
+export const registry = {
+  argv: null,
+  tests: []
+}

package/test/fixtures/tape-failure/package.json

@@ -13,6 +13,6 @@
     "url": "https://github.com/rvagg/polendina.git"
   },
   "devDependencies": {
-    "tape": "^4.12.1"
+    "tape": "~5.0.1"
   }
 }

package/test/fixtures/tape-failure-esm/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "fixture-tape-failure",
+  "version": "1.0.0",
+  "description": "test fixture",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "tape test.js"
+  },
+  "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rvagg/polendina.git"
+  },
+  "devDependencies": {
+    "tape": "~5.0.1"
+  }
+}

package/test/fixtures/tape-failure-esm/test.js

@@ -0,0 +1,29 @@
+/* globals WorkerGlobalScope ServiceWorkerGlobalScope */
+
+import tape from 'tape'
+
+tape('test suite 1 - worker', (t) => {
+  if (typeof ServiceWorkerGlobalScope !== 'undefined' && global instanceof ServiceWorkerGlobalScope) {
+    t.test('is in serviceworker', (t) => {
+      t.strictEqual(typeof ServiceWorkerGlobalScope, 'function')
+      t.end()
+    })
+  } else if (typeof WorkerGlobalScope !== 'undefined' && global instanceof WorkerGlobalScope) {
+    t.test('is in worker', (t) => {
+      t.strictEqual(typeof WorkerGlobalScope, 'function')
+      t.end()
+    })
+  } else {
+    t.test('is not in worker', (t) => {
+      t.strictEqual(typeof WorkerGlobalScope, 'undefined')
+      t.end()
+    })
+  }
+})
+
+tape('test suite 2 - failure', (t) => {
+  t.test('test case 1', (t) => {
+    t.fail('bork')
+    t.end()
+  })
+})

package/test/fixtures/webpack-merge/package.json

@@ -11,5 +11,8 @@
     "type": "git",
     "url": "https://github.com/rvagg/polendina.git"
   },
-  "license": "Apache-2.0"
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "chai": "^4.3.4"
+  }
 }

package/test/fixtures/webpack-merge/test.js

@@ -1,7 +1,6 @@
-const assert = require('assert')
-const qs = require('querystring')
+const { assert } = require('chai')
 
 assert.strictEqual(typeof assert.ok, 'function')
 console.log('assert.ok() is a function')
-assert.strictEqual(typeof qs.parse, 'function')
-console.log('querystring.parse() is a function')
+assert.strictEqual(WOOP, 'woop') // eslint-disable-line
+console.log('WOOP is set')

package/test/fixtures/webpack-merge/webpack.config.js

@@ -1,5 +1,5 @@
+const webpack = require('webpack')
+
 module.exports = {
-  node: {
-    querystring: 'empty'
-  }
+  plugins: [new webpack.DefinePlugin({ WOOP: '"woop"' })]
 }

package/test/test-bare-async.js

@@ -1,15 +1,19 @@
 /* globals describe it */
 
-const assert = require('assert')
-const path = require('path')
-const { runCli } = require('./common')
+import assert from 'assert'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { runCli } from './common.js'
 
-const bareSyncFixture = path.join(__dirname, 'fixtures/bare-async')
-const bareSyncFailureFixture = path.join(__dirname, 'fixtures/bare-async-failure')
+const __dirname = fileURLToPath(path.dirname(import.meta.url))
 
-describe('basic bare-async', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+for (const type of ['cjs', 'esm']) {
+  const bareAsyncFixture = path.join(__dirname, `fixtures/bare-async${type === 'esm' ? '-esm' : ''}`)
+  const bareAsyncFailureFixture = path.join(__dirname, `fixtures/bare-async-failure${type === 'esm' ? '-esm' : ''}`)
+
+  describe(`basic bare-async (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 testing is WORKER
   ✔ test-1.js
   test-2.js
@@ -18,51 +22,51 @@ testing bare fixture
     ✔ test2
 `
 
-  it('should run in page', async () => {
-    const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-async')
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
+    it('should run in page', async () => {
+      const { stdout, code } = await runCli(bareAsyncFixture, '--runner=bare-async')
+      assert.strictEqual(code, 0, 'exited with zero exit code')
+      const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
 
-  it('should run in worker', async () => {
-    const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-async --worker --page=false')
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    const expected = expectedTemplate.replace(/WORKER/, 'in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
+    it('should run in worker', async () => {
+      const { stdout, code } = await runCli(bareAsyncFixture, '--runner=bare-async --worker --page=false')
+      assert.strictEqual(code, 0, 'exited with zero exit code')
+      const expected = expectedTemplate.replace(/WORKER/, 'in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
 
-  it('should run in serviceworker', async () => {
-    const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-async --serviceworker --page=false')
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
+    it('should run in serviceworker', async () => {
+      const { stdout, code } = await runCli(bareAsyncFixture, '--runner=bare-async --serviceworker --page=false')
+      assert.strictEqual(code, 0, 'exited with zero exit code')
+      const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
 
-  it('should run in page, worker and serviceworker', async () => {
-    const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-async --worker --serviceworker')
-    assert.strictEqual(code, 0, 'exited with zero exit code')
+    it('should run in page, worker and serviceworker', async () => {
+      const { stdout, code } = await runCli(bareAsyncFixture, '--runner=bare-async --worker --serviceworker')
+      assert.strictEqual(code, 0, 'exited with zero exit code')
 
-    let expected = expectedTemplate.replace(/WORKER/, 'not in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+      let expected = expectedTemplate.replace(/WORKER/, 'not in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
 
-    expected = expectedTemplate.replace(/WORKER/, 'in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+      expected = expectedTemplate.replace(/WORKER/, 'in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
 
-    expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+      expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
   })
-})
 
-describe('failing bare-async', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+  describe(`failing bare-async (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 testing is WORKER
   ✔ test-1.js
   test-2.js
@@ -70,49 +74,50 @@ testing bare fixture
     ✔ test1
     ✘ test2
 `
-  const expectedStderr = 'AssertionError: \'nope\' undefined \'faily mcfailface\''
-
-  it('should fail in page', async () => {
-    let { stdout, stderr, code } = await runCli(bareSyncFailureFixture, '--runner=bare-async')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
-    const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in worker')
-    assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
-  })
+    const expectedStderr = 'AssertionError: faily mcfailface'
 
-  it('should fail in worker', async () => {
-    let { stdout, stderr, code } = await runCli(bareSyncFailureFixture, '--runner=bare-async --worker --page=false')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
-    const expected = expectedTemplate.replace(/WORKER/, 'in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-    assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
-  })
+    it('should fail in page', async () => {
+      let { stdout, stderr, code } = await runCli(bareAsyncFailureFixture, '--runner=bare-async')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
+      const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in worker')
+      assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    })
 
-  it('should fail in serviceworker', async () => {
-    let { stdout, stderr, code } = await runCli(bareSyncFailureFixture, '--runner=bare-async --serviceworker --page=false')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
-    const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-    assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
-  })
+    it('should fail in worker', async () => {
+      let { stdout, stderr, code } = await runCli(bareAsyncFailureFixture, '--runner=bare-async --worker --page=false')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
+      const expected = expectedTemplate.replace(/WORKER/, 'in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+      assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    })
+
+    it('should fail in serviceworker', async () => {
+      let { stdout, stderr, code } = await runCli(bareAsyncFailureFixture, '--runner=bare-async --serviceworker --page=false')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
+      const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running bare-async serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+      assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    })
 
-  it('should fail in page and not run in worker', async () => {
-    let { stdout, stderr, code } = await runCli(bareSyncFailureFixture, '--runner=bare-async --worker')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
-    const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
-    let found = stdout.indexOf(expected)
-    assert.ok(found > -1, 'stdout contains expected test output')
-    found = stdout.indexOf(expected, found + 1)
-    assert.ok(found === -1, 'stdout doesn\'t contain second instance of expected test output')
-    assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in page')
-    assert.ok(!stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
-    assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    it('should fail in page and not run in worker', async () => {
+      let { stdout, stderr, code } = await runCli(bareAsyncFailureFixture, '--runner=bare-async --worker')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = stdout.replace(/^ +at .*\n/gm, '') // stack traces
+      const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
+      let found = stdout.indexOf(expected)
+      assert.ok(found > -1, 'stdout contains expected test output')
+      found = stdout.indexOf(expected, found + 1)
+      assert.ok(found === -1, 'stdout doesn\'t contain second instance of expected test output')
+      assert.ok(stdout.includes('Running bare-async page tests with Puppeteer'), 'stdout contains expected output for running in page')
+      assert.ok(!stdout.includes('Running bare-async worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+      assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    })
   })
-})
+}