polendina 3.3.2 → 3.3.4

package/.github/dependabot.yml

@@ -17,138 +17,9 @@ updates:
       include: 'scope'
 
   - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-async'
+    directory: '/test/consumer'
     schedule:
       interval: 'daily'
     commit-message:
       prefix: 'chore'
       include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-async-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-async-failure'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-async-failure-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-sync'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-sync-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-sync-failure'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/bare-sync-failure-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/mocha'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/mocha-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/mocha-failure'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/mocha-failure-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/tape'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/tape-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/tape-failure'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/tape-failure-esm'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-
-  - package-ecosystem: 'npm'
-    directory: '/test/fixtures/webpack-merge'
-    schedule:
-      interval: 'daily'
-    commit-message:
-      prefix: 'chore'
-      include: 'scope'
-

package/.github/workflows/test-and-release.yml

@@ -19,9 +19,7 @@ jobs:
         run: |
           npm install --no-progress
       - name: Run tests
-        run: |
-          npm config set script-shell bash
-          npm test
+        run: npm test
   release:
     name: Release
     needs: test

package/AGENTS.md

@@ -65,6 +65,9 @@ Real usage, in increasing order of involvement. Each shape must keep working:
 - `polendina --runner=bare-async test/test.js` paired with
   `polendina-node bare-async test/test.js`. The same files run in Node.js and
   the browser with no test framework at all.
+- `import hex from '!!raw-loader!./fixtures/block.hex'` inside a test to read a
+  fixture as a string. Binary and hex fixture suites do this, declaring no
+  loader of their own.
 - `polendina --cleanup --webpack-config test/webpack.config.js test/test-*.js`
   where the config is `export default { externals: { standard: 'null' } }`.
   `js-ipld-schema` does this to stop webpack bundling a Node-only
@@ -102,8 +105,9 @@ Files:
   `index.html` and `page-run.js` are served static. `common-run.js`,
   `test-registry.cjs` and one of `mocha-run.js`, `tape-run.js`, `bare-run.js`
   are bundled as the last entry.
-- `test/` runs the CLI against `test/fixtures/*`, one real standalone package
-  per runner, in CJS and ESM, passing and failing.
+- `test/` packs polendina, installs it into temporary consumers outside the
+  repo, one per runner, and runs the CLI against `test/fixtures/*` from
+  inside them, one fixture per runner, in CJS and ESM, passing and failing.
 
 ### The deferral trick
 
@@ -132,9 +136,13 @@ believing it.
 
 Things that look wrong and are not. Each exists because something broke.
 
-- **`resolve.modules` and `resolveLoader.modules` list `process.cwd()` first,
-  polendina's `node_modules` second.** The consumer's mocha, tape and chai must
-  win. polendina has no mocha or tape in its own tree, on purpose.
+- **`resolve.modules` and `resolveLoader.modules` list the relative
+  `node_modules` first, polendina's own `node_modules` second.** The relative
+  entry walks up from the requesting file as Node does, so the consumer's
+  mocha, tape and chai win and hoisted or nested dependencies resolve from a
+  workspace package or any subdirectory. An absolute `cwd/node_modules` here
+  does not walk and breaks both. polendina has no mocha or tape in its own
+  tree, on purpose.
 - **Tape gets `resolve.fallback` for `stream` and `path`, `fs: false`, and
   `ProvidePlugin({ process })`.** Webpack 5 dropped Node core polyfills.
   Mocha's browser bundle is self-contained; tape's is not. `process`,
@@ -144,8 +152,13 @@ Things that look wrong and are not. Each exists because something broke.
   `polendina/node_modules` directory.
 - **`import 'mocha/mocha.js'` for side effect, then `globalThis.mocha`.**
   Mocha 11 ships UMD, 12 ships ESM. The global is the common denominator.
-  Both are supported at once. The `color()` / `useColors()` branch is the
-  same idea for older mochas.
+  Both are supported at once.
+- **`raw-loader` is a dependency that no polendina source references.**
+  Consumers load fixture files as text with
+  `import hex from '!!raw-loader!./fixtures/block.hex'` and declare nothing; the
+  loader resolves from polendina's tree through `resolveLoader.modules`. The
+  mocha fixtures assert it. Removing it or the second `resolveLoader` entry
+  breaks those consumers.
 - **`exprContextCritical: false`.** Mocha's bundle has a dynamic
   `require.resolve`; without this every run prints a webpack warning.
 - **`resolve.tsconfig: false`.** Webpack 5.109+ on Node 22.6+ follows a
