@app-connect/core 1.7.34 → 1.7.36

package/test/routes/dispositionRoutes.test.js

@@ -0,0 +1,192 @@
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../../handlers/disposition', () => ({
+  upsertCallDisposition: jest.fn(),
+}));
+jest.mock('../../lib/analytics', () => ({
+  init: jest.fn(),
+  track: jest.fn(),
+}));
+jest.mock('../../lib/jwt', () => ({
+  decodeJwt: jest.fn(),
+  generateJwt: jest.fn().mockReturnValue('refreshed-crm-jwt'),
+}));
+
+const disposition = require('../../handlers/disposition');
+const analytics = require('../../lib/analytics');
+const jwt = require('../../lib/jwt');
+const { createCoreRouter } = require('../../index');
+
+describe('Disposition Routes', () => {
+  let app;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jwt.decodeJwt.mockReturnValue({
+      id: 'crm-user-id',
+      platform: 'testCRM',
+    });
+    app = express();
+    app.use(express.json());
+    app.use('/', createCoreRouter());
+  });
+
+  test('PUT /callDisposition delegates decoded CRM identity and request body', async () => {
+    disposition.upsertCallDisposition.mockResolvedValue({
+      successful: true,
+      returnMessage: {
+        message: 'Disposition saved',
+        messageType: 'success',
+        ttl: 2000,
+      },
+      extraDataTracking: {
+        statusCode: 204,
+      },
+    });
+
+    const response = await request(app)
+      .put('/callDisposition')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        sessionId: 'session-1',
+        extensionNumber: '101',
+        hashedExtensionId: 'hashed-extension-1',
+        dispositions: [{ id: 'disp-1' }],
+        additionalSubmission: { note: 'extra' },
+      });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      successful: true,
+      returnMessage: {
+        message: 'Disposition saved',
+        messageType: 'success',
+        ttl: 2000,
+      },
+    });
+    expect(disposition.upsertCallDisposition).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'crm-user-id',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hashed-extension-1',
+      dispositions: [{ id: 'disp-1' }],
+      additionalSubmission: { note: 'extra' },
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Disposition call log',
+      interfaceName: 'dispositionCallLog',
+      connectorName: 'testCRM',
+      success: true,
+      extras: {
+        statusCode: 204,
+      },
+    }));
+  });
+
+  test('PUT /callDisposition rejects missing CRM auth token', async () => {
+    const response = await request(app)
+      .put('/callDisposition')
+      .send({
+        sessionId: 'session-1',
+      });
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Please go to Settings and authorize CRM platform');
+    expect(disposition.upsertCallDisposition).not.toHaveBeenCalled();
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Disposition call log',
+      success: false,
+    }));
+  });
+
+  test('PUT /callDisposition rejects invalid JWT token', async () => {
+    jwt.decodeJwt.mockReturnValue(null);
+
+    const response = await request(app)
+      .put('/callDisposition')
+      .query({ jwtToken: 'invalid-jwt' })
+      .send({
+        sessionId: 'session-1',
+      });
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Invalid JWT token');
+    expect(disposition.upsertCallDisposition).not.toHaveBeenCalled();
+  });
+
+  test('PUT /callDisposition rejects decoded token without user id', async () => {
+    jwt.decodeJwt.mockReturnValue({
+      platform: 'testCRM',
+    });
+
+    const response = await request(app)
+      .put('/callDisposition')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        sessionId: 'session-1',
+      });
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Please go to Settings and authorize CRM platform');
+    expect(disposition.upsertCallDisposition).not.toHaveBeenCalled();
+  });
+
+  test('PUT /callDisposition returns 401 when handler asks to revoke user session', async () => {
+    disposition.upsertCallDisposition.mockResolvedValue({
+      successful: false,
+      returnMessage: {
+        message: 'User session expired. Please connect again.',
+        messageType: 'warning',
+        ttl: 5000,
+      },
+      isRevokeUserSession: true,
+    });
+
+    const response = await request(app)
+      .put('/callDisposition')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        sessionId: 'session-1',
+      });
+
+    expect(response.status).toBe(401);
+    expect(response.body).toEqual({
+      successful: false,
+      returnMessage: {
+        message: 'User session expired. Please connect again.',
+        messageType: 'warning',
+        ttl: 5000,
+      },
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Disposition call log',
+      success: false,
+    }));
+  });
+
+  test('PUT /callDisposition maps handler exceptions to 400 error response', async () => {
+    disposition.upsertCallDisposition.mockRejectedValue(new Error('provider failed'));
+
+    const response = await request(app)
+      .put('/callDisposition')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        sessionId: 'session-1',
+      });
+
+    expect(response.status).toBe(400);
+    expect(response.body).toEqual({
+      error: 'provider failed',
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Disposition call log',
+      success: false,
+      extras: {
+        statusCode: 'unknown',
+      },
+    }));
+  });
+});
+

