feat(runner): provide meaningful stack on timeouts

Author: ph-fritsche

src/runner/TestContext.ts

@@ -29,29 +29,51 @@ export function setTestContext(on: object, context: TestSuite|TestGroup) {
             )
         }
     }
+
     const test = (
         title: string,
         callback: TestCallback,
         timeout?: number,
     ) => {
-        new TestFunction(context, title, callback, timeout)
+        const error = new Error()
+        const getErrorCallStack = async () => {
+            return error.stack?.split('\n').slice(2).join('\n')
+        }
+
+        new TestFunction(
+            context,
+            title,
+            callback,
+            timeout,
+            getErrorCallStack,
+        )
     }
-    test.each = <Args>(cases: Iterable<Args>) => (
-        title: string,
-        cb: TestCallback<Args extends (unknown[] | readonly unknown[]) ? [...Args] : [Args]>,
-        timeout?: number,
-    ) => {
-        for (const args of cases) {
-            const argsArray = (Array.isArray(args) ? args : [args]) as (Args extends (unknown[] | readonly unknown[]) ? [...Args] : [Args])
-            test(
-                vsprintf(title, argsArray),
-                function(this: TestFunction) {
-                    return cb.apply(this, argsArray)
-                },
-                timeout,
-            )
+    test.each = <Args>(cases: Iterable<Args>) => {
+        const error = new Error()
+        const getErrorCallStack = async () => {
+            return error.stack?.split('\n').slice(2).join('\n')
+        }
+
+        return (
+            title: string,
+            cb: TestCallback<Args extends (unknown[] | readonly unknown[]) ? [...Args] : [Args]>,
+            timeout?: number,
+        ) => {
+            for (const args of cases) {
+                const argsArray = (Array.isArray(args) ? args : [args]) as (Args extends (unknown[] | readonly unknown[]) ? [...Args] : [Args])
+                new TestFunction(
+                    context,
+                    vsprintf(title, argsArray),
+                    function(this: TestFunction) {
+                        return cb.apply(this, argsArray)
+                    },
+                    timeout,
+                    getErrorCallStack,
+                )
+            }
         }
     }
+
     const beforeAll = (cb: BeforeCallback) => {
         context.beforeAll.push(cb)
     }

src/runner/TestNode.ts

@@ -61,6 +61,7 @@ export class TestFunction extends TestChildNode {
         readonly title: string,
         readonly callback: TestCallback,
         readonly timeout?: number,
+        readonly getCallStack?: () => Promise<string|undefined>,
     ) {
         super(parent, title)
     }

src/runner/TestRunner.ts

@@ -148,19 +148,23 @@ export class TestRunner {
         const t0 = this.clock()
         let timer: number|undefined
         let reject: () => void = () => void 0
+        const timeoutSymbol = Symbol('timeout')
         try {
             await Promise.race([
                 new Promise((res, rej) => {
-                    timer = this.setTimeout(() => rej(
-                        new TimeoutError(`Test "${test.title}" timed out after ${timeout}ms.`),
-                    ), timeout)
+                    timer = this.setTimeout(() => rej(timeoutSymbol), timeout)
                 }),
                 test.callback.call(test),
             ])
             const duration = this.clock() - t0
             return new TestResult(test, undefined, duration)
         } catch (e) {
             const duration = this.clock() - t0
+            if (e === timeoutSymbol) {
+                const error = new TimeoutError(`Test "${test.title}" timed out after ${timeout}ms.`)
+                error.stack = `${error.name}: ${error.message}\n${await test.getCallStack?.() ?? ''}`
+                return new TestResult(test, error, duration)
+            }
             return new TestResult(test, this.normalizeError(e), duration)
         } finally {
             reject()