borp 0.4.2 → 0.6.0

package/.github/workflows/ci.yml

@@ -19,10 +19,10 @@ jobs:
         node-version: [18.x, 20.x, 21.x]
         os: [ubuntu-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Use Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
 
@@ -30,6 +30,16 @@ jobs:
         run: |
           npm install
 
+      - name: Lint
+        run: |
+          npm run lint
+
       - name: Run tests
         run: |
-          npm run test
+          npm run unit -- --reporter spec --reporter md:report.md --reporter gh
+
+      - name: Upload report
+        shell: bash
+        if: success() || failure() 
+        run: |
+          cat report.md >> "$GITHUB_STEP_SUMMARY"

package/README.md

@@ -17,7 +17,7 @@ npm i borp --save-dev
 borp --coverage
 ```
 
-Borp will autumatically run all tests files matching `*.test.{js|ts}`.
+Borp will automatically run all tests files matching `*.test.{js|ts}`.
 
 ### Example project setup
 
@@ -91,7 +91,72 @@ Note the use of `incremental: true`, which speed up compilation massively.
 * `--timeout` or `-t`, timeouts the tests after a given time; default is 30000 ms
 * `--coverage-exclude` or `-X`, a list of comma-separated patterns to exclude from the coverage report. All tests files are ignored by default.
 * `--ignore` or `-i`, ignore a glob pattern, and not look for tests there
+* `--expose-gc`, exposes the gc() function to tests
 * `--pattern` or `-p`, run tests matching the given glob pattern
+* `--reporter` or `-r`, set up a reporter, use a colon to set a file destination. Default: `spec`.
+
+## Reporters
+
+Here are the available reporters:
+
+* `md`: creates a markdown table, useful for setting up a Summary in your GitHub Action
+* `gh`: emits `::error` workflow commands for GitHub Actions to show inlined error. Enabled by default when running on GHA.
+* `tap`: outputs the test results in the TAP format.
+* `spec`: outputs the test results in a human-readable format.
+* `dot`: outputs the test results in a compact format, where each passing test is represented by a ., and each failing test is represented by a X.
+* `junit`: outputs test results in a jUnit XML format
+
+## GitHub Action Summary
+
+The following will automatically show the summary of the test run in the summary page of GitHub Actions.
+
+```yaml
+name: ci
+
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+      
+jobs:
+  test:
+    runs-on: ${{matrix.os}}
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 21.x]
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install
+        run: |
+          npm install
+
+      - name: Lint
+        run: |
+          npm run lint
+
+      - name: Run tests
+        run: |
+          npm run unit -- --reporter spec --reporter md:report.md
+
+      - name: Upload report
+        shell: bash
+        if: success() || failure() 
+        run: |
+          cat report.md >> "$GITHUB_STEP_SUMMARY"
+```
 
 ## License
 

package/borp.js

@@ -1,23 +1,23 @@
 #! /usr/bin/env node
 
 import { parseArgs } from 'node:util'
-import { tap, spec } from 'node:test/reporters'
+import Reporters from 'node:test/reporters'
 import { mkdtemp, rm, readFile } from 'node:fs/promises'
+import { createWriteStream } from 'node:fs'
 import { finished } from 'node:stream/promises'
 import { join, relative } from 'node:path'
 import posix from 'node:path/posix'
 import runWithTypeScript from './lib/run.js'
+import { MarkdownReporter, GithubWorkflowFailuresReporter } from './lib/reporters.js'
 import { Report } from 'c8'
 import os from 'node:os'
+import { execa } from 'execa'
 
-let reporter
 /* c8 ignore next 4 */
-if (process.stdout.isTTY) {
-  /* eslint new-cap: "off" */
-  reporter = new spec()
-} else {
-  reporter = tap
-}
+process.on('unhandledRejection', (err) => {
+  console.error(err)
+  process.exit(1)
+})
 
 const args = parseArgs({
   args: process.argv.slice(2),
@@ -30,17 +30,38 @@ const args = parseArgs({
     timeout: { type: 'string', short: 't', default: '30000' },
     'coverage-exclude': { type: 'string', short: 'X', multiple: true },
     ignore: { type: 'string', short: 'i', multiple: true },
-    help: { type: 'boolean', short: 'h' }
+    'expose-gc': { type: 'boolean' },
+    help: { type: 'boolean', short: 'h' },
+    reporter: {
+      type: 'string',
+      short: 'r',
+      default: ['spec'],
+      multiple: true
+    }
   },
   allowPositionals: true
 })
 
-/* c8 ignore next 4 */
+/* c8 ignore next 5 */
 if (args.values.help) {
   console.log(await readFile(new URL('./README.md', import.meta.url), 'utf8'))
   process.exit(0)
 }
 
+if (args.values['expose-gc'] && typeof global.gc !== 'function') {
+  try {
+    await execa('node', ['--expose-gc', ...process.argv.slice(1)], {
+      stdio: 'inherit',
+      env: {
+        ...process.env
+      }
+    })
+    process.exit(0)
+  } catch (error) {
+    process.exit(1)
+  }
+}
+
 if (args.values.concurrency) {
   args.values.concurrency = parseInt(args.values.concurrency)
 }
@@ -63,13 +84,44 @@ const config = {
 }
 
 try {
+  const pipes = []
+
+  const reporters = {
+    ...Reporters,
+    md: new MarkdownReporter(config),
+    gh: new GithubWorkflowFailuresReporter(config),
+    /* eslint new-cap: "off" */
+    spec: new Reporters.spec()
+  }
+
+  // If we're running in a GitHub action, adds the gh reporter
+  // by default so that we can report failures to GitHub
+  if (process.env.GITHUB_ACTION) {
+    args.values.reporter.push('gh')
+  }
+
+  for (const input of args.values.reporter) {
+    const [name, dest] = input.split(':')
+    const reporter = reporters[name]
+    if (!reporter) {
+      throw new Error(`Unknown reporter: ${name}`)
+    }
+    let output = process.stdout
+    if (dest) {
+      output = createWriteStream(dest)
+    }
+    pipes.push([reporter, output])
+  }
+
   const stream = await runWithTypeScript(config)
 
   stream.on('test:fail', () => {
     process.exitCode = 1
   })
 
-  stream.compose(reporter).pipe(process.stdout)
+  for (const [reporter, output] of pipes) {
+    stream.compose(reporter).pipe(output)
+  }
 
   await finished(stream)
 

package/fixtures/gc/gc.test.js

@@ -0,0 +1,8 @@
+import { doesNotThrow } from 'node:assert'
+import { test } from 'node:test'
+
+test('this needs gc', () => {
+  doesNotThrow(() => {
+    global.gc()
+  })
+})

package/fixtures/js-esm/lib/add.js

@@ -0,0 +1,3 @@
+export function add (x, y) {
+  return x + y
+}

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

@@ -0,0 +1,7 @@
+import { test } from 'node:test'
+import { add } from '../lib/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add', () => {
+  strictEqual(add(1, 2), 3)
+})

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

@@ -0,0 +1,7 @@
+import { test } from 'node:test'
+import { add } from '../lib/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add2', () => {
+  strictEqual(add(3, 2), 5)
+})

package/lib/reporters.js

@@ -0,0 +1,114 @@
+import { Transform } from 'node:stream'
+import { fileURLToPath } from 'node:url'
+
+function normalizeFile (file, cwd) {
+  let res = file
+  if (file.startsWith('file://')) {
+    try {
+      res = fileURLToPath(new URL(file))
+    } catch (err) {
+      if (err.code === 'ERR_INVALID_FILE_URL_PATH') {
+        res = fileURLToPath(new URL(file.replace('file:///', 'file://')))
+      }
+    }
+  }
+  res = res.replace(cwd, '')
+  if (res.startsWith('/') || res.startsWith('\\')) {
+    res = res.slice(1)
+  }
+  return res
+}
+
+function eventToLine (event) {
+  return `* __${event.data.name}__, duration ${event.data.details.duration_ms}ms, line ${event.data.line}\n`
+}
+
+export class MarkdownReporter extends Transform {
+  constructor (opts) {
+    super({
+      ...opts,
+      objectMode: true
+    })
+
+    this._files = {}
+    this._cwd = opts?.cwd
+  }
+
+  getFile (path) {
+    const file = this._files[path] || {
+      pass: [],
+      fail: []
+    }
+    this._files[path] = file
+    return file
+  }
+
+  _transform (event, encoding, callback) {
+    if (!event.data.file) {
+      callback()
+      return
+    }
+
+    const path = normalizeFile(event.data.file, this._cwd)
+    const file = this.getFile(path)
+    switch (event.type) {
+      case 'test:pass':
+        file.pass.push(event)
+        break
+      case 'test:fail':
+        file.fail.push(event)
+        break
+    }
+
+    callback()
+  }
+
+  _flush (callback) {
+    this.push('# Summary\n')
+    for (const [path, file] of Object.entries(this._files)) {
+      this.push(`## ${path}\n`)
+      if (file.pass.length > 0) {
+        this.push('### :white_check_mark: Pass\n')
+        for (const event of file.pass) {
+          this.push(eventToLine(event))
+        }
+      }
+      if (file.fail.length > 0) {
+        this.push('### :x: Fail\n')
+        for (const event of file.fail) {
+          this.push(eventToLine(event))
+        }
+      }
+    }
+    this.push(null)
+    callback()
+  }
+}
+
+export class GithubWorkflowFailuresReporter extends Transform {
+  constructor (opts) {
+    super({
+      ...opts,
+      objectMode: true
+    })
+
+    this._files = {}
+    this._cwd = opts?.cwd
+  }
+
+  _transform (event, encoding, callback) {
+    if (!event.data.file) {
+      callback()
+      return
+    }
+
+    const path = normalizeFile(event.data.file, this._cwd)
+    switch (event.type) {
+      case 'test:fail':
+        this.push(`::error file=${path},line=${event.data.line}::${event.data.name}\n`)
+        break
+    }
+
+    callback()
+  }
+}

