polendina 1.1.1 → 2.0.0-alpha

package/test/test-mocha.js

@@ -1,78 +1,82 @@
 /* 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 mochaFixture = path.join(__dirname, 'fixtures/mocha')
-const mochaFailureFixture = path.join(__dirname, 'fixtures/mocha-failure')
+const __dirname = fileURLToPath(path.dirname(import.meta.url))
 
 function removeTimings (stdout) {
   return stdout.replace(/\(\d+ms\)/g, '(Xms)')
 }
 
-describe('basic mocha', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+for (const type of ['cjs', 'esm']) {
+  const mochaFixture = path.join(__dirname, `fixtures/mocha${type === 'esm' ? '-esm' : ''}`)
+  const mochaFailureFixture = path.join(__dirname, `fixtures/mocha-failure${type === 'esm' ? '-esm' : ''}`)
+
+  describe(`basic mocha (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
   test suite 1
-    ✓ test case 1
-    ✓ test case 2
+    ✅ test case 1
+    ✅ test case 2
 
   test suite 2 - worker
-    ✓ is WORKER
+    ✅ is WORKER
 
   test suite 3
-    ✓ test case 1
-    ✓ test case 2
+    ✅ test case 1
+    ✅ test case 2
 `
 
-  it('should run in page', async () => {
-    const { stdout, code } = await runCli(mochaFixture)
-    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 mocha page tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
-
-  it('should run in worker', async () => {
-    const { stdout, code } = await runCli(mochaFixture, '--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 mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should run in serviceworker', async () => {
-    const { stdout, code } = await runCli(mochaFixture, '--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 mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    it('should run in page', async () => {
+      const { stdout, code } = await runCli(mochaFixture)
+      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 mocha page tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
+
+    it('should run in worker', async () => {
+      const { stdout, code } = await runCli(mochaFixture, '--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 mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should run in serviceworker', async () => {
+      const { stdout, code } = await runCli(mochaFixture, '--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 mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should run in page, worker and serviceworker', async () => {
+      const { stdout, code } = await runCli(mochaFixture, '--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 mocha page 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 mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+
+      expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
   })
 
-  it('should run in page, worker and serviceworker', async () => {
-    const { stdout, code } = await runCli(mochaFixture, '--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 mocha page 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 mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-
-    expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-})
-
-describe('failing mocha', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+  describe(`failing mocha (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
   test suite 1 - worker
-    ✓ is WORKER
+    ✅ is WORKER
 
   test suite 2 - failing
     1) should fail
@@ -86,43 +90,44 @@ describe('failing mocha', function () {
      Error: failing test
 `
 
-  it('should fail in page', async () => {
-    let { stdout, code } = await runCli(mochaFailureFixture)
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = removeTimings(stdout)
-    const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running mocha page tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in worker', async () => {
-    let { stdout, code } = await runCli(mochaFailureFixture, '--worker --page=false')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = removeTimings(stdout)
-    const expected = expectedTemplate.replace(/WORKER/, 'in worker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in serviceworker', async () => {
-    let { stdout, code } = await runCli(mochaFailureFixture, '--serviceworker --page=false')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = removeTimings(stdout)
-    const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
-    assert.ok(stdout.includes(expected), 'stdout contains expected test output')
-    assert.ok(stdout.includes('Running mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in page and not run in worker', async () => {
-    let { stdout, code } = await runCli(mochaFailureFixture, '--worker')
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    stdout = removeTimings(stdout)
-    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 mocha page tests with Puppeteer'), 'stdout contains expected output for running in page')
-    assert.ok(!stdout.includes('Running mocha worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+    it('should fail in page', async () => {
+      let { stdout, code } = await runCli(mochaFailureFixture)
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = removeTimings(stdout)
+      const expected = expectedTemplate.replace(/WORKER/, 'not in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running mocha page tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in worker', async () => {
+      let { stdout, code } = await runCli(mochaFailureFixture, '--worker --page=false')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = removeTimings(stdout)
+      const expected = expectedTemplate.replace(/WORKER/, 'in worker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running mocha worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in serviceworker', async () => {
+      let { stdout, code } = await runCli(mochaFailureFixture, '--serviceworker --page=false')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = removeTimings(stdout)
+      const expected = expectedTemplate.replace(/WORKER/, 'in serviceworker')
+      assert.ok(stdout.includes(expected), 'stdout contains expected test output')
+      assert.ok(stdout.includes('Running mocha serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in page and not run in worker', async () => {
+      let { stdout, code } = await runCli(mochaFailureFixture, '--worker')
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      stdout = removeTimings(stdout)
+      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 mocha page tests with Puppeteer'), 'stdout contains expected output for running in page')
+      assert.ok(!stdout.includes('Running mocha worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+    })
   })
-})
+}

package/test/test-polendina-node.js

@@ -1,14 +1,13 @@
 /* globals describe it */
 
-const assert = require('assert')
-const path = require('path')
-const { runCommand } = require('./common')
-const cli = path.join(__dirname, '../polendina-node-cli.js')
+import assert from 'assert'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { runCommand } from './common.js'
+
+const __dirname = fileURLToPath(path.dirname(import.meta.url))
 
