@app-connect/core 1.7.25 → 1.7.26

package/test/connector/registry.test.js

@@ -1,416 +1,416 @@
-const connectorRegistry = require('../../connector/registry');
-
-describe('ConnectorRegistry Interface Registration with Composition', () => {
-  beforeEach(() => {
-    // Clear the registry before each test
-    connectorRegistry.connectors.clear();
-    connectorRegistry.manifests.clear();
-    connectorRegistry.platformInterfaces.clear();
-  });
-
-  test('should register interface functions for a platform', () => {
-    const mockFunction = jest.fn();
-    
-    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
-    
-    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
-    expect(connectorRegistry.getPlatformInterfaces('testPlatform').get('testInterface')).toBe(mockFunction);
-  });
-
-  test('should throw error when registering non-function as interface', () => {
-    expect(() => {
-      connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', 'not a function');
-    }).toThrow('Interface function must be a function, got: string');
-  });
-
-  test('should return original connector when no interfaces are registered', () => {
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    const retrievedConnector = connectorRegistry.getConnector('testPlatform');
-    expect(retrievedConnector).toBe(mockConnector);
-  });
-
-  test('should return composed connector with interface functions when interfaces are registered', () => {
-    const mockInterface = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    // Register interface function first
-    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
-    
-    // Register connector
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    // Get composed connector
-    const composedConnector = connectorRegistry.getConnector('testPlatform');
-    
-    // Should be a different object (composed)
-    expect(composedConnector).not.toBe(mockConnector);
-    
-    // Should have the interface function
-    expect(composedConnector.customMethod).toBe(mockInterface);
-    
-    // Should still have original methods
-    expect(composedConnector.getAuthType).toBe(mockConnector.getAuthType);
-    expect(composedConnector.createCallLog).toBe(mockConnector.createCallLog);
-  });
-
-  test('should not override existing connector methods when composing interfaces', () => {
-    const existingMethod = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn(),
-      existingMethod: existingMethod
-    };
-
-    // Register connector first
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    // Try to register interface with same name as existing method
-    const newMethod = jest.fn();
-    connectorRegistry.registerConnectorInterface('testPlatform', 'existingMethod', newMethod);
-    
-    // Get composed connector
-    const composedConnector = connectorRegistry.getConnector('testPlatform');
-    
-    // Should not override the existing method
-    expect(composedConnector.existingMethod).toBe(existingMethod);
-    expect(composedConnector.existingMethod).not.toBe(newMethod);
-  });
-
-  test('should preserve original connector when composing interfaces', () => {
-    const mockInterface = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    // Get original connector
-    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
-    
-    // Original connector should be unchanged
-    expect(originalConnector).toBe(mockConnector);
-    expect(originalConnector.customMethod).toBeUndefined();
-    
-    // Composed connector should have the interface
-    const composedConnector = connectorRegistry.getConnector('testPlatform');
-    expect(composedConnector.customMethod).toBe(mockInterface);
-  });
-
-  test('should unregister interface functions', () => {
-    const mockFunction = jest.fn();
-    
-    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
-    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
-    
-    connectorRegistry.unregisterConnectorInterface('testPlatform', 'testInterface');
-    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
-  });
-
-  test('should return empty map for non-existent platform interfaces', () => {
-    const interfaces = connectorRegistry.getPlatformInterfaces('nonExistentPlatform');
-    expect(interfaces).toBeInstanceOf(Map);
-    expect(interfaces.size).toBe(0);
-  });
-
-  test('should return false for non-existent platform interface', () => {
-    expect(connectorRegistry.hasPlatformInterface('nonExistentPlatform', 'anyInterface')).toBe(false);
-  });
-
-  test('should handle multiple interface functions for same platform', () => {
-    const mockFunction1 = jest.fn();
-    const mockFunction2 = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-    
-    connectorRegistry.registerConnectorInterface('testPlatform', 'interface1', mockFunction1);
-    connectorRegistry.registerConnectorInterface('testPlatform', 'interface2', mockFunction2);
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    const platformInterfaces = connectorRegistry.getPlatformInterfaces('testPlatform');
-    expect(platformInterfaces.size).toBe(2);
-    expect(platformInterfaces.get('interface1')).toBe(mockFunction1);
-    expect(platformInterfaces.get('interface2')).toBe(mockFunction2);
-    
-    // Check composed connector has both interfaces
-    const composedConnector = connectorRegistry.getConnector('testPlatform');
-    expect(composedConnector.interface1).toBe(mockFunction1);
-    expect(composedConnector.interface2).toBe(mockFunction2);
-  });
-
-  test('should clean up platform interfaces when unregistering connector', () => {
-    const mockFunction = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
-    
-    connectorRegistry.unregisterConnector('testPlatform');
-    
-    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
-  });
-
-  test('should get connector capabilities correctly', async () => {
-    const mockInterface = jest.fn();
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    const capabilities = await connectorRegistry.getConnectorCapabilities('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 connector registration', () => {
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    // Register connector first
-    connectorRegistry.registerConnector('testPlatform', mockConnector);
-    
-    // Register interface function after
-    const mockInterface = jest.fn();
-    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
-    
-    // Get composed connector
-    const composedConnector = connectorRegistry.getConnector('testPlatform');
-    
-    // Should have the interface function
-    expect(composedConnector.customMethod).toBe(mockInterface);
-    
-    // Original connector should be unchanged
-    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
-    expect(originalConnector.customMethod).toBeUndefined();
-  });
-
-  test('should return interface-only connector when no base connector is registered', () => {
-    const mockInterface1 = jest.fn();
-    const mockInterface2 = jest.fn();
-    
-    // Register only interface functions, no base connector
-    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
-    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
-    
-    // Get connector - should return interface-only object
-    const interfaceOnlyConnector = connectorRegistry.getConnector('interfaceOnlyPlatform');
-    
-    // Should have interface functions
-    expect(interfaceOnlyConnector.method1).toBe(mockInterface1);
-    expect(interfaceOnlyConnector.method2).toBe(mockInterface2);
-    
-    // Should not have base connector methods
-    expect(interfaceOnlyConnector.getAuthType).toBeUndefined();
-    
-    // Should be a plain object, not inherited from any connector
-    expect(Object.getPrototypeOf(interfaceOnlyConnector)).toBe(Object.prototype);
-  });
-
-  test('should throw error when no connector and no interfaces are registered', () => {
-    expect(() => {
-      connectorRegistry.getConnector('nonExistentPlatform');
-    }).toThrow('Connector not found for platform: nonExistentPlatform');
-  });
-
-  test('should handle mixed scenarios correctly', async () => {
-    // Scenario 1: Only interfaces, no connector
-    connectorRegistry.registerConnectorInterface('mixedPlatform', 'interfaceMethod', jest.fn());
-    const interfaceOnly = connectorRegistry.getConnector('mixedPlatform');
-    expect(interfaceOnly.interfaceMethod).toBeDefined();
-    expect(interfaceOnly.getAuthType).toBeUndefined();
-    
-    // Scenario 2: Add connector later
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-    connectorRegistry.registerConnector('mixedPlatform', mockConnector);
-    
-    const composedConnector = connectorRegistry.getConnector('mixedPlatform');
-    expect(composedConnector.interfaceMethod).toBeDefined();
-    expect(composedConnector.getAuthType).toBeDefined();
-    expect(await composedConnector.getAuthType()).toBe('apiKey');
-  });
-
-  test('should set and get default manifest', () => {
-    const defaultManifest = {
-      name: 'Default CRM',
-      version: '1.0.0',
-      features: ['call_logging', 'contact_sync']
-    };
-
-    connectorRegistry.setDefaultManifest(defaultManifest);
-
-    // Get manifest with fallback should return default
-    const manifest = connectorRegistry.getManifest('nonExistentPlatform', true);
-    expect(manifest).toEqual(defaultManifest);
-  });
-
-  test('should throw error when getting manifest without fallback and platform not found', () => {
-    expect(() => {
-      connectorRegistry.getManifest('nonExistentPlatform', false);
-    }).toThrow('Manifest not found for platform: nonExistentPlatform');
-  });
-
-  test('should throw error when getting manifest with fallback but no default set', () => {
-    connectorRegistry.manifests.clear();
-    expect(() => {
-      connectorRegistry.getManifest('nonExistentPlatform', true);
-    }).toThrow('Manifest not found for platform: nonExistentPlatform');
-  });
-
-  test('should register connector with manifest', () => {
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-    const manifest = {
-      name: 'Test CRM',
-      version: '2.0.0',
-      authType: 'oauth'
-    };
-
-    connectorRegistry.registerConnector('testPlatformWithManifest', mockConnector, manifest);
-
-    const retrievedManifest = connectorRegistry.getManifest('testPlatformWithManifest');
-    expect(retrievedManifest).toEqual(manifest);
-  });
-
-  test('should set and get release notes', () => {
-    const releaseNotes = {
-      version: '1.5.0',
-      date: '2024-01-15',
-      changes: ['Bug fixes', 'New features']
-    };
-
-    connectorRegistry.setReleaseNotes(releaseNotes);
-
-    // getReleaseNotes currently returns the same object regardless of platform
-    const notes = connectorRegistry.getReleaseNotes('anyPlatform');
-    expect(notes).toEqual(releaseNotes);
-  });
-
-  test('should get registered platforms', () => {
-    const connector1 = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-    const connector2 = {
-      getAuthType: () => 'oauth',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnector('platform1', connector1);
-    connectorRegistry.registerConnector('platform2', connector2);
-
-    const platforms = connectorRegistry.getRegisteredPlatforms();
-    expect(platforms).toContain('platform1');
-    expect(platforms).toContain('platform2');
-    expect(platforms).toHaveLength(2);
-  });
-
-  test('should check if platform is registered', () => {
-    const mockConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnector('registeredPlatform', mockConnector);
-
-    expect(connectorRegistry.isRegistered('registeredPlatform')).toBe(true);
-    expect(connectorRegistry.isRegistered('unregisteredPlatform')).toBe(false);
-  });
-
-  test('should throw error for original connector when not found', () => {
-    expect(() => {
-      connectorRegistry.getOriginalConnector('nonExistentPlatform');
-    }).toThrow('Connector not found for platform: nonExistentPlatform');
-  });
-
-  test('should validate connector interface with missing required methods', () => {
-    const incompleteConnector = {
-      getAuthType: () => 'apiKey',
-      createCallLog: jest.fn()
-      // Missing updateCallLog
-    };
-
-    expect(() => {
-      connectorRegistry.registerConnector('incompletePlatform', incompleteConnector);
-    }).toThrow('Connector incompletePlatform missing required method: updateCallLog');
-  });
-
-  test('should return proxy connector when platform not found but proxy exists', () => {
-    const proxyConnector = {
-      getAuthType: () => 'proxy',
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn(),
-      proxy: true
-    };
-
-    connectorRegistry.registerConnector('proxy', proxyConnector);
-
-    const connector = connectorRegistry.getConnector('unknownPlatformWithProxy');
-    expect(connector).toBe(proxyConnector);
-    expect(connector.proxy).toBe(true);
-  });
-
-  test('should handle getAuthType error in getConnectorCapabilities', async () => {
-    const mockConnector = {
-      getAuthType: jest.fn().mockRejectedValue(new Error('Auth type error')),
-      createCallLog: jest.fn(),
-      updateCallLog: jest.fn()
-    };
-
-    connectorRegistry.registerConnector('errorPlatform', mockConnector);
-
-    const capabilities = await connectorRegistry.getConnectorCapabilities('errorPlatform');
-    expect(capabilities.authType).toBe('unknown');
-  });
-
-  test('should handle unregistering non-existent interface gracefully', () => {
-    // This should not throw
-    connectorRegistry.unregisterConnectorInterface('nonExistentPlatform', 'nonExistentInterface');
-    expect(connectorRegistry.hasPlatformInterface('nonExistentPlatform', 'nonExistentInterface')).toBe(false);
-  });
+const connectorRegistry = require('../../connector/registry');
+
+describe('ConnectorRegistry Interface Registration with Composition', () => {
+  beforeEach(() => {
+    // Clear the registry before each test
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
+  });
+
+  test('should register interface functions for a platform', () => {
+    const mockFunction = jest.fn();
+    
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
+    
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    expect(connectorRegistry.getPlatformInterfaces('testPlatform').get('testInterface')).toBe(mockFunction);
+  });
+
+  test('should throw error when registering non-function as interface', () => {
+    expect(() => {
+      connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', 'not a function');
+    }).toThrow('Interface function must be a function, got: string');
+  });
+
+  test('should return original connector when no interfaces are registered', () => {
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    const retrievedConnector = connectorRegistry.getConnector('testPlatform');
+    expect(retrievedConnector).toBe(mockConnector);
+  });
+
+  test('should return composed connector with interface functions when interfaces are registered', () => {
+    const mockInterface = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register interface function first
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Register connector
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
+    
+    // Should be a different object (composed)
+    expect(composedConnector).not.toBe(mockConnector);
+    
+    // Should have the interface function
+    expect(composedConnector.customMethod).toBe(mockInterface);
+    
+    // Should still have original methods
+    expect(composedConnector.getAuthType).toBe(mockConnector.getAuthType);
+    expect(composedConnector.createCallLog).toBe(mockConnector.createCallLog);
+  });
+
+  test('should not override existing connector methods when composing interfaces', () => {
+    const existingMethod = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      existingMethod: existingMethod
+    };
+
+    // Register connector first
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    // Try to register interface with same name as existing method
+    const newMethod = jest.fn();
+    connectorRegistry.registerConnectorInterface('testPlatform', 'existingMethod', newMethod);
+    
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
+    
+    // Should not override the existing method
+    expect(composedConnector.existingMethod).toBe(existingMethod);
+    expect(composedConnector.existingMethod).not.toBe(newMethod);
+  });
+
+  test('should preserve original connector when composing interfaces', () => {
+    const mockInterface = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    // Get original connector
+    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
+    
+    // Original connector should be unchanged
+    expect(originalConnector).toBe(mockConnector);
+    expect(originalConnector.customMethod).toBeUndefined();
+    
+    // Composed connector should have the interface
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
+    expect(composedConnector.customMethod).toBe(mockInterface);
+  });
+
+  test('should unregister interface functions', () => {
+    const mockFunction = jest.fn();
+    
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    connectorRegistry.unregisterConnectorInterface('testPlatform', 'testInterface');
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should return empty map for non-existent platform interfaces', () => {
+    const interfaces = connectorRegistry.getPlatformInterfaces('nonExistentPlatform');
+    expect(interfaces).toBeInstanceOf(Map);
+    expect(interfaces.size).toBe(0);
+  });
+
+  test('should return false for non-existent platform interface', () => {
+    expect(connectorRegistry.hasPlatformInterface('nonExistentPlatform', 'anyInterface')).toBe(false);
+  });
+
+  test('should handle multiple interface functions for same platform', () => {
+    const mockFunction1 = jest.fn();
+    const mockFunction2 = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    
+    connectorRegistry.registerConnectorInterface('testPlatform', 'interface1', mockFunction1);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'interface2', mockFunction2);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    const platformInterfaces = connectorRegistry.getPlatformInterfaces('testPlatform');
+    expect(platformInterfaces.size).toBe(2);
+    expect(platformInterfaces.get('interface1')).toBe(mockFunction1);
+    expect(platformInterfaces.get('interface2')).toBe(mockFunction2);
+    
+    // Check composed connector has both interfaces
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
+    expect(composedConnector.interface1).toBe(mockFunction1);
+    expect(composedConnector.interface2).toBe(mockFunction2);
+  });
+
+  test('should clean up platform interfaces when unregistering connector', () => {
+    const mockFunction = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    
+    connectorRegistry.unregisterConnector('testPlatform');
+    
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+  });
+
+  test('should get connector capabilities correctly', async () => {
+    const mockInterface = jest.fn();
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    const capabilities = await connectorRegistry.getConnectorCapabilities('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 connector registration', () => {
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    // Register connector first
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
+    
+    // Register interface function after
+    const mockInterface = jest.fn();
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
+    
+    // Should have the interface function
+    expect(composedConnector.customMethod).toBe(mockInterface);
+    
+    // Original connector should be unchanged
+    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
+    expect(originalConnector.customMethod).toBeUndefined();
+  });
+
+  test('should return interface-only connector when no base connector is registered', () => {
+    const mockInterface1 = jest.fn();
+    const mockInterface2 = jest.fn();
+    
+    // Register only interface functions, no base connector
+    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
+    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
+    
+    // Get connector - should return interface-only object
+    const interfaceOnlyConnector = connectorRegistry.getConnector('interfaceOnlyPlatform');
+    
+    // Should have interface functions
+    expect(interfaceOnlyConnector.method1).toBe(mockInterface1);
+    expect(interfaceOnlyConnector.method2).toBe(mockInterface2);
+    
+    // Should not have base connector methods
+    expect(interfaceOnlyConnector.getAuthType).toBeUndefined();
+    
+    // Should be a plain object, not inherited from any connector
+    expect(Object.getPrototypeOf(interfaceOnlyConnector)).toBe(Object.prototype);
+  });
+
+  test('should throw error when no connector and no interfaces are registered', () => {
+    expect(() => {
+      connectorRegistry.getConnector('nonExistentPlatform');
+    }).toThrow('Connector not found for platform: nonExistentPlatform');
+  });
+
+  test('should handle mixed scenarios correctly', async () => {
+    // Scenario 1: Only interfaces, no connector
+    connectorRegistry.registerConnectorInterface('mixedPlatform', 'interfaceMethod', jest.fn());
+    const interfaceOnly = connectorRegistry.getConnector('mixedPlatform');
+    expect(interfaceOnly.interfaceMethod).toBeDefined();
+    expect(interfaceOnly.getAuthType).toBeUndefined();
+    
+    // Scenario 2: Add connector later
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    connectorRegistry.registerConnector('mixedPlatform', mockConnector);
+    
+    const composedConnector = connectorRegistry.getConnector('mixedPlatform');
+    expect(composedConnector.interfaceMethod).toBeDefined();
+    expect(composedConnector.getAuthType).toBeDefined();
+    expect(await composedConnector.getAuthType()).toBe('apiKey');
+  });
+
+  test('should set and get default manifest', () => {
+    const defaultManifest = {
+      name: 'Default CRM',
+      version: '1.0.0',
+      features: ['call_logging', 'contact_sync']
+    };
+
+    connectorRegistry.setDefaultManifest(defaultManifest);
+
+    // Get manifest with fallback should return default
+    const manifest = connectorRegistry.getManifest('nonExistentPlatform', true);
+    expect(manifest).toEqual(defaultManifest);
+  });
+
+  test('should throw error when getting manifest without fallback and platform not found', () => {
+    expect(() => {
+      connectorRegistry.getManifest('nonExistentPlatform', false);
+    }).toThrow('Manifest not found for platform: nonExistentPlatform');
+  });
+
+  test('should throw error when getting manifest with fallback but no default set', () => {
+    connectorRegistry.manifests.clear();
+    expect(() => {
+      connectorRegistry.getManifest('nonExistentPlatform', true);
+    }).toThrow('Manifest not found for platform: nonExistentPlatform');
+  });
+
+  test('should register connector with manifest', () => {
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    const manifest = {
+      name: 'Test CRM',
+      version: '2.0.0',
+      authType: 'oauth'
+    };
+
+    connectorRegistry.registerConnector('testPlatformWithManifest', mockConnector, manifest);
+
+    const retrievedManifest = connectorRegistry.getManifest('testPlatformWithManifest');
+    expect(retrievedManifest).toEqual(manifest);
+  });
+
+  test('should set and get release notes', () => {
+    const releaseNotes = {
+      version: '1.5.0',
+      date: '2024-01-15',
+      changes: ['Bug fixes', 'New features']
+    };
+
+    connectorRegistry.setReleaseNotes(releaseNotes);
+
+    // getReleaseNotes currently returns the same object regardless of platform
+    const notes = connectorRegistry.getReleaseNotes('anyPlatform');
+    expect(notes).toEqual(releaseNotes);
+  });
+
+  test('should get registered platforms', () => {
+    const connector1 = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+    const connector2 = {
+      getAuthType: () => 'oauth',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnector('platform1', connector1);
+    connectorRegistry.registerConnector('platform2', connector2);
+
+    const platforms = connectorRegistry.getRegisteredPlatforms();
+    expect(platforms).toContain('platform1');
+    expect(platforms).toContain('platform2');
+    expect(platforms).toHaveLength(2);
+  });
+
+  test('should check if platform is registered', () => {
+    const mockConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnector('registeredPlatform', mockConnector);
+
+    expect(connectorRegistry.isRegistered('registeredPlatform')).toBe(true);
+    expect(connectorRegistry.isRegistered('unregisteredPlatform')).toBe(false);
+  });
+
+  test('should throw error for original connector when not found', () => {
+    expect(() => {
+      connectorRegistry.getOriginalConnector('nonExistentPlatform');
+    }).toThrow('Connector not found for platform: nonExistentPlatform');
+  });
+
+  test('should validate connector interface with missing required methods', () => {
+    const incompleteConnector = {
+      getAuthType: () => 'apiKey',
+      createCallLog: jest.fn()
+      // Missing updateCallLog
+    };
+
+    expect(() => {
+      connectorRegistry.registerConnector('incompletePlatform', incompleteConnector);
+    }).toThrow('Connector incompletePlatform missing required method: updateCallLog');
+  });
+
+  test('should return proxy connector when platform not found but proxy exists', () => {
+    const proxyConnector = {
+      getAuthType: () => 'proxy',
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      proxy: true
+    };
+
+    connectorRegistry.registerConnector('proxy', proxyConnector);
+
+    const connector = connectorRegistry.getConnector('unknownPlatformWithProxy');
+    expect(connector).toBe(proxyConnector);
+    expect(connector.proxy).toBe(true);
+  });
+
+  test('should handle getAuthType error in getConnectorCapabilities', async () => {
+    const mockConnector = {
+      getAuthType: jest.fn().mockRejectedValue(new Error('Auth type error')),
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn()
+    };
+
+    connectorRegistry.registerConnector('errorPlatform', mockConnector);
+
+    const capabilities = await connectorRegistry.getConnectorCapabilities('errorPlatform');
+    expect(capabilities.authType).toBe('unknown');
+  });
+
+  test('should handle unregistering non-existent interface gracefully', () => {
+    // This should not throw
+    connectorRegistry.unregisterConnectorInterface('nonExistentPlatform', 'nonExistentInterface');
+    expect(connectorRegistry.hasPlatformInterface('nonExistentPlatform', 'nonExistentInterface')).toBe(false);
+  });
 });