@app-connect/core 1.7.36 → 1.7.38

package/test/mcp/mcpHandlerMore.test.js

@@ -1,384 +0,0 @@
-const axios = require('axios');
-const fs = require('fs');
-const toolsModule = require('../../mcp/tools');
-const { LlmSessionModel } = require('../../models/llmSessionModel');
-const { CacheModel } = require('../../models/cacheModel');
-const { UserModel } = require('../../models/userModel');
-const { getHashValue } = require('../../lib/util');
-const jwt = require('../../lib/jwt');
-const { handleMcpRequest, handleWidgetToolCall } = require('../../mcp/mcpHandler');
-
-jest.mock('axios', () => ({ get: jest.fn() }));
-
-jest.mock('../../mcp/tools', () => ({
-  tools: [
-    {
-      definition: { name: 'getPublicConnectors', _meta: { existing: true } },
-      execute: jest.fn(),
-    },
-    {
-      definition: { name: 'simpleTool', outputSchema: { type: 'object' } },
-      execute: jest.fn(),
-    },
-    {
-      definition: { name: 'falseTool', outputSchema: { type: 'object' } },
-      execute: jest.fn(),
-    },
-    {
-      definition: { name: 'throwTool' },
-      execute: jest.fn(),
-    },
-  ],
-  widgetTools: [
-    {
-      definition: { name: 'widgetOnly' },
-      execute: jest.fn(),
-    },
-  ],
-}));
-
-jest.mock('../../models/llmSessionModel', () => ({
-  LlmSessionModel: {
-    findByPk: jest.fn(),
-    destroy: jest.fn(),
-    upsert: jest.fn(),
-  },
-}));
-
-jest.mock('../../models/cacheModel', () => ({
-  CacheModel: {
-    findByPk: jest.fn(),
-    upsert: jest.fn(),
-  },
-}));
-
-jest.mock('../../models/userModel', () => ({
-  UserModel: {
-    findByPk: jest.fn(),
-    findOne: jest.fn(),
-  },
-}));
-
-jest.mock('../../lib/util', () => ({
-  getHashValue: jest.fn(),
-}));
-
-jest.mock('../../lib/jwt', () => ({
-  decodeJwt: jest.fn(),
-  generateJwt: jest.fn(),
-}));
-
-jest.mock('../../lib/logger', () => ({
-  info: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-}));
-
-function mockResponse() {
-  return {
-    status: jest.fn().mockReturnThis(),
-    json: jest.fn(),
-    end: jest.fn(),
-  };
-}
-
-function makeRequest(method, params = {}, extra = {}) {
-  return {
-    body: {
-      jsonrpc: '2.0',
-      id: extra.id ?? 1,
-      method,
-      params,
-    },
-    headers: extra.headers || {},
-  };
-}
-
-function getTool(name) {
-  return [...toolsModule.tools, ...toolsModule.widgetTools]
-    .find(tool => tool.definition.name === name);
-}
-
-describe('MCP Handler additional protocol coverage', () => {
-  const originalAppServer = process.env.APP_SERVER;
-  const originalHashKey = process.env.HASH_KEY;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    process.env.APP_SERVER = 'https://app.example.test';
-    process.env.HASH_KEY = 'test-hash-key';
-
-    getTool('getPublicConnectors').execute.mockResolvedValue({ success: true });
-    getTool('simpleTool').execute.mockResolvedValue({
-      structuredContent: { success: true, data: { ok: true } },
-      content: [{ type: 'text', text: 'custom content' }],
-    });
-    getTool('falseTool').execute.mockResolvedValue({ success: false, error: 'blocked' });
-    getTool('throwTool').execute.mockRejectedValue(new Error('boom'));
-    getTool('widgetOnly').execute.mockResolvedValue({ success: true, data: { widget: true } });
-
-    axios.get.mockResolvedValue({ data: { id: 'rc-ext-1' } });
-    CacheModel.findByPk.mockResolvedValue(null);
-    CacheModel.upsert.mockResolvedValue([{}, true]);
-    LlmSessionModel.findByPk.mockResolvedValue(null);
-    LlmSessionModel.destroy.mockResolvedValue(1);
-    LlmSessionModel.upsert.mockResolvedValue([{}, true]);
-    UserModel.findByPk.mockResolvedValue({ id: 'user-1', accessToken: 'crm-token' });
-    UserModel.findOne.mockResolvedValue(null);
-    getHashValue.mockReturnValue('hashed-rc-ext-1');
-    jwt.decodeJwt.mockReturnValue({ id: 'user-1' });
-    jwt.generateJwt.mockReturnValue('generated-jwt');
-  });
-
-  afterAll(() => {
-    process.env.APP_SERVER = originalAppServer;
-    process.env.HASH_KEY = originalHashKey;
-  });
-
-  test('handles initialize, resources/list, ping, notifications, and unknown methods', async () => {
-    const initializeRes = mockResponse();
-    await handleMcpRequest(makeRequest('initialize'), initializeRes);
-    expect(initializeRes.json.mock.calls[0][0].result.serverInfo.name)
-      .toBe('rc-unified-crm-extension');
-
-    const listRes = mockResponse();
-    await handleMcpRequest(makeRequest('resources/list'), listRes);
-    expect(listRes.json.mock.calls[0][0].result.resources[0]).toEqual(expect.objectContaining({
-      name: 'connector-list-widget',
-      mimeType: 'text/html+skybridge',
-    }));
-
-    const pingRes = mockResponse();
-    await handleMcpRequest(makeRequest('ping'), pingRes);
-    expect(pingRes.json.mock.calls[0][0].result).toEqual({});
-
-    const notificationRes = mockResponse();
-    await handleMcpRequest(makeRequest('notifications/initialized'), notificationRes);
-    expect(notificationRes.status).toHaveBeenCalledWith(200);
-    expect(notificationRes.end).toHaveBeenCalled();
-    expect(notificationRes.json).not.toHaveBeenCalled();
-
-    const unknownRes = mockResponse();
-    await handleMcpRequest(makeRequest('no/such-method'), unknownRes);
-    expect(unknownRes.json.mock.calls[0][0].error).toEqual(expect.objectContaining({
-      code: -32601,
-      message: 'Method not found: no/such-method',
-    }));
-  });
-
-  test('decorates tools/list metadata and schemas', async () => {
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest('tools/list'), res);
-
-    const response = res.json.mock.calls[0][0];
-    const publicConnectors = response.result.tools.find(tool => tool.name === 'getPublicConnectors');
-    expect(publicConnectors._meta).toEqual(expect.objectContaining({
-      existing: true,
-      'openai/outputTemplate': expect.stringMatching(/^ui:\/\/widget\/ConnectorList-v\d+\.html$/),
-    }));
-    expect(publicConnectors.outputSchema.properties).toHaveProperty('serverUrl');
-  });
-
-  test('reads widget resources and falls back from dist html to dev html', async () => {
-    const invalidRes = mockResponse();
-    await handleMcpRequest(makeRequest('resources/read', { uri: 'file://bad.html' }), invalidRes);
-    expect(invalidRes.json.mock.calls[0][0].error).toEqual(expect.objectContaining({
-      code: -32602,
-      message: 'Unknown resource: file://bad.html',
-    }));
-
-    const readFileSpy = jest.spyOn(fs, 'readFileSync')
-      .mockImplementationOnce(() => { throw new Error('missing dist'); })
-      .mockReturnValueOnce('<html>widget</html>');
-
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest('resources/read', { uri: 'ui://widget/ConnectorList-v10.html' }), res);
-
-    const content = res.json.mock.calls[0][0].result.contents[0];
-    expect(content.text).toBe('<html>widget</html>');
-    expect(content._meta['openai/widgetDomain']).toBe('https://app.example.test');
-    expect(readFileSpy).toHaveBeenCalledTimes(2);
-    readFileSpy.mockRestore();
-  });
-
-  test('injects cached rc extension and valid CRM jwt into tool calls', async () => {
-    CacheModel.findByPk.mockResolvedValue({
-      data: { rcExtensionId: 'rc-ext-cached' },
-      expiry: new Date(Date.now() + 60000),
-    });
-    LlmSessionModel.findByPk.mockResolvedValue({
-      jwtToken: 'cached-jwt',
-      expiry: new Date(Date.now() + 60000),
-    });
-
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest(
-      'tools/call',
-      {
-        name: 'simpleTool',
-        arguments: { value: 1 },
-        _meta: { 'openai/session': 'openai-session-1' },
-      },
-      { headers: { authorization: 'Bearer rc-access-token' } }
-    ), res);
-
-    expect(axios.get).not.toHaveBeenCalled();
-    expect(getTool('simpleTool').execute).toHaveBeenCalledWith(expect.objectContaining({
-      value: 1,
-      rcAccessToken: 'rc-access-token',
-      openaiSessionId: 'openai-session-1',
-      rcExtensionId: 'rc-ext-cached',
-      jwtToken: 'cached-jwt',
-    }));
-    expect(res.json.mock.calls[0][0].result).toEqual(expect.objectContaining({
-      content: [{ type: 'text', text: 'custom content' }],
-      structuredContent: { success: true, data: { ok: true } },
-    }));
-  });
-
-  test('refreshes rc extension, removes expired sessions, and reuses fallback session jwt', async () => {
-    LlmSessionModel.findByPk
-      .mockResolvedValueOnce({
-        jwtToken: 'expired-jwt',
-        expiry: new Date(Date.now() - 60000),
-      })
-      .mockResolvedValueOnce({
-        jwtToken: 'fallback-jwt',
-        expiry: new Date(Date.now() + 60000),
-      });
-
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest(
-      'tools/call',
-      {
-        name: 'simpleTool',
-        arguments: {},
-        _meta: { 'openai/session': 'openai-session-2' },
-      },
-      { headers: { authorization: 'Bearer live-rc-token' } }
-    ), res);
-
-    expect(axios.get).toHaveBeenCalledWith(
-      'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
-      { headers: { Authorization: 'Bearer live-rc-token' } }
-    );
-    expect(CacheModel.upsert).toHaveBeenCalledWith(expect.objectContaining({
-      id: 'openai-session-2-rcExtensionId',
-      data: { rcExtensionId: 'rc-ext-1' },
-      status: 'resolved',
-    }));
-    expect(LlmSessionModel.destroy).toHaveBeenCalledWith({ where: { id: 'rc-ext-1' } });
-    expect(LlmSessionModel.upsert).toHaveBeenCalledWith(expect.objectContaining({
-      id: 'rc-ext-1',
-      jwtToken: 'fallback-jwt',
-    }));
-    expect(getTool('simpleTool').execute).toHaveBeenCalledWith(expect.objectContaining({
-      rcExtensionId: 'rc-ext-1',
-      jwtToken: 'fallback-jwt',
-    }));
-  });
-
-  test('creates a new llm session from the latest CRM user when no session exists', async () => {
-    LlmSessionModel.findByPk
-      .mockResolvedValueOnce(null)
-      .mockResolvedValueOnce(null)
-      .mockResolvedValueOnce({ jwtToken: 'generated-jwt' });
-    UserModel.findOne.mockResolvedValue({
-      id: 'user-2',
-      platform: 'salesforce',
-      accessToken: 'crm-token',
-    });
-
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest(
-      'tools/call',
-      {
-        name: 'falseTool',
-        arguments: {},
-        _meta: { 'openai/session': 'openai-session-3' },
-      },
-      { headers: { authorization: 'Bearer rc-token' } }
-    ), res);
-
-    expect(getHashValue).toHaveBeenCalledWith('rc-ext-1', 'test-hash-key');
-    expect(UserModel.findOne).toHaveBeenCalledWith(expect.objectContaining({
-      where: expect.objectContaining({ hashedRcExtensionId: 'hashed-rc-ext-1' }),
-      order: [['updatedAt', 'DESC']],
-    }));
-    expect(jwt.generateJwt).toHaveBeenCalledWith({ id: 'user-2', platform: 'salesforce' });
-    expect(res.json.mock.calls[0][0].result).toEqual(expect.objectContaining({
-      structuredContent: { success: false, error: 'blocked' },
-      isError: true,
-    }));
-  });
-
-  test('returns JSON-RPC errors for unknown or failed tools and handles request failures', async () => {
-    const missingRes = mockResponse();
-    await handleMcpRequest(makeRequest('tools/call', { name: 'missingTool', arguments: {} }), missingRes);
-    expect(missingRes.json.mock.calls[0][0].error).toEqual(expect.objectContaining({
-      code: -32603,
-      message: 'Tool execution failed: Tool not found: missingTool',
-    }));
-
-    const throwRes = mockResponse();
-    await handleMcpRequest(makeRequest('tools/call', { name: 'throwTool', arguments: {} }), throwRes);
-    expect(throwRes.json.mock.calls[0][0].error).toEqual(expect.objectContaining({
-      code: -32603,
-      message: 'Tool execution failed: boom',
-    }));
-
-    const malformedRes = mockResponse();
-    await handleMcpRequest({ headers: {} }, malformedRes);
-    expect(malformedRes.json.mock.calls[0][0]).toEqual(expect.objectContaining({
-      id: null,
-      error: expect.objectContaining({
-        code: -32603,
-        message: 'Internal server error',
-      }),
-    }));
-  });
-
-  test('continues tool calls when RC extension resolution fails', async () => {
-    axios.get.mockRejectedValue(new Error('invalid rc token'));
-
-    const res = mockResponse();
-    await handleMcpRequest(makeRequest(
-      'tools/call',
-      {
-        name: 'simpleTool',
-        arguments: {},
-        _meta: { 'openai/session': 'openai-session-4' },
-      },
-      { headers: { authorization: 'Bearer bad-token' } }
-    ), res);
-
-    expect(getTool('simpleTool').execute).toHaveBeenCalledWith(expect.objectContaining({
-      rcAccessToken: 'bad-token',
-      openaiSessionId: 'openai-session-4',
-    }));
-    expect(getTool('simpleTool').execute.mock.calls[0][0]).not.toHaveProperty('rcExtensionId');
-  });
-
-  test('handles widget tool call validation, success, and execution errors', async () => {
-    const missingRes = mockResponse();
-    await handleWidgetToolCall({ body: {} }, missingRes);
-    expect(missingRes.status).toHaveBeenCalledWith(400);
-    expect(missingRes.json).toHaveBeenCalledWith({ success: false, error: 'Missing tool name' });
-
-    const unknownRes = mockResponse();
-    await handleWidgetToolCall({ body: { tool: 'notRegistered' } }, unknownRes);
-    expect(unknownRes.status).toHaveBeenCalledWith(404);
-    expect(unknownRes.json).toHaveBeenCalledWith({ success: false, error: 'Unknown tool: notRegistered' });
-
-    const successRes = mockResponse();
-    await handleWidgetToolCall({ body: { tool: 'widgetOnly', toolArgs: { sessionId: 's1' } } }, successRes);
-    expect(getTool('widgetOnly').execute).toHaveBeenCalledWith({ sessionId: 's1' });
-    expect(successRes.json).toHaveBeenCalledWith({ success: true, data: { widget: true } });
-
-    getTool('widgetOnly').execute.mockRejectedValueOnce(new Error('widget failed'));
-    const failRes = mockResponse();
-    await handleWidgetToolCall({ body: { tool: 'widgetOnly' } }, failRes);
-    expect(failRes.status).toHaveBeenCalledWith(500);
-    expect(failRes.json).toHaveBeenCalledWith({ success: false, error: 'widget failed' });
-  });
-});