polendina 3.3.2 → 3.3.3

package/test/test-packed-install.js

@@ -1,87 +1,47 @@
-/* globals describe it before after */
+/* globals describe it */
 
-// Installs polendina from a packed tarball into a consumer outside this
-// repository and runs the CLI there. npm hoists polendina's dependencies into
-// the consumer's node_modules, a layout the in-repo fixtures never produce.
+// setup.js installs polendina from a packed tarball into consumers outside
+// this repository; check that layout is the hoisted one a real install has
+// and that each consumer carries only its own runner
 
 import assert from 'assert'
 import fs from 'fs'
-import os from 'os'
 import path from 'path'
-import { exec, execFile } from 'child_process'
-import { fileURLToPath } from 'url'
+import { consumers } from './common.js'
 
-const __dirname = fileURLToPath(path.dirname(import.meta.url))
-const root = path.join(__dirname, '..')
-const puppeteerVersion = JSON.parse(fs.readFileSync(path.join(root, 'node_modules/puppeteer/package.json'))).version
-
-function sh (command, cwd) {
-  return new Promise((resolve, reject) => {
-    exec(command, { cwd, env: { ...process.env, PUPPETEER_SKIP_DOWNLOAD: '1' } }, (err, stdout, stderr) => {
-      if (err) {
-        return reject(new Error(`${command}\n${stderr}`))
-      }
-      resolve(stdout.toString())
-    })
-  })
-}
-
-function cli (cwd, args) {
-  return new Promise((resolve) => {
-    const bin = path.join(cwd, 'node_modules/polendina/polendina-cli.js')
-    execFile(process.execPath, [bin, ...args], { cwd }, (err, stdout, stderr) => {
-      resolve({ code: err ? err.code : 0, stdout: stdout.toString(), stderr: stderr.toString() })
-    })
-  })
-}
+const present = (dir, ...segments) => fs.promises.access(path.join(dir, ...segments))
+const absent = (dir, ...segments) => assert.rejects(present(dir, ...segments))
 
 describe('packed install', function () {
-  this.timeout(300000)
-  let consumer
-
-  before(async () => {
-    consumer = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'polendina-consumer-'))
-    const [{ filename }] = JSON.parse(await sh(`npm pack --json --pack-destination "${consumer}"`, root))
-    await fs.promises.writeFile(path.join(consumer, 'package.json'), JSON.stringify({ name: 'consumer', version: '1.0.0', private: true }))
-    await fs.promises.writeFile(path.join(consumer, 'test-tape.js'), `
-      const tape = require('tape')
-      tape('packed', (t) => { t.ok(true, 'runs'); t.end() })
-    `)
-    await fs.promises.writeFile(path.join(consumer, 'test-mocha.js'), `
-      /* globals describe it */
-      describe('packed', () => { it('runs', () => { if (!true) throw new Error('nope') }) })
-    `)
-    await sh(`npm install --no-audit --no-fund --no-package-lock --prefer-offline "./${filename}" tape mocha puppeteer@${puppeteerVersion}`, consumer)
-  })
-
-  after(async () => {
-    if (consumer) {
-      await fs.promises.rm(consumer, { recursive: true, force: true })
+  it('hoists polendina dependencies into every consumer tree', async () => {
+    for (const dir of Object.values(consumers())) {
+      await absent(dir, 'node_modules/polendina/node_modules/stream-browserify')
+      await present(dir, 'node_modules/stream-browserify')
     }
   })
 
-  it('hoists dependencies', async () => {
-    await assert.rejects(fs.promises.access(path.join(consumer, 'node_modules/polendina/node_modules/stream-browserify')))
-    await fs.promises.access(path.join(consumer, 'node_modules/stream-browserify'))
+  it('installs each runner only in its own consumer', async () => {
+    const { mocha, mocha11, tape, bare } = consumers()
+    await present(mocha, 'node_modules/mocha')
+    await present(mocha11, 'node_modules/mocha')
+    await present(tape, 'node_modules/tape')
+    await absent(mocha, 'node_modules/tape')
+    await absent(tape, 'node_modules/mocha')
+    await absent(bare, 'node_modules/mocha')
+    await absent(bare, 'node_modules/tape')
   })
 
-  it('runs tape', async () => {
-    const { code, stdout, stderr } = await cli(consumer, ['--runner=tape', '--cleanup', 'test-tape.js'])
-    if (code !== 0) {
-      console.error(stdout, stderr)
-    }
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    assert.strictEqual(stderr, '', 'no stderr')
-    assert.ok(stdout.includes('ok 1 runs'), 'stdout contains tape output')
+  it('installs the previous mocha major in its consumer', async () => {
+    const { mocha, mocha11 } = consumers()
+    const major = (dir) => JSON.parse(fs.readFileSync(path.join(dir, 'node_modules/mocha/package.json'))).version.split('.')[0]
+    assert.strictEqual(major(mocha11), '11')
+    assert.notStrictEqual(major(mocha), '11')
   })
 
-  it('runs mocha', async () => {
-    const { code, stdout, stderr } = await cli(consumer, ['--cleanup', 'test-mocha.js'])
-    if (code !== 0) {
-      console.error(stdout, stderr)
+  it('does not install mocha or tape in polendina itself', async () => {
+    for (const dir of Object.values(consumers())) {
+      await absent(dir, 'node_modules/polendina/node_modules/mocha')
+      await absent(dir, 'node_modules/polendina/node_modules/tape')
     }
-    assert.strictEqual(code, 0, 'exited with zero exit code')
-    assert.strictEqual(stderr, '', 'no stderr')
-    assert.ok(stdout.includes('1 passing'), 'stdout contains mocha output')
   })
 })

package/test/test-polendina-node.js

@@ -1,27 +1,17 @@
 /* globals describe it */
 
 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 cli = path.join(__dirname, '../polendina-node-cli.js')
-
-function runCli (mode, cwd) {
-  return runCommand(`${cli} ${mode} test*.js`, cwd)
-}
+import { runNodeCli } from './common.js'
 
 function removeTiming (stdout) {
   return stdout.replace(/Took [\d.]+ seconds/, 'Took X seconds')
 }
 
 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' : ''}`)
+  const bareSyncFixture = `bare-sync${type === 'esm' ? '-esm' : ''}`
+  const bareSyncFailureFixture = `bare-sync-failure${type === 'esm' ? '-esm' : ''}`
+  const bareAsyncFixture = `bare-async${type === 'esm' ? '-esm' : ''}`
+  const bareAsyncFailureFixture = `bare-async-failure${type === 'esm' ? '-esm' : ''}`
 
   describe(`polendina-node bare-sync (${type})`, function () {
     this.timeout(60000)
@@ -33,7 +23,7 @@ testing bare fixture
   ✔ test-2.js
 Took X seconds
 `
-      const { stdout, stderr, code } = await runCli('bare-sync', bareSyncFixture)
+      const { stdout, stderr, code } = await runNodeCli('bare', bareSyncFixture, 'bare-sync')
       if (code !== 0) {
         console.error(stderr)
       }
@@ -49,7 +39,7 @@ testing bare fixture
   ✘ test-2.js
 Took X seconds
 `
-      const { stdout, stderr, code } = await runCli('bare-sync', bareSyncFailureFixture)
+      const { stdout, stderr, code } = await runNodeCli('bare', bareSyncFailureFixture, 'bare-sync')
       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')
@@ -68,7 +58,7 @@ testing bare fixture
     ✔ test2
 Took X seconds
 `
-      const { stdout, stderr, code } = await runCli('bare-async', bareAsyncFixture)
+      const { stdout, stderr, code } = await runNodeCli('bare', bareAsyncFixture, 'bare-async')
       if (code !== 0) {
         console.error(stderr)
       }
@@ -86,7 +76,7 @@ testing bare fixture
     ✘ test2
 Took X seconds
 `
-      const { stdout, stderr, code } = await runCli('bare-async', bareAsyncFailureFixture)
+      const { stdout, stderr, code } = await runNodeCli('bare', bareAsyncFailureFixture, 'bare-async')
       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,11 @@
 /* globals describe it */
 
 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))
-
 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' : ''}`)
+  const tapeFixture = `tape${type === 'esm' ? '-esm' : ''}`
+  const tapeFailureFixture = `tape-failure${type === 'esm' ? '-esm' : ''}`
 
   describe(`basic tape (${type})`, function () {
     this.timeout(60000)
@@ -37,7 +33,7 @@ ok 5 all good
 `
 
     it('should run in page', async () => {
-      const { stdout, stderr, code } = await runCli(tapeFixture, '--runner=tape')
+      const { stdout, stderr, code } = await runCli('tape', tapeFixture, ['--runner=tape'])
       if (code !== 0) {
         console.error(stderr)
       }
@@ -51,7 +47,7 @@ ok 5 all good
     })
 
     it('should run in worker', async () => {
-      const { stdout, stderr, code } = await runCli(tapeFixture, '--runner=tape --worker --page=false')
+      const { stdout, stderr, code } = await runCli('tape', tapeFixture, ['--runner=tape', '--worker', '--page=false'])
       if (code !== 0) {
         console.error(stderr)
       }
@@ -65,7 +61,7 @@ ok 5 all good
     })
 
     it('should run in serviceworker', async () => {
-      const { stdout, stderr, code } = await runCli(tapeFixture, '--runner=tape --serviceworker --page=false')
+      const { stdout, stderr, code } = await runCli('tape', tapeFixture, ['--runner=tape', '--serviceworker', '--page=false'])
       if (code !== 0) {
         console.error(stderr)
       }
@@ -79,7 +75,7 @@ ok 5 all good
     })
 
     it('should run in page, worker and serviceworker', async () => {
-      const { stdout, stderr, code } = await runCli(tapeFixture, '--runner=tape --worker --serviceworker')
+      const { stdout, stderr, code } = await runCli('tape', tapeFixture, ['--runner=tape', '--worker', '--serviceworker'])
       if (code !== 0) {
         console.error(stderr)
       }
@@ -131,7 +127,7 @@ not ok 2 bork
 `
 
     it('should fail in page', async () => {
-      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape')
+      let { stdout, code } = await runCli('tape', 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')
@@ -143,7 +139,7 @@ not ok 2 bork
     })
 
     it('should fail in worker', async () => {
-      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --worker --page=false')
+      let { stdout, code } = await runCli('tape', 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')
@@ -155,7 +151,7 @@ not ok 2 bork
     })
 
     it('should fail in serviceworker', async () => {
-      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --serviceworker --page=false')
+      let { stdout, code } = await runCli('tape', 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')
@@ -167,7 +163,7 @@ not ok 2 bork
     })
 
     it('should fail in page and not run in worker', async () => {
-      let { stdout, code } = await runCli(tapeFailureFixture, '--runner=tape --worker')
+      let { stdout, code } = await runCli('tape', 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')

package/test/test-webpack-merge.js

@@ -1,12 +1,8 @@
 /* globals describe it */
 
 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')
+const webpackMergeFixture = 'webpack-merge'
 
 describe('basic webpack-merge', function () {
   this.timeout(60000)
@@ -16,7 +12,7 @@ assert.ok() is a function
 WOOP is set
   ✔ test.js
 `
-    const { stdout, stderr, code } = await runCli(webpackMergeFixture, '--runner=bare-sync --webpack-config webpack.config.js')
+    const { stdout, stderr, code } = await runCli('bare', webpackMergeFixture, ['--runner=bare-sync', '--webpack-config', 'webpack.config.js'])
     if (code !== 0) {
       console.error(stderr)
     }
@@ -35,7 +31,7 @@ assert.ok() is a function
 `
     const expectedStderr = 'WOOP is not defined'
 
-    const { stdout, stderr, code } = await runCli(webpackMergeFixture, '--runner=bare-sync')
+    const { stdout, stderr, code } = await runCli('bare', 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')