borp 0.3.0 → 0.4.0

package/README.md

@@ -21,7 +21,18 @@ Borp will autumatically run all tests files matching `*.test.{js|ts}`.
 
 ### Example project setup
 
-As an example, consider having a `src/add.ts` file  
+```
+.
+├── 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 {
@@ -29,11 +40,11 @@ export function add (x: number, y: number): number {
 }
 ```
 
-and a `test/add.test.ts` file:
+and a `src/test/add.test.ts` file:
 
 ```typescript
 import { test } from 'node:test'
-import { add } from '../src/add.js'
+import { add } from '../lib/add.js'
 import { strictEqual } from 'node:assert'
 
 test('add', () => {
@@ -41,7 +52,7 @@ test('add', () => {
 })
 ```
 
-and the following `tsconfig`:
+and the following `tsconfig.json`:
 
 ```json
 {
@@ -79,6 +90,8 @@ Note the use of `incremental: true`, which speed up compilation massively.
 * `--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
 

package/borp.js

@@ -2,12 +2,13 @@
 
 import { parseArgs } from 'node:util'
 import { tap, spec } from 'node:test/reporters'
-import { mkdtemp, rm } from 'node:fs/promises'
+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 */
@@ -24,14 +25,22 @@ 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' }
+    '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)
 }
@@ -42,7 +51,7 @@ if (args.values.timeout) {
 
 let covDir
 if (args.values.coverage) {
-  covDir = await mkdtemp(join(process.cwd(), 'coverage-'))
+  covDir = await mkdtemp(join(os.tmpdir(), 'coverage-'))
   process.env.NODE_V8_COVERAGE = covDir
 }
 
@@ -65,15 +74,12 @@ try {
   await finished(stream)
 
   if (covDir) {
-    let exclude = (args.values['coverage-exclude'] || '').split(',').filter(Boolean)
+    let exclude = args.values['coverage-exclude']
 
-    if (exclude.length === 0) {
-      exclude = undefined
-    } else if (config.prefix) {
+    if (exclude && 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,
@@ -87,6 +93,9 @@ try {
   console.error(err)
 } finally {
   if (covDir) {
-    await rm(covDir, { recursive: true })
+    try {
+      await rm(covDir, { recursive: true, maxRetries: 10, retryDelay: 100 })
+      /* c8 ignore next 2 */
+    } catch {}
   }
 }

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

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

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/fixtures/only-src/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/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/lib/run.js

@@ -2,20 +2,10 @@ 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 { 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
@@ -28,7 +18,7 @@ function deferred () {
 
 export default async function runWithTypeScript (config) {
   const { cwd } = config
-  const chunks = []
+  let pushable = []
   const tsconfigPath = await findUp('tsconfig.json', { cwd })
 
   let prefix = ''
@@ -39,22 +29,20 @@ export default async function runWithTypeScript (config) {
     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')
+      // 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))
@@ -65,9 +53,10 @@ export default async function runWithTypeScript (config) {
   }
   config.prefix = prefix
   config.setup = (test) => {
-    for (const chunk of chunks) {
+    for (const chunk of pushable) {
       test.reporter.push(chunk)
     }
+    pushable = test.reporter
   }
 
   let tscChild
@@ -82,7 +71,7 @@ export default async function runWithTypeScript (config) {
     tscChild.stdout.setEncoding('utf8')
     tscChild.stdout.on('data', (data) => {
       if (data.includes('Watching for file changes')) {
-        chunks.push({
+        pushable.push({
           type: 'test:diagnostic',
           data: {
             nesting: 0,
@@ -93,8 +82,7 @@ export default async function runWithTypeScript (config) {
         p.resolve()
       }
       if (data.includes('error TS')) {
-        const toPush = stream || chunks
-        toPush.push({
+        pushable.push({
           type: 'test:fail',
           data: {
             nesting: 0,
@@ -115,20 +103,23 @@ export default async function runWithTypeScript (config) {
   }
 
   let files = config.files || []
-  const ignore = join('node_modules', '**')
+  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) {
-      config.pattern = join(prefix, config.pattern)
+      pattern = join(prefix, pattern)
+      pattern = pattern.replace(/ts$/, 'js')
     }
-    files = await glob(config.pattern, { ignore, cwd, windowsPathsNoEscape: true })
+    files = await glob(pattern, { ignore, cwd, windowsPathsNoEscape: true })
   } else if (prefix) {
-    files = await glob(join(prefix, join('test', '**', '*.test.{cjs,mjs,js}')), { ignore, cwd, windowsPathsNoEscape: true })
+    files = await glob(join(prefix, join('**', '*.test.{cjs,mjs,js}')), { ignore, cwd, windowsPathsNoEscape: true })
   } else {
-    files = await glob(join('test', '**', '*.test.{cjs,mjs,js}'), { ignore, cwd, windowsPathsNoEscape: true })
+    files = await glob(join('**', '*.test.{cjs,mjs,js}'), { ignore, cwd, windowsPathsNoEscape: true })
   }
 
   config.files = files

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "borp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "node:test wrapper with TypeScript support",
   "main": "borp.js",
   "scripts": {
-    "clean": "rm -rf fixtures/*/dist .test-* coverage-*",
+    "clean": "rm -rf fixtures/*/dist .test-*",
     "lint": "standard | snazzy",
-    "unit": "node borp.js --concurrency=1 --coverage --coverage-exclude \"fixtures/**/*,test/**/*\"",
+    "unit": "node borp.js --ignore \"fixtures/**/*\" --coverage --coverage-exclude \"fixtures/**/*\" --coverage-exclude \"test/**/*\"",
     "test": "npm run clean ; npm run lint && npm run unit"
   },
   "keywords": [],

package/test/basic.test.js

@@ -45,3 +45,123 @@ test('ts-cjs', async (t) => {
 
   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/watch.test.js

@@ -17,7 +17,9 @@ test('watch', async (t) => {
   const controller = new AbortController()
   t.after(async () => {
     controller.abort()
-    await rm(dir, { recursive: true })
+    try {
+      await rm(dir, { recursive: true, retryDelay: 100, maxRetries: 10 })
+    } catch {}
   })
 
   const config = {
@@ -67,7 +69,9 @@ test('watch file syntax error', async (t) => {
   const controller = new AbortController()
   t.after(async () => {
     controller.abort()
-    await rm(dir, { recursive: true })
+    try {
+      await rm(dir, { recursive: true, retryDelay: 100, maxRetries: 10 })
+    } catch {}
   })
 
   const config = {