polendina 1.0.0 → 2.0.0-alpha

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')
+    })
   })
-})
+}

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')
+    })
   })
-})
+}