@app-connect/core 1.7.34 → 1.7.36

package/test/connector/proxy/index.test.js

@@ -126,6 +126,86 @@ describe('proxy connector - more coverage', () => {
     expect(token).toBe(Buffer.from('abc:').toString('base64'));
   });
 
+  test('getOauthInfo maps configured OAuth settings and falls back when config loading fails', async () => {
+    const oauthConfig = {
+      auth: {
+        type: 'oauth',
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+        tokenUrl: 'https://auth.example.com/token',
+        redirectUri: 'https://app.example.com/callback'
+      },
+      operations: {}
+    };
+
+    await expect(proxy.getOauthInfo({
+      proxyConfig: oauthConfig,
+      tokenUrl: 'https://override.example.com/token'
+    })).resolves.toEqual({
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      accessTokenUri: 'https://override.example.com/token',
+      redirectUri: 'https://app.example.com/callback'
+    });
+
+    Connector.getProxyConfig.mockRejectedValueOnce(new Error('config unavailable'));
+    await expect(proxy.getOauthInfo({ proxyId: 'missing-config' })).resolves.toEqual({});
+    await expect(proxy.getAuthType({ proxyId: '' })).resolves.toBe('apiKey');
+  });
+
+  test('getUserInfo returns a warning when the proxy config has no getUserInfo operation', async () => {
+    await expect(proxy.getUserInfo({
+      proxyConfig: { operations: {} },
+      platform: 'minimal'
+    })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        messageType: 'warning',
+        message: 'Could not load user information. The platform does not support getUserInfo operation.'
+      }
+    });
+  });
+
+  test('getUserList maps configured list responses and returns empty when unsupported', async () => {
+    const userListConfig = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: {
+        getUserList: {
+          method: 'GET',
+          url: '/users',
+          responseMapping: {
+            listPath: 'body.records',
+            idPath: 'user.id',
+            namePath: 'profile.name',
+            emailPath: 'email'
+          }
+        }
+      }
+    };
+    axios.mockResolvedValueOnce({
+      data: {
+        records: [
+          { user: { id: 'u1' }, profile: { name: 'Ada' }, email: 'ada@example.com' },
+          { user: { id: 'u2' }, profile: { name: 'Grace' }, email: 'grace@example.com' }
+        ]
+      }
+    });
+
+    await expect(proxy.getUserList({
+      user: { platformAdditionalInfo: { proxyId: 'p1' } },
+      authHeader: 'Bearer token',
+      proxyConfig: userListConfig
+    })).resolves.toEqual([
+      { id: 'u1', name: 'Ada', email: 'ada@example.com' },
+      { id: 'u2', name: 'Grace', email: 'grace@example.com' }
+    ]);
+
+    await expect(proxy.getUserList({
+      user: { platformAdditionalInfo: { proxyId: 'p1' } },
+      proxyConfig: { operations: {} }
+    })).resolves.toEqual([]);
+  });
+
   test('getUserInfo maps id/name/message/platformAdditionalInfo', async () => {
     const cfg = JSON.parse(JSON.stringify(sampleConfig));
     delete cfg.auth; // ensure provided authHeader is used
@@ -165,6 +245,37 @@ describe('proxy connector - more coverage', () => {
     expect(out.matchedContactInfo[0].id).toBe('c1');
   });
 
+  test('contact operations return supported empty responses when omitted from manifest', async () => {
+    const proxyConfig = { operations: {} };
+    const user = { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } };
+
+    await expect(proxy.findContact({
+      user,
+      authHeader: 'x',
+      phoneNumber: '+1',
+      proxyConfig
+    })).resolves.toEqual({ successful: true, matchedContactInfo: [] });
+
+    await expect(proxy.findContactWithName({
+      user,
+      authHeader: 'x',
+      name: 'Ada',
+      proxyConfig
+    })).resolves.toEqual({ successful: true, matchedContactInfo: [] });
+
+    await expect(proxy.createContact({
+      user,
+      authHeader: 'x',
+      phoneNumber: '+1',
+      newContactName: 'Ada',
+      newContactType: 'Contact',
+      proxyConfig
+    })).resolves.toEqual({
+      contactInfo: null,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+  });
+
   test('createContact maps object response', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig);
     axios.mockResolvedValue({ data: { id: 'c2', name: 'Bob', type: 'Lead' } });
@@ -182,6 +293,70 @@ describe('proxy connector - more coverage', () => {
     expect(res.returnMessage.messageType).toBe('success');
   });
 
+  test('call and message log operations return Not supported when omitted from manifest', async () => {
+    const proxyConfig = { operations: {} };
+    const user = { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } };
+    const commonCall = {
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      authHeader: 'x',
+      proxyConfig
+    };
+
+    await expect(proxy.createCallLog({
+      ...commonCall,
+      callLog: { direction: 'Inbound', startTime: Date.now(), duration: 30 },
+      note: ''
+    })).resolves.toEqual({
+      logId: undefined,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.getCallLog({
+      user,
+      callLogId: 'L1',
+      contactId: 'c1',
+      authHeader: 'x',
+      proxyConfig
+    })).resolves.toEqual({
+      callLogInfo: null,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.updateCallLog({
+      user,
+      existingCallLog: { thirdPartyLogId: 'L1' },
+      authHeader: 'x',
+      startTime: Date.now(),
+      duration: 30,
+      proxyConfig
+    })).resolves.toEqual({
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.createMessageLog({
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      authHeader: 'x',
+      message: { creationTime: Date.now() },
+      proxyConfig
+    })).resolves.toEqual({
+      logId: undefined,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.updateMessageLog({
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      existingMessageLog: { thirdPartyLogId: 'M1' },
+      message: { creationTime: Date.now() },
+      authHeader: 'x',
+      proxyConfig
+    })).resolves.toEqual({
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+  });
+
   test('createMessageLog maps idPath and updateMessageLog returns success', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig);
     axios.mockResolvedValueOnce({ data: { activity: { id: 'M1' } } });
@@ -227,6 +402,40 @@ describe('proxy connector - more coverage', () => {
     expect(res.returnMessage.message).toMatch(/Not supported/);
   });
 
+  test('upsertCallDisposition performs configured operation when supported', async () => {
+    const dispositionConfig = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: {
+        upsertCallDisposition: {
+          method: 'POST',
+          url: '/activities/{{thirdPartyLogId}}/disposition',
+          body: {
+            result: '{{dispositions.0.value}}'
+          }
+        }
+      }
+    };
+    Connector.getProxyConfig.mockResolvedValue(dispositionConfig);
+    axios.mockResolvedValueOnce({ data: { ok: true } });
+
+    const res = await proxy.upsertCallDisposition({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      existingCallLog: { thirdPartyLogId: 'L1' },
+      authHeader: 'x',
+      dispositions: [{ value: 'Connected' }]
+    });
+
+    expect(res).toEqual({
+      logId: 'L1',
+      returnMessage: { message: 'Disposition updated', messageType: 'success', ttl: 2000 }
+    });
+    expect(axios.mock.calls[0][0]).toMatchObject({
+      method: 'POST',
+      url: 'https://api.example.com/activities/L1/disposition',
+      data: { result: 'Connected' }
+    });
+  });
+
   test('getLicenseStatus maps values with custom config', async () => {
     const licenseConfig = {
       requestDefaults: { baseUrl: 'https://api.example.com' },
@@ -252,6 +461,23 @@ describe('proxy connector - more coverage', () => {
     expect(s.licenseStatusDescription).toBe('All good');
   });
 
+  test('getLicenseStatus handles missing users and missing license operations', async () => {
+    UserModel.findByPk.mockResolvedValueOnce(null);
+    await expect(proxy.getLicenseStatus({ userId: 'missing', platform: 'x' })).resolves.toEqual({
+      isLicenseValid: false,
+      licenseStatus: 'Invalid (User not found)',
+      licenseStatusDescription: ''
+    });
+
+    UserModel.findByPk.mockResolvedValueOnce({ id: 'u1', accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } });
+    Connector.getProxyConfig.mockResolvedValueOnce({ operations: {} });
+    await expect(proxy.getLicenseStatus({ userId: 'u1', platform: 'x' })).resolves.toEqual({
+      isLicenseValid: true,
+      licenseStatus: 'Basic',
+      licenseStatusDescription: ''
+    });
+  });
+
   test('unAuthorize without custom op clears tokens and saves user', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig); // no unAuthorize op
     const user = { accessToken: 't', refreshToken: 'r', save: jest.fn(), platformAdditionalInfo: { proxyId: 'p1' } };
@@ -275,5 +501,25 @@ describe('proxy connector - more coverage', () => {
     expect(out.returnMessage.message).toMatch(/Logged out/);
     expect(user.accessToken).toBe('');
   });
+
+  test('unAuthorize returns a database warning when saving cleared tokens fails', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    const user = {
+      accessToken: 't',
+      refreshToken: 'r',
+      save: jest.fn().mockRejectedValue(new Error('save failed')),
+      platformAdditionalInfo: { proxyId: 'p1' }
+    };
+
+    await expect(proxy.unAuthorize({ user })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        message: 'Database operation failed',
+        messageType: 'warning'
+      }
+    });
+    expect(user.accessToken).toBe('');
+    expect(user.refreshToken).toBe('');
+  });
 });
 

package/test/connector/proxy/sample.json

@@ -47,6 +47,7 @@
           "namePath": "name",
           "typePath": "",
           "phonePath": "",
+          "createdDatePath": "",
           "additionalInfoPath": ""
         }
       }

package/test/handlers/admin.test.js

@@ -29,6 +29,7 @@ const oauth = require('../../lib/oauth');
 const { RingCentral } = require('../../lib/ringcentral');
 const { Connector } = require('../../models/dynamo/connectorSchema');
 const { sequelize } = require('../../models/sequelize');
+const { getHashValue } = require('../../lib/util');
 
 describe('Admin Handler', () => {
   beforeAll(async () => {
@@ -612,5 +613,348 @@ describe('Admin Handler', () => {
       expect(result[0].rcUser[0].extensionId).toBe('ext-existing');
     });
   });
+
+  describe('reports and mapping branch coverage', () => {
+    beforeEach(() => {
+      process.env.RINGCENTRAL_SERVER = 'https://platform.example.com';
+      process.env.RINGCENTRAL_CLIENT_ID = 'client-id';
+      process.env.RINGCENTRAL_CLIENT_SECRET = 'client-secret';
+      process.env.APP_SERVER = 'https://app.example.com';
+      process.env.HASH_KEY = 'hash-key';
+    });
+
+    afterEach(() => {
+      delete process.env.RINGCENTRAL_SERVER;
+      delete process.env.RINGCENTRAL_CLIENT_ID;
+      delete process.env.RINGCENTRAL_CLIENT_SECRET;
+      delete process.env.APP_SERVER;
+      delete process.env.HASH_KEY;
+    });
+
+    test('getAdminReport builds aggregation rows and skips unnamed records', async () => {
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      const getCallsAggregationData = jest.fn().mockResolvedValue({
+        data: {
+          groupedBy: 'Users',
+          records: [
+            {},
+            {
+              info: { name: 'Agent 1' },
+              counters: {
+                callsByDirection: { values: { inbound: 2, outbound: 1 } },
+                callsByResponse: { values: { answered: 1 } }
+              },
+              timers: {
+                allCalls: { values: 90 }
+              }
+            },
+            {
+              info: { name: 'Agent 2' },
+              counters: {
+                callsByDirection: { values: { inbound: 0, outbound: 0 } },
+                callsByResponse: { values: { answered: 0 } }
+              },
+              timers: {
+                allCalls: { values: 0 }
+              }
+            }
+          ]
+        }
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallsAggregationData
+      }));
+
+      const result = await adminHandler.getAdminReport({
+        rcAccountId: 'account',
+        timezone: 'UTC',
+        timeFrom: '2026-07-01T00:00:00Z',
+        timeTo: '2026-07-31T23:59:59Z',
+        groupBy: 'undefined'
+      });
+
+      expect(result.groupedBy).toBe('Users');
+      expect(result.itemKeys).toEqual(['Agent 1', 'Agent 2']);
+      expect(result.callLogStats[0]).toMatchObject({
+        name: 'Agent 1',
+        inboundCallCount: 2,
+        outboundCallCount: 1,
+        answeredCallCount: 1,
+        answeredCallPercentage: '50.00%',
+        totalTalkTime: '90.00',
+        averageTalkTime: '30.00'
+      });
+      expect(result.callLogStats[1]).toMatchObject({
+        name: 'Agent 2',
+        answeredCallPercentage: '0%',
+        totalTalkTime: 0,
+        averageTalkTime: 0
+      });
+      expect(getCallsAggregationData).toHaveBeenCalledWith(expect.objectContaining({
+        groupBy: 'Company'
+      }));
+    });
+
+    test('getUserReport builds call and SMS stats', async () => {
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallLogData: jest.fn().mockResolvedValue({
+          records: [
+            { direction: 'Inbound', result: 'Call connected', duration: 120 },
+            { direction: 'Inbound', result: 'Missed', duration: 0 },
+            { direction: 'Outbound', result: 'Accepted', duration: 60 }
+          ]
+        }),
+        getSMSData: jest.fn().mockResolvedValue({
+          records: [
+            { direction: 'Outbound' },
+            { direction: 'Inbound' },
+            { direction: 'Inbound' }
+          ]
+        })
+      }));
+
+      const result = await adminHandler.getUserReport({
+        rcAccountId: 'account',
+        rcExtensionId: '101',
+        timezone: 'UTC',
+        timeFrom: '2026-07-01T00:00:00Z',
+        timeTo: '2026-07-31T23:59:59Z'
+      });
+
+      expect(result).toEqual({
+        callLogStats: {
+          inboundCallCount: 2,
+          outboundCallCount: 1,
+          answeredCallCount: 1,
+          answeredCallPercentage: '50.00%',
+          totalTalkTime: 3,
+          averageTalkTime: 1
+        },
+        smsLogStats: {
+          smsSentCount: 1,
+          smsReceivedCount: 2
+        }
+      });
+    });
+
+    test('report helpers return empty data on missing env or provider errors', async () => {
+      delete process.env.RINGCENTRAL_SERVER;
+      await expect(adminHandler.getAdminReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+      await expect(adminHandler.getUserReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+
+      process.env.RINGCENTRAL_SERVER = 'https://platform.example.com';
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallsAggregationData: jest.fn().mockRejectedValue(new Error('aggregation failed')),
+        getCallLogData: jest.fn().mockRejectedValue(new Error('call log failed'))
+      }));
+
+      await expect(adminHandler.getAdminReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+      await expect(adminHandler.getUserReport({ rcAccountId: 'account', rcExtensionId: '101' })).resolves.toBeNull();
+    });
+
+    test('getUserMapping updates existing mappings, creates new matches, and handles oauth revocation', async () => {
+      await AdminConfigModel.create({
+        id: 'hashed-branch-mapping',
+        userMappings: [
+          { crmUserId: 'crm-user-1', rcExtensionId: 'ext-existing' }
+        ]
+      });
+      const user = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+      const connector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key'),
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-1', name: 'Existing User', email: 'existing@example.com' },
+          { id: 'crm-user-2', name: 'Jane Smith', email: 'jane@example.com' },
+          { id: 'crm-user-3', name: 'No Match', email: 'nomatch@example.com' }
+        ])
+      };
+      connectorRegistry.getConnector.mockReturnValue(connector);
+
+      const result = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-branch-mapping',
+        rcExtensionList: [
+          { id: 'ext-existing', name: 'Existing RC', email: 'existing@example.com', extensionNumber: '100' },
+          { id: 'ext-jane', firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com', extensionNumber: '101' }
+        ]
+      });
+
+      expect(result).toHaveLength(3);
+      expect(result[0].rcUser[0].extensionId).toBe('ext-existing');
+      expect(result[1].rcUser[0].extensionId).toBe('ext-jane');
+      expect(result[2].rcUser).toEqual([]);
+      const updatedConfig = await AdminConfigModel.findByPk('hashed-branch-mapping');
+      expect(updatedConfig.userMappings).toEqual(expect.arrayContaining([
+        expect.objectContaining({ crmUserId: 'crm-user-2', rcExtensionId: ['ext-jane'] })
+      ]));
+
+      connectorRegistry.getConnector.mockReturnValue({
+        getUserList: jest.fn(),
+        getAuthType: jest.fn().mockResolvedValue('oauth'),
+        getOauthInfo: jest.fn().mockResolvedValue({})
+      });
+      oauth.checkAndRefreshAccessToken.mockResolvedValueOnce(null);
+      await expect(adminHandler.getUserMapping({
+        user: {
+          platform: 'testCRM',
+          hostname: 'crm.example.com',
+          accessToken: 'expired-token',
+          platformAdditionalInfo: {}
+        },
+        hashedRcAccountId: 'hashed-branch-mapping',
+        rcExtensionList: []
+      })).resolves.toMatchObject({
+        successful: false,
+        isRevokeUserSession: true
+      });
+    });
+
+    test('getUserMapping initializes mappings when no admin config exists and reports database errors', async () => {
+      const user = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+      connectorRegistry.getConnector.mockReturnValue({
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key'),
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-10', name: 'Alex Agent', email: 'alex@example.com' }
+        ])
+      });
+
+      const result = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-new-mapping',
+        rcExtensionList: [
+          { id: 'ext-alex', firstName: 'Alex', lastName: 'Agent', email: 'alex@example.com', extensionNumber: '201' }
+        ]
+      });
+
+      expect(result[0].rcUser[0].extensionId).toBe('ext-alex');
+      const newConfig = await AdminConfigModel.findByPk('hashed-new-mapping');
+      expect(newConfig.userMappings).toEqual([
+        { crmUserId: 'crm-user-10', rcExtensionId: ['ext-alex'] }
+      ]);
+
+      jest.spyOn(AdminConfigModel, 'findByPk').mockRejectedValueOnce(new Error('read failed'));
+      const errorResult = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-error',
+        rcExtensionList: []
+      });
+      expect(errorResult.successful).toBe(false);
+      AdminConfigModel.findByPk.mockRestore();
+    });
+
+    test('reinitializeUserMapping handles missing capability, proxy limits, oauth revoke, apiKey remap, and update failure', async () => {
+      const baseUser = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+
+      connectorRegistry.getConnector.mockReturnValueOnce({});
+      await expect(adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({ getUserList: jest.fn() });
+      Connector.getProxyConfig.mockResolvedValueOnce({ operations: {} });
+      await expect(adminHandler.reinitializeUserMapping({
+        user: {
+          ...baseUser,
+          platformAdditionalInfo: { proxyId: 'proxy-1' }
+        },
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn(),
+        getAuthType: jest.fn().mockResolvedValue('oauth'),
+        getOauthInfo: jest.fn().mockResolvedValue({})
+      });
+      oauth.checkAndRefreshAccessToken.mockResolvedValueOnce(null);
+      await expect(adminHandler.reinitializeUserMapping({
+        user: {
+          ...baseUser,
+          hostname: 'crm.example.com'
+        },
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toMatchObject({
+        successful: false,
+        isRevokeUserSession: true
+      });
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-20', name: 'Matched User', email: 'matched@example.com' },
+          { id: 'crm-user-21', name: 'Unmatched User', email: 'unmatched@example.com' }
+        ]),
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key')
+      });
+      const result = await adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: [
+          { id: 'ext-20', firstName: 'Matched', lastName: 'User', email: 'matched@example.com', extensionNumber: '301' }
+        ]
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].rcUser[0].extensionId).toBe('ext-20');
+      expect(result[1].rcUser).toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn().mockResolvedValue([]),
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key')
+      });
+      jest.spyOn(AdminConfigModel, 'create').mockRejectedValueOnce(new Error('write failed'));
+      const failure = await adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit-fail',
+        rcExtensionList: []
+      });
+      expect(failure.successful).toBe(false);
+      AdminConfigModel.create.mockRestore();
+    });
+  });
 });