@@ -155,9 +168,8 @@ Things that look wrong and are not. Each exists because something broke.
   forward-slashed.** Tests in subdirectories and Windows paths both broke the
   cwd-relative version. Three separate fixes landed here. Paths in
   `wrap-loader.cjs` are the most common regression site in the repo.
-- **`puppeteer.launch({ args: ['--no-sandbox'], headless: 'new' })`.**
-  `--no-sandbox` for root in Docker and CI. `'new'` was a Puppeteer 20
-  deprecation fix and is itself a candidate for removal on current Puppeteer.
+- **`puppeteer.launch({ args: ['--no-sandbox'] })`.** `--no-sandbox` for
+  root in Docker and CI. Headless is Puppeteer's default and is not named.
 - **`st({ cache: false })`.** A stale cached bundle between page, worker and
   serviceworker runs on Windows.
 - **`setTimeout(...).unref()` for `--timeout`.** A clean finish must not be
@@ -167,12 +179,22 @@ Things that look wrong and are not. Each exists because something broke.
   enumeration would otherwise see the wrong keys.
 - **`polendina-cli` exits with the mocha failure count; `polendina-node` exits
   0 or 1.** The first matches mocha's own behaviour. Keep both.
-- **`test:install` is a bash loop that `npm i`s every fixture with
-  `--no-package-lock`, and CI sets `script-shell bash` for Windows.** Each
-  fixture is a real package with its own devDependencies so the suite proves
-  fence one. mocha and tape must never become devDependencies of the root
-  package: they would land in polendina's `node_modules` and silently mask a
-  broken consumer resolve. `test:run` uses `npx mocha` for the same reason.
+- **The test frameworks live in `test/consumer/package.json`, not the root
+  package, and `test:run` uses `npx --yes mocha`.** mocha and tape must never
+  become devDependencies of the root package: they would land in polendina's
+  `node_modules` and silently mask a broken consumer resolve. That file is
+  the one place dependabot bumps them; it is never installed as is. The flag,
+  not an `npm_config_yes=` prefix, because npm scripts run under cmd.exe on
+  Windows and a `VAR=value` prefix is not a command there.
+- **One consumer per runner, never one consumer with every framework.** Tape
+  and polendina both depend on `readable-stream`. Installed together with
+  mocha, npm nests whichever versions clash and the fixtures run on a tree no
+  real consumer has. Each consumer installs only what its runner's fixtures
+  import.
+- **Fixture `package.json` files declare only a name and, for ESM, a
+  `type`.** Their dependencies come from the consumer they are copied into.
+  The webpack-merge fixture's config `require('webpack')` finds the hoisted
+  copy there, as a real consumer's would.
 - **`test/common.js` asserts empty stderr on success and always passes
   `--cleanup`.** Any stray warning is a test failure. Fixtures stay clean
   between runs only because of the flag.
@@ -212,14 +234,23 @@ green matrix is a Node.js interop issue, not a flaky test.
 ## Testing polendina itself
 
 ```bash
-npm test                     # lint, install fixtures, run the matrix (slow)
-npm run test:install         # once, after a fixture package.json changes
-npx mocha test/test-mocha.js # one runner's suite
-npx mocha test/test-packed-install.js   # the real install layout, needs a warm npm cache
-cd test/fixtures/mocha && ../../../polendina-cli.js --cleanup test-*.js   # by hand
-cd test/fixtures/mocha && ../../../polendina-cli.js test-*.js --stats     # keep build/ to inspect
+npm test                                                  # lint and the whole matrix
+npx mocha --require test/setup.js test/test-mocha.js      # one runner's suite
+POLENDINA_KEEP_CONSUMERS=1 npx mocha --require test/setup.js test/test-tape.js   # keep the consumers to poke at
+cd test/fixtures/mocha && ../../../polendina-cli.js test-*.js --stats     # by hand, in-repo layout, keep build/
 ```
 
+`test/setup.js` is a mocha global fixture. It packs the working tree, writes
+a `package.json` per consumer, installs the tarball with that consumer's
+frameworks into a temporary directory, copies `test/fixtures` in, and removes
+everything afterwards. Its `variants` table maps a consumer name to the
+packages it installs: `mocha` and `bare` take chai, `tape` takes tape,
+`mocha11` pins the previous mocha major. Bare names take their version range
+from `test/consumer/package.json`. Each suite names the consumer it runs in
+when it calls `runCli`. The installs run in parallel from the npm cache with
+the Chrome that puppeteer already downloaded for the root install, so they
+need a warm cache and take well under a minute.
+
 ### Install topologies
 
 polendina resolves modules two ways at once: Node resolution for its own
