@app-connect/core 1.7.36 → 1.7.38

package/test/lib/util.test.js

@@ -1,329 +0,0 @@
-jest.mock('tz-lookup');
-jest.mock('country-state-city');
-
-const tzlookup = require('tz-lookup');
-const { State } = require('country-state-city');
-const {
-  getTimeZone,
-  getHashValue,
-  secondsToHoursMinutesSeconds,
-  getMostRecentDate,
-  getMediaReaderLinkByPlatformMediaLink
-} = require('../../lib/util');
-
-describe('Utility Functions', () => {
-  describe('getTimeZone', () => {
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    test('should return timezone for valid state and country', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue({
-        name: 'California',
-        latitude: '36.778259',
-        longitude: '-119.417931'
-      });
-      tzlookup.mockReturnValue('America/Los_Angeles');
-
-      // Act
-      const result = getTimeZone('US', 'CA');
-
-      // Assert
-      expect(State.getStateByCodeAndCountry).toHaveBeenCalledWith('CA', 'US');
-      expect(tzlookup).toHaveBeenCalledWith('36.778259', '-119.417931');
-      expect(result).toBe('America/Los_Angeles');
-    });
-
-    test('should return "Unknown timezone" when state not found', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue(null);
-
-      // Act
-      const result = getTimeZone('XX', 'YY');
-
-      // Assert
-      expect(result).toBe('Unknown timezone');
-      expect(tzlookup).not.toHaveBeenCalled();
-    });
-
-    test('should handle different country/state combinations', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue({
-        name: 'Tokyo',
-        latitude: '35.6762',
-        longitude: '139.6503'
-      });
-      tzlookup.mockReturnValue('Asia/Tokyo');
-
-      // Act
-      const result = getTimeZone('JP', 'TK');
-
-      // Assert
-      expect(result).toBe('Asia/Tokyo');
-    });
-
-    test('should handle European timezone', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue({
-        name: 'Bavaria',
-        latitude: '48.7904',
-        longitude: '11.4979'
-      });
-      tzlookup.mockReturnValue('Europe/Berlin');
-
-      // Act
-      const result = getTimeZone('DE', 'BY');
-
-      // Assert
-      expect(result).toBe('Europe/Berlin');
-    });
-
-    test('should handle tzlookup throwing an error', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue({
-        name: 'Invalid Location',
-        latitude: '999',
-        longitude: '999'
-      });
-      tzlookup.mockImplementation(() => {
-        throw new Error('Invalid coordinates');
-      });
-
-      // Act & Assert
-      expect(() => getTimeZone('XX', 'YY')).toThrow('Invalid coordinates');
-    });
-
-    test('should handle state with missing latitude/longitude', () => {
-      // Arrange
-      State.getStateByCodeAndCountry = jest.fn().mockReturnValue({
-        name: 'Some State',
-        latitude: null,
-        longitude: null
-      });
-      tzlookup.mockReturnValue(null);
-
-      // Act
-      const result = getTimeZone('US', 'XX');
-
-      // Assert - tzlookup is called with null coords, returns null
-      expect(tzlookup).toHaveBeenCalledWith(null, null);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getHashValue', () => {
-    test('should generate consistent hash for same input', () => {
-      const hash1 = getHashValue('test-string', 'secret-key');
-      const hash2 = getHashValue('test-string', 'secret-key');
-
-      expect(hash1).toBe(hash2);
-    });
-
-    test('should generate different hashes for different strings', () => {
-      const hash1 = getHashValue('string-1', 'secret-key');
-      const hash2 = getHashValue('string-2', 'secret-key');
-
-      expect(hash1).not.toBe(hash2);
-    });
-
-    test('should generate different hashes for different keys', () => {
-      const hash1 = getHashValue('test-string', 'key-1');
-      const hash2 = getHashValue('test-string', 'key-2');
-
-      expect(hash1).not.toBe(hash2);
-    });
-
-    test('should return a 64-character hex string (SHA-256)', () => {
-      const hash = getHashValue('test', 'key');
-
-      expect(hash).toHaveLength(64);
-      expect(hash).toMatch(/^[0-9a-f]{64}$/);
-    });
-
-    test('should handle empty string', () => {
-      const hash = getHashValue('', 'secret-key');
-
-      expect(hash).toHaveLength(64);
-      expect(hash).toMatch(/^[0-9a-f]{64}$/);
-    });
-
-    test('should handle special characters', () => {
-      const hash = getHashValue('test@#$%^&*()', 'key!@#');
-
-      expect(hash).toHaveLength(64);
-      expect(hash).toMatch(/^[0-9a-f]{64}$/);
-    });
-  });
-
-  describe('secondsToHoursMinutesSeconds', () => {
-    test('should return "0 seconds" for 0', () => {
-      expect(secondsToHoursMinutesSeconds(0)).toBe('0 seconds');
-    });
-
-    test('should return singular "second" for 1 second', () => {
-      expect(secondsToHoursMinutesSeconds(1)).toBe('1 second');
-    });
-
-    test('should return plural "seconds" for multiple seconds', () => {
-      expect(secondsToHoursMinutesSeconds(30)).toBe('30 seconds');
-    });
-
-    test('should return singular "minute" for 60 seconds', () => {
-      expect(secondsToHoursMinutesSeconds(60)).toBe('1 minute');
-    });
-
-    test('should return plural "minutes" for multiple minutes', () => {
-      expect(secondsToHoursMinutesSeconds(120)).toBe('2 minutes');
-    });
-
-    test('should return minutes and seconds combined', () => {
-      expect(secondsToHoursMinutesSeconds(90)).toBe('1 minute, 30 seconds');
-    });
-
-    test('should return singular "hour" for 3600 seconds', () => {
-      expect(secondsToHoursMinutesSeconds(3600)).toBe('1 hour');
-    });
-
-    test('should return plural "hours" for multiple hours', () => {
-      expect(secondsToHoursMinutesSeconds(7200)).toBe('2 hours');
-    });
-
-    test('should return hours, minutes, and seconds combined', () => {
-      expect(secondsToHoursMinutesSeconds(3661)).toBe('1 hour, 1 minute, 1 second');
-    });
-
-    test('should return hours and minutes combined (no seconds)', () => {
-      expect(secondsToHoursMinutesSeconds(3660)).toBe('1 hour, 1 minute');
-    });
-
-    test('should return hours and seconds combined (no minutes)', () => {
-      expect(secondsToHoursMinutesSeconds(3601)).toBe('1 hour, 1 second');
-    });
-
-    test('should handle large values', () => {
-      // 2 hours, 30 minutes, 45 seconds
-      expect(secondsToHoursMinutesSeconds(9045)).toBe('2 hours, 30 minutes, 45 seconds');
-    });
-
-    test('should return input directly if not a number', () => {
-      expect(secondsToHoursMinutesSeconds('not a number')).toBe('not a number');
-      expect(secondsToHoursMinutesSeconds(undefined)).toBe(undefined);
-      // Note: null coerces to 0 via isNaN(null) === false, so returns "0 seconds"
-      expect(secondsToHoursMinutesSeconds(null)).toBe('0 seconds');
-    });
-
-    test('should handle NaN', () => {
-      expect(secondsToHoursMinutesSeconds(NaN)).toBe(NaN);
-    });
-
-    test('should handle negative numbers', () => {
-      // Negative numbers are technically invalid but should be handled gracefully
-      // Current implementation treats them as numbers and processes them
-      const result = secondsToHoursMinutesSeconds(-60);
-      // -60 / 3600 = -0.016... floors to -1 hour
-      // The behavior with negatives is implementation-defined
-      expect(typeof result).toBe('string');
-    });
-
-    test('should handle floating point numbers', () => {
-      // 90.5 seconds = 1 minute + remainder; decimal seconds are preserved
-      expect(secondsToHoursMinutesSeconds(90.5)).toBe('1 minute, 30.5 seconds');
-    });
-  });
-
-  describe('getMostRecentDate', () => {
-    test('should return 0 for empty array', () => {
-      expect(getMostRecentDate({ allDateValues: [] })).toBe(0);
-    });
-
-    test('should return the single date from single-element array', () => {
-      const date = new Date('2024-01-15').getTime();
-      expect(getMostRecentDate({ allDateValues: [date] })).toBe(date);
-    });
-
-    test('should return the most recent date from multiple dates', () => {
-      const date1 = new Date('2024-01-01').getTime();
-      const date2 = new Date('2024-06-15').getTime();
-      const date3 = new Date('2024-03-10').getTime();
-
-      expect(getMostRecentDate({ allDateValues: [date1, date2, date3] })).toBe(date2);
-    });
-
-    test('should handle numeric timestamps', () => {
-      const timestamps = [1000, 5000, 3000, 2000];
-      expect(getMostRecentDate({ allDateValues: timestamps })).toBe(5000);
-    });
-
-    test('should skip null values', () => {
-      const date1 = new Date('2024-01-01').getTime();
-      const date2 = new Date('2024-06-15').getTime();
-
-      expect(getMostRecentDate({ allDateValues: [date1, null, date2, null] })).toBe(date2);
-    });
-
-    test('should skip undefined values', () => {
-      const date1 = new Date('2024-01-01').getTime();
-      const date2 = new Date('2024-06-15').getTime();
-
-      expect(getMostRecentDate({ allDateValues: [date1, undefined, date2] })).toBe(date2);
-    });
-
-    test('should return 0 for array with only null/undefined values', () => {
-      expect(getMostRecentDate({ allDateValues: [null, undefined, null] })).toBe(0);
-    });
-
-    test('should handle all same dates', () => {
-      const sameDate = new Date('2024-05-01').getTime();
-      expect(getMostRecentDate({ allDateValues: [sameDate, sameDate, sameDate] })).toBe(sameDate);
-    });
-  });
-
-  describe('getMediaReaderLinkByPlatformMediaLink', () => {
-    test('should return null for null input', () => {
-      expect(getMediaReaderLinkByPlatformMediaLink(null)).toBeNull();
-    });
-
-    test('should return null for undefined input', () => {
-      expect(getMediaReaderLinkByPlatformMediaLink(undefined)).toBeNull();
-    });
-
-    test('should return null for empty string', () => {
-      expect(getMediaReaderLinkByPlatformMediaLink('')).toBeNull();
-    });
-
-    test('should return media reader link for valid platform media link', () => {
-      const platformLink = 'https://media.ringcentral.com/restapi/v1.0/account/123/extension/456/message-store/789/content/abc';
-      const result = getMediaReaderLinkByPlatformMediaLink(platformLink);
-
-      expect(result).toBe(`https://ringcentral.github.io/ringcentral-media-reader/?media=${encodeURIComponent(platformLink)}`);
-    });
-
-    test('should properly encode special characters in URL', () => {
-      const platformLink = 'https://media.ringcentral.com/test?param=value&other=123';
-      const result = getMediaReaderLinkByPlatformMediaLink(platformLink);
-
-      expect(result).toContain('https://ringcentral.github.io/ringcentral-media-reader/?media=');
-      expect(result).toContain(encodeURIComponent(platformLink));
-    });
-
-    test('should handle simple URL', () => {
-      const platformLink = 'https://example.com/media.mp3';
-      const result = getMediaReaderLinkByPlatformMediaLink(platformLink);
-
-      expect(result).toBe(`https://ringcentral.github.io/ringcentral-media-reader/?media=${encodeURIComponent(platformLink)}`);
-    });
-
-    test('should handle URL with query parameters', () => {
-      const platformLink = 'https://media.ringcentral.com/file?id=123&type=audio';
-      const result = getMediaReaderLinkByPlatformMediaLink(platformLink);
-
-      expect(result).toContain('ringcentral-media-reader');
-      // Verify the URL is properly encoded
-      expect(result).not.toContain('&type=');
-      expect(result).toContain('%26type%3D');
-    });
-  });
-
-});
-

