@app-connect/core 1.7.10 → 1.7.12

package/test/mcp/tools/getGoogleFilePicker.test.js

@@ -0,0 +1,281 @@
+const getGoogleFilePicker = require('../../../mcp/tools/getGoogleFilePicker');
+const jwt = require('../../../lib/jwt');
+const { UserModel } = require('../../../models/userModel');
+const axios = require('axios');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../models/userModel');
+jest.mock('axios');
+
+describe('MCP Tool: getGoogleFilePicker', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.APP_SERVER = 'https://test-app-server.com';
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(getGoogleFilePicker.definition).toBeDefined();
+      expect(getGoogleFilePicker.definition.name).toBe('getGoogleFilePicker');
+      expect(getGoogleFilePicker.definition.description).toContain('REQUIRES AUTHENTICATION');
+      expect(getGoogleFilePicker.definition.description).toContain('Google Sheets file picker');
+      expect(getGoogleFilePicker.definition.inputSchema).toBeDefined();
+    });
+
+    test('should require jwtToken parameter', () => {
+      expect(getGoogleFilePicker.definition.inputSchema.required).toContain('jwtToken');
+    });
+
+    test('should have optional sheetName parameter', () => {
+      expect(getGoogleFilePicker.definition.inputSchema.properties).toHaveProperty('sheetName');
+      expect(getGoogleFilePicker.definition.inputSchema.required).not.toContain('sheetName');
+    });
+
+    test('should have correct annotations', () => {
+      expect(getGoogleFilePicker.definition.annotations).toEqual({
+        readOnlyHint: false,
+        openWorldHint: true,
+        destructiveHint: false
+      });
+    });
+  });
+
+  describe('execute - file picker URL', () => {
+    test('should return file picker URL successfully', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123'
+      });
+
+      UserModel.findByPk.mockResolvedValue({
+        id: 'user-123',
+        name: 'Test User'
+      });
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          filePickerUrl: 'https://test-app-server.com/googleSheets/filePicker?token=mock-jwt-token}',
+          message: expect.stringContaining('Please open this URL')
+        }
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(UserModel.findByPk).toHaveBeenCalledWith('user-123');
+    });
+  });
+
+  describe('execute - create new sheet', () => {
+    test('should create new sheet when sheetName is provided', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123'
+      });
+
+      UserModel.findByPk.mockResolvedValue({
+        id: 'user-123',
+        name: 'Test User'
+      });
+
+      const mockSheetResponse = {
+        data: {
+          success: true,
+          data: {
+            sheetId: 'sheet-123',
+            sheetName: 'My Call Logs'
+          }
+        }
+      };
+
+      axios.post.mockResolvedValue(mockSheetResponse);
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token',
+        sheetName: 'My Call Logs'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          sheetId: 'sheet-123',
+          sheetName: 'My Call Logs'
+        }
+      });
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://test-app-server.com/googleSheets/sheet?jwtToken=mock-jwt-token',
+        { name: 'My Call Logs' }
+      );
+    });
+
+    test('should return error when sheet creation fails', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123'
+      });
+
+      UserModel.findByPk.mockResolvedValue({
+        id: 'user-123',
+        name: 'Test User'
+      });
+
+      axios.post.mockRejectedValue(new Error('Failed to create sheet'));
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token',
+        sheetName: 'My Call Logs'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Failed to create sheet');
+      expect(result.errorDetails).toBeDefined();
+    });
+  });
+
+  describe('execute - error handling', () => {
+    test('should return error when jwtToken is missing', async () => {
+      // Act
+      const result = await getGoogleFilePicker.execute({});
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'JWT token is required. Please authenticate with googleSheets platform first using the doAuth tool.'
+      });
+    });
+
+    test('should return error when jwtToken is null', async () => {
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: null
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'JWT token is required. Please authenticate with googleSheets platform first using the doAuth tool.'
+      });
+    });
+
+    test('should return error when JWT is invalid (no userId)', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        // id is missing
+        platform: 'googleSheets'
+      });
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'invalid-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'Invalid JWT token: userId not found'
+      });
+    });
+
+    test('should return error when JWT decode returns null', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue(null);
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'malformed-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'Invalid JWT token: userId not found'
+      });
+    });
+
+    test('should return error when user not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'nonexistent-user'
+      });
+
+      UserModel.findByPk.mockResolvedValue(null);
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'User not found. Please authenticate with googleSheets platform first.'
+      });
+      expect(UserModel.findByPk).toHaveBeenCalledWith('nonexistent-user');
+    });
+
+    test('should handle database errors gracefully', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123'
+      });
+
+      UserModel.findByPk.mockRejectedValue(new Error('Database connection failed'));
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Database connection failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle JWT decode errors gracefully', async () => {
+      // Arrange
+      jwt.decodeJwt.mockImplementation(() => {
+        throw new Error('JWT decode error');
+      });
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'corrupted-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('JWT decode error');
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle errors without message property', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123'
+      });
+
+      const errorWithoutMessage = { code: 'UNKNOWN_ERROR' };
+      UserModel.findByPk.mockRejectedValue(errorWithoutMessage);
+
+      // Act
+      const result = await getGoogleFilePicker.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Unknown error occurred');
+    });
+  });
+});
+

