@app-connect/core 0.0.2 → 1.5.8

package/test/adapter/registry.test.js

@@ -0,0 +1,271 @@
+const adapterRegistry = require('../../adapter/registry');
+
+describe('AdapterRegistry Interface Registration with Composition', () => {
+  beforeEach(() => {
+    // Clear the registry before each test
+    adapterRegistry.adapters.clear();
+    adapterRegistry.manifests.clear();
+    adapterRegistry.platformInterfaces.clear();
+  });
+
+  test('should register interface functions for a platform', () => {
+    const mockFunction = jest.fn();
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    expect(adapterRegistry.getPlatformInterfaces('testPlatform').get('testInterface')).toBe(mockFunction);
+  });
+
+  test('should throw error when registering non-function as interface', () => {
+    expect(() => {
+      adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', 'not a function');
+    }).toThrow('Interface function must be a function, got: string');
+  });
+
+  test('should return original adapter when no interfaces are registered', () => {
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const retrievedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(retrievedAdapter).toBe(mockAdapter);
+  });
+
+  test('should return composed adapter with interface functions when interfaces are registered', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register interface function first
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Register adapter
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should be a different object (composed)
+    expect(composedAdapter).not.toBe(mockAdapter);
+    
+    // Should have the interface function
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+    
+    // Should still have original methods
+    expect(composedAdapter.getAuthType).toBe(mockAdapter.getAuthType);
+    expect(composedAdapter.createCallLog).toBe(mockAdapter.createCallLog);
+  });
+
+  test('should not override existing adapter methods when composing interfaces', () => {
+    const existingMethod = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      existingMethod: existingMethod
+    };
+
+    // Register adapter first
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Try to register interface with same name as existing method
+    const newMethod = jest.fn();
+    adapterRegistry.registerAdapterInterface('testPlatform', 'existingMethod', newMethod);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should not override the existing method
+    expect(composedAdapter.existingMethod).toBe(existingMethod);
+    expect(composedAdapter.existingMethod).not.toBe(newMethod);
+  });
+
+  test('should preserve original adapter when composing interfaces', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Get original adapter
+    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
+    
+    // Original adapter should be unchanged
+    expect(originalAdapter).toBe(mockAdapter);
+    expect(originalAdapter.customMethod).toBeUndefined();
+    
+    // Composed adapter should have the interface
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+  });
+
+  test('should unregister interface functions', () => {
+    const mockFunction = jest.fn();
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    adapterRegistry.unregisterAdapterInterface('testPlatform', 'testInterface');
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should return empty map for non-existent platform interfaces', () => {
+    const interfaces = adapterRegistry.getPlatformInterfaces('nonExistentPlatform');
+    expect(interfaces).toBeInstanceOf(Map);
+    expect(interfaces.size).toBe(0);
+  });
+
+  test('should return false for non-existent platform interface', () => {
+    expect(adapterRegistry.hasPlatformInterface('nonExistentPlatform', 'anyInterface')).toBe(false);
+  });
+
+  test('should handle multiple interface functions for same platform', () => {
+    const mockFunction1 = jest.fn();
+    const mockFunction2 = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    
+    adapterRegistry.registerAdapterInterface('testPlatform', 'interface1', mockFunction1);
+    adapterRegistry.registerAdapterInterface('testPlatform', 'interface2', mockFunction2);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const platformInterfaces = adapterRegistry.getPlatformInterfaces('testPlatform');
+    expect(platformInterfaces.size).toBe(2);
+    expect(platformInterfaces.get('interface1')).toBe(mockFunction1);
+    expect(platformInterfaces.get('interface2')).toBe(mockFunction2);
+    
+    // Check composed adapter has both interfaces
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    expect(composedAdapter.interface1).toBe(mockFunction1);
+    expect(composedAdapter.interface2).toBe(mockFunction2);
+  });
+
+  test('should clean up platform interfaces when unregistering adapter', () => {
+    const mockFunction = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    adapterRegistry.unregisterAdapter('testPlatform');
+    
+    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should get adapter capabilities correctly', () => {
+    const mockInterface = jest.fn();
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    const capabilities = adapterRegistry.getAdapterCapabilities('testPlatform');
+    
+    expect(capabilities.platform).toBe('testPlatform');
+    expect(capabilities.originalMethods).toContain('getAuthType');
+    expect(capabilities.originalMethods).toContain('createCallLog');
+    expect(capabilities.originalMethods).toContain('updateCallLog');
+    expect(capabilities.composedMethods).toContain('customMethod');
+    expect(capabilities.registeredInterfaces).toContain('customMethod');
+    expect(capabilities.authType).toBe('apiKey');
+  });
+
+  test('should handle interface registration after adapter registration', () => {
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register adapter first
+    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    
+    // Register interface function after
+    const mockInterface = jest.fn();
+    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Get composed adapter
+    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    
+    // Should have the interface function
+    expect(composedAdapter.customMethod).toBe(mockInterface);
+    
+    // Original adapter should be unchanged
+    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
+    expect(originalAdapter.customMethod).toBeUndefined();
+  });
+
+  test('should return interface-only adapter when no base adapter is registered', () => {
+    const mockInterface1 = jest.fn();
+    const mockInterface2 = jest.fn();
+    
+    // Register only interface functions, no base adapter
+    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
+    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
+    
+    // Get adapter - should return interface-only object
+    const interfaceOnlyAdapter = adapterRegistry.getAdapter('interfaceOnlyPlatform');
+    
+    // Should have interface functions
+    expect(interfaceOnlyAdapter.method1).toBe(mockInterface1);
+    expect(interfaceOnlyAdapter.method2).toBe(mockInterface2);
+    
+    // Should not have base adapter methods
+    expect(interfaceOnlyAdapter.getAuthType).toBeUndefined();
+    
+    // Should be a plain object, not inherited from any adapter
+    expect(Object.getPrototypeOf(interfaceOnlyAdapter)).toBe(Object.prototype);
+  });
+
+  test('should throw error when no adapter and no interfaces are registered', () => {
+    expect(() => {
+      adapterRegistry.getAdapter('nonExistentPlatform');
+    }).toThrow('Adapter not found for platform: nonExistentPlatform');
+  });
+
+  test('should handle mixed scenarios correctly', () => {
+    // Scenario 1: Only interfaces, no adapter
+    adapterRegistry.registerAdapterInterface('mixedPlatform', 'interfaceMethod', jest.fn());
+    const interfaceOnly = adapterRegistry.getAdapter('mixedPlatform');
+    expect(interfaceOnly.interfaceMethod).toBeDefined();
+    expect(interfaceOnly.getAuthType).toBeUndefined();
+    
+    // Scenario 2: Add adapter later
+    const mockAdapter = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    adapterRegistry.registerAdapter('mixedPlatform', mockAdapter);
+    
+    const composedAdapter = adapterRegistry.getAdapter('mixedPlatform');
+    expect(composedAdapter.interfaceMethod).toBeDefined();
+    expect(composedAdapter.getAuthType).toBeDefined();
+    expect(composedAdapter.getAuthType()).toBe('apiKey');
+  });
+}); 

