borp 0.2.0 → 0.4.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,98 @@
+# 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
+
+```
+.
+├── src
+│   ├── lib
+│   │   └── add.ts
+│   └── test
+│       └── add.test.ts
+└── tsconfig.json
+
+```
+
+As an example, consider having a `src/lib/add.ts` file  
+
+```typescript
+export function add (x: number, y: number): number {
+  return x + y
+}
+```
+
+and a `src/test/add.test.ts` file:
+
+```typescript
+import { test } from 'node:test'
+import { add } from '../lib/add.js'
+import { strictEqual } from 'node:assert'
+
+test('add', () => {
+  strictEqual(add(1, 2), 3)
+})
+```
+
+and the following `tsconfig.json`:
+
+```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.
+* `--ignore` or `-i`, ignore a glob pattern, and not look for tests there
+* `--pattern` or `-p`, run tests matching the given glob pattern
+
+## License
+
+MIT

package/borp.js

@@ -2,27 +2,19 @@
 
 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, readFile } 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'
+import os from 'node:os'
 
 let reporter
+/* c8 ignore next 4 */
 if (process.stdout.isTTY) {
-  reporter = spec()
+  /* eslint new-cap: "off" */
+  reporter = new spec()
 } else {
   reporter = tap
 }
@@ -33,65 +25,77 @@ 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', default: os.availableParallelism() - 1 + '' },
+    coverage: { type: 'boolean', short: 'C' },
+    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' }
   },
   allowPositionals: true
 })
 
+/* c8 ignore next 4 */
+if (args.values.help) {
+  console.log(await readFile(new URL('./README.md', import.meta.url), 'utf8'))
+  process.exit(0)
+}
+
 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(os.tmpdir(), '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']
+
+    if (exclude && config.prefix) {
+      const localPrefix = relative(process.cwd(), config.prefix)
+      exclude = exclude.map((file) => posix.join(localPrefix, file))
+    }
+    const report = Report({
+      reporter: ['text'],
+      tempDirectory: covDir,
+      exclude
+    })
+
+    await report.run()
+  }
+  /* c8 ignore next 3 */
+} catch (err) {
+  console.error(err)
+} finally {
+  if (covDir) {
+    try {
+      await rm(covDir, { recursive: true, maxRetries: 10, retryDelay: 100 })
+      /* c8 ignore next 2 */
+    } catch {}
+  }
+}

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/only-src/src/add.test.ts

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

package/fixtures/only-src/src/add2.test.ts

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

package/{fixture → fixtures/only-src}/tsconfig.json

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

package/fixtures/src-to-dist/src/lib/add.ts

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

package/fixtures/src-to-dist/src/test/add.test.ts

@@ -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/src-to-dist/src/test/add2.test.ts

@@ -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/fixtures/src-to-dist/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/fixtures/ts-cjs/package.json

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

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

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

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/fixtures/ts-cjs/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/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,135 @@
+import { run } from 'node:test'
+import { glob } from 'glob'
+import { findUp } from 'find-up'
+import { createRequire } from 'node:module'
+import { join, dirname } from 'node:path'
+import { access, readFile } from 'node:fs/promises'
+import { execa } from 'execa'
+
+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
+  let pushable = []
+  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) {
+      // This will throw if we cannot find the `tsc` binary
+      await access(tscPath)
+
+      // Watch is handled aftterwards
+      if (!config.watch) {
+        const start = Date.now()
+        await execa('node', [tscPath], { cwd: dirname(tsconfigPath) })
+        pushable.push({
+          type: 'test:diagnostic',
+          data: {
+            nesting: 0,
+            message: `TypeScript compilation complete (${Date.now() - start}ms)`
+          }
+        })
+      }
+    }
+    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 pushable) {
+      test.reporter.push(chunk)
+    }
+    pushable = test.reporter
+  }
+
+  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')) {
+        pushable.push({
+          type: 'test:diagnostic',
+          data: {
+            nesting: 0,
+            message: `TypeScript compilation complete (${Date.now() - start}ms)`
+          }
+        })
+
+        p.resolve()
+      }
+      if (data.includes('error TS')) {
+        pushable.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 = config.ignore || []
+  ignore.unshift('node_modules/**/*')
+  if (files.length > 0) {
+    if (prefix) {
+      files = files.map((file) => join(prefix, file.replace(/ts$/, 'js')))
+    }
+  } else if (config.pattern) {
+    let pattern = config.pattern
+    if (prefix) {
+      pattern = join(prefix, pattern)
+      pattern = pattern.replace(/ts$/, 'js')
+    }
+    files = await glob(pattern, { ignore, cwd, windowsPathsNoEscape: true })
+  } 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 })
+  }
+
+  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.4.0",
   "type": "module",
   "description": "node:test wrapper with TypeScript support",
   "main": "borp.js",
   "scripts": {
-    "test": "standard | snazzy"
+    "clean": "rm -rf fixtures/*/dist .test-*",
+    "lint": "standard | snazzy",
+    "unit": "node borp.js --ignore \"fixtures/**/*\" --coverage --coverage-exclude \"fixtures/**/*\" --coverage-exclude \"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,167 @@
+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
+})
+
+test('ts-esm with named failes', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 3 })
+  const config = {
+    files: ['test/add.test.ts'],
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const names = new Set(['add'])
+
+  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('pattern', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 3 })
+  const config = {
+    files: [],
+    pattern: 'test/*2.test.ts',
+    cwd: join(import.meta.url, '..', 'fixtures', 'ts-esm')
+  }
+
+  const stream = await runWithTypeScript(config)
+
+  const names = new Set(['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('no files', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 4 })
+  const config = {
+    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('src-to-dist', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 4 })
+  const config = {
+    files: [],
+    cwd: join(import.meta.url, '..', 'fixtures', 'src-to-dist')
+  }
+
+  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('only-src', async (t) => {
+  const { strictEqual, completed, match } = tspl(t, { plan: 4 })
+  const config = {
+    files: [],
+    cwd: join(import.meta.url, '..', 'fixtures', 'only-src')
+  }
+
+  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
+})

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,111 @@
+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()
+    try {
+      await rm(dir, { recursive: true, retryDelay: 100, maxRetries: 10 })
+    } catch {}
+  })
+
+  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()
+    try {
+      await rm(dir, { recursive: true, retryDelay: 100, maxRetries: 10 })
+    } catch {}
+  })
+
+  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
+})