@app-connect/core 1.7.10 → 1.7.12

package/test/mcp/tools/findContactByPhone.test.js

@@ -0,0 +1,284 @@
+const findContactByPhone = require('../../../mcp/tools/findContactByPhone');
+const jwt = require('../../../lib/jwt');
+const connectorRegistry = require('../../../connector/registry');
+const contactCore = require('../../../handlers/contact');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../connector/registry');
+jest.mock('../../../handlers/contact');
+
+describe('MCP Tool: findContactByPhone', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(findContactByPhone.definition).toBeDefined();
+      expect(findContactByPhone.definition.name).toBe('findContactByPhone');
+      expect(findContactByPhone.definition.description).toContain('REQUIRES AUTHENTICATION');
+      expect(findContactByPhone.definition.inputSchema).toBeDefined();
+    });
+
+    test('should require jwtToken and phoneNumber parameters', () => {
+      expect(findContactByPhone.definition.inputSchema.required).toContain('jwtToken');
+      expect(findContactByPhone.definition.inputSchema.required).toContain('phoneNumber');
+    });
+
+    test('should have optional parameters', () => {
+      expect(findContactByPhone.definition.inputSchema.properties).toHaveProperty('overridingFormat');
+      expect(findContactByPhone.definition.inputSchema.properties).toHaveProperty('isExtension');
+    });
+  });
+
+  describe('execute', () => {
+    test('should find contact by phone successfully', async () => {
+      // Arrange
+      const mockContact = {
+        id: 'contact-123',
+        name: 'John Doe',
+        phone: '+1234567890',
+        type: 'Contact'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        findContact: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      contactCore.findContact.mockResolvedValue({
+        successful: true,
+        contact: mockContact,
+        returnMessage: { message: 'Contact found' }
+      });
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+1234567890'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: mockContact
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
+      expect(contactCore.findContact).toHaveBeenCalledWith({
+        platform: 'testCRM',
+        userId: 'user-123',
+        phoneNumber: '+1234567890',
+        overridingFormat: '',
+        isExtension: false
+      });
+    });
+
+    test('should handle overriding format parameter', async () => {
+      // Arrange
+      const mockContact = {
+        id: 'contact-456',
+        name: 'Jane Smith',
+        phone: '1234567890'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        findContact: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      contactCore.findContact.mockResolvedValue({
+        successful: true,
+        contact: mockContact
+      });
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+1234567890',
+        overridingFormat: '1234567890'
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(contactCore.findContact).toHaveBeenCalledWith({
+        platform: 'testCRM',
+        userId: 'user-123',
+        phoneNumber: '+1234567890',
+        overridingFormat: '1234567890',
+        isExtension: false
+      });
+    });
+
+    test('should handle isExtension parameter', async () => {
+      // Arrange
+      const mockContact = {
+        id: 'contact-789',
+        name: 'Bob Johnson',
+        phone: '101'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        findContact: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      contactCore.findContact.mockResolvedValue({
+        successful: true,
+        contact: mockContact
+      });
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '101',
+        isExtension: true
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(contactCore.findContact).toHaveBeenCalledWith({
+        platform: 'testCRM',
+        userId: 'user-123',
+        phoneNumber: '101',
+        overridingFormat: '',
+        isExtension: true
+      });
+    });
+
+    test('should return error when contact not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        findContact: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      contactCore.findContact.mockResolvedValue({
+        successful: false,
+        contact: null,
+        returnMessage: { message: 'Contact not found' }
+      });
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+9999999999'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'Contact not found'
+      });
+    });
+
+    test('should return error when JWT is invalid', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        platform: 'testCRM'
+        // id is missing
+      });
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'invalid-token',
+        phoneNumber: '+1234567890'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid JWT token');
+    });
+
+    test('should return error when platform connector not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'unknownCRM'
+      });
+
+      connectorRegistry.getConnector.mockReturnValue(null);
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+1234567890'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Platform connector not found');
+    });
+
+    test('should return error when findContact is not implemented', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {}; // No findContact method
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+1234567890'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not implemented');
+    });
+
+    test('should handle unexpected errors gracefully', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        findContact: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      contactCore.findContact.mockRejectedValue(
+        new Error('Database connection failed')
+      );
+
+      // Act
+      const result = await findContactByPhone.execute({
+        jwtToken: 'mock-jwt-token',
+        phoneNumber: '+1234567890'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Database connection failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+  });
+});
+

