gemini-executor 0.1.0

package/agents/gemini-executor/__tests__/integration.test.ts

@@ -0,0 +1,486 @@
+/**
+ * Integration Tests for Gemini Executor
+ *
+ * Tests the complete execute() function with mocked Gemini CLI calls,
+ * including error handling, retry logic, and result formatting.
+ */
+
+import { execute, checkGeminiCLI, ExecutionOptions } from '../index';
+
+// Mock child_process module
+jest.mock('child_process');
+
+// Get reference to the mocked exec function
+import { exec } from 'child_process';
+const mockExec = exec as jest.MockedFunction<typeof exec>;
+
+describe('Integration Tests', () => {
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    mockExec.mockReset();
+  });
+
+  describe('Successful Execution', () => {
+    test('should execute successfully with valid options', async () => {
+      // Mock successful execution - exec uses callback (error, stdout, stderr)
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'This is Gemini response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.output).toBe('This is Gemini response');
+      expect(result.metadata.retries).toBe(0);
+      expect(result.metadata.duration).toBeGreaterThan(0);
+    });
+
+    test('should handle JSON output format', async () => {
+      const jsonOutput = JSON.stringify({
+        response: 'Gemini JSON response',
+        data: { key: 'value' }
+      });
+
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, jsonOutput, '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query',
+        outputFormat: 'json'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.output).toBe(jsonOutput);
+    });
+
+    test('should include file references', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'File analysis complete', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Analyze files',
+        files: ['/path/to/file.txt']
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(mockExec).toHaveBeenCalled();
+    });
+
+    test('should use custom model', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Response from thinking model', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Complex query',
+        model: 'gemini-2.0-flash-thinking-exp'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.model).toContain('gemini');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should return error for empty query', async () => {
+      const options: ExecutionOptions = {
+        query: ''
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Query cannot be empty');
+      expect(result.metadata.retries).toBe(0);
+    });
+
+    test('should return error for whitespace-only query', async () => {
+      const options: ExecutionOptions = {
+        query: '   \n\t   '
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Query cannot be empty');
+    });
+
+    test('should handle command execution errors', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(new Error('Command failed'), '', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Command failed');
+    });
+
+    test('should handle timeout errors', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(new Error('Timeout exceeded'), '', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Long running query'
+      };
+
+      const config = {
+        timeout: 1000 // 1 second
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeTruthy();
+    });
+
+    test('should handle stderr without stdout', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, '', 'Error: API rate limit exceeded');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('API rate limit');
+    });
+  });
+
+  describe('Retry Logic', () => {
+    test('should retry on failure', async () => {
+      // Fail twice, then succeed
+      mockExec
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(new Error('Temporary error'), '', '');
+          return {} as any;
+        })
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(new Error('Temporary error'), '', '');
+          return {} as any;
+        })
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(null, 'Success after retries', '');
+          return {} as any;
+        });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        maxRetries: 3
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(true);
+      expect(result.output).toBe('Success after retries');
+      expect(result.metadata.retries).toBe(2);
+      expect(mockExec).toHaveBeenCalledTimes(3);
+    }, 15000); // Increase timeout to 15s for retry logic
+
+    test('should fail after max retries', async () => {
+      // Always fail
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(new Error('Persistent error'), '', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        maxRetries: 3
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Persistent error');
+      expect(result.metadata.retries).toBe(2); // maxRetries - 1
+      expect(mockExec).toHaveBeenCalledTimes(3);
+    }, 15000); // Increase timeout
+
+    test('should implement exponential backoff', async () => {
+      const startTime = Date.now();
+
+      mockExec
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(new Error('Error 1'), '', '');
+          return {} as any;
+        })
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(new Error('Error 2'), '', '');
+          return {} as any;
+        })
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(null, 'Success', '');
+          return {} as any;
+        });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        maxRetries: 3
+      };
+
+      const result = await execute(options, config);
+
+      const duration = Date.now() - startTime;
+
+      expect(result.success).toBe(true);
+      // Should take at least 1s + 2s = 3s due to exponential backoff
+      expect(duration).toBeGreaterThanOrEqual(3000);
+    }, 15000); // Increase timeout to 15s
+
+    test('should not retry on validation errors', async () => {
+      const options: ExecutionOptions = {
+        query: '' // Invalid
+      };
+
+      const config = {
+        maxRetries: 5
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(false);
+      expect(result.metadata.retries).toBe(0);
+      // mockExec should not be called at all
+      expect(mockExec).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Configuration Overrides', () => {
+    test('should use custom CLI path', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Custom path response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        cliPath: '/custom/path/gemini'
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(true);
+      const call = mockExec.mock.calls[0][0];
+      expect(call).toContain('/custom/path/gemini');
+    });
+
+    test('should use custom timeout', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        timeout: 300000 // 5 minutes
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(true);
+      const callOptions = mockExec.mock.calls[0][1];
+      expect(callOptions).toBeDefined();
+      expect(callOptions?.timeout).toBe(300000);
+    });
+
+    test('should disable yolo mode', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const config = {
+        yolo: false
+      };
+
+      const result = await execute(options, config);
+
+      expect(result.success).toBe(true);
+      const command = mockExec.mock.calls[0][0];
+      expect(command).not.toContain('-y');
+    });
+  });
+
+  describe('Gemini CLI Availability Check', () => {
+    test('should return true if Gemini CLI is available', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'gemini version 1.0.0', '');
+        return {} as any;
+      });
+
+      const isAvailable = await checkGeminiCLI();
+
+      expect(isAvailable).toBe(true);
+    });
+
+    test('should return false if Gemini CLI is not found', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(new Error('Command not found'), '', '');
+        return {} as any;
+      });
+
+      const isAvailable = await checkGeminiCLI();
+
+      expect(isAvailable).toBe(false);
+    });
+
+    test('should check custom CLI path', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'version info', '');
+        return {} as any;
+      });
+
+      const isAvailable = await checkGeminiCLI({
+        cliPath: '/custom/gemini'
+      });
+
+      expect(isAvailable).toBe(true);
+      const command = mockExec.mock.calls[0][0];
+      expect(command).toContain('/custom/gemini');
+    });
+  });
+
+  describe('Metadata Tracking', () => {
+    test('should track execution duration', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        setTimeout(() => {
+          callback?.(null, 'Response', '');
+        }, 100);
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.duration).toBeGreaterThanOrEqual(100);
+      expect(result.metadata.duration).toBeLessThan(200);
+    });
+
+    test('should track model used', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query',
+        model: 'gemini-pro'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.model).toBe('gemini-pro');
+    });
+
+    test('should track retry count', async () => {
+      mockExec
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(new Error('Fail 1'), '', '');
+          return {} as any;
+        })
+        .mockImplementationOnce((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+          callback?.(null, 'Success', '');
+          return {} as any;
+        });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.retries).toBe(1);
+    }, 15000); // Increase timeout for retry
+  });
+
+  describe('Large Buffer Handling', () => {
+    test('should handle large output (10MB)', async () => {
+      const largeOutput = 'x'.repeat(10 * 1024 * 1024); // 10MB
+
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, largeOutput, '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Generate large output'
+      };
+
+      const result = await execute(options);
+
+      expect(result.success).toBe(true);
+      expect(result.output?.length).toBe(10 * 1024 * 1024);
+    });
+
+    test('should set appropriate maxBuffer', async () => {
+      mockExec.mockImplementation((_cmd: string, _options: any, callback?: (error: any, stdout: string, stderr: string) => void) => {
+        callback?.(null, 'Response', '');
+        return {} as any;
+      });
+
+      const options: ExecutionOptions = {
+        query: 'Test query'
+      };
+
+      await execute(options);
+
+      const callOptions = mockExec.mock.calls[0][1];
+      expect(callOptions).toBeDefined();
+      expect(callOptions?.maxBuffer).toBe(10 * 1024 * 1024); // 10MB
+    });
+  });
+});