test: make withTempDir and withLinkedWorktreeFixture async-safe

Convert test helpers to properly await async callbacks before cleanup.
This prevents race conditions where temp directories or worktrees are
cleaned up before async operations complete. Adds dedicated tests
validating cleanup waits for pending promises.

Author: kenryu42

tests/bin/doctor/config.test.ts

@@ -10,17 +10,17 @@ import { getConfigInfo } from '@/bin/doctor/config';
 import { withTempDir } from '../../helpers.ts';
 
 describe('getConfigInfo', () => {
-  test('handles missing config files', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('handles missing config files', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       const info = getConfigInfo(tmpDir);
       expect(info.projectConfig.exists).toBe(false);
       expect(info.effectiveRules).toEqual([]);
       expect(info.shadowedRules).toEqual([]);
     });
   });
 
-  test('detects valid project config', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('detects valid project config', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(
         join(tmpDir, '.safety-net.json'),
         JSON.stringify({
@@ -44,8 +44,8 @@ describe('getConfigInfo', () => {
     });
   });
 
-  test('detects invalid project config', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('detects invalid project config', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(join(tmpDir, '.safety-net.json'), '{ "version": 2 }');
       const info = getConfigInfo(tmpDir);
       expect(info.projectConfig.exists).toBe(true);
@@ -54,8 +54,8 @@ describe('getConfigInfo', () => {
     });
   });
 
-  test('excludes rules from invalid config (wrong version)', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('excludes rules from invalid config (wrong version)', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(
         join(tmpDir, '.safety-net.json'),
         JSON.stringify({
@@ -77,24 +77,24 @@ describe('getConfigInfo', () => {
     });
   });
 
-  test('handles malformed JSON in config', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('handles malformed JSON in config', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(join(tmpDir, '.safety-net.json'), '{ invalid json }');
       const info = getConfigInfo(tmpDir);
       expect(info.effectiveRules).toEqual([]);
     });
   });
 
-  test('handles empty config file', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('handles empty config file', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(join(tmpDir, '.safety-net.json'), '   ');
       const info = getConfigInfo(tmpDir);
       expect(info.effectiveRules).toEqual([]);
     });
   });
 
-  test('handles config without rules array', () => {
-    withTempDir('doctor-test-', (tmpDir) => {
+  test('handles config without rules array', async () => {
+    await withTempDir('doctor-test-', (tmpDir) => {
       writeFileSync(join(tmpDir, '.safety-net.json'), '{ "version": 1 }');
       const info = getConfigInfo(tmpDir);
       expect(info.effectiveRules).toEqual([]);

tests/bin/explain/command.test.ts

@@ -34,8 +34,11 @@ function expectDangerousTextStep(command: string): void {
   ).toBeDefined();
 }
 
-function expectWorktreeExplainBlocked(command: (mainWorktree: string) => string, reason: string) {
-  withLinkedWorktreeFixture((fixture) => {
+async function expectWorktreeExplainBlocked(
+  command: (mainWorktree: string) => string,
+  reason: string,
+) {
+  await withLinkedWorktreeFixture((fixture) => {
     withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
       const result = explainCommand(command(toShellPath(fixture.mainWorktree)), {
         cwd: fixture.linkedWorktree,
@@ -394,22 +397,14 @@ describe('explainCommand shell wrapper edge cases', () => {
 
 describe('explainCommand max recursion depth', () => {
   test('deeply nested command hits max recursion', () => {
-    const deepNested =
-      'bash -c "bash -c \\"bash -c \\\\\\"bash -c \\\\\\\\\\\\\\"bash -c \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"echo deep\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\"\\\\\\"\\"" ';
-    const steps = getTraceSteps(explainCommand(deepNested));
-    expect(
-      steps.filter((s) => s.type === 'recurse').length +
-        (recursionLimitErrorStep(deepNested) ? 1 : 0),
-    ).toBeGreaterThan(0);
+    const deepNested = nestedBashCommand('echo deep', 10);
+    expect(recursionLimitErrorStep(deepNested)).toBeTruthy();
   });
 
   test('hits exact max recursion depth of 5', () => {
     const level5 =
       'bash -c "bash -c \\"bash -c \\\\\\"bash -c \\\\\\\\\\\\\\"bash -c \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"echo hi\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\"\\\\\\"\\"" ';
-    const steps = getTraceSteps(explainCommand(level5));
-    expect(
-      steps.filter((s) => s.type === 'recurse').length >= 3 || recursionLimitErrorStep(level5),
-    ).toBeTruthy();
+    expect(recursionLimitErrorStep(level5)).toBeFalsy();
   });
 
   test('hits max recursion depth with 10 nested bash -c calls', () => {
@@ -581,54 +576,57 @@ describe('explainCommand fallback scan with find', () => {
 });
 
 describe('explainCommand worktree parity', () => {
-  test('uses wrapper cwd when explaining worktree relaxation', () => {
-    expectWorktreeExplainBlocked((main) => `env -C ${main} git reset --hard`, 'git reset --hard');
+  test('uses wrapper cwd when explaining worktree relaxation', async () => {
+    await expectWorktreeExplainBlocked(
+      (main) => `env -C ${main} git reset --hard`,
+      'git reset --hard',
+    );
   });
 
-  test('carries exported git context overrides into later segments', () => {
-    expectWorktreeExplainBlocked(
+  test('carries exported git context overrides into later segments', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `export GIT_WORK_TREE=${main}; git reset --hard`,
       'git reset --hard',
     );
   });
 
-  test('passes wrapper cwd into recursive explain analysis', () => {
-    expectWorktreeExplainBlocked(
+  test('passes wrapper cwd into recursive explain analysis', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `env -C ${main} sh -c "git reset --hard"`,
       'git reset --hard',
     );
   });
 
-  test('passes stripped env into recursive explain analysis', () => {
-    expectWorktreeExplainBlocked(
+  test('passes stripped env into recursive explain analysis', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `GIT_WORK_TREE=${main} sh -c "git reset --hard"`,
       'git reset --hard',
     );
   });
 
-  test('carries nested exported git context overrides across inner segments', () => {
-    expectWorktreeExplainBlocked(
+  test('carries nested exported git context overrides across inner segments', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `sh -c "export GIT_WORK_TREE=${main}; git reset --hard"`,
       'git reset --hard',
     );
   });
 
-  test('includes keyword-export git context overrides in current segment', () => {
-    expectWorktreeExplainBlocked(
+  test('includes keyword-export git context overrides in current segment', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `set -k; git restore file.txt GIT_WORK_TREE=${main}`,
       'git restore',
     );
   });
 
-  test('includes nested keyword-export git context overrides in current segment', () => {
-    expectWorktreeExplainBlocked(
+  test('includes nested keyword-export git context overrides in current segment', async () => {
+    await expectWorktreeExplainBlocked(
       (main) => `sh -c "set -k; git restore file.txt GIT_WORK_TREE=${main}"`,
       'git restore',
     );
   });
 
-  test('honors parallel nested overrides when explaining remote commands', () => {
-    withLinkedWorktreeFixture((fixture) => {
+  test('honors parallel nested overrides when explaining remote commands', async () => {
+    await withLinkedWorktreeFixture((fixture) => {
       withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
         const result = explainCommand('parallel -S host sh -c "git reset --hard" ::: x', {
           cwd: fixture.linkedWorktree,
@@ -640,8 +638,8 @@ describe('explainCommand worktree parity', () => {
     });
   });
 
-  test('does not report worktree relaxation for fallback embedded git', () => {
-    withLinkedWorktreeFixture((fixture) => {
+  test('does not report worktree relaxation for fallback embedded git', async () => {
+    await withLinkedWorktreeFixture((fixture) => {
       withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
         const result = explainCommand('ssh host git clean -f', { cwd: fixture.linkedWorktree });
         const worktreeStep = result.trace.segments

tests/core/analyze/analyze-coverage.test.ts

@@ -11,7 +11,7 @@ import {
 
 const EMPTY_CONFIG: Config = { version: 1, rules: [] };
 
-function analyzeInLinkedWorktree(command: (mainWorktree: string) => string) {
+async function analyzeInLinkedWorktree(command: (mainWorktree: string) => string) {
   return withLinkedWorktreeFixture((fixture) =>
     withEnv({ SAFETY_NET_WORKTREE: '1' }, () =>
       analyzeCommand(command(toShellPath(fixture.mainWorktree)), {
@@ -180,15 +180,15 @@ describe('analyzeCommand (coverage)', () => {
   });
 
   describe('shell git context env state branches', () => {
-    test('command -- export target is tracked across segments', () => {
-      const result = analyzeInLinkedWorktree(
+    test('command -- export target is tracked across segments', async () => {
+      const result = await analyzeInLinkedWorktree(
         (main) => `command -- export GIT_WORK_TREE=${main}; git reset --hard`,
       );
       expect(result?.reason).toContain('git reset --hard');
     });
 
-    test('command inspection with no executable target leaves later git context unchanged', () => {
-      withLinkedWorktreeFixture((fixture) => {
+    test('command inspection with no executable target leaves later git context unchanged', async () => {
+      await withLinkedWorktreeFixture((fixture) => {
         withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
           expect(
             analyzeCommand(
@@ -213,8 +213,8 @@ describe('analyzeCommand (coverage)', () => {
       });
     });
 
-    test('export option parsing tracks only valid export operands', () => {
-      withLinkedWorktreeFixture((fixture) => {
+    test('export option parsing tracks only valid export operands', async () => {
+      await withLinkedWorktreeFixture((fixture) => {
         withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
           expect(
             analyzeCommand(
@@ -227,16 +227,21 @@ describe('analyzeCommand (coverage)', () => {
             ),
           ).toBeNull();
 
-          const result = analyzeInLinkedWorktree(
-            (main) => `export -- GIT_WORK_TREE=${main}; git reset --hard`,
+          const result = analyzeCommand(
+            `export -- GIT_WORK_TREE=${toShellPath(fixture.mainWorktree)}; git reset --hard`,
+            {
+              cwd: fixture.linkedWorktree,
+              config: EMPTY_CONFIG,
+              worktreeMode: true,
+            },
           );
           expect(result?.reason).toContain('git reset --hard');
         });
       });
     });
 
-    test('exporting an unset tracked name uses an empty effective value', () => {
-      withLinkedWorktreeFixture((fixture) => {
+    test('exporting an unset tracked name uses an empty effective value', async () => {
+      await withLinkedWorktreeFixture((fixture) => {
         withEnv({ SAFETY_NET_WORKTREE: '1' }, () => {
           const result = analyzeCommand('export GIT_WORK_TREE; git reset --hard', {
             cwd: fixture.linkedWorktree,

tests/helpers.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { withLinkedWorktreeFixture, withTempDir } from './helpers.ts';
+
+describe('test helpers', () => {
+  test('withTempDir waits for async callbacks before cleanup', async () => {
+    let tempDir = '';
+
+    await withTempDir('safety-net-helper-', async (dir) => {
+      tempDir = dir;
+      await Promise.resolve();
+      expect(existsSync(dir)).toBe(true);
+    });
+
+    expect(existsSync(tempDir)).toBe(false);
+  });
+
+  test('withLinkedWorktreeFixture waits for async callbacks before cleanup', async () => {
+    let rootDir = '';
+
+    await withLinkedWorktreeFixture(async (fixture) => {
+      rootDir = fixture.rootDir;
+      await Promise.resolve();
+      expect(existsSync(fixture.rootDir)).toBe(true);
+    });
+
+    expect(existsSync(rootDir)).toBe(false);
+  });
+});

tests/helpers.ts

@@ -64,10 +64,11 @@ export function withEnv<T>(env: Record<string, string>, fn: () => T): T {
   }
 }
 
-export function withTempDir<T>(prefix: string, fn: (dir: string) => T): T {
+export async function withTempDir<T>(prefix: string, fn: (dir: string) => T | Promise<T>) {
   const dir = mkdtempSync(join(tmpdir(), prefix));
   try {
-    return fn(dir);
+    const result = await fn(dir);
+    return result;
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
@@ -202,10 +203,13 @@ export function createLinkedWorktreeFixture(): LinkedWorktreeFixture {
   };
 }
 
-export function withLinkedWorktreeFixture<T>(fn: (fixture: LinkedWorktreeFixture) => T): T {
+export async function withLinkedWorktreeFixture<T>(
+  fn: (fixture: LinkedWorktreeFixture) => T | Promise<T>,
+) {
   const fixture = createLinkedWorktreeFixture();
   try {
-    return fn(fixture);
+    const result = await fn(fixture);
+    return result;
   } finally {
     fixture.cleanup();
   }