feat: Added callbacks.

Author: ShogunPanda

README.md

@@ -76,6 +76,9 @@ The supported options are the following:
   - `colors`: If use colors. Default is `true`.
   - `compare`: If compare tests in the output. Default is `false`.
   - `compareMode`: When comparing is enabled, this can be set to `base` in order to always compare a test to the slowest one. The default is to compare a test to the immediate slower one.
+- `onTestStart`: Callback invoked every time a test is started.
+- `onTestEnd`: Callback invoked every time a test has finished.
+- `onTestError`: Callback invoked every time a test could not be loaded. If the test function throws an error or rejects, `onTestEnd` will be invoked instead.
 
 ## Results structure
 

src/index.ts

@@ -29,16 +29,19 @@ function scheduleNextTest(context: Context): void {
 
 function run(context: Context): void {
   const name = context.tests[context.current][0]
+  const workerData = {
+    path: process.argv[1],
+    index: context.current,
+    iterations: context.iterations,
+    warmup: context.warmup,
+    errorThreshold: context.errorThreshold
+  }
 
-  const worker = new Worker(runnerPath, {
-    workerData: {
-      path: process.argv[1],
-      index: context.current,
-      iterations: context.iterations,
-      warmup: context.warmup,
-      errorThreshold: context.errorThreshold
-    }
-  })
+  const worker = new Worker(runnerPath, { workerData })
+
+  if (context.onTestStart) {
+    context.onTestStart(name, workerData, worker)
+  }
 
   worker.on('error', error => {
     context.results[name] = {
@@ -55,13 +58,21 @@ function run(context: Context): void {
 
     context.current++
 
+    if (context.onTestError) {
+      context.onTestError(name, error, worker)
+    }
+
     scheduleNextTest(context)
   })
 
   worker.on('message', result => {
     context.results[name] = result
     context.current++
 
+    if (context.onTestEnd) {
+      context.onTestEnd(name, result, worker)
+    }
+
     scheduleNextTest(context)
   })
 }
@@ -109,7 +120,10 @@ export function cronometro(
   }
 
   // Parse and validate options
-  const { iterations, errorThreshold, print, warmup } = { ...defaultOptions, ...options }
+  const { iterations, errorThreshold, print, warmup, onTestStart, onTestEnd, onTestError } = {
+    ...defaultOptions,
+    ...options
+  }
 
   if (typeof iterations !== 'number' || iterations < 1) {
     callback(new Error('The iterations option must be a positive number.'))
@@ -121,6 +135,21 @@ export function cronometro(
     return promise
   }
 
+  if (onTestStart && typeof onTestStart !== 'function') {
+    callback(new Error('The onTestStart option must be a function.'))
+    return promise
+  }
+
+  if (onTestEnd && typeof onTestEnd !== 'function') {
+    callback(new Error('The onTestEnd option must be a function.'))
+    return promise
+  }
+
+  if (onTestError && typeof onTestError !== 'function') {
+    callback(new Error('The onTestError option must be a function.'))
+    return promise
+  }
+
   // Prepare the test
   const context: Context = {
     warmup,
@@ -130,7 +159,10 @@ export function cronometro(
     tests: Object.entries(tests), // Convert tests to a easier to process [name, func] list,
     results: {},
     current: 0,
-    callback
+    callback,
+    onTestStart,
+    onTestEnd,
+    onTestError
   }
 
   process.nextTick(() => run(context))

src/models.ts

@@ -1,5 +1,6 @@
 import { Histogram } from 'hdr-histogram-js'
 import { resolve } from 'node:path'
+import { Worker } from 'node:worker_threads'
 
 export interface PrintOptions {
   colors?: boolean
@@ -16,6 +17,9 @@ export interface Options {
   errorThreshold: number
   print: boolean | PrintOptions
   warmup: boolean
+  onTestStart?: (name: string, data: object, worker: Worker) => void
+  onTestEnd?: (name: string, result: Result, worker: Worker) => void
+  onTestError?: (name: string, error: Error, worker: Worker) => void
 }
 
 export type StaticTest = () => any
@@ -64,6 +68,9 @@ export interface Context {
   results: Results
   current: number
   callback: Callback
+  onTestStart?: (name: string, data: object, worker: Worker) => void
+  onTestEnd?: (name: string, result: Result, worker: Worker) => void
+  onTestError?: (name: string, error: Error, worker: Worker) => void
 }
 
 export interface WorkerContext {

test/asyncImport.test.ts

@@ -21,7 +21,7 @@ async function main(): Promise<void> {
       () => false
     )
   } else {
-    t.only('Collecting results', async t => {
+    t.test('Collecting results', async t => {
       const results = await cronometro(
         {
           single() {

test/callbacks.test.ts

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+
+import { isMainThread, Worker } from 'node:worker_threads'
+import t from 'tap'
+import { cronometro, Result, TestFunction } from '../src/index.js'
+
+if (!isMainThread) {
+  cronometro(
+    {
+      single() {
+        Buffer.alloc(10)
+      },
+      multiple() {
+        throw new Error('INVALID')
+      },
+      missing: undefined as unknown as TestFunction
+    },
+    () => false
+  )
+} else {
+  t.test('Callbacks', async t => {
+    await cronometro(
+      {
+        single() {
+          Buffer.alloc(10)
+        },
+        multiple() {
+          throw new Error('INVALID')
+        },
+        missing() {
+          Buffer.alloc(10)
+        }
+      },
+      {
+        iterations: 10,
+        print: false,
+        onTestStart(name: string, data: any, worker: Worker) {
+          t.match(name, /single|multiple|missing/)
+          t.ok(data.index < 3)
+          t.ok(worker instanceof Worker)
+        },
+        onTestEnd(name: string, result: Result, worker: Worker) {
+          if (result.success) {
+            t.same(name, 'single')
+            t.ok(result.size > 0)
+          } else {
+            t.same(name, 'multiple')
+            t.same(result.error!.message, 'INVALID')
+          }
+          t.ok(worker instanceof Worker)
+        },
+        onTestError(name: string, error: Error, worker: Worker) {
+          t.same(name, 'missing')
+          t.same(error.message, "Cannot read properties of undefined (reading 'test')")
+          t.ok(worker instanceof Worker)
+        }
+      }
+    )
+  })
+}

test/errorHandling.test.ts

@@ -61,7 +61,7 @@ if (!isMainThread) {
     await t.rejects(import('../src/runner.js'), { message: 'Do not run this file as main script.' })
   })
 
-  t.only('Runner reports setup errors', async t => {
+  t.test('Runner reports setup errors', async t => {
     const results = await cronometro(
       {
         notDefined() {

test/optionsValidation.test.ts

@@ -37,4 +37,55 @@ t.test('Options validation', async t => {
       t.equal(err!.message, 'The errorThreshold option must be a number between 0 and 100.')
     }
   )
+
+  cronometro(
+    {
+      single() {
+        Buffer.alloc(10)
+      },
+      multiple() {
+        Buffer.alloc(10)
+        Buffer.alloc(20)
+      }
+    },
+    { onTestStart: 1 as any },
+    err => {
+      t.type(err, 'Error')
+      t.equal(err!.message, 'The onTestStart option must be a function.')
+    }
+  )
+
+  cronometro(
+    {
+      single() {
+        Buffer.alloc(10)
+      },
+      multiple() {
+        Buffer.alloc(10)
+        Buffer.alloc(20)
+      }
+    },
+    { onTestEnd: 1 as any },
+    err => {
+      t.type(err, 'Error')
+      t.equal(err!.message, 'The onTestEnd option must be a function.')
+    }
+  )
+
+  cronometro(
+    {
+      single() {
+        Buffer.alloc(10)
+      },
+      multiple() {
+        Buffer.alloc(10)
+        Buffer.alloc(20)
+      }
+    },
+    { onTestError: 1 as any },
+    err => {
+      t.type(err, 'Error')
+      t.equal(err!.message, 'The onTestError option must be a function.')
+    }
+  )
 })

test/success.test.ts

@@ -18,7 +18,7 @@ if (!isMainThread) {
     () => false
   )
 } else {
-  t.only('Collecting results', async t => {
+  t.test('Collecting results', async t => {
     const results = await cronometro(
       {
         single() {