test: address CodeRabbit review on PR #8

- Add runWhoami dry-run regression for whitespace-only TESTSPRITE_API_URL
- Add commitBundle rollback-rename failure coverage (documents known gap)
- Clean up bundle.commit temp dirs after each test

Author: SahilRakhaiya05

src/commands/auth.test.ts

@@ -643,6 +643,21 @@ describe('runWhoami', () => {
     expect(printed).toEqual(sampleMe);
   });
 
+  it('dry-run: whitespace-only TESTSPRITE_API_URL falls through to prod default endpoint', async () => {
+    const { capture, deps } = makeCapture();
+    await runWhoami(
+      { profile: 'default', output: 'text', debug: false, dryRun: true },
+      {
+        ...deps,
+        env: { TESTSPRITE_API_URL: '   ' },
+        credentialsPath,
+        fetchImpl: makeFetch(meResponse()),
+      },
+    );
+    const out = capture.stdout.join('\n');
+    expect(out).toContain('endpoint: https://api.testsprite.com');
+  });
+
   it('L1788: text output includes the resolved endpoint URL', async () => {
     writeProfile(
       'default',

src/lib/bundle.commit.test.ts

@@ -1,5 +1,12 @@
 import type * as NodeFsPromises from 'node:fs/promises';
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -35,8 +42,16 @@ describe('commitBundle', () => {
     rmMock.mockReset();
   });
 
-  it('rolls back to the prior complete bundle when the staging swap fails', async () => {
+  async function withTempParent(run: (parent: string) => Promise<void>): Promise<void> {
     const parent = mkdtempSync(join(tmpdir(), 'bundle-commit-parent-'));
+    try {
+      await run(parent);
+    } finally {
+      await realRm(parent, { recursive: true, force: true }).catch(() => undefined);
+    }
+  }
+
+  function seedBundleDirs(parent: string): { dir: string; tmpDir: string } {
     const dir = join(parent, 'bundle');
     const tmpDir = join(dir, '.tmp');
 
@@ -49,48 +64,70 @@ describe('commitBundle', () => {
     writeFileSync(join(tmpDir, 'result.json'), '{}\n', 'utf8');
     writeFileSync(join(tmpDir, 'steps', '01-evidence.json'), '{"step":9}\n', 'utf8');
 
-    renameMock.mockImplementation(async (oldPath, newPath) => {
-      const src = String(oldPath);
-      const dest = String(newPath);
-      if (src.includes('.staging.') && !dest.includes('.prior.')) {
-        throw Object.assign(new Error('simulated atomic swap failure'), { code: 'EACCES' });
-      }
-      return realRename(oldPath, newPath);
-    });
-
-    await expect(commitBundle(tmpDir, dir)).rejects.toThrow('simulated atomic swap failure');
+    return { dir, tmpDir };
+  }
 
-    expect(readFileSync(join(dir, 'meta.json'), 'utf8')).toBe('{"snapshotId":"snap_old"}\n');
-    expect(readFileSync(join(dir, 'steps', '01-evidence.json'), 'utf8')).toBe('{"step":1}\n');
-    const leftovers = readdirSync(parent).filter(
-      name => name.includes('.staging.') || name.includes('.prior.'),
-    );
-    expect(leftovers).toEqual([]);
+  it('rolls back to the prior complete bundle when the staging swap fails', async () => {
+    await withTempParent(async parent => {
+      const { dir, tmpDir } = seedBundleDirs(parent);
+
+      renameMock.mockImplementation(async (oldPath, newPath) => {
+        const src = String(oldPath);
+        const dest = String(newPath);
+        if (src.includes('.staging.') && !dest.includes('.prior.')) {
+          throw Object.assign(new Error('simulated atomic swap failure'), { code: 'EACCES' });
+        }
+        return realRename(oldPath, newPath);
+      });
+
+      await expect(commitBundle(tmpDir, dir)).rejects.toThrow('simulated atomic swap failure');
+
+      expect(readFileSync(join(dir, 'meta.json'), 'utf8')).toBe('{"snapshotId":"snap_old"}\n');
+      expect(readFileSync(join(dir, 'steps', '01-evidence.json'), 'utf8')).toBe('{"step":1}\n');
+      const leftovers = readdirSync(parent).filter(
+        name => name.includes('.staging.') || name.includes('.prior.'),
+      );
+      expect(leftovers).toEqual([]);
+    });
   });
 
   it('keeps the new bundle when post-swap prior-dir cleanup fails', async () => {
-    const parent = mkdtempSync(join(tmpdir(), 'bundle-commit-parent-'));
-    const dir = join(parent, 'bundle');
-    const tmpDir = join(dir, '.tmp');
+    await withTempParent(async parent => {
+      const { dir, tmpDir } = seedBundleDirs(parent);
 
-    mkdirSync(join(dir, 'steps'), { recursive: true });
-    writeFileSync(join(dir, 'meta.json'), '{"snapshotId":"snap_old"}\n', 'utf8');
-    writeFileSync(join(dir, 'steps', '01-evidence.json'), '{"step":1}\n', 'utf8');
+      rmMock.mockImplementation(async (path, options) => {
+        if (String(path).includes('.prior.')) {
+          throw Object.assign(new Error('simulated prior cleanup failure'), { code: 'EACCES' });
+        }
+        return realRm(path, options);
+      });
 
-    mkdirSync(join(tmpDir, 'steps'), { recursive: true });
-    writeFileSync(join(tmpDir, 'meta.json'), '{"snapshotId":"snap_new"}\n', 'utf8');
-    writeFileSync(join(tmpDir, 'steps', '01-evidence.json'), '{"step":9}\n', 'utf8');
+      await expect(commitBundle(tmpDir, dir)).resolves.toBeUndefined();
 
-    rmMock.mockImplementation(async (path, options) => {
-      if (String(path).includes('.prior.')) {
-        throw Object.assign(new Error('simulated prior cleanup failure'), { code: 'EACCES' });
-      }
-      return realRm(path, options);
+      expect(readFileSync(join(dir, 'meta.json'), 'utf8')).toBe('{"snapshotId":"snap_new"}\n');
+      expect(readFileSync(join(dir, 'steps', '01-evidence.json'), 'utf8')).toBe('{"step":9}\n');
     });
+  });
 
-    await expect(commitBundle(tmpDir, dir)).resolves.toBeUndefined();
-
-    expect(readFileSync(join(dir, 'meta.json'), 'utf8')).toBe('{"snapshotId":"snap_new"}\n');
-    expect(readFileSync(join(dir, 'steps', '01-evidence.json'), 'utf8')).toBe('{"step":9}\n');
+  it('propagates when rollback rename fails after a staging swap error', async () => {
+    await withTempParent(async parent => {
+      const { dir, tmpDir } = seedBundleDirs(parent);
+
+      renameMock.mockImplementation(async (oldPath, newPath) => {
+        const src = String(oldPath);
+        const dest = String(newPath);
+        if (src.includes('.staging.') && !dest.includes('.prior.')) {
+          throw Object.assign(new Error('simulated atomic swap failure'), { code: 'EACCES' });
+        }
+        if (src.includes('.prior.') && dest === dir) {
+          throw Object.assign(new Error('simulated rollback rename failure'), { code: 'EACCES' });
+        }
+        return realRename(oldPath, newPath);
+      });
+
+      await expect(commitBundle(tmpDir, dir)).rejects.toThrow('simulated rollback rename failure');
+      // Known gap: double-failure can leave `dir` absent until manual recovery.
+      expect(existsSync(dir)).toBe(false);
+    });
   });
 });