octocode-cli 1.2.5 → 1.2.7

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

@@ -0,0 +1,205 @@
+/**
+ * Integration tests for circuit breaker functionality.
+ *
+ * @module tests/integration/circuitBreaker
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  withCircuitBreaker,
+  resetCircuit,
+  getCircuitState,
+  configureCircuit,
+  CircuitOpenError,
+} from '../../utils/circuitBreaker.js';
+
+describe('Circuit Breaker', () => {
+  beforeEach(() => {
+    // Reset all circuits before each test
+    resetCircuit('test');
+    resetCircuit('lsp');
+    resetCircuit('github');
+    resetCircuit('local');
+  });
+
+  describe('Basic Functionality', () => {
+    it('allows requests when circuit is closed', async () => {
+      const result = await withCircuitBreaker('test', () => Promise.resolve('ok'));
+      expect(result).toBe('ok');
+      expect(getCircuitState('test').state).toBe('closed');
+    });
+
+    it('passes through function return values', async () => {
+      const expected = { data: 'test', count: 42 };
+      const result = await withCircuitBreaker('test', () => Promise.resolve(expected));
+      expect(result).toEqual(expected);
+    });
+
+    it('propagates errors while circuit is closed', async () => {
+      const error = new Error('test error');
+      await expect(
+        withCircuitBreaker('test', () => Promise.reject(error))
+      ).rejects.toThrow('test error');
+    });
+  });
+
+  describe('State Transitions', () => {
+    it('opens after reaching failure threshold', async () => {
+      // Configure test circuit with low threshold
+      configureCircuit('test', {
+        failureThreshold: 2,
+        successThreshold: 1,
+        resetTimeoutMs: 1000,
+      });
+
+      const failingFn = () => Promise.reject(new Error('fail'));
+
+      // First failure
+      await withCircuitBreaker('test', failingFn).catch(() => {});
+      expect(getCircuitState('test').state).toBe('closed');
+
+      // Second failure - should open circuit
+      await withCircuitBreaker('test', failingFn).catch(() => {});
+      expect(getCircuitState('test').state).toBe('open');
+    });
+
+    it('rejects immediately when circuit is open', async () => {
+      // Force circuit open
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 10000,
+      });
+
+      await withCircuitBreaker('test', () => Promise.reject(new Error('fail'))).catch(() => {});
+
+      // Next call should be rejected immediately
+      await expect(
+        withCircuitBreaker('test', () => Promise.resolve('ok'))
+      ).rejects.toThrow(CircuitOpenError);
+    });
+
+    it('transitions to half-open after reset timeout', async () => {
+      vi.useFakeTimers();
+
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 1000,
+      });
+
+      // Open the circuit
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+      expect(getCircuitState('test').state).toBe('open');
+
+      // Advance time past reset timeout
+      vi.advanceTimersByTime(1100);
+
+      // Next call should be allowed (half-open state)
+      const result = await withCircuitBreaker('test', () => Promise.resolve('recovered'));
+      expect(result).toBe('recovered');
+      expect(getCircuitState('test').state).toBe('closed');
+
+      vi.useRealTimers();
+    });
+
+    it('closes after success in half-open state', async () => {
+      vi.useFakeTimers();
+
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 100,
+      });
+
+      // Open circuit
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+      
+      // Wait for reset
+      vi.advanceTimersByTime(150);
+
+      // Successful call should close circuit
+      await withCircuitBreaker('test', () => Promise.resolve('ok'));
+      expect(getCircuitState('test').state).toBe('closed');
+
+      vi.useRealTimers();
+    });
+
+    it('reopens if failure occurs in half-open state', async () => {
+      vi.useFakeTimers();
+
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 100,
+      });
+
+      // Open circuit
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+      
+      // Wait for reset
+      vi.advanceTimersByTime(150);
+
+      // Another failure should reopen circuit
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+      expect(getCircuitState('test').state).toBe('open');
+
+      vi.useRealTimers();
+    });
+  });
+
+  describe('Pre-configured Circuits', () => {
+    it('has LSP circuit configured', () => {
+      expect(getCircuitState('lsp').state).toBe('closed');
+    });
+
+    it('has GitHub circuit configured', () => {
+      expect(getCircuitState('github').state).toBe('closed');
+    });
+  });
+
+  describe('CircuitOpenError', () => {
+    it('includes circuit name and retry time', async () => {
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 5000,
+      });
+
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+
+      try {
+        await withCircuitBreaker('test', () => Promise.resolve());
+        expect.fail('Should have thrown');
+      } catch (e) {
+        expect(e).toBeInstanceOf(CircuitOpenError);
+        const error = e as CircuitOpenError;
+        expect(error.circuitName).toBe('test');
+        expect(error.retryAfterMs).toBeGreaterThan(0);
+        expect(error.retryAfterMs).toBeLessThanOrEqual(5000);
+      }
+    });
+  });
+
+  describe('Reset Functionality', () => {
+    it('resets circuit to closed state', async () => {
+      configureCircuit('test', {
+        failureThreshold: 1,
+        successThreshold: 1,
+        resetTimeoutMs: 10000,
+      });
+
+      // Open circuit
+      await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
+      expect(getCircuitState('test').state).toBe('open');
+
+      // Reset
+      resetCircuit('test');
+      expect(getCircuitState('test').state).toBe('closed');
+
+      // Should allow requests again
+      const result = await withCircuitBreaker('test', () => Promise.resolve('ok'));
+      expect(result).toBe('ok');
+    });
+  });
+});

package/skills/octocode-research/src/__tests__/integration/routes.test.ts

@@ -0,0 +1,374 @@
+/**
+ * Integration tests for route validation and response handling.
+ *
+ * @module tests/integration/routes
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, it, expect, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { localRoutes } from '../../routes/local.js';
+import { githubRoutes } from '../../routes/github.js';
+import { lspRoutes } from '../../routes/lsp.js';
+import { packageRoutes } from '../../routes/package.js';
+
+// Mock the MCP cache
+vi.mock('../../mcpCache.js', () => ({
+  getMcpContent: vi.fn().mockReturnValue({
+    tools: {},
+    prompts: {},
+    instructions: 'Test instructions',
+    baseHints: [],
+    genericErrorHints: [],
+  }),
+  initializeMcpContent: vi.fn().mockResolvedValue({}),
+  isMcpInitialized: vi.fn().mockReturnValue(true),
+}));
+
+// Mock the MCP tools
+vi.mock('../../index.js', () => ({
+  localSearchCode: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      files: []\n      totalMatches: 0' }],
+  }),
+  localGetFileContent: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      path: test.ts\n      content: "test"' }],
+  }),
+  localFindFiles: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      files: []' }],
+  }),
+  localViewStructure: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      structuredOutput: ""' }],
+  }),
+  githubSearchCode: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      files: []' }],
+  }),
+  githubGetFileContent: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      content: "test"' }],
+  }),
+  githubSearchRepositories: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      repositories: []' }],
+  }),
+  githubViewRepoStructure: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      structure: {}' }],
+  }),
+  githubSearchPullRequests: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      pull_requests: []' }],
+  }),
+  lspGotoDefinition: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      definition: null' }],
+  }),
+  lspFindReferences: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      references: []' }],
+  }),
+  lspCallHierarchy: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      calls: []' }],
+  }),
+  packageSearch: vi.fn().mockResolvedValue({
+    content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      packages: []' }],
+  }),
+}));
+
+// Create app factory with routes (matching actual server.ts configuration)
+function createApp(): any {
+  const app = express();
+  app.use(express.json());
+  // Routes are mounted at root, matching server.ts
+  app.use('/', localRoutes);
+  app.use('/', githubRoutes);
+  app.use('/', lspRoutes);
+  app.use('/', packageRoutes);
+  return app;
+}
+
+describe('Route Validation', () => {
+  describe('Local Routes', () => {
+    describe('GET /localSearchCode', () => {
+      it('validates required pattern parameter', async () => {
+        const res = await request(createApp()).get('/localSearchCode');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid search request', async () => {
+        const res = await request(createApp())
+          .get('/localSearchCode')
+          .query({ pattern: 'test', path: '/test' });
+        expect(res.status).toBe(200);
+        expect(res.body).toHaveProperty('content');
+      });
+
+      it('returns proper response structure', async () => {
+        const res = await request(createApp())
+          .get('/localSearchCode')
+          .query({ pattern: 'test', path: '/test' });
+        expect(res.body).toHaveProperty('content');
+        expect(Array.isArray(res.body.content)).toBe(true);
+      });
+    });
+
+    describe('GET /localGetFileContent', () => {
+      it('validates required path parameter', async () => {
+        const res = await request(createApp()).get('/localGetFileContent');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid content request', async () => {
+        const res = await request(createApp())
+          .get('/localGetFileContent')
+          .query({ path: '/test/file.ts' });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /localFindFiles', () => {
+      it('validates required path parameter', async () => {
+        const res = await request(createApp()).get('/localFindFiles');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid find request', async () => {
+        const res = await request(createApp())
+          .get('/localFindFiles')
+          .query({ path: '/test' });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /localViewStructure', () => {
+      it('validates required path parameter', async () => {
+        const res = await request(createApp()).get('/localViewStructure');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid structure request', async () => {
+        const res = await request(createApp())
+          .get('/localViewStructure')
+          .query({ path: '/test' });
+        expect(res.status).toBe(200);
+      });
+    });
+  });
+
+  describe('GitHub Routes', () => {
+    describe('GET /githubSearchCode', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/githubSearchCode');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid search request', async () => {
+        const res = await request(createApp())
+          .get('/githubSearchCode')
+          .query({
+            keywordsToSearch: 'test',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /githubGetFileContent', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/githubGetFileContent');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid content request', async () => {
+        const res = await request(createApp())
+          .get('/githubGetFileContent')
+          .query({
+            owner: 'test',
+            repo: 'test',
+            path: 'test.ts',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /githubSearchRepositories', () => {
+      it('validates required keywords or topics', async () => {
+        const res = await request(createApp())
+          .get('/githubSearchRepositories')
+          .query({
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid repos request with keywords', async () => {
+        const res = await request(createApp())
+          .get('/githubSearchRepositories')
+          .query({
+            keywordsToSearch: 'test-keyword',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+
+      it('accepts valid repos request with topics', async () => {
+        const res = await request(createApp())
+          .get('/githubSearchRepositories')
+          .query({
+            topicsToSearch: 'test-topic',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /githubViewRepoStructure', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/githubViewRepoStructure');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid structure request', async () => {
+        const res = await request(createApp())
+          .get('/githubViewRepoStructure')
+          .query({
+            owner: 'test',
+            repo: 'test',
+            branch: 'main',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /githubSearchPullRequests', () => {
+      it('accepts valid PRs request', async () => {
+        const res = await request(createApp())
+          .get('/githubSearchPullRequests')
+          .query({
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+  });
+
+  describe('LSP Routes', () => {
+    describe('GET /lspGotoDefinition', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/lspGotoDefinition');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid definition request', async () => {
+        const res = await request(createApp())
+          .get('/lspGotoDefinition')
+          .query({
+            uri: 'file:///test.ts',
+            symbolName: 'test',
+            lineHint: 1,
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /lspFindReferences', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/lspFindReferences');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid references request', async () => {
+        const res = await request(createApp())
+          .get('/lspFindReferences')
+          .query({
+            uri: 'file:///test.ts',
+            symbolName: 'test',
+            lineHint: 1,
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+
+    describe('GET /lspCallHierarchy', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/lspCallHierarchy');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid calls request', async () => {
+        const res = await request(createApp())
+          .get('/lspCallHierarchy')
+          .query({
+            uri: 'file:///test.ts',
+            symbolName: 'test',
+            lineHint: 1,
+            direction: 'incoming',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+  });
+
+  describe('Package Routes', () => {
+    describe('GET /packageSearch', () => {
+      it('validates required parameters', async () => {
+        const res = await request(createApp()).get('/packageSearch');
+        expect(res.status).toBe(400);
+      });
+
+      it('accepts valid npm package search', async () => {
+        const res = await request(createApp())
+          .get('/packageSearch')
+          .query({
+            name: 'express',
+            ecosystem: 'npm',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+
+      it('accepts valid python package search', async () => {
+        const res = await request(createApp())
+          .get('/packageSearch')
+          .query({
+            name: 'requests',
+            ecosystem: 'python',
+            mainResearchGoal: 'test',
+            researchGoal: 'test',
+            reasoning: 'test',
+          });
+        expect(res.status).toBe(200);
+      });
+    });
+  });
+
+  describe('Response Structure', () => {
+    it('includes content array in all responses', async () => {
+      const res = await request(createApp())
+        .get('/localSearchCode')
+        .query({ pattern: 'test', path: '/test' });
+      expect(res.body).toHaveProperty('content');
+      expect(Array.isArray(res.body.content)).toBe(true);
+    });
+
+    it('includes structuredContent in responses', async () => {
+      const res = await request(createApp())
+        .get('/localSearchCode')
+        .query({ pattern: 'test', path: '/test' });
+      expect(res.body).toHaveProperty('structuredContent');
+    });
+  });
+});