EPMRPP-114318 || Add client-side validations and truncation

__tests__/helpers.spec.js

@@ -123,4 +123,215 @@ describe('Helpers', () => {
       expect(fs.open).toHaveBeenCalledWith('rp-launch-uuid-fileOne.tmp', 'w', expect.any(Function));
     });
   });
+
+  describe('cleanBinaryCharacters', () => {
+    it('should return empty string for falsy input', () => {
+      expect(helpers.cleanBinaryCharacters('')).toBe('');
+      expect(helpers.cleanBinaryCharacters(null)).toBe('');
+      expect(helpers.cleanBinaryCharacters(undefined)).toBe('');
+    });
+
+    it('should replace NUL character with replacement char', () => {
+      expect(helpers.cleanBinaryCharacters('hello\x00world')).toBe('hello\uFFFDworld');
+    });
+
+    it('should replace ESC character with replacement char', () => {
+      expect(helpers.cleanBinaryCharacters('test\x1Bvalue')).toBe('test\uFFFDvalue');
+    });
+
+    it('should replace multiple binary characters', () => {
+      const input = '\x00start\x01mid\x1Bend';
+      const result = helpers.cleanBinaryCharacters(input);
+      expect(result).toBe('\uFFFDstart\uFFFDmid\uFFFDend');
+      expect(result).not.toContain('\x00');
+      expect(result).not.toContain('\x01');
+      expect(result).not.toContain('\x1B');
+    });
+
+    it('should not replace normal whitespace characters (tab, newline, carriage return)', () => {
+      const input = 'line1\tindented\nline2\r\nline3';
+      expect(helpers.cleanBinaryCharacters(input)).toBe(input);
+    });
+
+    it('should leave regular text unchanged', () => {
+      expect(helpers.cleanBinaryCharacters('Hello World 123!')).toBe('Hello World 123!');
+    });
+
+    it('should replace all purely binary control characters', () => {
+      const binaryCodes = [
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0b, 0x0c, 0x0e, 0x0f, 0x10,
+        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
+        0x1f, 0x7f,
+      ];
+      const input = binaryCodes.map((c) => String.fromCharCode(c)).join('');
+      const result = helpers.cleanBinaryCharacters(input);
+      expect(result).toBe('\uFFFD'.repeat(binaryCodes.length));
+    });
+
+    it('should replace BS (\\x08) control character', () => {
+      expect(helpers.cleanBinaryCharacters('foo\x08bar')).toBe('foo\uFFFDbar');
+    });
+
+    it('should replace VT (\\x0B) control character', () => {
+      expect(helpers.cleanBinaryCharacters('foo\x0Bbar')).toBe('foo\uFFFDbar');
+    });
+
+    it('should replace FF (\\x0C) control character', () => {
+      expect(helpers.cleanBinaryCharacters('foo\x0Cbar')).toBe('foo\uFFFDbar');
+    });
+
+    it('should replace SO..SI and DLE (\\x0E-\\x10) control characters', () => {
+      const input = 'a\x0Eb\x0Fc\x10d';
+      expect(helpers.cleanBinaryCharacters(input)).toBe('a\uFFFDb\uFFFDc\uFFFDd');
+    });
+
+    it('should replace FS..US (\\x1C-\\x1F) control characters', () => {
+      const input = 'a\x1Cb\x1Dc\x1Ed\x1Fe';
+      expect(helpers.cleanBinaryCharacters(input)).toBe('a\uFFFDb\uFFFDc\uFFFDd\uFFFDe');
+    });
+
+    it('should replace DEL (\\x7F) control character', () => {
+      expect(helpers.cleanBinaryCharacters('foo\x7Fbar')).toBe('foo\uFFFDbar');
+    });
+
+    it('should preserve only TAB, LF, CR among C0 whitespace controls', () => {
+      expect(helpers.cleanBinaryCharacters('\t\n\r')).toBe('\t\n\r');
+    });
+  });
+
+  describe('sanitizeField', () => {
+    it('should return null/undefined for null/undefined input', () => {
+      expect(helpers.sanitizeField(null, 256)).toBeNull();
+      expect(helpers.sanitizeField(undefined, 256)).toBeUndefined();
+    });
+
+    it('should return empty string for empty string input', () => {
+      expect(helpers.sanitizeField('', 256)).toBe('');
+    });
+
+    it('should not truncate strings within limit', () => {
+      expect(helpers.sanitizeField('short', 256)).toBe('short');
+    });
+
+    it('should truncate strings exceeding limit with "..." suffix', () => {
+      const input = 'a'.repeat(300);
+      const result = helpers.sanitizeField(input, 256);
+      expect(result.length).toBe(256);
+      expect(result.endsWith('...')).toBe(true);
+    });
+
+    it('should clean binary characters and truncate', () => {
+      const input = 'bad\x00name' + 'n'.repeat(300);
+      const result = helpers.sanitizeField(input, 256);
+      expect(result).not.toContain('\x00');
+      expect(result.length).toBe(256);
+      expect(result.endsWith('...')).toBe(true);
+    });
+
+    it('should skip binary cleanup when replaceBinaryChars is false', () => {
+      const input = 'bad\x00name';
+      const result = helpers.sanitizeField(input, 256, { replaceBinaryChars: false });
+      expect(result).toContain('\x00');
+    });
+
+    it('should skip truncation when truncateFields is false', () => {
+      const input = 'a'.repeat(300);
+      const result = helpers.sanitizeField(input, 256, { truncateFields: false });
+      expect(result.length).toBe(300);
+    });
+
+    it('should handle limit of 0', () => {
+      expect(helpers.sanitizeField('test', 0)).toBe('');
+    });
+
+    it('should handle limit smaller than replacement length', () => {
+      const result = helpers.sanitizeField('a'.repeat(10), 2);
+      expect(result.length).toBe(2);
+    });
+  });
+
+  describe('truncateAttributes', () => {
+    it('should return non-array input unchanged', () => {
+      expect(helpers.truncateAttributes(null)).toBeNull();
+      expect(helpers.truncateAttributes(undefined)).toBeUndefined();
+    });
+
+    it('should filter out non-object entries', () => {
+      const result = helpers.truncateAttributes(['string', 123, { key: 'k', value: 'v' }]);
+      expect(result).toEqual([{ key: 'k', value: 'v' }]);
+    });
+
+    it('should truncate attribute keys longer than 128 chars', () => {
+      const longKey = 'k'.repeat(140);
+      const result = helpers.truncateAttributes([{ key: longKey, value: 'v' }]);
+      expect(result[0].key.length).toBe(128);
+      expect(result[0].key.endsWith('...')).toBe(true);
+    });
+
+    it('should truncate attribute values longer than 128 chars', () => {
+      const longValue = 'v'.repeat(140);
+      const result = helpers.truncateAttributes([{ key: 'k', value: longValue }]);
+      expect(result[0].value.length).toBe(128);
+      expect(result[0].value.endsWith('...')).toBe(true);
+    });
+
+    it('should not truncate attributes within limit', () => {
+      const result = helpers.truncateAttributes([{ key: 'k'.repeat(128), value: 'v'.repeat(128) }]);
+      expect(result[0].key.length).toBe(128);
+      expect(result[0].value.length).toBe(128);
+    });
+
+    it('should preserve system attribute flag', () => {
+      const result = helpers.truncateAttributes([{ key: 'k', value: 'v', system: true }]);
+      expect(result[0].system).toBe(true);
+    });
+
+    it('should limit attributes to 256 entries sorted by key', () => {
+      const attributes = [];
+      for (let i = 0; i < 300; i++) {
+        attributes.push({ key: `k${i.toString().padStart(3, '0')}`, value: 'v' });
+      }
+      const result = helpers.truncateAttributes(attributes);
+      expect(result.length).toBe(256);
+      expect(result[0].key).toBe('k000');
+      expect(result[255].key).toBe('k255');
+    });
+
+    it('should clean binary characters in attribute keys and values', () => {
+      const result = helpers.truncateAttributes([{ key: 'a\x00key', value: 'v\x1Balue' }]);
+      expect(result[0].key).not.toContain('\x00');
+      expect(result[0].value).not.toContain('\x1B');
+      expect(result[0].key).toContain('\uFFFD');
+      expect(result[0].value).toContain('\uFFFD');
+    });
+
+    it('should skip binary cleanup when replaceBinaryChars is false', () => {
+      const result = helpers.truncateAttributes([{ key: 'a\x00key', value: 'v\x1Balue' }], {
+        replaceBinaryChars: false,
+      });
+      expect(result[0].key).toContain('\x00');
+      expect(result[0].value).toContain('\x1B');
+    });
+
+    it('should skip length truncation when truncateAttributes is false', () => {
+      const longValue = 'v'.repeat(200);
+      const result = helpers.truncateAttributes([{ key: 'k', value: longValue }], {
+        truncateAttributes: false,
+      });
+      expect(result[0].value.length).toBe(200);
+    });
+
+    it('should filter attributes without a value when truncation is enabled', () => {
+      const result = helpers.truncateAttributes([
+        { key: 'k1', value: 'v1' },
+        { key: 'k2' },
+      ]);
+      expect(result.length).toBe(1);
+      expect(result[0].key).toBe('k1');
+    });
+
+    it('should return empty array for empty input', () => {
+      expect(helpers.truncateAttributes([])).toEqual([]);
+    });
+  });
 });