@app-connect/core 1.7.0-beta.3 → 1.7.0-beta.5

package/test/adapter/registry.test.js

@@ -1,190 +1,190 @@
-const adapterRegistry = require('../../adapter/registry');
+const connectorRegistry = require('../../connector/registry');
 
-describe('AdapterRegistry Interface Registration with Composition', () => {
+describe('ConnectorRegistry Interface Registration with Composition', () => {
   beforeEach(() => {
     // Clear the registry before each test
-    adapterRegistry.adapters.clear();
-    adapterRegistry.manifests.clear();
-    adapterRegistry.platformInterfaces.clear();
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
   });
 
   test('should register interface functions for a platform', () => {
     const mockFunction = jest.fn();
     
-    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
     
-    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
-    expect(adapterRegistry.getPlatformInterfaces('testPlatform').get('testInterface')).toBe(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(() => {
-      adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', 'not a function');
+      connectorRegistry.registerConnectorInterface('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 = {
+  test('should return original connector when no interfaces are registered', () => {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    const retrievedAdapter = adapterRegistry.getAdapter('testPlatform');
-    expect(retrievedAdapter).toBe(mockAdapter);
+    const retrievedConnector = connectorRegistry.getConnector('testPlatform');
+    expect(retrievedConnector).toBe(mockConnector);
   });
 
-  test('should return composed adapter with interface functions when interfaces are registered', () => {
+  test('should return composed connector with interface functions when interfaces are registered', () => {
     const mockInterface = jest.fn();
-    const mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
     // Register interface function first
-    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
     
-    // Register adapter
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    // Register connector
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    // Get composed adapter
-    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
     
     // Should be a different object (composed)
-    expect(composedAdapter).not.toBe(mockAdapter);
+    expect(composedConnector).not.toBe(mockConnector);
     
     // Should have the interface function
-    expect(composedAdapter.customMethod).toBe(mockInterface);
+    expect(composedConnector.customMethod).toBe(mockInterface);
     
     // Should still have original methods
-    expect(composedAdapter.getAuthType).toBe(mockAdapter.getAuthType);
-    expect(composedAdapter.createCallLog).toBe(mockAdapter.createCallLog);
+    expect(composedConnector.getAuthType).toBe(mockConnector.getAuthType);
+    expect(composedConnector.createCallLog).toBe(mockConnector.createCallLog);
   });
 
-  test('should not override existing adapter methods when composing interfaces', () => {
+  test('should not override existing connector methods when composing interfaces', () => {
     const existingMethod = jest.fn();
-    const mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn(),
       existingMethod: existingMethod
     };
 
-    // Register adapter first
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    // Register connector first
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
     // Try to register interface with same name as existing method
     const newMethod = jest.fn();
-    adapterRegistry.registerAdapterInterface('testPlatform', 'existingMethod', newMethod);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'existingMethod', newMethod);
     
-    // Get composed adapter
-    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
     
     // Should not override the existing method
-    expect(composedAdapter.existingMethod).toBe(existingMethod);
-    expect(composedAdapter.existingMethod).not.toBe(newMethod);
+    expect(composedConnector.existingMethod).toBe(existingMethod);
+    expect(composedConnector.existingMethod).not.toBe(newMethod);
   });
 
-  test('should preserve original adapter when composing interfaces', () => {
+  test('should preserve original connector when composing interfaces', () => {
     const mockInterface = jest.fn();
-    const mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
-    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    // Get original adapter
-    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
+    // Get original connector
+    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
     
-    // Original adapter should be unchanged
-    expect(originalAdapter).toBe(mockAdapter);
-    expect(originalAdapter.customMethod).toBeUndefined();
+    // Original connector should be unchanged
+    expect(originalConnector).toBe(mockConnector);
+    expect(originalConnector.customMethod).toBeUndefined();
     
-    // Composed adapter should have the interface
-    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
-    expect(composedAdapter.customMethod).toBe(mockInterface);
+    // 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();
     
-    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
-    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
     
-    adapterRegistry.unregisterAdapterInterface('testPlatform', 'testInterface');
-    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+    connectorRegistry.unregisterConnectorInterface('testPlatform', 'testInterface');
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
   });
 
   test('should return empty map for non-existent platform interfaces', () => {
-    const interfaces = adapterRegistry.getPlatformInterfaces('nonExistentPlatform');
+    const interfaces = connectorRegistry.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);
+    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 mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
     
-    adapterRegistry.registerAdapterInterface('testPlatform', 'interface1', mockFunction1);
-    adapterRegistry.registerAdapterInterface('testPlatform', 'interface2', mockFunction2);
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'interface1', mockFunction1);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'interface2', mockFunction2);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    const platformInterfaces = adapterRegistry.getPlatformInterfaces('testPlatform');
+    const platformInterfaces = connectorRegistry.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);
+    // 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 adapter', () => {
+  test('should clean up platform interfaces when unregistering connector', () => {
     const mockFunction = jest.fn();
-    const mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
-    adapterRegistry.registerAdapterInterface('testPlatform', 'testInterface', mockFunction);
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'testInterface', mockFunction);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(true);
     
-    adapterRegistry.unregisterAdapter('testPlatform');
+    connectorRegistry.unregisterConnector('testPlatform');
     
-    expect(adapterRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
+    expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
   });
 
-  test('should get adapter capabilities correctly', () => {
+  test('should get connector capabilities correctly', () => {
     const mockInterface = jest.fn();
-    const mockAdapter = {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
-    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    const capabilities = adapterRegistry.getAdapterCapabilities('testPlatform');
+    const capabilities = connectorRegistry.getConnectorCapabilities('testPlatform');
     
     expect(capabilities.platform).toBe('testPlatform');
     expect(capabilities.originalMethods).toContain('getAuthType');
@@ -195,77 +195,77 @@ describe('AdapterRegistry Interface Registration with Composition', () => {
     expect(capabilities.authType).toBe('apiKey');
   });
 
-  test('should handle interface registration after adapter registration', () => {
-    const mockAdapter = {
+  test('should handle interface registration after connector registration', () => {
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
 
-    // Register adapter first
-    adapterRegistry.registerAdapter('testPlatform', mockAdapter);
+    // Register connector first
+    connectorRegistry.registerConnector('testPlatform', mockConnector);
     
     // Register interface function after
     const mockInterface = jest.fn();
-    adapterRegistry.registerAdapterInterface('testPlatform', 'customMethod', mockInterface);
+    connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
     
-    // Get composed adapter
-    const composedAdapter = adapterRegistry.getAdapter('testPlatform');
+    // Get composed connector
+    const composedConnector = connectorRegistry.getConnector('testPlatform');
     
     // Should have the interface function
-    expect(composedAdapter.customMethod).toBe(mockInterface);
+    expect(composedConnector.customMethod).toBe(mockInterface);
     
-    // Original adapter should be unchanged
-    const originalAdapter = adapterRegistry.getOriginalAdapter('testPlatform');
-    expect(originalAdapter.customMethod).toBeUndefined();
+    // Original connector should be unchanged
+    const originalConnector = connectorRegistry.getOriginalConnector('testPlatform');
+    expect(originalConnector.customMethod).toBeUndefined();
   });
 
-  test('should return interface-only adapter when no base adapter is registered', () => {
+  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 adapter
-    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
-    adapterRegistry.registerAdapterInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
+    // Register only interface functions, no base connector
+    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method1', mockInterface1);
+    connectorRegistry.registerConnectorInterface('interfaceOnlyPlatform', 'method2', mockInterface2);
     
-    // Get adapter - should return interface-only object
-    const interfaceOnlyAdapter = adapterRegistry.getAdapter('interfaceOnlyPlatform');
+    // Get connector - should return interface-only object
+    const interfaceOnlyConnector = connectorRegistry.getConnector('interfaceOnlyPlatform');
     
     // Should have interface functions
-    expect(interfaceOnlyAdapter.method1).toBe(mockInterface1);
-    expect(interfaceOnlyAdapter.method2).toBe(mockInterface2);
+    expect(interfaceOnlyConnector.method1).toBe(mockInterface1);
+    expect(interfaceOnlyConnector.method2).toBe(mockInterface2);
     
-    // Should not have base adapter methods
-    expect(interfaceOnlyAdapter.getAuthType).toBeUndefined();
+    // Should not have base connector methods
+    expect(interfaceOnlyConnector.getAuthType).toBeUndefined();
     
-    // Should be a plain object, not inherited from any adapter
-    expect(Object.getPrototypeOf(interfaceOnlyAdapter)).toBe(Object.prototype);
+    // Should be a plain object, not inherited from any connector
+    expect(Object.getPrototypeOf(interfaceOnlyConnector)).toBe(Object.prototype);
   });
 
-  test('should throw error when no adapter and no interfaces are registered', () => {
+  test('should throw error when no connector and no interfaces are registered', () => {
     expect(() => {
-      adapterRegistry.getAdapter('nonExistentPlatform');
-    }).toThrow('Adapter not found for platform: nonExistentPlatform');
+      connectorRegistry.getConnector('nonExistentPlatform');
+    }).toThrow('Connector 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');
+    // 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 adapter later
-    const mockAdapter = {
+    // Scenario 2: Add connector later
+    const mockConnector = {
       getAuthType: () => 'apiKey',
       createCallLog: jest.fn(),
       updateCallLog: jest.fn()
     };
-    adapterRegistry.registerAdapter('mixedPlatform', mockAdapter);
+    connectorRegistry.registerConnector('mixedPlatform', mockConnector);
     
-    const composedAdapter = adapterRegistry.getAdapter('mixedPlatform');
-    expect(composedAdapter.interfaceMethod).toBeDefined();
-    expect(composedAdapter.getAuthType).toBeDefined();
-    expect(composedAdapter.getAuthType()).toBe('apiKey');
+    const composedConnector = connectorRegistry.getConnector('mixedPlatform');
+    expect(composedConnector.interfaceMethod).toBeDefined();
+    expect(composedConnector.getAuthType).toBeDefined();
+    expect(composedConnector.getAuthType()).toBe('apiKey');
   });
 }); 

package/test/handlers/auth.test.js

@@ -1,14 +1,14 @@
 const authHandler = require('../../handlers/auth');
-const adapterRegistry = require('../../adapter/registry');
+const connectorRegistry = require('../../connector/registry');
 
-// Mock the adapter registry
-jest.mock('../../adapter/registry');
+// Mock the connector registry
+jest.mock('../../connector/registry');
 
 describe('Auth Handler', () => {
   beforeEach(() => {
     // Reset mocks
     jest.clearAllMocks();
-    global.testUtils.resetAdapterRegistry();
+    global.testUtils.resetConnectorRegistry();
   });
 
   describe('onApiKeyLogin', () => {
@@ -30,12 +30,12 @@ describe('Auth Handler', () => {
         }
       };
 
-      const mockAdapter = global.testUtils.createMockAdapter({
+      const mockConnector = global.testUtils.createMockConnector({
         getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
         getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
       });
       
-      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       const requestData = {
         platform: 'testCRM',
@@ -52,8 +52,8 @@ describe('Auth Handler', () => {
       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({
+      expect(mockConnector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'test-api-key' });
+      expect(mockConnector.getUserInfo).toHaveBeenCalledWith({
         authHeader: 'Basic dGVzdC1hcGkta2V5Og==',
         hostname: 'test.example.com',
         additionalInfo: {},
@@ -73,12 +73,12 @@ describe('Auth Handler', () => {
         }
       };
 
-      const mockAdapter = global.testUtils.createMockAdapter({
+      const mockConnector = global.testUtils.createMockConnector({
         getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
         getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
       });
       
-      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       const requestData = {
         platform: 'testCRM',
@@ -95,10 +95,10 @@ describe('Auth Handler', () => {
       expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
     });
 
-    test('should throw error when adapter not found', async () => {
+    test('should throw error when connector not found', async () => {
       // Arrange
-      adapterRegistry.getAdapter.mockImplementation(() => {
-        throw new Error('Adapter not found for platform: testCRM');
+      connectorRegistry.getConnector.mockImplementation(() => {
+        throw new Error('Connector not found for platform: testCRM');
       });
 
       const requestData = {
@@ -110,7 +110,7 @@ describe('Auth Handler', () => {
 
       // Act & Assert
       await expect(authHandler.onApiKeyLogin(requestData))
-        .rejects.toThrow('Adapter not found for platform: testCRM');
+        .rejects.toThrow('Connector not found for platform: testCRM');
     });
   });
 
@@ -128,12 +128,12 @@ describe('Auth Handler', () => {
         status: 200
       };
 
-      const mockAdapter = global.testUtils.createMockAdapter({
+      const mockConnector = global.testUtils.createMockConnector({
         getOauthInfo: jest.fn().mockResolvedValue({}),
         authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
       });
       
-      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       // Mock UserModel.findOne to return a user
       const { UserModel } = require('../../models/userModel');
@@ -156,13 +156,13 @@ describe('Auth Handler', () => {
         ...mockValidationResponse,
         failReason: ''
       });
-      expect(mockAdapter.authValidation).toHaveBeenCalledWith({ user: mockUser });
+      expect(mockConnector.authValidation).toHaveBeenCalledWith({ user: mockUser });
     });
 
     test('should handle user not found in database', async () => {
       // Arrange
-      const mockAdapter = global.testUtils.createMockAdapter();
-      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+      const mockConnector = global.testUtils.createMockConnector();
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       // Mock UserModel.findOne to return null (user not found)
       const { UserModel } = require('../../models/userModel');
@@ -197,12 +197,12 @@ describe('Auth Handler', () => {
         status: 401
       };
 
-      const mockAdapter = global.testUtils.createMockAdapter({
+      const mockConnector = global.testUtils.createMockConnector({
         getOauthInfo: jest.fn().mockResolvedValue({}),
         authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
       });
       
-      adapterRegistry.getAdapter.mockReturnValue(mockAdapter);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       // Mock UserModel.findOne to return a user
       const { UserModel } = require('../../models/userModel');

package/test/setup.js

@@ -106,17 +106,17 @@ global.testUtils = {
     ...overrides
   }),
 
-  // Helper to reset adapter registry
-  resetAdapterRegistry: () => {
-    const adapterRegistry = require('../adapter/registry');
-    adapterRegistry.adapters.clear();
-    adapterRegistry.manifests.clear();
-    adapterRegistry.platformInterfaces.clear();
-    adapterRegistry.releaseNotes = {};
+  // Helper to reset connector registry
+  resetConnectorRegistry: () => {
+    const connectorRegistry = require('../connector/registry');
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
+    connectorRegistry.releaseNotes = {};
   },
 
-  // Helper to create mock adapter
-  createMockAdapter: (overrides = {}) => ({
+  // Helper to create mock connector
+  createMockConnector: (overrides = {}) => ({
     getAuthType: jest.fn().mockReturnValue('apiKey'),
     getUserInfo: jest.fn().mockResolvedValue({
       successful: true,