@@ -230,30 +261,34 @@ test setup covers all three cases.
 
 | Topology | polendina's own `node_modules` | What it hides |
 |----------|-------------------------------|---------------|
-| Fixtures in this repo | The dev tree, two directories up | Fixtures can walk up and find polendina's dev dependencies. A missing fixture dependency, or any package added to the root, is silently masked. This is why mocha and tape must never be root dependencies. |
+| Fixtures run in this repo by hand | The dev tree, two directories up | Fixtures can walk up and find polendina's dev dependencies. A missing dependency, or any package added to the root, is silently masked. Fine for poking at a bundle, proves nothing about resolution. |
 | Symlinked working copy in a consumer | polendina's own full tree, separate from the consumer's | Two complete trees, no hoisting, no version contention. Cleaner than any real install. Will not reproduce a hoisting break. |
-| Published install in a consumer | Mostly absent: dependencies are hoisted into the consumer's flat tree | Anything that assumes a file exists under `polendina/node_modules/` breaks. Version conflicts between polendina's dependencies and the consumer's resolve by npm nesting and are then found by `resolve.modules` in whichever order npm left them. This is reality. |
+| Published install in a consumer | Mostly absent: dependencies are hoisted into the consumer's flat tree | Anything that assumes a file exists under `polendina/node_modules/` breaks. Version conflicts between polendina's dependencies and the consumer's resolve by npm nesting and are then found by `resolve.modules` in whichever order npm left them. This is reality, and it is what the suite runs in. |
 
 Consequences:
 
-- A resolution change passing the fixture suite proves little on its own.
-  `test/test-packed-install.js` covers the published layout for tape and
-  mocha; extend it when a change touches resolution.
 - Never reference polendina's own `node_modules` by path. Resolve through
   Node from a file inside polendina so it works wherever npm put the package.
-- The `webpack-merge` fixture resolves `webpack` by walking up to polendina's
-  tree, which stands in for a real consumer with no webpack of their own.
-  That is the fixture topology leaking, and it happens to match reality
-  because webpack is hoisted.
+- The fixtures sit in a subdirectory of the consumer, so the suite also
+  stands in for a workspace package whose dependencies are hoisted to a
+  parent. Module resolution must walk up.
+- `test/test-packed-install.js` asserts the layout itself: polendina's
+  dependencies hoisted, each framework present only in its own consumer,
+  mocha and tape absent from polendina's own tree.
 
 Rules the suite relies on:
 
-- polendina is tested the way it is used: as a CLI run from inside a consumer
-  directory. Do not import `polendina.js` into tests to make them faster.
-- Fixture `package.json` files are real and own their test framework.
+- polendina is tested the way it is used: as a CLI installed from a tarball
+  and run from inside a consumer directory. Do not import `polendina.js` into
+  tests to make them faster.
+- The mocha spec reporter's pass symbol differs between majors in the
+  browser bundle, so mocha expectations take the tick from a per-consumer
+  table rather than a literal.
 - Every runner has a passing and a failing fixture, in CJS and ESM. A new
-  runner or mode adds all four. A new code path in an existing runner adds an
-  assertion to the existing fixtures rather than a new fixture.
+  runner or mode adds all four, a row in `variants` with its framework, and
+  that framework in `test/consumer/package.json`. A new code path in an
+  existing runner adds an assertion to the existing fixtures rather than a
+  new fixture.
 - Expected output is matched as exact multi-line strings with timings
   scrubbed. When output changes on purpose, update the expectation and say so
   in the PR.
@@ -288,19 +323,16 @@ Good work, roughly in order of value:
 
 - **Keep the matrix green.** Pick up a red dependabot PR, find the fallout,
   land the fix with the bump. This is the single most useful thing.
