octocode-cli 1.2.5 → 1.2.7

package/skills/octocode-research/src/__tests__/unit/circuitBreaker.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Unit tests for circuit breaker utilities.
+ *
+ * @module tests/unit/circuitBreaker
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  withCircuitBreaker,
+  getCircuitState,
+  resetCircuit,
+  configureCircuit,
+  CircuitOpenError,
+  getAllCircuitStates,
+} from '../../utils/circuitBreaker.js';
+
+describe('withCircuitBreaker', () => {
+  beforeEach(() => {
+    // Reset test circuit before each test
+    resetCircuit('test');
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('executes operation successfully when circuit is closed', async () => {
+    const operation = vi.fn().mockResolvedValue('success');
+
+    const result = await withCircuitBreaker('test', operation);
+
+    expect(result).toBe('success');
+    expect(operation).toHaveBeenCalledTimes(1);
+    expect(getCircuitState('test').state).toBe('closed');
+  });
+
+  it('opens circuit after failure threshold', async () => {
+    configureCircuit('test', { failureThreshold: 3 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    // First 3 failures should open the circuit
+    for (let i = 0; i < 3; i++) {
+      await expect(withCircuitBreaker('test', operation)).rejects.toThrow('fail');
+    }
+
+    expect(getCircuitState('test').state).toBe('open');
+  });
+
+  it('uses fallback when circuit is open', async () => {
+    configureCircuit('test', { failureThreshold: 1, resetTimeoutMs: 10000 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+    const fallback = vi.fn().mockReturnValue('fallback');
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+
+    // Should use fallback
+    const result = await withCircuitBreaker('test', operation, fallback);
+
+    expect(result).toBe('fallback');
+    expect(fallback).toHaveBeenCalled();
+  });
+
+  it('throws CircuitOpenError when open and no fallback', async () => {
+    configureCircuit('test', { failureThreshold: 1, resetTimeoutMs: 10000 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+
+    // Should throw CircuitOpenError
+    await expect(withCircuitBreaker('test', operation)).rejects.toBeInstanceOf(
+      CircuitOpenError
+    );
+  });
+
+  it('enters half-open state after reset timeout', async () => {
+    configureCircuit('test', { failureThreshold: 1, resetTimeoutMs: 1000 });
+    const operation = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValue('success');
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+    expect(getCircuitState('test').state).toBe('open');
+
+    // Advance time past reset timeout
+    vi.advanceTimersByTime(1001);
+
+    // Next attempt should try (half-open)
+    const result = await withCircuitBreaker('test', operation);
+    expect(result).toBe('success');
+  });
+
+  it('closes circuit after success threshold in half-open', async () => {
+    configureCircuit('test', {
+      failureThreshold: 1,
+      successThreshold: 2,
+      resetTimeoutMs: 1000,
+    });
+
+    const failOp = vi.fn().mockRejectedValue(new Error('fail'));
+    const successOp = vi.fn().mockResolvedValue('success');
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
+
+    // Advance time to half-open
+    vi.advanceTimersByTime(1001);
+
+    // First success - still half-open
+    await withCircuitBreaker('test', successOp);
+    expect(getCircuitState('test').state).toBe('half-open');
+
+    // Second success - should close
+    await withCircuitBreaker('test', successOp);
+    expect(getCircuitState('test').state).toBe('closed');
+  });
+
+  it('reopens circuit if half-open attempt fails', async () => {
+    configureCircuit('test', { failureThreshold: 1, resetTimeoutMs: 1000 });
+
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+
+    // Advance time to half-open
+    vi.advanceTimersByTime(1001);
+
+    // Fail in half-open - should go back to open
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+    expect(getCircuitState('test').state).toBe('open');
+  });
+
+  it('resets failures on success in closed state', async () => {
+    configureCircuit('test', { failureThreshold: 3 });
+
+    const failOp = vi.fn().mockRejectedValue(new Error('fail'));
+    const successOp = vi.fn().mockResolvedValue('success');
+
+    // 2 failures
+    await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
+    await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
+    expect(getCircuitState('test').failures).toBe(2);
+
+    // 1 success resets failures
+    await withCircuitBreaker('test', successOp);
+    expect(getCircuitState('test').failures).toBe(0);
+
+    // Still closed
+    expect(getCircuitState('test').state).toBe('closed');
+  });
+});
+
+describe('getCircuitState', () => {
+  beforeEach(() => {
+    resetCircuit('test');
+  });
+
+  it('returns initial state for new circuit', () => {
+    const state = getCircuitState('new-circuit');
+
+    expect(state.state).toBe('closed');
+    expect(state.failures).toBe(0);
+    expect(state.isHealthy).toBe(true);
+  });
+
+  it('returns accurate failure count', async () => {
+    configureCircuit('test', { failureThreshold: 5 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+
+    const state = getCircuitState('test');
+    expect(state.failures).toBe(2);
+  });
+
+  it('reports unhealthy when circuit is open', async () => {
+    configureCircuit('test', { failureThreshold: 1 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+
+    const state = getCircuitState('test');
+    expect(state.isHealthy).toBe(false);
+  });
+});
+
+describe('resetCircuit', () => {
+  it('resets circuit to closed state', async () => {
+    configureCircuit('test', { failureThreshold: 1 });
+    const operation = vi.fn().mockRejectedValue(new Error('fail'));
+
+    // Open the circuit
+    await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
+    expect(getCircuitState('test').state).toBe('open');
+
+    // Reset
+    resetCircuit('test');
+
+    expect(getCircuitState('test').state).toBe('closed');
+    expect(getCircuitState('test').failures).toBe(0);
+  });
+});
+
+describe('getAllCircuitStates', () => {
+  beforeEach(() => {
+    resetCircuit('circuit-a');
+    resetCircuit('circuit-b');
+  });
+
+  it('returns states for all known circuits', async () => {
+    configureCircuit('circuit-a', { failureThreshold: 1 });
+    const failOp = vi.fn().mockRejectedValue(new Error('fail'));
+    const successOp = vi.fn().mockResolvedValue('success');
+
+    // Open circuit-a
+    await expect(withCircuitBreaker('circuit-a', failOp)).rejects.toThrow();
+
+    // Keep circuit-b closed
+    await withCircuitBreaker('circuit-b', successOp);
+
+    const states = getAllCircuitStates();
+
+    expect(states['circuit-a'].state).toBe('open');
+    expect(states['circuit-a'].isHealthy).toBe(false);
+    expect(states['circuit-b'].state).toBe('closed');
+    expect(states['circuit-b'].isHealthy).toBe(true);
+  });
+});
+
+describe('CircuitOpenError', () => {
+  it('contains circuit name and retry info', () => {
+    const error = new CircuitOpenError('test', 5000);
+
+    expect(error.circuitName).toBe('test');
+    expect(error.retryAfterMs).toBe(5000);
+    expect(error.message).toContain('test');
+    expect(error.message).toContain('5s');
+  });
+});

package/skills/octocode-research/src/__tests__/unit/errorHandler.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Unit tests for error handler middleware.
+ *
+ * @module tests/unit/errorHandler
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { Request, Response, NextFunction } from 'express';
+import { errorHandler, type ApiError } from '../../middleware/errorHandler.js';
+import type { z } from 'zod/v4';
+import { fireAndForgetWithTimeout } from '../../utils/asyncTimeout.js';
+
+// Mock the logger
+vi.mock('../../utils/logger.js', () => ({
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  sanitizeQueryParams: vi.fn((q) => q),
+}));
+
+// Mock the session error logging
+vi.mock('../../index.js', () => ({
+  logSessionError: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Mock the async timeout
+vi.mock('../../utils/asyncTimeout.js', () => ({
+  fireAndForgetWithTimeout: vi.fn(),
+}));
+
+describe('errorHandler', () => {
+  let mockReq: Partial<Request>;
+  let mockRes: Partial<Response>;
+  let mockNext: NextFunction;
+  let jsonMock: ReturnType<typeof vi.fn>;
+  let statusMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    jsonMock = vi.fn();
+    statusMock = vi.fn().mockReturnValue({ json: jsonMock });
+
+    mockReq = {
+      method: 'POST',
+      path: '/tools/call/localSearchCode',
+      query: {},
+    };
+
+    mockRes = {
+      status: statusMock as unknown as Response['status'],
+    };
+
+    mockNext = vi.fn();
+  });
+
+  describe('status code handling', () => {
+    it('uses error statusCode if provided', () => {
+      const error: ApiError = new Error('Bad request');
+      error.statusCode = 400;
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(statusMock).toHaveBeenCalledWith(400);
+    });
+
+    it('defaults to 500 for server errors', () => {
+      const error: ApiError = new Error('Internal error');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(statusMock).toHaveBeenCalledWith(500);
+    });
+  });
+
+  describe('response format', () => {
+    it('returns success: false', () => {
+      const error: ApiError = new Error('Test error');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(jsonMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+        })
+      );
+    });
+
+    it('includes error message', () => {
+      const error: ApiError = new Error('Test error message');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(jsonMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          error: expect.objectContaining({
+            message: 'Test error message',
+          }),
+        })
+      );
+    });
+
+    it('uses error code if provided', () => {
+      const error: ApiError = new Error('Test error');
+      error.code = 'CUSTOM_ERROR';
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(jsonMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          error: expect.objectContaining({
+            code: 'CUSTOM_ERROR',
+          }),
+        })
+      );
+    });
+
+    it('defaults to INTERNAL_ERROR code', () => {
+      const error: ApiError = new Error('Test error');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(jsonMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          error: expect.objectContaining({
+            code: 'INTERNAL_ERROR',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('validation error details', () => {
+    it('includes details for 400 errors', () => {
+      const error: ApiError = new Error('Validation failed');
+      error.statusCode = 400;
+      error.details = [
+        { path: ['queries'], message: 'Required', code: 'invalid_type', expected: 'array' } as z.core.$ZodIssue,
+      ];
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      expect(jsonMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          error: expect.objectContaining({
+            details: expect.arrayContaining([
+              expect.objectContaining({ path: ['queries'] }),
+            ]),
+          }),
+        })
+      );
+    });
+
+    it('excludes details for 500 errors', () => {
+      const error: ApiError = new Error('Server error');
+      error.details = [{ path: ['internal'], message: 'Debug info', code: 'custom' } as z.core.$ZodIssue];
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      const response = jsonMock.mock.calls[0][0];
+      expect(response.error.details).toBeUndefined();
+    });
+  });
+
+  describe('tool name extraction', () => {
+    it('extracts tool name from /tools/call/:toolName path', () => {
+      mockReq.path = '/tools/call/localSearchCode';
+      const error: ApiError = new Error('Test');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      // Verify fireAndForgetWithTimeout was called (tool name is passed to logSessionError)
+      expect(fireAndForgetWithTimeout).toHaveBeenCalled();
+    });
+
+    it('uses unknown for non-tool paths', () => {
+      mockReq.path = '/prompts/list';
+      const error: ApiError = new Error('Test');
+
+      errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
+
+      // Tool name should be 'unknown' for non-tool paths
+      expect(fireAndForgetWithTimeout).toHaveBeenCalled();
+    });
+  });
+});

package/skills/octocode-research/src/__tests__/unit/httpPreprocess.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Unit tests for HTTP preprocessing utilities.
+ *
+ * Tests type coercion, path safety, and array handling for HTTP query strings.
+ *
+ * @module tests/unit/httpPreprocess
+ */
+
+import { describe, it, expect } from 'vitest';
+import { toNumber, toBoolean, toArray, safePath, numericString, booleanString, stringArray } from '../../validation/httpPreprocess.js';
+
+describe('toNumber', () => {
+  it('passes through numbers', () => {
+    expect(toNumber(42)).toBe(42);
+    expect(toNumber(0)).toBe(0);
+  });
+
+  it('converts numeric strings to integers', () => {
+    expect(toNumber('42')).toBe(42);
+    expect(toNumber('0')).toBe(0);
+    expect(toNumber('100')).toBe(100);
+  });
+
+  it('returns non-numeric strings as-is', () => {
+    expect(toNumber('abc')).toBe('abc');
+    expect(toNumber('12.5')).toBe('12.5'); // floats not supported
+    expect(toNumber('12abc')).toBe('12abc');
+  });
+
+  it('returns non-string/non-number values as-is', () => {
+    expect(toNumber(null)).toBeNull();
+    expect(toNumber(undefined)).toBeUndefined();
+    expect(toNumber(true)).toBe(true);
+    expect(toNumber([])).toEqual([]);
+  });
+});
+
+describe('toBoolean', () => {
+  it('passes through booleans', () => {
+    expect(toBoolean(true)).toBe(true);
+    expect(toBoolean(false)).toBe(false);
+  });
+
+  it('converts string "true" and "false"', () => {
+    expect(toBoolean('true')).toBe(true);
+    expect(toBoolean('false')).toBe(false);
+  });
+
+  it('returns other values as-is', () => {
+    expect(toBoolean('yes')).toBe('yes');
+    expect(toBoolean('1')).toBe('1');
+    expect(toBoolean(null)).toBeNull();
+    expect(toBoolean(undefined)).toBeUndefined();
+  });
+});
+
+describe('toArray', () => {
+  it('passes through arrays', () => {
+    expect(toArray(['a', 'b'])).toEqual(['a', 'b']);
+    expect(toArray([])).toEqual([]);
+  });
+
+  it('splits comma-separated strings', () => {
+    expect(toArray('a,b,c')).toEqual(['a', 'b', 'c']);
+    expect(toArray('ts,js')).toEqual(['ts', 'js']);
+  });
+
+  it('trims whitespace around items', () => {
+    expect(toArray('a , b , c')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('returns empty array for empty string', () => {
+    expect(toArray('')).toEqual([]);
+  });
+
+  it('returns empty array for whitespace-only string', () => {
+    expect(toArray('  ')).toEqual([]);
+  });
+
+  it('filters out empty items from trailing commas', () => {
+    expect(toArray('a,b,')).toEqual(['a', 'b']);
+    expect(toArray(',a')).toEqual(['a']);
+  });
+
+  it('handles single value strings', () => {
+    expect(toArray('typescript')).toEqual(['typescript']);
+  });
+
+  it('returns non-string/non-array values as-is', () => {
+    expect(toArray(null)).toBeNull();
+    expect(toArray(undefined)).toBeUndefined();
+    expect(toArray(42)).toBe(42);
+  });
+});
+
+describe('safePath', () => {
+  it('accepts valid paths', () => {
+    expect(safePath.safeParse('/Users/dev/project').success).toBe(true);
+    expect(safePath.safeParse('/tmp/test').success).toBe(true);
+    expect(safePath.safeParse('src/utils.ts').success).toBe(true);
+  });
+
+  it('rejects null bytes', () => {
+    expect(safePath.safeParse('/path/\0/exploit').success).toBe(false);
+  });
+
+  it('rejects directory traversal', () => {
+    expect(safePath.safeParse('../../../etc/passwd').success).toBe(false);
+    expect(safePath.safeParse('src/../../etc/passwd').success).toBe(false);
+  });
+
+  it('rejects URL-encoded traversal', () => {
+    expect(safePath.safeParse('%2e%2e%2fetc/passwd').success).toBe(false);
+    expect(safePath.safeParse('/path/%2e%2e/exploit').success).toBe(false);
+  });
+
+  it('rejects backslashes on non-Windows', () => {
+    if (process.platform !== 'win32') {
+      expect(safePath.safeParse('path\\to\\file').success).toBe(false);
+    }
+  });
+});
+
+describe('numericString (Zod schema)', () => {
+  it('parses string numbers', () => {
+    expect(numericString.parse('10')).toBe(10);
+  });
+
+  it('handles undefined', () => {
+    expect(numericString.parse(undefined)).toBeUndefined();
+  });
+});
+
+describe('booleanString (Zod schema)', () => {
+  it('parses string booleans', () => {
+    expect(booleanString.parse('true')).toBe(true);
+    expect(booleanString.parse('false')).toBe(false);
+  });
+
+  it('handles undefined', () => {
+    expect(booleanString.parse(undefined)).toBeUndefined();
+  });
+});
+
+describe('stringArray (Zod schema)', () => {
+  it('parses comma-separated strings', () => {
+    expect(stringArray.parse('a,b,c')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('passes through arrays', () => {
+    expect(stringArray.parse(['x', 'y'])).toEqual(['x', 'y']);
+  });
+
+  it('handles empty string', () => {
+    expect(stringArray.parse('')).toEqual([]);
+  });
+});