sofia-cli 0.1.1 → 0.1.4

package/dist/tests/unit/mcp/retryPolicy.spec.js

@@ -1,218 +0,0 @@
-/**
- * T006: Unit tests for retryPolicy.
- *
- * Verifies:
- * - withRetry retries once on connection-refused
- * - withRetry retries once on timeout
- * - withRetry does NOT retry on auth-failure
- * - withRetry does NOT retry on unknown error
- * - Applies ±20% jitter to initial delay
- * - Logs warn on retry attempt
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { withRetry, isRetryable, classifyMcpError } from '../../../src/mcp/retryPolicy.js';
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function makeLogger() {
-    return {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn(),
-        trace: vi.fn(),
-        fatal: vi.fn(),
-        child: vi.fn().mockReturnThis(),
-        level: 'silent',
-    };
-}
-function makeConnRefusedError() {
-    const err = new Error('connect ECONNREFUSED 127.0.0.1:3000');
-    err.code = 'ECONNREFUSED';
-    return err;
-}
-function makeTimeoutError() {
-    const err = new Error('connect ETIMEDOUT');
-    err.code = 'ETIMEDOUT';
-    return err;
-}
-function makeDnsError() {
-    const err = new Error('getaddrinfo ENOTFOUND example.com');
-    err.code = 'ENOTFOUND';
-    return err;
-}
-function makeAuthError() {
-    const err = new Error('401 Unauthorized');
-    err.code = 'ERR_TLS_CERT_ALTNAME_INVALID';
-    return err;
-}
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe('withRetry()', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('returns result when fn succeeds on first try', async () => {
-        const fn = vi.fn().mockResolvedValue('success');
-        const result = await withRetry(fn, {
-            serverName: 'test',
-            toolName: 'tool',
-        });
-        expect(result).toBe('success');
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    it('retries once on connection-refused and succeeds', async () => {
-        const fn = vi
-            .fn()
-            .mockRejectedValueOnce(makeConnRefusedError())
-            .mockResolvedValueOnce('recovered');
-        const logger = makeLogger();
-        const resultPromise = withRetry(fn, {
-            serverName: 'ctx7',
-            toolName: 'resolve',
-            initialDelayMs: 100,
-            logger,
-        });
-        // Advance past the delay
-        await vi.advanceTimersByTimeAsync(200);
-        const result = await resultPromise;
-        expect(result).toBe('recovered');
-        expect(fn).toHaveBeenCalledTimes(2);
-    });
-    it('retries once on timeout and succeeds', async () => {
-        const fn = vi.fn().mockRejectedValueOnce(makeTimeoutError()).mockResolvedValueOnce('ok');
-        const resultPromise = withRetry(fn, {
-            serverName: 'github',
-            toolName: 'create_repo',
-            initialDelayMs: 100,
-        });
-        await vi.advanceTimersByTimeAsync(200);
-        const result = await resultPromise;
-        expect(result).toBe('ok');
-        expect(fn).toHaveBeenCalledTimes(2);
-    });
-    it('retries once on dns-failure and succeeds', async () => {
-        const fn = vi.fn().mockRejectedValueOnce(makeDnsError()).mockResolvedValueOnce('resolved');
-        const resultPromise = withRetry(fn, {
-            serverName: 'remote',
-            toolName: 'call',
-            initialDelayMs: 100,
-        });
-        await vi.advanceTimersByTimeAsync(200);
-        const result = await resultPromise;
-        expect(result).toBe('resolved');
-        expect(fn).toHaveBeenCalledTimes(2);
-    });
-    it('does NOT retry on auth-failure — throws immediately', async () => {
-        const fn = vi.fn().mockRejectedValue(makeAuthError());
-        await expect(withRetry(fn, {
-            serverName: 'github',
-            toolName: 'create_repo',
-            initialDelayMs: 100,
-        })).rejects.toThrow('401 Unauthorized');
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    it('does NOT retry on unknown error — throws immediately', async () => {
-        const fn = vi.fn().mockRejectedValue(new Error('something unexpected'));
-        await expect(withRetry(fn, {
-            serverName: 'test',
-            toolName: 'tool',
-            initialDelayMs: 100,
-        })).rejects.toThrow('something unexpected');
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    it('throws the second error when retry also fails', async () => {
-        const fn = vi
-            .fn()
-            .mockRejectedValueOnce(makeConnRefusedError())
-            .mockRejectedValueOnce(new Error('second failure'));
-        // Attach the rejection handler immediately to avoid unhandled rejection warning
-        const resultPromise = withRetry(fn, {
-            serverName: 'test',
-            toolName: 'tool',
-            initialDelayMs: 100,
-        }).catch((err) => err);
-        await vi.advanceTimersByTimeAsync(200);
-        const err = await resultPromise;
-        expect(err).toBeInstanceOf(Error);
-        expect(err.message).toBe('second failure');
-        expect(fn).toHaveBeenCalledTimes(2);
-    });
-    it('logs warn on retry attempt with server, tool, attempt, delayMs, errorClass', async () => {
-        const fn = vi.fn().mockRejectedValueOnce(makeConnRefusedError()).mockResolvedValueOnce('ok');
-        const logger = makeLogger();
-        const resultPromise = withRetry(fn, {
-            serverName: 'context7',
-            toolName: 'resolve-library-id',
-            initialDelayMs: 1000,
-            logger,
-        });
-        await vi.advanceTimersByTimeAsync(1500);
-        await resultPromise;
-        expect(logger.warn).toHaveBeenCalledTimes(1);
-        const warnCall = logger.warn.mock.calls[0];
-        const logObj = warnCall[0];
-        expect(logObj).toHaveProperty('server', 'context7');
-        expect(logObj).toHaveProperty('tool', 'resolve-library-id');
-        expect(logObj).toHaveProperty('attempt', 1);
-        expect(logObj).toHaveProperty('delayMs');
-        expect(logObj).toHaveProperty('errorClass', 'connection-refused');
-    });
-    it('applies ±20% jitter to delay', async () => {
-        // We'll override Math.random to test jitter boundaries
-        const originalRandom = Math.random;
-        // First test: random = 0 → jitter factor = 1 + (0*2-1)*0.2 = 0.8
-        Math.random = () => 0;
-        const fn1 = vi.fn().mockRejectedValueOnce(makeConnRefusedError()).mockResolvedValueOnce('ok');
-        const logger1 = makeLogger();
-        const p1 = withRetry(fn1, {
-            serverName: 'test',
-            toolName: 'tool',
-            initialDelayMs: 1000,
-            jitter: 0.2,
-            logger: logger1,
-        });
-        await vi.advanceTimersByTimeAsync(1500);
-        await p1;
-        const delay1 = logger1.warn.mock.calls[0][0].delayMs;
-        expect(delay1).toBe(800); // 1000 * 0.8
-        // Second test: random = 1 → jitter factor = 1 + (1*2-1)*0.2 = 1.2
-        Math.random = () => 1;
-        const fn2 = vi.fn().mockRejectedValueOnce(makeConnRefusedError()).mockResolvedValueOnce('ok');
-        const logger2 = makeLogger();
-        const p2 = withRetry(fn2, {
-            serverName: 'test',
-            toolName: 'tool',
-            initialDelayMs: 1000,
-            jitter: 0.2,
-            logger: logger2,
-        });
-        await vi.advanceTimersByTimeAsync(1500);
-        await p2;
-        const delay2 = logger2.warn.mock.calls[0][0].delayMs;
-        expect(delay2).toBe(1200); // 1000 * 1.2
-        Math.random = originalRandom;
-    });
-});
-describe('isRetryable()', () => {
-    it('returns true for connection-refused', () => {
-        expect(isRetryable(makeConnRefusedError())).toBe(true);
-    });
-    it('returns true for timeout', () => {
-        expect(isRetryable(makeTimeoutError())).toBe(true);
-    });
-    it('returns true for dns-failure', () => {
-        expect(isRetryable(makeDnsError())).toBe(true);
-    });
-    it('returns false for auth-failure', () => {
-        expect(isRetryable(makeAuthError())).toBe(false);
-    });
-    it('returns false for unknown error', () => {
-        expect(isRetryable(new Error('random'))).toBe(false);
-    });
-});
-describe('classifyMcpError (re-export)', () => {
-    it('classifies ECONNREFUSED as connection-refused', () => {
-        expect(classifyMcpError(makeConnRefusedError())).toBe('connection-refused');
-    });
-});

package/dist/tests/unit/mcp/timeoutValidation.spec.js

@@ -1,46 +0,0 @@
-/**
- * T044: Timeout validation test for SC-003-007.
- *
- * Forces a short timeoutMs on MCP calls and asserts that a classified
- * 'timeout' error is returned/thrown and handled gracefully by adapters.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { classifyMcpError } from '../../../src/mcp/mcpManager.js';
-describe('Timeout validation (T044)', () => {
-    it('classifyMcpError identifies AbortError as timeout', () => {
-        const error = new DOMException('The operation was aborted', 'AbortError');
-        const classification = classifyMcpError(error);
-        expect(classification).toBe('timeout');
-    });
-    it('classifyMcpError identifies timeout message strings', () => {
-        const error = new Error('Request timed out after 30000ms');
-        const classification = classifyMcpError(error);
-        expect(classification).toBe('timeout');
-    });
-    it('classifyMcpError identifies ETIMEDOUT errno as timeout', () => {
-        const error = Object.assign(new Error('connect ETIMEDOUT'), { code: 'ETIMEDOUT' });
-        const classification = classifyMcpError(error);
-        expect(classification).toBe('timeout');
-    });
-    it('adapters handle timeout errors gracefully without crashing', async () => {
-        const { GitHubMcpAdapter } = await import('../../../src/develop/githubMcpAdapter.js');
-        const timeoutMcpManager = {
-            isAvailable: vi.fn().mockReturnValue(true),
-            callTool: vi
-                .fn()
-                .mockRejectedValue(new DOMException('The operation was aborted', 'AbortError')),
-            markConnected: vi.fn(),
-            markDisconnected: vi.fn(),
-            disconnectAll: vi.fn(),
-        };
-        const adapter = new GitHubMcpAdapter(timeoutMcpManager);
-        // createRepository should degrade gracefully
-        const repoResult = await adapter.createRepository({
-            name: 'test-repo',
-            description: 'test',
-            private: true,
-        });
-        // Should return a degraded result, not throw
-        expect(repoResult).toBeDefined();
-    });
-});