-- **Remove dead weight with evidence.** `raw-loader` is a dependency no source
-  references. The `--coverage` flag and the `pti` TODO have never shipped. The
-  commented-out `page.on('console')` block is dead. The `useColors` branch is
-  unreachable on supported mochas. Each removal is one PR with a full test run
-  and a `git log -S` showing where it came from.
-- **Move the fixtures into the packed consumer.** `test/test-packed-install.js`
-  already packs polendina and installs it into a temporary consumer outside
-  the repo, the only layout a real user has. Running the existing fixture
-  directories from inside that consumer would replace seventeen `npm i` runs
-  and seventeen dependabot entries with one install, close the topology leak
-  for every test, and make a second consumer on the previous mocha major
-  cheap. The fixtures and their assertions stay as they are; only where they
-  run changes.
+- **Remove dead weight with evidence.** A flag that never shipped, a branch
+  unreachable on supported versions. Each removal is one PR with a full test
+  run and a `git log -S` showing where it came from. A dependency with no
+  reference in this repo is not evidence on its own: `raw-loader` is used
+  only from consumers' inline loader strings. Search the consumers first.
+- **Make dynamic `import()` work in Worker and ServiceWorker modes.** Webpack
+  splits each one into a chunk and loads it through a script tag, which only
+  a page has. `module.parser.javascript.dynamicImportMode: 'eager'` would
+  inline them into the single bundle; the mocha fixtures' raw-loader case
+  would then pass as a dynamic import in all three scopes.
 - **Make failures legible.** When a resolve fails inside a consumer's
   dependency, the webpack error is the user's only clue. Better messages
   around bundle errors and the timeout are cheap wins.

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [3.3.4](https://github.com/rvagg/polendina/compare/v3.3.3...v3.3.4) (2026-10-24)
+
+### Trivial Changes
+
+* remove dead code, document and test raw-loader ([#206](https://github.com/rvagg/polendina/issues/206)) ([3ce94c0](https://github.com/rvagg/polendina/commit/3ce94c02208d72e8c174d6607bc30266e2ad69aa))
+
+## [3.3.3](https://github.com/rvagg/polendina/compare/v3.3.2...v3.3.3) (2026-10-24)
+
+### Tests
+
+* run fixtures from a packed install in temporary consumers ([#205](https://github.com/rvagg/polendina/issues/205)) ([d1601fc](https://github.com/rvagg/polendina/commit/d1601fcc94b50bb6192629173500b85443a405f2))
+
 ## [3.3.2](https://github.com/rvagg/polendina/compare/v3.3.1...v3.3.2) (2026-10-24)
 
 ### Bug Fixes

package/README.md

@@ -20,6 +20,7 @@
   * [bare-sync](#bare-sync)
   * [bare-async](#bare-async)
 * [TypeScript support (and other Webpack extensions)](#typescript-support-and-other-webpack-extensions)
+* [Loading fixture files](#loading-fixture-files)
 * [polendina-node: the minimal Node.js test runner](#polendina-node-the-minimal-nodejs-test-runner)
 * [Minimising Puppeteer's size](#minimising-puppeteers-size)
   * [Global and npx](#global-and-npx)
@@ -187,6 +188,16 @@ module.exports = {
 $ polendina --cleanup test/*.spec.ts --webpack-config webpack.config.ts.js
 ```
 
+## Loading fixture files
+
+polendina bundles [raw-loader](https://ghub.io/raw-loader) so a test can read a fixture file as a string without any configuration, using webpack's inline loader syntax:
+
+```js
+import hex from '!!raw-loader!./fixtures/block.hex'
+```
+
+The leading `!!` stops any other loader from touching the file. In a CommonJS test the string is on `require('!!raw-loader!./fixtures/block.hex').default`. A dynamic `import()` works too, but only in page mode: webpack loads it as a separate chunk through a script tag, which Workers and ServiceWorkers do not have.
+
 
 ## `polendina-node`: the minimal Node.js test runner
 

package/lib/puppeteer.js

@@ -1,15 +1,12 @@
 import puppeteer from 'puppeteer'
-// TODO
-// const pti = require('puppeteer-to-istanbul')
-// const { copyFile } = require('fs').promises
 import { log, error, logRaw, logWrite, flushLogs } from './log.js'
 
 // wrap our convoluted _run() function in a pure Promise that can handle
 // both standard throws and the callback that ends it. _run() needs to handle
 // ends in a few different ways, hence the hack.
-export function run (outputDir, port, timeout, mode, runner, coverage) {
+export function run (outputDir, port, timeout, mode, runner) {
   return new Promise((resolve, reject) => {
-    _run(outputDir, port, timeout, mode, runner, coverage, (err, errors) => {
+    _run(outputDir, port, timeout, mode, runner, (err, errors) => {
       if (err) {
         return reject(err)
       }
@@ -21,10 +18,10 @@ export function run (outputDir, port, timeout, mode, runner, coverage) {
 // this can throw, or it can end via `callback()` which may or may not contain
 // a runtime-error argument and a "number of errors from tests" argument.
 // the callback may be triggered by proper test end or failure, or a timeout.
-async function _run (outputDir, port, timeout, mode, runner, coverage, callback) {
+async function _run (outputDir, port, timeout, mode, runner, callback) {
   let executionQueue = Promise.resolve()
 
-  const browser = await puppeteer.launch({ args: ['--no-sandbox'], headless: 'new' })
+  const browser = await puppeteer.launch({ args: ['--no-sandbox'] })
   const [page] = await browser.pages()
 
   // this works as a debounce exit method, when process.stdout.write() is used
@@ -44,13 +41,6 @@ async function _run (outputDir, port, timeout, mode, runner, coverage, callback)
       executionQueue.then(async () => {
         flushLogs(true)
         executionQueue = null
-        /* TODO
-        if (coverage) {
-          const jsCoverage = await page.coverage.stopJSCoverage()
-          pti.write([...jsCoverage])
-          await copyFile('build/bundle.js.map', '.nyc_output/js/bundle.js.map')
-        }
-        */
         await browser.close()
       }).catch(callback)
         .then(() => { callback(null, errors) })
@@ -64,24 +54,6 @@ async function _run (outputDir, port, timeout, mode, runner, coverage, callback)
     }
   }
 
-  // this should be a rare, or impossible event since we intercept console.log
-  /*
-  page.on('console', (msg) => {
-    if (!executionQueue) {
-      error(`log after end: ${msg.text()}`)
-      return
-    }
-    const args = []
-    executionQueue = executionQueue.then(async () => {
-      logRaw('info', -1, await Promise.all(args))
-    })
-    for (const arg of msg.args()) {
-      args.push(arg.evaluate(n => n))
-    }
-    maybeEnd()
-  })
-  */
-
   page.on('error', (error) => console.error(error))
   page.on('pageerror', (error) => console.error(error))
 
@@ -97,10 +69,6 @@ async function _run (outputDir, port, timeout, mode, runner, coverage, callback)
     maybeEnd()
   })
 
-  if (coverage) {
-    await page.coverage.startJSCoverage()
-  }
-
   const url = `http://localhost:${port}/?mode=${mode}&runner=${runner}`
   log(`Running ${runner} ${mode} tests with Puppeteer via\n                ${url}`)
   if (runner !== 'mocha') {

package/lib/webpack.config.js

@@ -34,14 +34,17 @@ export function webpackConfig (env, options, runner) {
       // published deps; tsconfig-aware resolution follows it and fails every resolve
       // inside that dependency.
       tsconfig: false,
+      // the consumer's tree first, walking up from the requesting file as Node
+      // does so hoisted and nested dependencies resolve; polendina's own tree
+      // is only a fallback for its runner shims
       modules: [
-        path.join(process.cwd(), 'node_modules'),
+        'node_modules',
         path.join(__dirname, '../node_modules')
       ]
     },
     resolveLoader: {
       modules: [
-        path.join(process.cwd(), 'node_modules'),
+        'node_modules',
         path.join(__dirname, '../node_modules')
       ]
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polendina",
-  "version": "3.3.2",
+  "version": "3.3.4",
   "description": "Non-UI browser testing for JavaScript libraries from the command-line",
   "main": "polendina.js",
   "type": "module",
@@ -26,9 +26,8 @@
   },
   "scripts": {
     "lint": "standard",
-    "test:install": "for f in $(cd test/fixtures/; ls); do (cd test/fixtures/$f && grep devDependencies package.json > /dev/null && npm i --no-audit --no-fund --no-package-lock) || true; done",
-    "test:run": "npm_config_yes=true npx mocha test/test-*.js",
-    "test": "npm run lint && npm run test:install && npm run test:run"
+    "test:run": "npx --yes mocha --require test/setup.js test/test-*.js",
+    "test": "npm run lint && npm run test:run"
   },
   "repository": {
     "type": "git",

package/polendina-cli.js

@@ -52,12 +52,6 @@ const argv = yargs(hideBin(process.argv))
     describe: 'Number of seconds to wait before auto-failing the test suite',
     default: 30
   })
-  .option('coverage', {
-    type: 'boolean',
-    describe: 'Enable coverage reporting',
-    default: false,
-    hidden: true
-  })
   .option('webpack-config', {
     type: 'string',
     describe: 'Supply a path to a webpack.config.js to merge into Polendina\'s Webpack config (use with caution)',

package/polendina.js

@@ -132,7 +132,7 @@ export class Polendina {
       server.on('error', reject)
       server.listen(() => {
         const port = server.address().port
-        puppeteer(this.outputDir, port, this._options.timeout, mode, this._options.runner, this._options.coverage)
+        puppeteer(this.outputDir, port, this._options.timeout, mode, this._options.runner)
           .then((errors) => {
             server.close(() => {
               if (this._options.runner !== 'mocha') {

package/resources/common-run.js

@@ -26,12 +26,10 @@ export const log = {
     executionQueue(() => globalThis.polendinaLog(['info', logSeq++].concat(args)))
     return executionQueue
   },
-  // TODO
   warn: (...args) => {
     executionQueue(() => globalThis.polendinaLog(['warn', logSeq++].concat(args)))
     return executionQueue
   },
-  // TODO
   error: (...args) => {
     executionQueue(() => globalThis.polendinaLog(['error', logSeq++].concat(args)))
     return executionQueue
@@ -87,7 +85,6 @@ function setupLogging () {
     log.info.apply(null, args)
   }
 
-  // TODO: differentiate
   console.warn = log.warn
   console.error = log.error
 }

package/resources/mocha-run.js

@@ -8,12 +8,7 @@ import { registry, executionQueue, log, setup } from './common-run.js'
 async function runMocha () {
   const mochaLocal = globalThis.mocha
   mochaLocal.setup({ reporter: registry.argv.mochaReporter, ui: 'bdd' })
-  // mocha@7 deprecated useColors()
-  if (typeof mochaLocal.color === 'function') {
-    mochaLocal.color(true)
-  } else if (typeof mochaLocal.useColors === 'function') {
-    mochaLocal.useColors(true)
-  }
+  mochaLocal.color(true)
 
   // the well-behaved reporters, like spec, are easy to intercept
   mochaLocal.constructor.reporters.Base.consoleLog = log.info

package/test/common.js

@@ -1,19 +1,37 @@
 import path from 'path'
 import assert from 'assert'
 import { execFile } from 'child_process'
-import { fileURLToPath } from 'url'
 
-const __dirname = fileURLToPath(path.dirname(import.meta.url))
-const cli = path.join(__dirname, '../polendina-cli.js')
+// consumers installed by setup.js, one per runner, named by its variants table
+export function consumers () {
+  return JSON.parse(process.env.POLENDINA_CONSUMERS)
+}
+
+export function consumer (name) {
+  const dir = consumers()[name]
+  if (!dir) {
+    throw new Error(`no consumer named ${name}`)
+  }
+  return dir
+}
+
+// runs the installed polendina CLI from inside a copied fixture directory;
+// resolved at call time because consumers exist only once setup.js has run
+export async function runCli (consumerName, fixture, args = []) {
+  const dir = consumer(consumerName)
+  const cli = path.join(dir, 'node_modules/polendina/polendina-cli.js')
+  return runCommand(cli, ['test*.js', 'test/test*.js', '--cleanup', ...args], path.join(dir, 'fixtures', fixture))
+}
 
-export async function runCli (cwd, args) {
-  return runCommand(`${cli} test*.js test/test*.js --cleanup ${args || ''}`, cwd)
+export async function runNodeCli (consumerName, fixture, mode) {
+  const dir = consumer(consumerName)
+  const cli = path.join(dir, 'node_modules/polendina/polendina-node-cli.js')
+  return runCommand(cli, [mode, 'test*.js'], path.join(dir, 'fixtures', fixture))
 }
 
-export async function runCommand (command, cwd) {
+export async function runCommand (script, args, cwd) {
   return new Promise((resolve, reject) => {
-    const args = command.split(' ').filter(Boolean)
-    execFile(process.execPath, args, { cwd }, (err, stdout, stderr) => {
+    execFile(process.execPath, [script, ...args], { cwd }, (err, stdout, stderr) => {
       const code = err ? err.code : 0
       if (!code) {
         try {
@@ -22,8 +40,7 @@ export async function runCommand (command, cwd) {
           return reject(e)
         }
       }
-      const out = { stdout: stdout.toString(), stderr: stderr.toString(), code }
-      resolve(out)
+      resolve({ stdout: stdout.toString(), stderr: stderr.toString(), code })
     })
   })
 }