package/test/handlers/auth.test.js

@@ -0,0 +1,231 @@
+const authHandler = require('../../handlers/auth');
+const adapterRegistry = require('../../adapter/registry');
+
+// Mock the adapter registry
+jest.mock('../../adapter/registry');
+
+describe('Auth Handler', () => {
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+    global.testUtils.resetAdapterRegistry();
+  });
+
+  describe('onApiKeyLogin', () => {
+    test('should handle successful API key login', async () => {
+      // Arrange
+      const mockUserInfo = {
+        successful: true,
+        platformUserInfo: {
+          id: 'test-user-id',
+          name: 'Test User',
+          timezoneName: 'America/Los_Angeles',
+          timezoneOffset: 0,
+          platformAdditionalInfo: {}
+        },
+        returnMessage: {
+          messageType: 'success',
+          message: 'Login successful',
+          ttl: 1000
+        }
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'test-api-key',
+        additionalInfo: {}
+      };
+
+      // Act
+      const result = await authHandler.onApiKeyLogin(requestData);
+
+      // Assert
+      expect(result.userInfo).toBeDefined();
+      expect(result.userInfo.id).toBe('test-user-id');
+      expect(result.userInfo.name).toBe('Test User');
+      expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
+      expect(mockAdapter.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'test-api-key' });
+      expect(mockAdapter.getUserInfo).toHaveBeenCalledWith({
+        authHeader: 'Basic dGVzdC1hcGkta2V5Og==',
+        hostname: 'test.example.com',
+        additionalInfo: {},
+        apiKey: 'test-api-key'
+      });
+    });
+
+    test('should handle failed API key login', async () => {
+      // Arrange
+      const mockUserInfo = {
+        successful: false,
+        platformUserInfo: null,
+        returnMessage: {
+          messageType: 'error',
+          message: 'Invalid API key',
+          ttl: 3000
+        }
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'invalid-api-key',
+        additionalInfo: {}
+      };
+
+      // Act
+      const result = await authHandler.onApiKeyLogin(requestData);
+
+      // Assert
+      expect(result.userInfo).toBeNull();
+      expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
+    });
+
+    test('should throw error when adapter not found', async () => {
+      // Arrange
+      adapterRegistry.getAdapter.mockImplementation(() => {
+        throw new Error('Adapter not found for platform: testCRM');
+      });
+
+      const requestData = {
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        apiKey: 'test-api-key',
+        additionalInfo: {}
+      };
+
+      // Act & Assert
+      await expect(authHandler.onApiKeyLogin(requestData))
+        .rejects.toThrow('Adapter not found for platform: testCRM');
+    });
+  });
+
+  describe('authValidation', () => {
+    test('should validate user authentication successfully', async () => {
+      // Arrange
+      const mockUser = global.testUtils.createMockUser();
+      const mockValidationResponse = {
+        successful: true,
+        returnMessage: {
+          messageType: 'success',
+          message: 'Authentication valid',
+          ttl: 1000
+        },
+        status: 200
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getOauthInfo: jest.fn().mockResolvedValue({}),
+        authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return a user
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(mockUser);
+
+      // Mock oauth.checkAndRefreshAccessToken
+      const oauth = require('../../lib/oauth');
+      jest.spyOn(oauth, 'checkAndRefreshAccessToken').mockResolvedValue(mockUser);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'test-user-id'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        ...mockValidationResponse,
+        failReason: ''
+      });
+      expect(mockAdapter.authValidation).toHaveBeenCalledWith({ user: mockUser });
+    });
+
+    test('should handle user not found in database', async () => {
+      // Arrange
+      const mockAdapter = global.testUtils.createMockAdapter();
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return null (user not found)
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(null);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'non-existent-user'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        successful: false,
+        status: 404,
+        failReason: 'App Connect. User not found in database'
+      });
+    });
+
+    test('should handle validation failure', async () => {
+      // Arrange
+      const mockUser = global.testUtils.createMockUser();
+      const mockValidationResponse = {
+        successful: false,
+        returnMessage: {
+          messageType: 'error',
+          message: 'Authentication failed',
+          ttl: 3000
+        },
+        status: 401
+      };
+
+      const mockAdapter = global.testUtils.createMockAdapter({
+        getOauthInfo: jest.fn().mockResolvedValue({}),
+        authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
+      });
+      
+      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+
+      // Mock UserModel.findOne to return a user
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findOne').mockResolvedValue(mockUser);
+
+      // Mock oauth.checkAndRefreshAccessToken
+      const oauth = require('../../lib/oauth');
+      jest.spyOn(oauth, 'checkAndRefreshAccessToken').mockResolvedValue(mockUser);
+
+      const requestData = {
+        platform: 'testCRM',
+        userId: 'test-user-id'
+      };
+
+      // Act
+      const result = await authHandler.authValidation(requestData);
+
+      // Assert
+      expect(result).toEqual({
+        ...mockValidationResponse,
+        failReason: 'CRM. API failed'
+      });
+      expect(result.successful).toBe(false);
+    });
+  });
+}); 