package/lib/run.js

@@ -17,6 +17,10 @@ function deferred () {
 }
 
 export default async function runWithTypeScript (config) {
+  // This is a hack to override
+  // https://github.com/nodejs/node/commit/d5c9adf3df
+  delete process.env.NODE_TEST_CONTEXT
+
   const { cwd } = config
   let pushable = []
   const tsconfigPath = await findUp('tsconfig.json', { cwd })
@@ -36,6 +40,7 @@ export default async function runWithTypeScript (config) {
       if (!config.watch) {
         const start = Date.now()
         await execa('node', [tscPath], { cwd: dirname(tsconfigPath) })
+        process.stdout.write(`TypeScript compilation complete (${Date.now() - start}ms)\n`)
         pushable.push({
           type: 'test:diagnostic',
           data: {
@@ -53,10 +58,18 @@ export default async function runWithTypeScript (config) {
   }
   config.prefix = prefix
   config.setup = (test) => {
-    for (const chunk of pushable) {
-      test.reporter.push(chunk)
+    /* c8 ignore next 12 */
+    if (test.reporter) {
+      for (const chunk of pushable) {
+        test.reporter.push(chunk)
+      }
+      pushable = test.reporter
+    } else {
+      for (const chunk of pushable) {
+        test.push(chunk)
+      }
+      pushable = test
     }
-    pushable = test.reporter
   }
 
   let tscChild
@@ -119,7 +132,7 @@ export default async function runWithTypeScript (config) {
   } else if (prefix) {
     files = await glob(join(prefix, join('**', '*.test.{cjs,mjs,js}')), { ignore, cwd, windowsPathsNoEscape: true })
   } else {
-    files = await glob(join('**', '*.test.{cjs,mjs,js}'), { ignore, cwd, windowsPathsNoEscape: true })
+    files = await glob(join('**', '*.test.{cjs,mjs,js}'), { ignore, cwd, windowsPathsNoEscape: true, absolute: true })
   }
 
   config.files = files

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "borp",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "type": "module",
   "description": "node:test wrapper with TypeScript support",
   "main": "borp.js",
   "bin": {
     "borp": "borp.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mcollina/borp"
+  },
   "scripts": {
     "clean": "rm -rf fixtures/*/dist .test-*",
     "lint": "standard | snazzy",
@@ -25,7 +29,7 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "c8": "^8.0.1",
+    "c8": "^9.0.0",
     "execa": "^8.0.1",
     "find-up": "^7.0.0",
     "glob": "^10.3.10"

package/test/basic.test.js

@@ -165,3 +165,24 @@ test('only-src', async (t) => {
 
   await completed
 })
+
+test('js-esm', async (t) => {
+  const { strictEqual, completed } = tspl(t, { plan: 2 })
+  const config = {
+    files: [],
+    cwd: join(import.meta.url, '..', 'fixtures', 'js-esm')
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const names = new Set(['add', 'add2'])
+
+  stream.on('test:pass', (test) => {
+    strictEqual(names.has(test.name), true)
+    names.delete(test.name)
+  })
+
+  stream.resume()
+
+  await completed
+})

package/test/cli.test.js

@@ -5,6 +5,8 @@ import { rejects } from 'node:assert'
 
 const borp = join(import.meta.url, '..', 'borp.js')
 
+delete process.env.GITHUB_ACTION
+
 test('limit concurrency', async () => {
   await execa('node', [
     borp,
@@ -23,3 +25,22 @@ test('failing test set correct status code', async () => {
     cwd: join(import.meta.url, '..', 'fixtures', 'fails')
   }))
 })
+
+test('--expose-gc flag enables garbage collection in tests', async () => {
+  await execa('node', [
+    borp,
+    '--expose-gc'
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'gc')
+  })
+})
+
+test('failing test with --expose-gc flag sets correct status code', async () => {
+  // execa rejects if status code is not 0
+  await rejects(execa('node', [
+    borp,
+    '--expose-gc'
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'fails')
+  }))
+})

package/test/coverage.test.js

@@ -3,6 +3,7 @@ import { match, doesNotMatch } from 'node:assert'
 import { execa } from 'execa'
 import { join } from 'desm'
 
+delete process.env.GITHUB_ACTION
 const borp = join(import.meta.url, '..', 'borp.js')
 
 test('coverage', async () => {

package/test/reporters.test.js

@@ -0,0 +1,172 @@
+import { MarkdownReporter, GithubWorkflowFailuresReporter } from '../lib/reporters.js'
+import { test, describe } from 'node:test'
+import { strictEqual } from 'node:assert'
+
+const cwd = process.platform === 'win32' ? 'C:\\foo' : '/foo'
+const base = process.platform === 'win32' ? 'file://C:\\foo\\test\\' : 'file:///foo/test/'
+
+describe('MarkdownReporter', async () => {
+  test('should write a report', async () => {
+    const reporter = new MarkdownReporter({ cwd })
+
+    // This is skipped
+    reporter.write({
+      type: 'test:start',
+      data: {}
+    })
+
+    reporter.write({
+      type: 'test:pass',
+      data: {
+        name: 'add',
+        file: base + 'add.test.ts',
+        line: 1,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.write({
+      type: 'test:pass',
+      data: {
+        name: 'add2',
+        file: base + 'add.test.ts',
+        line: 2,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.write({
+      type: 'test:fail',
+      data: {
+        name: 'add3',
+        file: base + 'add.test.ts',
+        line: 10,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+    reporter.end()
+
+    let output = ''
+    for await (const chunk of reporter) {
+      output += chunk
+    }
+
+    strictEqual(output.replaceAll('\\', '/'), `# Summary
+## test/add.test.ts
+### :white_check_mark: Pass
+* __add__, duration 100ms, line 1
+* __add2__, duration 100ms, line 2
+### :x: Fail
+* __add3__, duration 100ms, line 10
+`)
+  })
+
+  test('skip fail heading if no failing tests', async () => {
+    const reporter = new MarkdownReporter({ cwd })
+
+    reporter.write({
+      type: 'test:pass',
+      data: {
+        name: 'add',
+        file: base + 'add.test.ts',
+        line: 1,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.write({
+      type: 'test:pass',
+      data: {
+        name: 'add2',
+        file: base + 'add.test.ts',
+        line: 2,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.end()
+
+    let output = ''
+    for await (const chunk of reporter) {
+      output += chunk
+    }
+
+    strictEqual(output.replaceAll('\\', '/'), `# Summary
+## test/add.test.ts
+### :white_check_mark: Pass
+* __add__, duration 100ms, line 1
+* __add2__, duration 100ms, line 2
+`)
+  })
+})
+
+describe('GithubWorkflowFailuresReporter', async () => {
+  test('should write error in github format', async () => {
+    const reporter = new GithubWorkflowFailuresReporter({ cwd })
+
+    // This is skipped
+    reporter.write({
+      type: 'test:start',
+      data: {}
+    })
+
+    reporter.write({
+      type: 'test:pass',
+      data: {
+        name: 'add',
+        file: base + 'add.test.ts',
+        line: 1,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.write({
+      type: 'test:fail',
+      data: {
+        name: 'add2',
+        file: base + 'add.test.ts',
+        line: 2,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+
+    reporter.write({
+      type: 'test:fail',
+      data: {
+        name: 'add3',
+        file: base + 'add.test.ts',
+        line: 10,
+        details: {
+          duration_ms: 100
+        }
+      }
+    })
+    reporter.end()
+
+    let output = ''
+    for await (const chunk of reporter) {
+      output += chunk
+    }
+
+    const expected = [
+      '::error file=test/add.test.ts,line=2::add2\n',
+      '::error file=test/add.test.ts,line=10::add3\n'
+    ].join('')
+
+    strictEqual(output.replaceAll('\\', '/'), expected)
+  })
+})