add tests

Author: betegon

packages/core/test/lib/integrations/mcp-server/mcpServerErrorCapture.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as currentScopes from '../../../../src/currentScopes';
+import * as exports from '../../../../src/exports';
+import { captureError } from '../../../../src/integrations/mcp-server/errorCapture';
+import { wrapMcpServerWithSentry } from '../../../../src/integrations/mcp-server';
+import { createMockMcpServer } from './testUtils';
+
+describe('MCP Server Error Capture', () => {
+  const captureExceptionSpy = vi.spyOn(exports, 'captureException');
+  const getClientSpy = vi.spyOn(currentScopes, 'getClient');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    getClientSpy.mockReturnValue({
+      getOptions: () => ({ sendDefaultPii: true }),
+    } as ReturnType<typeof currentScopes.getClient>);
+  });
+
+  describe('captureError', () => {
+    it('should capture errors with default error type', () => {
+      const error = new Error('Test error');
+
+      captureError(error);
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'handler_execution',
+        },
+      });
+    });
+
+    it('should capture errors with custom error type', () => {
+      const error = new Error('Tool execution failed');
+
+      captureError(error, 'tool_execution');
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'tool_execution',
+        },
+      });
+    });
+
+    it('should capture transport errors', () => {
+      const error = new Error('Connection failed');
+
+      captureError(error, 'transport');
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'transport',
+        },
+      });
+    });
+
+    it('should capture protocol errors', () => {
+      const error = new Error('Invalid JSON-RPC request');
+
+      captureError(error, 'protocol');
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'protocol',
+        },
+      });
+    });
+
+    it('should capture validation errors', () => {
+      const error = new Error('Invalid parameters');
+
+      captureError(error, 'validation');
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'validation',
+        },
+      });
+    });
+
+    it('should capture timeout errors', () => {
+      const error = new Error('Operation timed out');
+
+      captureError(error, 'timeout');
+
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        tags: {
+          mcp_error_type: 'timeout',
+        },
+      });
+    });
+
+    it('should not capture when no client is available', () => {
+      getClientSpy.mockReturnValue(undefined);
+
+      const error = new Error('Test error');
+
+      captureError(error, 'tool_execution');
+
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle Sentry capture errors gracefully', () => {
+      captureExceptionSpy.mockImplementation(() => {
+        throw new Error('Sentry error');
+      });
+
+      const error = new Error('Test error');
+
+      // Should not throw
+      expect(() => captureError(error, 'tool_execution')).not.toThrow();
+    });
+
+    it('should handle undefined client gracefully', () => {
+      getClientSpy.mockReturnValue(undefined);
+
+      const error = new Error('Test error');
+
+      // Should not throw and not capture
+      expect(() => captureError(error, 'tool_execution')).not.toThrow();
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Error Capture Integration', () => {
+    let mockMcpServer: ReturnType<typeof createMockMcpServer>;
+    let wrappedMcpServer: ReturnType<typeof createMockMcpServer>;
+
+    beforeEach(() => {
+      mockMcpServer = createMockMcpServer();
+      wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+    });
+
+    it('should capture tool execution errors and continue normal flow', async () => {
+      const toolError = new Error('Tool execution failed');
+      const mockToolHandler = vi.fn().mockRejectedValue(toolError);
+
+      wrappedMcpServer.tool('failing-tool', mockToolHandler);
+
+      await expect(mockToolHandler({ input: 'test' }, { requestId: 'req-123', sessionId: 'sess-456' })).rejects.toThrow(
+        'Tool execution failed',
+      );
+
+      // The capture should be set up correctly
+      expect(captureExceptionSpy).toHaveBeenCalledTimes(0); // No capture yet since we didn't call the wrapped handler
+    });
+
+    it('should handle Sentry capture errors gracefully', async () => {
+      captureExceptionSpy.mockImplementation(() => {
+        throw new Error('Sentry error');
+      });
+
+      // Test that the capture function itself doesn't throw
+      const toolError = new Error('Tool execution failed');
+      const mockToolHandler = vi.fn().mockRejectedValue(toolError);
+
+      wrappedMcpServer.tool('failing-tool', mockToolHandler);
+
+      // The error capture should be resilient to Sentry errors
+      expect(captureExceptionSpy).toHaveBeenCalledTimes(0);
+    });
+  });
+});

packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as currentScopes from '../../../../src/currentScopes';
+import { wrapMcpServerWithSentry } from '../../../../src/integrations/mcp-server';
+import * as tracingModule from '../../../../src/tracing';
+import { createMockMcpServer } from './testUtils';
+
+describe('wrapMcpServerWithSentry', () => {
+  const startSpanSpy = vi.spyOn(tracingModule, 'startSpan');
+  const startInactiveSpanSpy = vi.spyOn(tracingModule, 'startInactiveSpan');
+  const getClientSpy = vi.spyOn(currentScopes, 'getClient');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Mock client to return sendDefaultPii:
+    getClientSpy.mockReturnValue({
+      getOptions: () => ({ sendDefaultPii: true }),
+      getDsn: () => ({ publicKey: 'test-key', host: 'test-host' }),
+      emit: vi.fn(),
+    } as any);
+  });
+
+  it('should return the same instance (modified) if it is a valid MCP server instance', () => {
+    const mockMcpServer = createMockMcpServer();
+    const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+
+    expect(wrappedMcpServer).toBe(mockMcpServer);
+  });
+
+  it('should return the input unchanged if it is not a valid MCP server instance', () => {
+    const invalidMcpServer = {
+      resource: () => {},
+      tool: () => {},
+      // Missing required methods
+    };
+
+    const result = wrapMcpServerWithSentry(invalidMcpServer);
+    expect(result).toBe(invalidMcpServer);
+
+    // Methods should not be wrapped
+    expect(result.resource).toBe(invalidMcpServer.resource);
+    expect(result.tool).toBe(invalidMcpServer.tool);
+
+    // No calls to startSpan or startInactiveSpan
+    expect(startSpanSpy).not.toHaveBeenCalled();
+    expect(startInactiveSpanSpy).not.toHaveBeenCalled();
+  });
+
+  it('should not wrap the same instance twice', () => {
+    const mockMcpServer = createMockMcpServer();
+
+    const wrappedOnce = wrapMcpServerWithSentry(mockMcpServer);
+    const wrappedTwice = wrapMcpServerWithSentry(wrappedOnce);
+
+    expect(wrappedTwice).toBe(wrappedOnce);
+  });
+
+  it('should wrap the connect method to intercept transport', () => {
+    const mockMcpServer = createMockMcpServer();
+    const originalConnect = mockMcpServer.connect;
+
+    const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+
+    expect(wrappedMcpServer.connect).not.toBe(originalConnect);
+    expect(typeof wrappedMcpServer.connect).toBe('function');
+  });
+
+  it('should wrap handler methods (tool, resource, prompt)', () => {
+    const mockMcpServer = createMockMcpServer();
+    const originalTool = mockMcpServer.tool;
+    const originalResource = mockMcpServer.resource;
+    const originalPrompt = mockMcpServer.prompt;
+
+    const wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+
+    expect(wrappedMcpServer.tool).not.toBe(originalTool);
+    expect(wrappedMcpServer.resource).not.toBe(originalResource);
+    expect(wrappedMcpServer.prompt).not.toBe(originalPrompt);
+  });
+
+  describe('Handler Wrapping', () => {
+    let mockMcpServer: ReturnType<typeof createMockMcpServer>;
+    let wrappedMcpServer: ReturnType<typeof createMockMcpServer>;
+
+    beforeEach(() => {
+      mockMcpServer = createMockMcpServer();
+      wrappedMcpServer = wrapMcpServerWithSentry(mockMcpServer);
+    });
+
+    it('should register tool handlers without throwing errors', () => {
+      const toolHandler = vi.fn();
+
+      expect(() => {
+        wrappedMcpServer.tool('test-tool', toolHandler);
+      }).not.toThrow();
+    });
+
+    it('should register resource handlers without throwing errors', () => {
+      const resourceHandler = vi.fn();
+
+      expect(() => {
+        wrappedMcpServer.resource('test-resource', resourceHandler);
+      }).not.toThrow();
+    });
+
+    it('should register prompt handlers without throwing errors', () => {
+      const promptHandler = vi.fn();
+
+      expect(() => {
+        wrappedMcpServer.prompt('test-prompt', promptHandler);
+      }).not.toThrow();
+    });
+
+    it('should handle multiple arguments when registering handlers', () => {
+      const nonFunctionArg = { config: 'value' };
+
+      expect(() => {
+        wrappedMcpServer.tool('test-tool', nonFunctionArg, 'other-arg');
+      }).not.toThrow();
+    });
+  });
+});