package/test/mcp/tools/getCallLog.test.js

@@ -0,0 +1,286 @@
+const getCallLog = require('../../../mcp/tools/getCallLog');
+const jwt = require('../../../lib/jwt');
+const connectorRegistry = require('../../../connector/registry');
+const logCore = require('../../../handlers/log');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../connector/registry');
+jest.mock('../../../handlers/log');
+
+describe('MCP Tool: getCallLog', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(getCallLog.definition).toBeDefined();
+      expect(getCallLog.definition.name).toBe('getCallLog');
+      expect(getCallLog.definition.description).toContain('REQUIRES AUTHENTICATION');
+      expect(getCallLog.definition.inputSchema).toBeDefined();
+    });
+
+    test('should require jwtToken and sessionIds parameters', () => {
+      expect(getCallLog.definition.inputSchema.required).toContain('jwtToken');
+      expect(getCallLog.definition.inputSchema.required).toContain('sessionIds');
+    });
+
+    test('should have requireDetails optional parameter', () => {
+      expect(getCallLog.definition.inputSchema.properties).toHaveProperty('requireDetails');
+    });
+  });
+
+  describe('execute', () => {
+    test('should get call log successfully', async () => {
+      // Arrange
+      const mockLogs = [
+        {
+          id: 'log-123',
+          sessionId: 'session-123',
+          contactId: 'contact-123',
+          phoneNumber: '+1234567890',
+          callDirection: 'Inbound',
+          callDuration: 120
+        }
+      ];
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.getCallLog.mockResolvedValue({
+        successful: true,
+        logs: mockLogs,
+        returnMessage: { message: 'Logs retrieved' }
+      });
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: mockLogs
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
+      expect(logCore.getCallLog).toHaveBeenCalledWith({
+        userId: 'user-123',
+        sessionIds: 'session-123',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+    });
+
+    test('should get call logs with multiple session IDs', async () => {
+      // Arrange
+      const mockLogs = [
+        { sessionId: 'session-123', contactId: 'contact-123' },
+        { sessionId: 'session-456', contactId: 'contact-456' }
+      ];
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.getCallLog.mockResolvedValue({
+        successful: true,
+        logs: mockLogs
+      });
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123,session-456'
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(2);
+      expect(logCore.getCallLog).toHaveBeenCalledWith({
+        userId: 'user-123',
+        sessionIds: 'session-123,session-456',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+    });
+
+    test('should get call logs with detailed information', async () => {
+      // Arrange
+      const mockLogs = [
+        {
+          sessionId: 'session-123',
+          contactId: 'contact-123',
+          detailedInfo: { recording: 'url', transcript: 'text' }
+        }
+      ];
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.getCallLog.mockResolvedValue({
+        successful: true,
+        logs: mockLogs
+      });
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123',
+        requireDetails: true
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(mockLogs);
+      expect(logCore.getCallLog).toHaveBeenCalledWith({
+        userId: 'user-123',
+        sessionIds: 'session-123',
+        platform: 'testCRM',
+        requireDetails: true
+      });
+    });
+
+    test('should return error when logs not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.getCallLog.mockResolvedValue({
+        successful: false,
+        logs: [],
+        returnMessage: { message: 'Logs not found' }
+      });
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'non-existent-session'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'Logs not found'
+      });
+    });
+
+    test('should return error when JWT is invalid', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        platform: 'testCRM'
+        // id is missing
+      });
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'invalid-token',
+        sessionIds: 'session-123'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid JWT token');
+    });
+
+    test('should return error when platform connector not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'unknownCRM'
+      });
+
+      connectorRegistry.getConnector.mockReturnValue(null);
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Platform connector not found');
+    });
+
+    test('should return error when getCallLog is not implemented', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {}; // No getCallLog method
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not implemented');
+    });
+
+    test('should handle unexpected errors gracefully', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.getCallLog.mockRejectedValue(
+        new Error('Database query failed')
+      );
+
+      // Act
+      const result = await getCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        sessionIds: 'session-123'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Database query failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+  });
+});
+