package/test/mcp/mcpHandler.test.js

@@ -1,73 +0,0 @@
-const { handleMcpRequest } = require('../../mcp/mcpHandler');
-
-function mockResponse() {
-  return {
-    status: jest.fn().mockReturnThis(),
-    json: jest.fn(),
-    end: jest.fn(),
-  };
-}
-
-describe('MCP Handler', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test('tools/list includes output schemas for registered tools', async () => {
-    const req = {
-      body: {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'tools/list',
-      },
-      headers: {},
-    };
-    const res = mockResponse();
-
-    await handleMcpRequest(req, res);
-
-    expect(res.status).toHaveBeenCalledWith(200);
-    const response = res.json.mock.calls[0][0];
-    const getHelp = response.result.tools.find(tool => tool.name === 'getHelp');
-    const getPublicConnectors = response.result.tools.find(tool => tool.name === 'getPublicConnectors');
-
-    expect(getHelp.outputSchema).toEqual(expect.objectContaining({
-      type: 'object',
-      required: ['success', 'data'],
-    }));
-    expect(getPublicConnectors.outputSchema.properties).toHaveProperty('serverUrl');
-  });
-
-  test('tools/call returns structuredContent matching the tool output', async () => {
-    const req = {
-      body: {
-        jsonrpc: '2.0',
-        id: 2,
-        method: 'tools/call',
-        params: {
-          name: 'getHelp',
-          arguments: {},
-        },
-      },
-      headers: {},
-    };
-    const res = mockResponse();
-
-    await handleMcpRequest(req, res);
-
-    expect(res.status).toHaveBeenCalledWith(200);
-    const response = res.json.mock.calls[0][0];
-
-    expect(response.result.structuredContent).toEqual(expect.objectContaining({
-      success: true,
-      data: expect.objectContaining({
-        overview: expect.any(String),
-        steps: expect.any(Array),
-      }),
-    }));
-    expect(response.result.content[0]).toEqual(expect.objectContaining({
-      type: 'text',
-      text: expect.stringContaining('"success": true'),
-    }));
-  });
-});