-const bareSyncFixture = path.join(__dirname, 'fixtures/bare-sync')
-const bareSyncFailureFixture = path.join(__dirname, 'fixtures/bare-sync-failure')
-const bareAsyncFixture = path.join(__dirname, 'fixtures/bare-async')
-const bareAsyncFailureFixture = path.join(__dirname, 'fixtures/bare-async-failure')
+const cli = path.join(__dirname, '../polendina-node-cli.js')
 
 function runCli (mode, cwd) {
   return runCommand(`${cli} ${mode} test*.js`, cwd)
@@ -18,40 +17,46 @@ function removeTiming (stdout) {
   return stdout.replace(/Took [\d.]+ seconds/, 'Took X seconds')
 }
 
-describe('polendina-node bare-sync', function () {
-  this.timeout(20000)
-  it('pass', async () => {
-    const expected =
+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' : ''}`)
+  const bareAsyncFixture = path.join(__dirname, `fixtures/bare-async${type === 'esm' ? '-esm' : ''}`)
+  const bareAsyncFailureFixture = path.join(__dirname, `fixtures/bare-async-failure${type === 'esm' ? '-esm' : ''}`)
+
+  describe(`polendina-node bare-sync (${type})`, function () {
+    this.timeout(20000)
+    it('pass', async () => {
+      const expected =
 `testing is not in worker
   ✔ test-1.js
 testing bare fixture
   ✔ test-2.js
 Took X seconds
 `
-    const { stdout, code } = await runCli('bare-sync', bareSyncFixture)
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    assert.strictEqual(removeTiming(stdout), expected)
-  })
+      const { stdout, code } = await runCli('bare-sync', bareSyncFixture)
+      assert.strictEqual(code, 0, 'exited with zero exit code')
+      assert.strictEqual(removeTiming(stdout), expected)
+    })
 
-  it('failure', async () => {
-    const expected =
+    it('failure', async () => {
+      const expected =
 `testing is not in worker
   ✔ test-1.js
 testing bare fixture
   ✘ test-2.js
 Took X seconds
 `
-    const { stdout, stderr, code } = await runCli('bare-sync', bareSyncFailureFixture)
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    assert.strictEqual(removeTiming(stdout), expected)
-    assert.ok(stderr.includes('AssertionError [ERR_ASSERTION]: \'nope\' != \'faily mcfailface\''), 'stderr contains expected output')
+      const { stdout, stderr, code } = await runCli('bare-sync', bareSyncFailureFixture)
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      assert.strictEqual(removeTiming(stdout), expected)
+      assert.ok(stderr.includes('AssertionError: faily mcfailface'), 'stderr contains expected output')
+    })
   })
-})
 
-describe('polendina-node bare-async', function () {
-  this.timeout(20000)
-  it('pass', async () => {
-    const expected =
+  describe(`polendina-node bare-async (${type})`, function () {
+    this.timeout(20000)
+    it('pass', async () => {
+      const expected =
 `testing is not in worker
   ✔ test-1.js
   test-2.js
@@ -60,13 +65,13 @@ testing bare fixture
     ✔ test2
 Took X seconds
 `
-    const { stdout, code } = await runCli('bare-async', bareAsyncFixture)
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    assert.strictEqual(removeTiming(stdout), expected)
-  })
+      const { stdout, code } = await runCli('bare-async', bareAsyncFixture)
+      assert.strictEqual(code, 0, 'exited with zero exit code')
+      assert.strictEqual(removeTiming(stdout), expected)
+    })
 
-  it('failure', async () => {
-    const expected =
+    it('failure', async () => {
+      const expected =
 `testing is not in worker
   ✔ test-1.js
   test-2.js
@@ -75,9 +80,10 @@ testing bare fixture
     ✘ test2
 Took X seconds
 `
-    const { stdout, stderr, code } = await runCli('bare-async', bareAsyncFailureFixture)
-    assert.strictEqual(code, 1, 'exited with non-zero exit code')
-    assert.strictEqual(removeTiming(stdout), expected)
-    assert.ok(stderr.includes('AssertionError [ERR_ASSERTION]: \'nope\' != \'faily mcfailface\''), 'stderr contains expected output')
+      const { stdout, stderr, code } = await runCli('bare-async', bareAsyncFailureFixture)
+      assert.strictEqual(code, 1, 'exited with non-zero exit code')
+      assert.strictEqual(removeTiming(stdout), expected)
+      assert.ok(stderr.includes('AssertionError: faily mcfailface'), 'stderr contains expected output')
+    })
   })
-})
+}

package/test/test-tape.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 tapeFixture = path.join(__dirname, 'fixtures/tape')
-const tapeFailureFixture = path.join(__dirname, 'fixtures/tape-failure')
+const __dirname = fileURLToPath(path.dirname(import.meta.url))
 
-describe('basic tape', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+for (const type of ['cjs', 'esm']) {
+  const tapeFixture = path.join(__dirname, `fixtures/tape${type === 'esm' ? '-esm' : ''}`)
+  const tapeFailureFixture = path.join(__dirname, `fixtures/tape-failure${type === 'esm' ? '-esm' : ''}`)
+
+  describe(`basic tape (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 TAP version 13
 # test suite 1
 # test case 1
@@ -32,51 +36,51 @@ ok 5 all good
 # ok
 `
 
-  it('should run in page', async () => {
-    const { stdout, code } = await runCli(tapeFixture, '--runner=tape')
-    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 tape page tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
-
-  it('should run in worker', async () => {
-    const { stdout, code } = await runCli(tapeFixture, '--runner=tape --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 tape worker tests with Puppeteer'), 'stdout contains expected output for running in page')
-  })
-
-  it('should run in serviceworker', async () => {
-    const { stdout, code } = await runCli(tapeFixture, '--runner=tape --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 tape 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(tapeFixture, '--runner=tape --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 tape 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 tape 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 tape serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    it('should run in page', async () => {
+      const { stdout, code } = await runCli(tapeFixture, '--runner=tape')
+      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 tape page tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
+
+    it('should run in worker', async () => {
+      const { stdout, code } = await runCli(tapeFixture, '--runner=tape --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 tape worker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
+
+    it('should run in serviceworker', async () => {
+      const { stdout, code } = await runCli(tapeFixture, '--runner=tape --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 tape 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(tapeFixture, '--runner=tape --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 tape 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 tape 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 tape serviceworker tests with Puppeteer'), 'stdout contains expected output for running in page')
+    })
   })
-})
 
-describe('failing tape', function () {
-  this.timeout(20000)
-  const expectedTemplate = `
+  describe(`failing tape (${type})`, function () {
+    this.timeout(20000)
+    const expectedTemplate = `
 TAP version 13
 # test suite 1 - worker
 # is WORKER
@@ -96,43 +100,44 @@ not ok 2 bork
 # fail  1
 `
 
-  it('should fail in page', async () => {
-    let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape')
-    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 tape page tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in worker', async () => {
-    let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in serviceworker', async () => {
-    let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
-  })
-
-  it('should fail in page and not run in worker', async () => {
-    let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape page tests with Puppeteer'), 'stdout contains expected output for running in page')
-    assert.ok(!stdout.includes('Running tape worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+    it('should fail in page', async () => {
+      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape')
+      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 tape page tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in worker', async () => {
+      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape worker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in serviceworker', async () => {
+      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape serviceworker tests with Puppeteer'), 'stdout contains expected output for running in worker')
+    })
+
+    it('should fail in page and not run in worker', async () => {
+      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --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 tape page tests with Puppeteer'), 'stdout contains expected output for running in page')
+      assert.ok(!stdout.includes('Running tape worker tests with Puppeteer'), 'stdout doesn\'t contain expected output for running in worker')
+    })
   })
-})
+}

package/test/test-webpack-merge.js

@@ -1,33 +1,35 @@
 /* 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 __dirname = fileURLToPath(path.dirname(import.meta.url))
 const webpackMergeFixture = path.join(__dirname, 'fixtures/webpack-merge')
 
 describe('basic webpack-merge', function () {
   this.timeout(20000)
-  it('should run plain', async () => {
+  it('should run with a custom config', async () => {
     const expected = `
 assert.ok() is a function
-querystring.parse() is a function
+WOOP is set
   ✔ test.js
 `
-    const { stdout, code } = await runCli(webpackMergeFixture, '--runner=bare-sync')
+    const { stdout, code } = await runCli(webpackMergeFixture, '--runner=bare-sync --webpack-config webpack.config.js')
     assert.strictEqual(code, 0, 'exited with zero exit code')
     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 fail with custom config', async () => {
+  it('should fail without a custom config', async () => {
     const expectedStdout = `
 assert.ok() is a function
   ✘ test.js
 `
-    const expectedStderr = '\'undefined\' === \'function\''
+    const expectedStderr = 'WOOP is not defined'
 
-    const { stdout, stderr, code } = await runCli(webpackMergeFixture, '--runner=bare-sync --webpack-config webpack.config.js')
+    const { stdout, stderr, code } = await runCli(webpackMergeFixture, '--runner=bare-sync')
     assert.strictEqual(code, 1, 'exited with zero exit code')
     assert.ok(stdout.includes(expectedStdout), 'stdout contains expected test output')
     assert.ok(stderr.includes(expectedStderr), 'stderr contains expected test output')

package/CHANGELOG.md

@@ -1,11 +0,0 @@
-### [1.1.1](https://github.com/rvagg/polendina/compare/v1.1.0...v1.1.1) (2021-12-07)
-
-
-### Bug Fixes
-
-* no build step for release ([b91faf0](https://github.com/rvagg/polendina/commit/b91faf08395e6f8bc44b21d02d94c2136bcac942))
-
-
-### Trivial Changes
-
-* add auto-releases ([#17](https://github.com/rvagg/polendina/issues/17)) ([9e71246](https://github.com/rvagg/polendina/commit/9e71246667ba96d8253aa180271728b35e700b45))

package/test/fixtures/mocha8/index.js

@@ -1 +0,0 @@
-module.exports = 'polendina test'