borp 0.2.0 → 0.3.0

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: standard
+    versions:
+    - 16.0.3

package/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+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@v3
+
+      - name: Use Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install
+        run: |
+          npm install
+
+      - name: Run tests
+        run: |
+          npm run test

package/README.md

@@ -0,0 +1,85 @@
+# borp
+
+Borp is a typescript-aware runner for tests written using `node:test`.
+It also support code coverage via [c8](http://npm.im/c8).
+
+Borp is self-hosted, i.e. Borp runs its own tests.
+
+## Install
+
+```bash
+npm i borp --save-dev
+```
+
+## Usage
+
+```bash
+borp --coverage
+```
+
+Borp will autumatically run all tests files matching `*.test.{js|ts}`.
+
+### Example project setup
+
+As an example, consider having a `src/add.ts` file  
+
+```typescript
+export function add (x: number, y: number): number {
+  return x + y
+}
+```
+
+and a `test/add.test.ts` file:
+
+```typescript
+import { test } from 'node:test'
+import { add } from '../src/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add', () => {
+  strictEqual(add(1, 2), 3)
+})
+```
+
+and the following `tsconfig`:
+
+```json
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "outDir": "dist",
+    "sourceMap": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "resolveJsonModule": true,
+    "removeComments": true,
+    "newLine": "lf",
+    "noUnusedLocals": true,
+    "noFallthroughCasesInSwitch": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "lib": [
+      "ESNext"
+    ],
+    "incremental": true
+  }
+}
+```
+
+Note the use of `incremental: true`, which speed up compilation massively.
+
+## Options
+
+* `--coverage` or `-C`, enables code coverage
+* `--only` or `-o`, only run `node:test` with the `only` option set  
+* `--watch` or `-w`, re-run tests on changes
+* `--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.
+
+## License
+
+MIT

package/borp.js

@@ -2,27 +2,18 @@
 
 import { parseArgs } from 'node:util'
 import { tap, spec } from 'node:test/reporters'
-import { run } from 'node:test'
-import { glob } from 'glob'
-import { findUp } from 'find-up'
-import { createRequire } from 'node:module'
-import { resolve, join, dirname } from 'node:path'
-import { access, readFile } from 'node:fs/promises'
-import { execa } from 'execa'
-
-async function isFileAccessible (filename, directory) {
-  try {
-    const filePath = directory ? resolve(directory, filename) : filename
-    await access(filePath)
-    return true
-  } catch (err) {
-    return false
-  }
-}
+import { mkdtemp, rm } from 'node:fs/promises'
+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 { Report } from 'c8'
 
 let reporter
+/* c8 ignore next 4 */
 if (process.stdout.isTTY) {
-  reporter = spec()
+  /* eslint new-cap: "off" */
+  reporter = new spec()
 } else {
   reporter = tap
 }
@@ -33,7 +24,10 @@ const args = parseArgs({
     only: { type: 'boolean', short: 'o' },
     watch: { type: 'boolean', short: 'w' },
     pattern: { type: 'string', short: 'p' },
-    concurrency: { type: 'string', short: 'c' }
+    concurrency: { type: 'string', short: 'c' },
+    coverage: { type: 'boolean', short: 'C' },
+    timeout: { type: 'string', short: 't', default: '30000' },
+    'coverage-exclude': { type: 'string', short: 'X' }
   },
   allowPositionals: true
 })
@@ -42,56 +36,57 @@ if (args.values.concurrency) {
   args.values.concurrency = parseInt(args.values.concurrency)
 }
 
-const tsconfigPath = await findUp('tsconfig.json')
-
-let prefix = ''
-
-if (tsconfigPath) {
-  try {
-    const _require = createRequire(process.cwd())
-    const typescriptPathCWD = _require.resolve('typescript')
-    const tscPath = join(typescriptPathCWD, '..', '..', 'bin', 'tsc')
-    if (tscPath) {
-      const isAccessible = await isFileAccessible(tscPath)
-      if (isAccessible) {
-        await execa(tscPath, { cwd: dirname(tsconfigPath), stdio: 'inherit' })
-      }
-    }
-    const tsconfig = JSON.parse(await readFile(tsconfigPath))
-    const outDir = tsconfig.compilerOptions.outDir
-    if (outDir) {
-      prefix = join(dirname(tsconfigPath), outDir)
-    }
-  } catch (err) {
-    console.log(err)
-  }
+if (args.values.timeout) {
+  args.values.timeout = parseInt(args.values.timeout)
 }
 
-let files
-if (args.positionals.length > 0) {
-  if (prefix) {
-    files = args.positionals.map((file) => join(prefix, file.replace(/ts$/, 'js')))
-  } else {
-    files = args.positionals
-  }
-} else if (args.values.pattern) {
-  if (prefix) {
-    args.values.pattern = join(prefix, args.values.pattern)
-  }
-  files = await glob(args.values.pattern, { ignore: 'node_modules/**' })
-} else {
-  if (prefix) {
-    files = await glob(join(prefix, 'test/**/*.test.{cjs,mjs,js}'), { ignore: 'node_modules/**' })
-  } else {
-    files = await glob('test/**/*.test.{cjs,mjs,js}', { ignore: 'node_modules/**' })
-  }
+let covDir
+if (args.values.coverage) {
+  covDir = await mkdtemp(join(process.cwd(), 'coverage-'))
+  process.env.NODE_V8_COVERAGE = covDir
 }
 
 const config = {
   ...args.values,
-  files
+  files: args.positionals,
+  pattern: args.values.pattern,
+  cwd: process.cwd()
 }
 
-run(config)
-  .compose(reporter)
-  .pipe(process.stdout)
+try {
+  const stream = await runWithTypeScript(config)
+
+  stream.on('test:fail', () => {
+    process.exitCode = 1
+  })
+
+  stream.compose(reporter).pipe(process.stdout)
+
+  await finished(stream)
+
+  if (covDir) {
+    let exclude = (args.values['coverage-exclude'] || '').split(',').filter(Boolean)
+
+    if (exclude.length === 0) {
+      exclude = undefined
+    } else if (config.prefix) {
+      const localPrefix = relative(process.cwd(), config.prefix)
+      exclude = exclude.map((file) => posix.join(localPrefix, file))
+    }
+    console.log('>> Excluding from coverage:', exclude)
+    const report = Report({
+      reporter: ['text'],
+      tempDirectory: covDir,
+      exclude
+    })
+
+    await report.run()
+  }
+  /* c8 ignore next 3 */
+} catch (err) {
+  console.error(err)
+} finally {
+  if (covDir) {
+    await rm(covDir, { recursive: true })
+  }
+}

package/fixtures/fails/test/wrong.test.js

@@ -0,0 +1,6 @@
+import { strictEqual } from 'node:assert'
+import { test } from 'node:test'
+
+test('this will fail', () => {
+  strictEqual(1, 2)
+})

package/fixtures/ts-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/fixtures/ts-cjs/test/add2.test.ts

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

package/{fixture → fixtures/ts-cjs}/tsconfig.json

@@ -18,6 +18,7 @@
     "skipLibCheck": true,
     "lib": [
       "ESNext"
-    ]
+    ],
+    "incremental": true
   }
 }

package/fixtures/ts-esm/src/add.ts

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

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

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

package/fixtures/ts-esm/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "outDir": "dist",
+    "sourceMap": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "resolveJsonModule": true,
+    "removeComments": true,
+    "newLine": "lf",
+    "noUnusedLocals": true,
+    "noFallthroughCasesInSwitch": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "lib": [
+      "ESNext"
+    ],
+    "incremental": true
+  }
+}

package/lib/run.js

@@ -0,0 +1,144 @@
+import { run } from 'node:test'
+import { glob } from 'glob'
+import { findUp } from 'find-up'
+import { createRequire } from 'node:module'
+import { resolve, join, dirname } from 'node:path'
+import { access, readFile } from 'node:fs/promises'
+import { execa } from 'execa'
+
+async function isFileAccessible (filename, directory) {
+  try {
+    const filePath = directory ? resolve(directory, filename) : filename
+    await access(filePath)
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+function deferred () {
+  let resolve
+  let reject
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve
+    reject = _reject
+  })
+  return { resolve, reject, promise }
+}
+
+export default async function runWithTypeScript (config) {
+  const { cwd } = config
+  const chunks = []
+  const tsconfigPath = await findUp('tsconfig.json', { cwd })
+
+  let prefix = ''
+  let tscPath
+
+  if (tsconfigPath) {
+    const _require = createRequire(cwd)
+    const typescriptPathCWD = _require.resolve('typescript')
+    tscPath = join(typescriptPathCWD, '..', '..', 'bin', 'tsc')
+    if (tscPath) {
+      const isAccessible = await isFileAccessible(tscPath)
+      if (isAccessible) {
+        // Watch is handled aftterwards
+        if (!config.watch) {
+          const start = Date.now()
+          await execa('node', [tscPath], { cwd: dirname(tsconfigPath) })
+          chunks.push({
+            type: 'test:diagnostic',
+            data: {
+              nesting: 0,
+              message: `TypeScript compilation complete (${Date.now() - start}ms)`
+            }
+          })
+        }
+      } else {
+        throw new Error('Could not find tsc')
+      }
+    }
+    const tsconfig = JSON.parse(await readFile(tsconfigPath))
+    const outDir = tsconfig.compilerOptions.outDir
+    if (outDir) {
+      prefix = join(dirname(tsconfigPath), outDir)
+    }
+  }
+  config.prefix = prefix
+  config.setup = (test) => {
+    for (const chunk of chunks) {
+      test.reporter.push(chunk)
+    }
+  }
+
+  let tscChild
+  /* eslint prefer-const: "off" */
+  let stream
+  let p
+
+  if (config.watch) {
+    p = deferred()
+    const start = Date.now()
+    tscChild = execa('node', [tscPath, '--watch'], { cwd })
+    tscChild.stdout.setEncoding('utf8')
+    tscChild.stdout.on('data', (data) => {
+      if (data.includes('Watching for file changes')) {
+        chunks.push({
+          type: 'test:diagnostic',
+          data: {
+            nesting: 0,
+            message: `TypeScript compilation complete (${Date.now() - start}ms)`
+          }
+        })
+
+        p.resolve()
+      }
+      if (data.includes('error TS')) {
+        const toPush = stream || chunks
+        toPush.push({
+          type: 'test:fail',
+          data: {
+            nesting: 0,
+            name: data.trim()
+          }
+        })
+      }
+    })
+    if (config.signal) {
+      config.signal.addEventListener('abort', () => {
+        tscChild.kill()
+      })
+    }
+  }
+
+  if (p) {
+    await p.promise
+  }
+
+  let files = config.files || []
+  const ignore = join('node_modules', '**')
+  if (files.length > 0) {
+    if (prefix) {
+      files = files.map((file) => join(prefix, file.replace(/ts$/, 'js')))
+    }
+  } else if (config.pattern) {
+    if (prefix) {
+      config.pattern = join(prefix, config.pattern)
+    }
+    files = await glob(config.pattern, { ignore, cwd, windowsPathsNoEscape: true })
+  } else if (prefix) {
+    files = await glob(join(prefix, join('test', '**', '*.test.{cjs,mjs,js}')), { ignore, cwd, windowsPathsNoEscape: true })
+  } else {
+    files = await glob(join('test', '**', '*.test.{cjs,mjs,js}'), { ignore, cwd, windowsPathsNoEscape: true })
+  }
+
+  config.files = files
+
+  stream = run(config)
+
+  stream.on('close', () => {
+    if (tscChild) {
+      tscChild.kill()
+    }
+  })
+  return stream
+}

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "borp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "node:test wrapper with TypeScript support",
   "main": "borp.js",
   "scripts": {
-    "test": "standard | snazzy"
+    "clean": "rm -rf fixtures/*/dist .test-* coverage-*",
+    "lint": "standard | snazzy",
+    "unit": "node borp.js --concurrency=1 --coverage --coverage-exclude \"fixtures/**/*,test/**/*\"",
+    "test": "npm run clean ; npm run lint && npm run unit"
   },
   "keywords": [],
   "author": "Matteo Collina <hello@matteocollina.com>",
   "license": "MIT",
   "devDependencies": {
+    "@matteo.collina/tspl": "^0.1.0",
     "@types/node": "^20.10.0",
+    "desm": "^1.3.0",
     "snazzy": "^9.0.0",
     "standard": "^17.1.0",
     "typescript": "^5.3.2"
   },
   "dependencies": {
+    "c8": "^8.0.1",
     "execa": "^8.0.1",
     "find-up": "^7.0.0",
     "glob": "^10.3.10"

package/test/basic.test.js

@@ -0,0 +1,47 @@
+import { test } from 'node:test'
+import { tspl } from '@matteo.collina/tspl'
+import runWithTypeScript from '../lib/run.js'
+import { join } from 'desm'
+
+test('ts-esm', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 4 })
+  const config = {
+    files: [],
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const names = new Set(['add', 'add2'])
+
+  stream.once('data', (test) => {
+    strictEqual(test.type, 'test:diagnostic')
+    match(test.data.message, /TypeScript compilation complete \(\d+ms\)/)
+  })
+
+  stream.on('test:pass', (test) => {
+    strictEqual(names.has(test.name), true)
+    names.delete(test.name)
+  })
+
+  await completed
+})
+
+test('ts-cjs', async (t) => {
+  const { strictEqual, completed } = tspl(t, { plan: 2 })
+  const config = {
+    files: [],
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-cjs')
+  }
+
+  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)
+  })
+
+  await completed
+})

package/test/cli.test.js

@@ -0,0 +1,25 @@
+import { test } from 'node:test'
+import { execa } from 'execa'
+import { join } from 'desm'
+import { rejects } from 'node:assert'
+
+const borp = join(import.meta.url, '..', 'borp.js')
+
+test('limit concurrency', async () => {
+  await execa('node', [
+    borp,
+    '--concurrency',
+    '1'
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  })
+})
+
+test('failing test set correct status code', async () => {
+  // execa rejects if status code is not 0
+  await rejects(execa('node', [
+    borp
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'fails')
+  }))
+})

package/test/coverage.test.js

@@ -0,0 +1,36 @@
+import { test } from 'node:test'
+import { match, doesNotMatch } from 'node:assert'
+import { execa } from 'execa'
+import { join } from 'desm'
+
+const borp = join(import.meta.url, '..', 'borp.js')
+
+test('coverage', async () => {
+  const res = await execa('node', [
+    borp,
+    '--coverage'
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  })
+
+  match(res.stdout, /% Stmts/)
+  match(res.stdout, /All files/)
+  match(res.stdout, /add\.ts/)
+})
+
+test('coverage excludes', async () => {
+  const res = await execa('node', [
+    borp,
+    '--coverage',
+    '--coverage-exclude=src'
+  ], {
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  })
+
+  match(res.stdout, /% Stmts/)
+  match(res.stdout, /All files/)
+  doesNotMatch(res.stdout, /add\.ts/)
+  // The test files are shown
+  match(res.stdout, /add\.test\.ts/)
+  match(res.stdout, /add2\.test\.ts/)
+})

package/test/watch.test.js

@@ -0,0 +1,107 @@
+import { test } from 'node:test'
+import { tspl } from '@matteo.collina/tspl'
+import runWithTypeScript from '../lib/run.js'
+import { join } from 'desm'
+import { mkdtemp, cp, writeFile, rm } from 'node:fs/promises'
+import path from 'node:path'
+import { once } from 'node:events'
+
+test('watch', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 3 })
+
+  const dir = path.resolve(await mkdtemp('.test-watch'))
+  await cp(join(import.meta.url, '..', 'fixtures', 'ts-esm'), dir, {
+    recursive: true
+  })
+
+  const controller = new AbortController()
+  t.after(async () => {
+    controller.abort()
+    await rm(dir, { recursive: true })
+  })
+
+  const config = {
+    files: [],
+    cwd: dir,
+    signal: controller.signal,
+    watch: true
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const fn = (test) => {
+    if (test.type === 'test:fail') {
+      strictEqual(test.data.name, 'add')
+      stream.removeListener('data', fn)
+    }
+  }
+  stream.on('data', fn)
+
+  const [test] = await once(stream, 'data')
+  strictEqual(test.type, 'test:diagnostic')
+  match(test.data.message, /TypeScript compilation complete \(\d+ms\)/)
+
+  const toWrite = `
+import { test } from 'node:test'
+import { add } from '../src/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add', () => {
+  strictEqual(add(1, 2), 4)
+})
+`
+  const file = path.join(dir, 'test', 'add.test.ts')
+  await writeFile(file, toWrite)
+
+  await completed
+})
+
+test('watch file syntax error', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 3 })
+
+  const dir = path.resolve(await mkdtemp('.test-watch'))
+  await cp(join(import.meta.url, '..', 'fixtures', 'ts-esm'), dir, {
+    recursive: true
+  })
+
+  const controller = new AbortController()
+  t.after(async () => {
+    controller.abort()
+    await rm(dir, { recursive: true })
+  })
+
+  const config = {
+    files: [],
+    cwd: dir,
+    signal: controller.signal,
+    watch: true
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const fn = (test) => {
+    if (test.type === 'test:fail') {
+      match(test.data.name, /add\.test\.ts/)
+      stream.removeListener('data', fn)
+    }
+  }
+  stream.on('data', fn)
+
+  const [test] = await once(stream, 'data')
+  strictEqual(test.type, 'test:diagnostic')
+  match(test.data.message, /TypeScript compilation complete \(\d+ms\)/)
+
+  const toWrite = `
+import { test } from 'node:test'
+import { add } from '../src/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add', () => {
+  strictEqual(add(1, 2), 3
+})
+`
+  const file = path.join(dir, 'test', 'add.test.ts')
+  await writeFile(file, toWrite)
+
+  await completed
+})