package/test/mcp/tools/getPublicConnectors.test.js

@@ -0,0 +1,128 @@
+const getPublicConnectors = require('../../../mcp/tools/getPublicConnectors');
+const developerPortal = require('../../../connector/developerPortal');
+
+// Mock the developerPortal module
+jest.mock('../../../connector/developerPortal');
+
+describe('MCP Tool: getPublicConnectors', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete process.env.RC_ACCOUNT_ID;
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(getPublicConnectors.definition).toBeDefined();
+      expect(getPublicConnectors.definition.name).toBe('getPublicConnectors');
+      expect(getPublicConnectors.definition.description).toContain('Auth flow step.1');
+      expect(getPublicConnectors.definition.inputSchema).toBeDefined();
+      expect(getPublicConnectors.definition.inputSchema.type).toBe('object');
+    });
+
+    test('should have no required parameters', () => {
+      expect(getPublicConnectors.definition.inputSchema.required).toEqual([]);
+    });
+  });
+
+  describe('execute', () => {
+    test('should return public connectors successfully', async () => {
+      // Arrange - use supported platform names: 'googleSheets' and 'clio'
+      const mockConnectors = [
+        { id: '1', name: 'googleSheets', displayName: 'Google Sheets' },
+        { id: '2', name: 'clio', displayName: 'Clio' }
+      ];
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockConnectors
+      });
+
+      // Act
+      const result = await getPublicConnectors.execute();
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: ['Google Sheets', 'Clio']
+      });
+      expect(developerPortal.getPublicConnectorList).toHaveBeenCalledTimes(1);
+    });
+
+    test('should include private connectors when RC_ACCOUNT_ID is set', async () => {
+      // Arrange - use supported platform names
+      process.env.RC_ACCOUNT_ID = 'test-account-id';
+      
+      const mockPublicConnectors = [
+        { id: '1', name: 'googleSheets', displayName: 'Google Sheets' }
+      ];
+      const mockPrivateConnectors = [
+        { id: '3', name: 'clio', displayName: 'Clio' }
+      ];
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockPublicConnectors
+      });
+      developerPortal.getPrivateConnectorList.mockResolvedValue({
+        privateConnectors: mockPrivateConnectors
+      });
+
+      // Act
+      const result = await getPublicConnectors.execute();
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: ['Google Sheets', 'Clio']
+      });
+      expect(developerPortal.getPublicConnectorList).toHaveBeenCalledTimes(1);
+      expect(developerPortal.getPrivateConnectorList).toHaveBeenCalledTimes(1);
+    });
+
+    test('should return empty array when no connectors available', async () => {
+      // Arrange
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: []
+      });
+
+      // Act
+      const result = await getPublicConnectors.execute();
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: []
+      });
+    });
+
+    test('should handle errors gracefully', async () => {
+      // Arrange
+      const errorMessage = 'Failed to fetch connectors';
+      developerPortal.getPublicConnectorList.mockRejectedValue(
+        new Error(errorMessage)
+      );
+
+      // Act
+      const result = await getPublicConnectors.execute();
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe(errorMessage);
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle network errors', async () => {
+      // Arrange
+      const networkError = new Error('Network request failed');
+      networkError.code = 'ECONNREFUSED';
+      developerPortal.getPublicConnectorList.mockRejectedValue(networkError);
+
+      // Act
+      const result = await getPublicConnectors.execute();
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Network request failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+  });
+});
+

package/test/mcp/tools/logout.test.js

@@ -0,0 +1,169 @@
+const logout = require('../../../mcp/tools/logout');
+const jwt = require('../../../lib/jwt');
+const { UserModel } = require('../../../models/userModel');
+const connectorRegistry = require('../../../connector/registry');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../models/userModel');
+jest.mock('../../../connector/registry');
+
+describe('MCP Tool: logout', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(logout.definition).toBeDefined();
+      expect(logout.definition.name).toBe('logout');
+      expect(logout.definition.description).toContain('Logout');
+      expect(logout.definition.inputSchema).toBeDefined();
+    });
+
+    test('should have jwtToken property', () => {
+      expect(logout.definition.inputSchema.properties).toHaveProperty('jwtToken');
+    });
+  });
+
+  describe('execute', () => {
+    test('should logout user successfully', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-access-token'
+      };
+
+      const mockConnector = {
+        unAuthorize: jest.fn().mockResolvedValue({
+          returnMessage: {
+            messageType: 'success',
+            message: 'Logged out successfully'
+          }
+        })
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          message: expect.stringContaining('IMPORTANT')
+        }
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(UserModel.findByPk).toHaveBeenCalledWith('test-user-id');
+      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
+      expect(mockConnector.unAuthorize).toHaveBeenCalledWith({
+        user: mockUser
+      });
+    });
+
+    test('should return error when user not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'non-existent-user',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'User not found',
+        errorDetails: 'User not found'
+      });
+    });
+
+    test('should handle logout errors gracefully', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+
+      const mockConnector = {
+        unAuthorize: jest.fn().mockRejectedValue(
+          new Error('Logout API failed')
+        )
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Logout API failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle invalid JWT token', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'invalid-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    test('should handle missing platform connector', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'unknownCRM'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'unknownCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});
+