package/test/lib/jwt.test.js

@@ -0,0 +1,161 @@
+const jwt = require('../../lib/jwt');
+
+describe('JWT Utility', () => {
+  beforeEach(() => {
+    // Reset environment
+    process.env.APP_SERVER_SECRET_KEY = 'test-secret-key';
+  });
+
+  describe('generateJwt', () => {
+    test('should generate JWT token from payload', () => {
+      // Arrange
+      const payload = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+
+      // Act
+      const token = jwt.generateJwt(payload);
+
+      // Assert
+      expect(token).toBeDefined();
+      expect(typeof token).toBe('string');
+      expect(token.split('.')).toHaveLength(3); // JWT has 3 parts
+    });
+
+    test('should generate different tokens for different payloads', () => {
+      // Arrange
+      const payload1 = { id: 'user1', platform: 'testCRM' };
+      const payload2 = { id: 'user2', platform: 'testCRM' };
+
+      // Act
+      const token1 = jwt.generateJwt(payload1);
+      const token2 = jwt.generateJwt(payload2);
+
+      // Assert
+      expect(token1).not.toBe(token2);
+    });
+  });
+
+  describe('decodeJwt', () => {
+    test('should decode valid JWT token', () => {
+      // Arrange
+      const payload = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+      const token = jwt.generateJwt(payload);
+
+      // Act
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(payload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+
+    test('should return null for invalid token', () => {
+      // Arrange
+      const invalidToken = 'invalid.jwt.token';
+
+      // Act
+      const decoded = jwt.decodeJwt(invalidToken);
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+
+    test('should return null for malformed token', () => {
+      // Arrange
+      const malformedToken = 'not-a-jwt-token';
+
+      // Act
+      const decoded = jwt.decodeJwt(malformedToken);
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+
+    test('should return null for token with wrong secret', () => {
+      // Arrange
+      const payload = { id: 'test-user-id', platform: 'testCRM' };
+      const token = jwt.generateJwt(payload);
+      
+      // Change secret temporarily
+      const originalSecret = process.env.APP_SERVER_SECRET_KEY;
+      process.env.APP_SERVER_SECRET_KEY = 'different-secret';
+
+      // Act
+      const decoded = jwt.decodeJwt(token);
+
+      // Restore secret
+      process.env.APP_SERVER_SECRET_KEY = originalSecret;
+
+      // Assert
+      expect(decoded).toBeNull();
+    });
+  });
+
+  describe('generateJwt and decodeJwt round trip', () => {
+    test('should successfully generate and decode complex payload', () => {
+      // Arrange
+      const complexPayload = {
+        id: 'test-user-id',
+        platform: 'testCRM',
+        timestamp: Date.now(),
+        metadata: {
+          timezone: 'America/Los_Angeles',
+          preferences: {
+            autoLog: true,
+            callPop: false
+          }
+        }
+      };
+
+      // Act
+      const token = jwt.generateJwt(complexPayload);
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(complexPayload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+
+    test('should handle empty payload', () => {
+      // Arrange
+      const emptyPayload = {};
+
+      // Act
+      const token = jwt.generateJwt(emptyPayload);
+      const decoded = jwt.decodeJwt(token);
+
+      // Assert
+      expect(decoded).toMatchObject(emptyPayload);
+      expect(decoded).toHaveProperty('exp');
+      expect(decoded).toHaveProperty('iat');
+    });
+  });
+
+  describe('error handling', () => {
+    test('should handle missing secret key', () => {
+      // Arrange
+      const payload = { id: 'test-user-id' };
+      delete process.env.APP_SERVER_SECRET_KEY;
+
+      // Act & Assert
+      expect(() => jwt.generateJwt(payload)).toThrow();
+    });
+
+    test('should handle null payload', () => {
+      // Act & Assert
+      expect(() => jwt.generateJwt(null)).toThrow();
+    });
+
+    test('should handle undefined payload', () => {
+      // Act & Assert
+      expect(() => jwt.generateJwt(undefined)).toThrow();
+    });
+  });
+});