fix: we at least detect the failure, but lose the route

lib/translator/render.ts

@@ -52,7 +52,7 @@ function renderDiag(context: Context, failure: Result) {
     return `\n    ${diag.type}: ${failure.name}\n${stackAndMaybeCode}`;
   }
 
-  return inspect({...failure.diag}, {depth: 3, colors: true}).replace(
+  return inspect(failure, {depth: 3, colors: true}).replace(
     /^/gm,
     '     ',
   );

lib/tree/builder.ts

@@ -16,10 +16,12 @@ export interface AssertNode {
 export type TreeNode = ChildNode | AssertNode;
 
 export class BuildTree {
-  readonly ours: TreeNode[] = [];
+  private readonly ours: TreeNode[] = [];
   private currentChild?: BuildTree;
+  private readonly comments: string[] = [];
 
   constructor(parser: TapParser) {
+    parser.on('comment', (comment) => this.comments.push(comment));
     parser.on('child', (child) => {
       if (undefined !== this.currentChild) {
         throw new Error(
@@ -33,7 +35,7 @@ export class BuildTree {
         this.ours.push({
           kind: 'child',
           result,
-          children: [...this.currentChild.ours],
+          children: [...this.currentChild.finished()],
         });
         this.currentChild = undefined;
       } else {
@@ -45,13 +47,10 @@ export class BuildTree {
     });
   }
 
-  collapse(path: string[], results: TreeNode[]): void {
-    if (this.ours) {
-      results.push(...this.ours);
-    }
-
+  finished(): TreeNode[] {
     if (this.currentChild) {
-      this.currentChild.collapse([...path, 'unknown'], results);
+      this.ours.push(...this.currentChild.finished());
     }
+    return this.ours;
   }
 }

lib/tree/flatten.ts

@@ -1,24 +1,18 @@
-import type {SerializableError, TestResult} from '@jest/test-result';
+import type { SerializableError, TestResult } from '@jest/test-result';
 import type { Result } from 'tap-parser';
-import type { BuildTree, ChildNode, TreeNode } from './builder';
+import type { BuildTree, ChildNode } from './builder';
 import { pushExceptionFailure, pushTestResults } from '../translator/render';
 import { Context } from '../context';
 
 export function flatten(context: Context, result: TestResult, builder: BuildTree): void {
-  const events = builder.ours;
+  const events = builder.finished();
   const first = events[0];
   if (first?.kind === 'child') {
     handle(context, result, first, []);
   }
   if (events.length > 1) {
     pushExceptionFailure(context, result, new Error('invalid root array length') as SerializableError, 'events.length');
   }
-
-  const path: string[] = [];
-  const results: TreeNode[] = [];
-  builder.ours.length = 0;
-  builder.collapse(path, results);
-  console.log(path, results);
 }
 
 function handle(context: Context, result: TestResult, node: ChildNode, path: string[]): void {

lib/types.d.ts

@@ -4,8 +4,9 @@ declare module 'tap-parser' {
   interface TapParser extends NodeJS.WritableStream {}
 
   class TapParser {
-    on(event: 'child', handler: (child: TapParser) => void): this;
     on(event: 'assert', handler: (result: Result) => void): this;
+    on(event: 'child', handler: (child: TapParser) => void): this;
+    on(event: 'comment', handler: (comment: string) => void): this;
   }
 
   namespace TapParser {

test/__snapshots__/terminations.spec.ts.snap

@@ -0,0 +1,14 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`translation of terminations handles a test which timed out 1`] = `
+"
+  ✕  bravo
+     Result {
+       ok: <yellow>false</>,
+       id: <yellow>2</>,
+       name: <green>'timeout!'</>,
+       diag: { signal: <green>'SIGTERM'</>, expired: <green>'TAP'</>, test: <green>'bravo'</> },
+       fullname: <green>'timeout.js bravo'</>
+     }
+"
+`;

test/terminations.spec.ts

@@ -4,11 +4,11 @@ import { testTranslation } from './translate.spec';
 describe('translation of terminations', () => {
   it('handles a test which timed out', async () => {
     const result = await testTranslation('./fixtures/timeout.tap');
-    expect(result.failureMessage).toBeUndefined();
-    expect(result.numFailingTests).toBe(0);
+    expect(result.numFailingTests).toBe(1);
     expect(result.numPendingTests).toBe(0);
     expect(result.numPassingTests).toBe(1);
     expect(result.skipped).toBe(false);
+    expect(result.failureMessage).toMatchSnapshot();
     expect(result.testResults).toStrictEqual([
       expect.objectContaining({
         title: 'alpha',