polendina 1.1.1 → 2.0.0-alpha

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

@@ -0,0 +1,47 @@
+/* globals WorkerGlobalScope ServiceWorkerGlobalScope */
+
+import tape from 'tape'
+import fixture from './index.js'
+
+tape('test suite 1', (t) => {
+  t.test('test case 1', (t) => {
+    t.strictEqual(fixture, 'polendina test')
+    t.end()
+  })
+
+  t.test('test case 2', (t) => {
+    t.ok(true, 'all good')
+    t.end()
+  })
+})
+
+tape('test suite 2 - 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 3', (t) => {
+  t.test('test case 1', (t) => {
+    t.strictEqual(fixture, 'polendina test')
+    t.end()
+  })
+
+  t.test('test case 2', (t) => {
+    t.ok(true, 'all good')
+    t.end()
+  })
+})

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

@@ -13,6 +13,6 @@
     "url": "https://github.com/rvagg/polendina.git"
   },
   "devDependencies": {
-    "tape": "^5.0.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')
+    })
   })
-})
+}

package/test/test-bare-sync.js

@@ -1,114 +1,119 @@
 /* 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-sync')
-const bareSyncFailureFixture = path.join(__dirname, 'fixtures/bare-sync-failure')
+const __dirname = fileURLToPath(path.dirname(import.meta.url))
 
-describe('basic bare-sync', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+for (const type of ['cjs', 'esm']) {
+  const bareSyncFixture = path.join(__dirname, `fixtures/bare-sync${type === 'esm' ? '-esm' : ''}`)
+  const bareSyncFailureFixture = path.join(__dirname, `fixtures/bare-sync-failure${type === 'esm' ? '-esm' : ''}`)
+
+  describe(`basic bare-sync (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 testing is WORKER
   ✔ test-1.js
 testing bare fixture
   ✔ test-2.js
 `
 
-  it('should run in page', async () => {
-    const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-sync')
-    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-sync page tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
+    it('should run in page', async () => {
+      const { stdout, code } = await runCli(bareSyncFixture, '--runner=bare-sync')
+      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-sync 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-sync --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-sync worker 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-sync --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-sync 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-sync --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-sync serviceworker 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-sync --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-sync 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-sync --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(bareSyncFixture, '--runner=bare-sync --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-sync 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-sync 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-sync 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-sync 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-sync 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-sync serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
   })
-})
 
-describe('failing bare-sync', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+  describe(`failing bare-sync (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 testing is WORKER
   ✔ test-1.js
 testing bare fixture
   ✘ test-2.js
 `
-  const expectedStderr = 'AssertionError: \'nope\' undefined \'faily mcfailface\''
-
-  it('should fail in page', async () => {
-    let { stdout, stderr, code } = await runCli(bareSyncFailureFixture, '--runner=bare-sync')
-    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-sync 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-sync --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-sync 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(bareSyncFailureFixture, '--runner=bare-sync')
+      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-sync 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-sync --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-sync 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(bareSyncFailureFixture, '--runner=bare-sync --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-sync 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(bareSyncFailureFixture, '--runner=bare-sync --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-sync 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-sync --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-sync page tests with Puppeteer'), 'stdout contains expected output for running in page')
-    assert.ok(!stdout.includes('Running bare-sync 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(bareSyncFailureFixture, '--runner=bare-sync --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-sync page tests with Puppeteer'), 'stdout contains expected output for running in page')
+      assert.ok(!stdout.includes('Running bare-sync worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+      assert.ok(stderr.includes(expectedStderr), 'stderr contains expected output')
+    })
   })
-})
+}