test: cover least-tested modules (timemachine, purgeable, docker, homebrew, dns, config)

Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: guhcostan

src/maintenance/dns-cache.test.ts

@@ -1,82 +1,139 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { flushDnsCache } from './dns-cache.js';
 
-// Mock child_process spawn
-const mockOn = vi.fn();
-const mockStdout = { on: vi.fn() };
-const mockStderr = { on: vi.fn() };
+interface FakeProcess {
+  stdout?: string;
+  stderr?: string;
+  code?: number;
+  error?: Error;
+}
+
+const spawnCalls: Array<{ command: string; args: string[] }> = [];
+let respond: (command: string, args: string[]) => FakeProcess;
 
 vi.mock('child_process', () => ({
-  spawn: vi.fn(() => {
+  spawn: (command: string, args: string[]) => {
+    spawnCalls.push({ command, args });
+    const result = respond(command, args);
+
     return {
-      stdout: mockStdout,
-      stderr: mockStderr,
-      on: (event: string, callback: (code: number) => void) => {
-        if (event === 'close') {
-          // Simulate successful execution by default
-          setTimeout(() => callback(0), 0);
+      stdout: {
+        on: (event: string, callback: (data: Buffer) => void) => {
+          if (event === 'data' && result.stdout) {
+            setTimeout(() => callback(Buffer.from(result.stdout as string)), 0);
+          }
+        },
+      },
+      stderr: {
+        on: (event: string, callback: (data: Buffer) => void) => {
+          if (event === 'data' && result.stderr) {
+            setTimeout(() => callback(Buffer.from(result.stderr as string)), 0);
+          }
+        },
+      },
+      on: (event: string, callback: (arg?: number | Error) => void) => {
+        if (event === 'error' && result.error) {
+          setTimeout(() => callback(result.error), 0);
+        }
+        if (event === 'close' && !result.error) {
+          setTimeout(() => callback(result.code ?? 0), 0);
         }
-        return mockOn(event, callback);
       },
     };
-  }),
+  },
 }));
 
-describe('dns-cache', () => {
+describe('flushDnsCache', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
-    mockStdout.on.mockReset();
-    mockStderr.on.mockReset();
-    mockOn.mockReset();
-    
-    // Setup default mock behavior
-    mockStdout.on.mockImplementation(() => {
-      // No output by default
-    });
-    mockStderr.on.mockImplementation(() => {
-      // No error output by default
-    });
+    spawnCalls.length = 0;
+    respond = () => ({ code: 0 });
+    vi.spyOn(process, 'getuid').mockReturnValue(501);
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  describe('flushDnsCache', () => {
-    it('should return a MaintenanceResult', async () => {
-      const result = await flushDnsCache();
+  it('should require sudo when not root and sudo needs a password', async () => {
+    respond = () => ({ code: 1, stderr: 'a password is required' });
 
-      expect(result).toHaveProperty('success');
-      expect(result).toHaveProperty('message');
-      expect(typeof result.success).toBe('boolean');
-      expect(typeof result.message).toBe('string');
-    });
+    const result = await flushDnsCache();
 
-    it('should have error property when fails', async () => {
-      // The function checks for sudo permissions first
-      // If not running as root and can't sudo, it should fail with requiresSudo
-      const result = await flushDnsCache();
-
-      // Either it succeeds (if running with sudo) or it fails with proper error
-      expect(result).toHaveProperty('success');
-      expect(result).toHaveProperty('message');
-      
-      if (!result.success) {
-        expect(result.error || result.requiresSudo).toBeDefined();
-      }
+    expect(result).toEqual({
+      success: false,
+      message: 'DNS cache flush requires administrator privileges',
+      error: 'Run with sudo: sudo mac-cleaner-cli maintenance --dns',
+      requiresSudo: true,
     });
+    expect(spawnCalls).toEqual([{ command: 'sudo', args: ['-n', 'true'] }]);
+  });
 
-    it('should have requiresSudo property when sudo is needed', async () => {
-      const result = await flushDnsCache();
-      
-      // The result should have proper structure
-      expect(result).toHaveProperty('success');
-      expect(result).toHaveProperty('message');
-      
-      // If it needs sudo, requiresSudo should be set
-      if (!result.success && result.message.includes('privileges')) {
-        expect(result.requiresSudo).toBe(true);
-      }
-    });
+  it('should flush the cache directly when running as root', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+
+    const result = await flushDnsCache();
+
+    expect(result).toEqual({ success: true, message: 'DNS cache flushed successfully' });
+    expect(spawnCalls).toEqual([
+      { command: '/usr/bin/dscacheutil', args: ['-flushcache'] },
+      { command: '/usr/bin/killall', args: ['-HUP', 'mDNSResponder'] },
+    ]);
+  });
+
+  it('should flush the cache through sudo when passwordless sudo works', async () => {
+    const result = await flushDnsCache();
+
+    expect(result.success).toBe(true);
+    expect(spawnCalls).toEqual([
+      { command: 'sudo', args: ['-n', 'true'] },
+      { command: 'sudo', args: ['-n', '/usr/bin/dscacheutil', '-flushcache'] },
+      { command: 'sudo', args: ['-n', '/usr/bin/killall', '-HUP', 'mDNSResponder'] },
+    ]);
+  });
+
+  it('should report that sudo is required when the flush is not permitted', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+    respond = () => ({ code: 1, stderr: 'dscacheutil: Operation not permitted' });
+
+    const result = await flushDnsCache();
+
+    expect(result.success).toBe(false);
+    expect(result.message).toBe('Failed to flush DNS cache');
+    expect(result.error).toBe('Run with sudo: sudo mac-cleaner-cli maintenance --dns');
+    expect(result.requiresSudo).toBe(true);
+  });
+
+  it('should surface other failures verbatim', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+    respond = () => ({ code: 1, stderr: 'mDNSResponder: no matching processes' });
+
+    const result = await flushDnsCache();
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('mDNSResponder: no matching processes');
+    expect(result.requiresSudo).toBe(false);
+  });
+
+  it('should surface spawn errors', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+    respond = () => ({ error: new Error('spawn ENOENT') });
+
+    const result = await flushDnsCache();
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('spawn ENOENT');
+  });
+
+  it('should fail when killall fails after a successful flush', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+    respond = (command) => {
+      if (command === '/usr/bin/killall') return { code: 1, stderr: 'killall failed' };
+      return { code: 0 };
+    };
+
+    const result = await flushDnsCache();
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('killall failed');
   });
 });

src/maintenance/purgeable.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { freePurgeableSpace } from './purgeable.js';
+
+interface FakeProcess {
+  stderr?: string;
+  code?: number;
+  error?: Error;
+}
+
+const spawnCalls: Array<{ command: string; args: string[] }> = [];
+let respond: (command: string, args: string[]) => FakeProcess;
+
+vi.mock('child_process', () => ({
+  spawn: (command: string, args: string[]) => {
+    spawnCalls.push({ command, args });
+    const result = respond(command, args);
+
+    return {
+      stdout: { on: () => undefined },
+      stderr: {
+        on: (event: string, callback: (data: Buffer) => void) => {
+          if (event === 'data' && result.stderr) {
+            setTimeout(() => callback(Buffer.from(result.stderr as string)), 0);
+          }
+        },
+      },
+      on: (event: string, callback: (arg?: number | Error) => void) => {
+        if (event === 'error' && result.error) {
+          setTimeout(() => callback(result.error), 0);
+        }
+        if (event === 'close' && !result.error) {
+          setTimeout(() => callback(result.code ?? 0), 0);
+        }
+      },
+    };
+  },
+}));
+
+const PURGE = '/usr/sbin/purge';
+
+describe('freePurgeableSpace', () => {
+  beforeEach(() => {
+    spawnCalls.length = 0;
+    respond = () => ({ code: 0 });
+    vi.spyOn(process, 'getuid').mockReturnValue(501);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should run purge directly when running as root', async () => {
+    vi.spyOn(process, 'getuid').mockReturnValue(0);
+
+    const result = await freePurgeableSpace();
+
+    expect(result).toEqual({
+      success: true,
+      message: 'Purgeable space freed successfully',
+    });
+    expect(spawnCalls).toEqual([{ command: PURGE, args: [] }]);
+  });
+
+  it('should run purge through non-interactive sudo when not root', async () => {
+    const result = await freePurgeableSpace();
+
+    expect(result.success).toBe(true);
+    expect(spawnCalls).toEqual([{ command: 'sudo', args: ['-n', PURGE] }]);
+  });
+
+  it('should fall back to running purge without sudo', async () => {
+    respond = (command) => {
+      if (command === 'sudo') return { code: 1, stderr: 'a password is required' };
+      return { code: 0 };
+    };
+
+    const result = await freePurgeableSpace();
+
+    expect(result.success).toBe(true);
+    expect(spawnCalls.map((call) => call.command)).toEqual(['sudo', PURGE]);
+  });
+
+  it('should report that sudo is required when purge is not permitted', async () => {
+    respond = () => ({ code: 1, stderr: 'purge: Operation not permitted' });
+
+    const result = await freePurgeableSpace();
+
+    expect(result.success).toBe(false);
+    expect(result.message).toBe('Failed to free purgeable space');
+    expect(result.requiresSudo).toBe(true);
+    expect(result.error).toContain('sudo mac-cleaner-cli maintenance --purgeable');
+  });
+
+  it('should report that sudo is required on permission denied', async () => {
+    respond = () => ({ code: 1, stderr: 'Permission denied' });
+
+    const result = await freePurgeableSpace();
+
+    expect(result.requiresSudo).toBe(true);
+  });
+
+  it('should surface other failures verbatim', async () => {
+    respond = () => ({ code: 127, stderr: 'purge: command not found' });
+
+    const result = await freePurgeableSpace();
+
+    expect(result.success).toBe(false);
+    expect(result.requiresSudo).toBe(false);
+    expect(result.error).toBe('purge: command not found');
+  });
+
+  it('should surface spawn errors', async () => {
+    respond = () => ({ error: new Error('spawn ENOENT') });
+
+    const result = await freePurgeableSpace();
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('spawn ENOENT');
+  });
+});