package/test/routes/managedAuthRoutes.test.js

@@ -7,6 +7,9 @@ jest.mock('../../handlers/admin', () => ({
 }));
 jest.mock('../../handlers/managedAuth', () => ({
   getManagedAuthState: jest.fn(),
+  getManagedAuthAdminSettings: jest.fn(),
+  upsertOrgManagedAuthValues: jest.fn(),
+  upsertUserManagedAuthValues: jest.fn(),
 }));
 jest.mock('../../handlers/managedOAuth', () => ({
   getManagedOAuthState: jest.fn(),
@@ -21,11 +24,18 @@ jest.mock('../../lib/jwt', () => ({
   generateJwt: jest.fn().mockReturnValue('jwt-token'),
   decodeJwt: jest.fn(),
 }));
+jest.mock('../../models/userModel', () => ({
+  UserModel: {
+    findByPk: jest.fn(),
+  },
+}));
 
 const adminCore = require('../../handlers/admin');
 const managedAuthCore = require('../../handlers/managedAuth');
 const managedOAuthCore = require('../../handlers/managedOAuth');
 const authCore = require('../../handlers/auth');
+const jwt = require('../../lib/jwt');
+const { UserModel } = require('../../models/userModel');
 const { createCoreRouter } = require('../../index');
 
 describe('Managed Auth Routes', () => {
@@ -194,6 +204,147 @@ describe('Managed Auth Routes', () => {
     });
   });
 
+
+  describe('GET /admin/managedAuth', () => {
+    test('should use CRM jwt platform and validated admin account for settings lookup', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      managedAuthCore.getManagedAuthAdminSettings.mockResolvedValue({
+        orgFields: [{ const: 'apiKey' }],
+        userFields: [{ const: 'userToken' }],
+        orgValues: {},
+        userValues: [],
+      });
+
+      const response = await request(app)
+        .get('/admin/managedAuth')
+        .query({
+          jwtToken: 'crm-jwt',
+          rcAccessToken: 'valid-rc-token',
+          connectorId: 'shared-connector',
+          isPrivate: 'true',
+        });
+
+      expect(response.status).toBe(200);
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('crm-jwt');
+      expect(UserModel.findByPk).toHaveBeenCalledWith('crm-user-id');
+      expect(adminCore.validateAdminRole).toHaveBeenCalledWith({ rcAccessToken: 'valid-rc-token' });
+      expect(managedAuthCore.getManagedAuthAdminSettings).toHaveBeenCalledWith({
+        platform: 'salesforce',
+        rcAccountId: 'validated-account-id',
+        connectorId: 'shared-connector',
+        isPrivate: true,
+      });
+      expect(response.body.orgFields).toEqual([{ const: 'apiKey' }]);
+    });
+
+    test('should reject non-admin users before reading managed auth settings', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: false,
+        rcAccountId: 'validated-account-id',
+      });
+
+      const response = await request(app)
+        .get('/admin/managedAuth')
+        .query({
+          jwtToken: 'crm-jwt',
+          rcAccessToken: 'valid-rc-token',
+        });
+
+      expect(response.status).toBe(403);
+      expect(response.text).toBe('Admin validation failed');
+      expect(managedAuthCore.getManagedAuthAdminSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('POST /admin/managedAuth', () => {
+    test('should save org scoped values under the validated admin account and CRM platform', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      managedAuthCore.upsertOrgManagedAuthValues.mockResolvedValue({});
+
+      const response = await request(app)
+        .post('/admin/managedAuth')
+        .query({
+          jwtToken: 'crm-jwt',
+          rcAccessToken: 'valid-rc-token',
+          connectorId: 'private-connector',
+          isPrivate: 'true',
+        })
+        .send({
+          scope: 'org',
+          values: { apiKey: 'api-key' },
+          fieldsToRemove: ['oldApiKey'],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.text).toBe('Shared authentication updated');
+      expect(managedAuthCore.upsertOrgManagedAuthValues).toHaveBeenCalledWith({
+        rcAccountId: 'validated-account-id',
+        platform: 'salesforce',
+        values: { apiKey: 'api-key' },
+        fieldsToRemove: ['oldApiKey'],
+      });
+      expect(managedAuthCore.upsertUserManagedAuthValues).not.toHaveBeenCalled();
+    });
+
+    test('should save user scoped values with selected RingCentral extension details', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      managedAuthCore.upsertUserManagedAuthValues.mockResolvedValue({});
+
+      const response = await request(app)
+        .post('/admin/managedAuth')
+        .query({
+          jwtToken: 'crm-jwt',
+          rcAccessToken: 'valid-rc-token',
+        })
+        .send({
+          scope: 'user',
+          rcExtensionId: '101',
+          rcUserName: 'Ada Lovelace',
+          values: { userToken: 'token-101' },
+          fieldsToRemove: ['oldUserToken'],
+        });
+
+      expect(response.status).toBe(200);
+      expect(managedAuthCore.upsertUserManagedAuthValues).toHaveBeenCalledWith({
+        rcAccountId: 'validated-account-id',
+        platform: 'salesforce',
+        rcExtensionId: '101',
+        rcUserName: 'Ada Lovelace',
+        values: { userToken: 'token-101' },
+        fieldsToRemove: ['oldUserToken'],
+      });
+      expect(managedAuthCore.upsertOrgManagedAuthValues).not.toHaveBeenCalled();
+    });
+  });
   describe('POST /apiKeyLogin', () => {
 
     test('should validate rcAccessToken and ignore spoofed rc ids in body', async () => {

package/test/routes/pluginRoutes.test.js

@@ -0,0 +1,262 @@
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../../handlers/admin', () => ({
+  validateAdminRole: jest.fn(),
+}));
+jest.mock('../../handlers/plugin', () => ({
+  registerPluginAccount: jest.fn(),
+  unregisterPluginAccount: jest.fn(),
+  getPluginLicenseStatus: jest.fn(),
+}));
+jest.mock('../../lib/analytics', () => ({
+  init: jest.fn(),
+  track: jest.fn(),
+}));
+
+jest.mock('../../lib/jwt', () => ({
+  decodeJwt: jest.fn(),
+  generateJwt: jest.fn().mockReturnValue('refreshed-crm-jwt'),
+}));
+jest.mock('../../models/userModel', () => ({
+  UserModel: {
+    findByPk: jest.fn(),
+  },
+}));
+
+const adminCore = require('../../handlers/admin');
+const pluginCore = require('../../handlers/plugin');
+const analytics = require('../../lib/analytics');
+const jwt = require('../../lib/jwt');
+const { UserModel } = require('../../models/userModel');
+const { createCoreRouter } = require('../../index');
+
+describe('Plugin Routes', () => {
+  let app;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    app = express();
+    app.use(express.json());
+    app.use('/', createCoreRouter());
+  });
+
+  describe('POST /plugin/register', () => {
+    test('should validate admin role, reject spoofed account ids, and register the selected plugin', async () => {
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      pluginCore.registerPluginAccount.mockResolvedValue({ successful: true });
+
+      const response = await request(app)
+        .post('/plugin/register')
+        .query({ rcAccessToken: 'valid-rc-token' })
+        .send({
+          pluginId: 'plugin-1',
+          rcAccountId: 'validated-account-id',
+          pluginAccess: 'shared',
+          pluginName: 'plugin.sample',
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ successful: true });
+      expect(adminCore.validateAdminRole).toHaveBeenCalledWith({ rcAccessToken: 'valid-rc-token' });
+      expect(pluginCore.registerPluginAccount).toHaveBeenCalledWith({
+        pluginId: 'plugin-1',
+        rcAccessToken: 'valid-rc-token',
+        rcAccountId: 'validated-account-id',
+        pluginAccess: 'shared',
+        pluginName: 'plugin.sample',
+      });
+      expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+        eventName: 'Plugin Register',
+        interfaceName: 'pluginRegister',
+        success: true,
+      }));
+    });
+
+    test('should return a failed register response when plugin provider registration fails', async () => {
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      pluginCore.registerPluginAccount.mockRejectedValue(new Error('Plugin register API did not return jwtToken'));
+
+      const response = await request(app)
+        .post('/plugin/register')
+        .query({ rcAccessToken: 'valid-rc-token' })
+        .send({
+          pluginId: 'plugin-1',
+          rcAccountId: 'validated-account-id',
+          pluginAccess: 'shared',
+          pluginName: 'plugin.sample',
+        });
+
+      expect(response.status).toBe(400);
+      expect(response.body).toEqual({
+        successful: false,
+        returnMessage: 'Plugin register API did not return jwtToken',
+      });
+      expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+        eventName: 'Plugin Register',
+        interfaceName: 'pluginRegister',
+        success: false,
+      }));
+    });
+
+    test('should reject register requests when the body account does not match the validated admin account', async () => {
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+
+      const response = await request(app)
+        .post('/plugin/register')
+        .query({ rcAccessToken: 'valid-rc-token' })
+        .send({
+          pluginId: 'plugin-1',
+          rcAccountId: 'spoofed-account-id',
+          pluginAccess: 'shared',
+          pluginName: 'plugin.sample',
+        });
+
+      expect(response.status).toBe(403);
+      expect(response.body).toEqual({
+        successful: false,
+        returnMessage: 'rcAccountId mismatch',
+      });
+      expect(pluginCore.registerPluginAccount).not.toHaveBeenCalled();
+    });
+  });
+
+
+  describe('GET /plugin/licenseStatus', () => {
+    test('should require a CRM user session and return plugin license status for the requested account', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id', platform: 'salesforce' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      pluginCore.getPluginLicenseStatus.mockResolvedValue({
+        licenseStatus: true,
+        licenseStatusDescription: 'Active',
+      });
+
+      const response = await request(app)
+        .get('/plugin/licenseStatus')
+        .set('Authorization', 'Bearer crm-jwt')
+        .query({
+          rcAccountId: 'validated-account-id',
+          pluginId: 'plugin-1',
+        });
+
+      expect(response.status).toBe(200);
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('crm-jwt');
+      expect(UserModel.findByPk).toHaveBeenCalledWith('crm-user-id');
+      expect(pluginCore.getPluginLicenseStatus).toHaveBeenCalledWith({
+        rcAccountId: 'validated-account-id',
+        pluginId: 'plugin-1',
+      });
+      expect(response.body).toEqual({
+        licenseStatus: true,
+        licenseStatusDescription: 'Active',
+      });
+    });
+
+    test('should degrade plugin license provider errors to an invalid license response', async () => {
+      jwt.decodeJwt.mockReturnValue({ id: 'crm-user-id', platform: 'salesforce' });
+      UserModel.findByPk.mockResolvedValue({
+        id: 'crm-user-id',
+        platform: 'salesforce',
+      });
+      pluginCore.getPluginLicenseStatus.mockRejectedValue(new Error('provider timeout'));
+
+      const response = await request(app)
+        .get('/plugin/licenseStatus')
+        .set('Authorization', 'Bearer crm-jwt')
+        .query({
+          rcAccountId: 'validated-account-id',
+          pluginId: 'plugin-1',
+        });
+
+      expect(response.status).toBe(200);
+      expect(pluginCore.getPluginLicenseStatus).toHaveBeenCalledWith({
+        rcAccountId: 'validated-account-id',
+        pluginId: 'plugin-1',
+      });
+      expect(response.body).toEqual({
+        licenseStatus: false,
+        licenseStatusDescription: 'provider timeout',
+      });
+    });
+
+    test('should not query plugin license status without a CRM user session', async () => {
+      const response = await request(app)
+        .get('/plugin/licenseStatus')
+        .query({
+          rcAccountId: 'validated-account-id',
+          pluginId: 'plugin-1',
+        });
+
+      expect(response.status).toBe(400);
+      expect(response.text).toBe('Please go to Settings and authorize CRM platform');
+      expect(pluginCore.getPluginLicenseStatus).not.toHaveBeenCalled();
+    });
+  });
+  describe('DELETE /plugin/unregister', () => {
+    test('should validate admin role and unregister the selected plugin for the validated account', async () => {
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: true,
+        rcAccountId: 'validated-account-id',
+      });
+      pluginCore.unregisterPluginAccount.mockResolvedValue({ successful: true });
+
+      const response = await request(app)
+        .delete('/plugin/unregister')
+        .query({
+          rcAccessToken: 'valid-rc-token',
+          pluginId: 'plugin-1',
+          rcAccountId: 'validated-account-id',
+          pluginName: 'plugin.sample',
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ successful: true });
+      expect(adminCore.validateAdminRole).toHaveBeenCalledWith({ rcAccessToken: 'valid-rc-token' });
+      expect(pluginCore.unregisterPluginAccount).toHaveBeenCalledWith({
+        pluginId: 'plugin-1',
+        rcAccountId: 'validated-account-id',
+        pluginName: 'plugin.sample',
+      });
+      expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+        eventName: 'Plugin Unregister',
+        interfaceName: 'pluginUnregister',
+        success: true,
+      }));
+    });
+
+    test('should reject unregister requests from non-admin users', async () => {
+      adminCore.validateAdminRole.mockResolvedValue({
+        isValidated: false,
+        rcAccountId: 'validated-account-id',
+      });
+
+      const response = await request(app)
+        .delete('/plugin/unregister')
+        .query({
+          rcAccessToken: 'valid-rc-token',
+          pluginId: 'plugin-1',
+          rcAccountId: 'validated-account-id',
+          pluginName: 'plugin.sample',
+        });
+
+      expect(response.status).toBe(403);
+      expect(response.body).toEqual({
+        successful: false,
+        returnMessage: 'Admin validation failed',
+      });
+      expect(pluginCore.unregisterPluginAccount).not.toHaveBeenCalled();
+    });
+  });
+});