fix: properly handle promises in benchmark

Signed-off-by: Jérôme Benoit <[email protected]>

src/benchmark.js

@@ -29,7 +29,7 @@ import {
 } from './reporter/terminal/index.js'
 import { runtime } from './runtime.js'
 import { now } from './time.js'
-import { isAsyncFunction, isFunction, isObject } from './utils.js'
+import { isAsyncFnResource, isFunction, isObject } from './utils.js'
 
 let groupName = null
 const groups = new Map()
@@ -127,7 +127,7 @@ export function group(name, cb = undefined) {
       before: name.before ?? emptyFunction,
       after: name.after ?? emptyFunction,
     })
-  if (isAsyncFunction(cb)) {
+  if (isAsyncFnResource(cb)) {
     cb().then(() => {
       groupName = null
     })
@@ -172,7 +172,7 @@ export function bench(name, fn = undefined, opts = {}) {
     samples: opts.samples ?? defaultSamples,
     warmup: opts.warmup ?? true,
     baseline: false,
-    async: isAsyncFunction(fn),
+    async: isAsyncFnResource(fn),
   })
 }
 
@@ -212,7 +212,7 @@ export function baseline(name, fn = undefined, opts = {}) {
     samples: opts.samples ?? defaultSamples,
     warmup: opts.warmup ?? true,
     baseline: true,
-    async: isAsyncFunction(fn),
+    async: isAsyncFnResource(fn),
   })
 }
 
@@ -362,8 +362,7 @@ export async function run(opts = {}) {
       if (once) log('')
       log(groupHeader(groupName, opts))
     }
-
-    isAsyncFunction(groupOpts.before)
+    isAsyncFnResource(groupOpts.before)
       ? await groupOpts.before()
       : groupOpts.before()
 
@@ -373,8 +372,7 @@ export async function run(opts = {}) {
       opts,
       groupOpts
     )
-
-    isAsyncFunction(groupOpts.after)
+    isAsyncFnResource(groupOpts.after)
       ? await groupOpts.after()
       : groupOpts.after()
   }

src/lib.js

@@ -21,7 +21,7 @@ import { now } from './time.js'
 import {
   AsyncFunction,
   checkDividend,
-  isAsyncFunction,
+  isAsyncFnResource,
   isFunction,
   isObject,
 } from './utils.js'
@@ -185,7 +185,7 @@ export const overrideBenchmarkOptions = (benchmark, opts) => {
 /**
  * Measure a function runtime.
  *
- * @param {Function} [fn] function to measure
+ * @param {Function} fn function to measure
  * @param {Object} [opts={}] options object
  * @param {Boolean} [opts.async=undefined] function is async
  * @param {Number} [opts.samples=128] minimum number of benchmark samples
@@ -194,7 +194,7 @@ export const overrideBenchmarkOptions = (benchmark, opts) => {
  * @param {Function} [opts.now=undefined] nanoseconds timestamp function
  * @param {Function} [opts.before=()=>{}] before function hook
  * @param {Function} [opts.after=()=>{}] after function hook
- * @returns {Object} benchmark stats
+ * @returns {Promise<Object>} benchmark stats
  */
 export async function measure(fn, opts = {}) {
   checkBenchmarkArgs(fn, opts)
@@ -203,7 +203,7 @@ export async function measure(fn, opts = {}) {
       `expected boolean as 'async' option, got ${opts.async.constructor.name}`
     )
 
-  opts.async = opts.async ?? isAsyncFunction(fn)
+  opts.async = opts.async ?? isAsyncFnResource(fn)
   opts.time = opts.time ?? defaultTime
   opts.samples = opts.samples ?? defaultSamples
   opts.warmup =
@@ -216,8 +216,8 @@ export async function measure(fn, opts = {}) {
   opts.before = opts.before ?? emptyFunction
   opts.after = opts.after ?? emptyFunction
 
-  const asyncBefore = isAsyncFunction(opts.before)
-  const asyncAfter = isAsyncFunction(opts.after)
+  const asyncBefore = isAsyncFnResource(opts.before)
+  const asyncAfter = isAsyncFnResource(opts.after)
 
   const asyncFunction = opts.async || asyncBefore || asyncAfter
 

src/utils.js

@@ -1,13 +1,68 @@
+/**
+ * Checks if a value is a promise-like object.
+ *
+ * @param {unknown} maybePromiseLike the value to check
+ * @returns {Boolean} true if the value is a promise-like object
+ */
+const isPromiseLike = maybePromiseLike =>
+  maybePromiseLike !== null &&
+  typeof maybePromiseLike === 'object' &&
+  typeof maybePromiseLike.then === 'function'
+
+/**
+ * Checks if a value is a function.
+ *
+ * @param {unknown} fn the value to check
+ * @returns {Boolean} true if the value is a function
+ */
 export const isFunction = fn => {
   return typeof fn === 'function'
 }
 
 export const AsyncFunction = (async () => {}).constructor
 
-export const isAsyncFunction = fn => {
+/**
+ * An async function check helper only considering runtime support async syntax.
+ *
+ * @param {Function} fn the function to check
+ * @returns {Boolean} true if the function is an async function
+ */
+const isAsyncFunction = fn => {
   return AsyncFunction === fn?.constructor
 }
 
+/**
+ * An async function check helper considering runtime support async syntax and promise return.
+ *
+ * @param {Function} fn the function to check
+ * @returns {Boolean} true if the function is an async function or returns a promise
+ */
+export const isAsyncFnResource = fn => {
+  if (fn == null) {
+    return false
+  }
+  if (isAsyncFunction(fn)) {
+    return true
+  }
+  try {
+    const fnCall = fn()
+    const promiseLike = isPromiseLike(fnCall)
+    if (promiseLike) {
+      // silence promise rejection
+      fnCall.catch(() => {})
+    }
+    return promiseLike
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Checks if a value is an object.
+ *
+ * @param {unknown} value the value to check
+ * @returns {Boolean} true if the value is an object
+ */
 export const isObject = value => {
   return Object.prototype.toString.call(value).slice(8, -1) === 'Object'
 }

tests/test.js

@@ -9,17 +9,19 @@ bench('noop', () => {}, {
 })
 bench('async noop', async () => {})
 baseline('baseline noop', () => {})
-bench('async noop2', async () => Promise.resolve())
+bench('async promise noop', () => Promise.resolve())
 bench('error', () => {
   throw new Error('error')
 })
+bench('async promise reject', () => Promise.reject(new Error('reject')))
 
 group(() => {
   bench('a', () => {})
   bench('b', () => {})
   bench('e', () => {
     throw new Error("error 'e'")
   })
+  bench('r', () => Promise.reject(new Error("reject 'r'")))
 })
 
 group('group', () => {

tests/test.ts

@@ -9,17 +9,19 @@ bench('noop', () => {}, {
 })
 bench('async noop', async () => {})
 baseline('baseline noop', () => {})
-bench('async noop2', async () => Promise.resolve())
+bench('async promise noop', () => Promise.resolve())
 bench('error', () => {
   throw new Error('error')
 })
+bench('async promise reject', () => Promise.reject(new Error('reject')))
 
 group(() => {
   bench('a', () => {})
   bench('b', () => {})
   bench('e', () => {
     throw new Error("error 'e'")
   })
+  bench('r', () => Promise.reject(new Error("reject 'r'")))
 })
 
 group('group', () => {