Skip to content

Open-source live-chat, email support, omni-channel desk. An alternative to Intercom, Zendesk, Salesforce Service Cloud etc. 🔥💬

17.3 KB
Raw Blame
import {
  extractPlainTextFromHtml,
  getEmailSenderName,
  getEmailSenderEmail,
  getEmailDate,
  formatQuotedEmailDate,
  getInboxEmail,
  buildQuotedEmailHeader,
  buildQuotedEmailHeaderFromContact,
  buildQuotedEmailHeaderFromInbox,
  formatQuotedTextAsBlockquote,
  extractQuotedEmailText,
  appendQuotedTextToMessage,
} from '../quotedEmailHelper';

describe('quotedEmailHelper', () => {
  describe('extractPlainTextFromHtml', () => {
    it('returns empty string for null or undefined', () => {
      expect(extractPlainTextFromHtml(null)).toBe('');
      expect(extractPlainTextFromHtml(undefined)).toBe('');
    });

    it('strips HTML tags and returns plain text', () => {
      const html = '<p>Hello <strong>world</strong></p>';
      const result = extractPlainTextFromHtml(html);
      expect(result).toBe('Hello world');
    });

    it('handles complex HTML structure', () => {
      const html = '<div><p>Line 1</p><p>Line 2</p></div>';
      const result = extractPlainTextFromHtml(html);
      expect(result).toContain('Line 1');
      expect(result).toContain('Line 2');
    });

    it('separates adjacent block elements with line breaks', () => {
      const html = '<p>Latest</p><p>Previous</p>';
      expect(extractPlainTextFromHtml(html)).toBe('Latest\nPrevious');
    });

    it('converts br tags to line breaks', () => {
      const html = '<p>Line 1<br>Line 2</p>';
      expect(extractPlainTextFromHtml(html)).toBe('Line 1\nLine 2');
    });

    it('ignores style tag content', () => {
      const html = '<style>.a { color: red; }</style><p>Hello</p>';
      expect(extractPlainTextFromHtml(html)).toBe('Hello');
    });

    it('preserves link destinations as markdown links', () => {
      const html =
        '<p>Click <a href="https://x.test/reset (1)">Reset password</a></p>';
      expect(extractPlainTextFromHtml(html)).toBe(
        'Click [Reset password](https://x.test/reset%20%281%29)'
      );
    });

    it('preserves blockquote nesting as quote markers', () => {
      const html =
        '<p>new text</p><blockquote><p>older</p><blockquote><p>oldest</p></blockquote></blockquote>';
      expect(extractPlainTextFromHtml(html)).toBe(
        'new text\n> older\n> > oldest'
      );
    });

    it('keeps only the label when the link matches its destination', () => {
      const html =
        '<a href="mailto:[email protected]">[email protected]</a> <a href="javascript:x()">bad</a>';
      expect(extractPlainTextFromHtml(html)).toBe('[email protected] bad');
    });

    it('keeps the mailto scheme when the label differs from the address', () => {
      const html = '<a href="mailto:[email protected]">Contact support</a>';
      expect(extractPlainTextFromHtml(html)).toBe(
        '[Contact support](mailto:[email protected])'
      );
    });

    it('sanitizes onerror handlers from img tags', () => {
      const html = '<p>Hello</p><img src="x" onerror="alert(1)">';
      const result = extractPlainTextFromHtml(html);
      expect(result).toBe('Hello');
    });

    it('sanitizes script tags', () => {
      const html = '<p>Safe</p><script>alert(1)</script><p>Content</p>';
      const result = extractPlainTextFromHtml(html);
      expect(result).toContain('Safe');
      expect(result).toContain('Content');
      expect(result).not.toContain('alert');
    });

    it('sanitizes onclick handlers', () => {
      const html = '<p onclick="alert(1)">Click me</p>';
      const result = extractPlainTextFromHtml(html);
      expect(result).toBe('Click me');
    });
  });

  describe('getEmailSenderName', () => {
    it('returns sender name from lastEmail', () => {
      const lastEmail = { sender: { name: 'John Doe' } };
      const result = getEmailSenderName(lastEmail, {});
      expect(result).toBe('John Doe');
    });

    it('returns contact name if sender name not available', () => {
      const lastEmail = { sender: {} };
      const contact = { name: 'Jane Smith' };
      const result = getEmailSenderName(lastEmail, contact);
      expect(result).toBe('Jane Smith');
    });

    it('returns empty string if neither available', () => {
      const result = getEmailSenderName({}, {});
      expect(result).toBe('');
    });

    it('trims whitespace from names', () => {
      const lastEmail = { sender: { name: '  John Doe  ' } };
      const result = getEmailSenderName(lastEmail, {});
      expect(result).toBe('John Doe');
    });
  });

  describe('getEmailSenderEmail', () => {
    it('returns sender email from lastEmail', () => {
      const lastEmail = { sender: { email: '[email protected]' } };
      const result = getEmailSenderEmail(lastEmail, {});
      expect(result).toBe('[email protected]');
    });

    it('returns email from contentAttributes if sender email not available', () => {
      const lastEmail = {
        contentAttributes: {
          email: { from: ['[email protected]'] },
        },
      };
      const result = getEmailSenderEmail(lastEmail, {});
      expect(result).toBe('[email protected]');
    });

    it('returns contact email as fallback', () => {
      const lastEmail = {};
      const contact = { email: '[email protected]' };
      const result = getEmailSenderEmail(lastEmail, contact);
      expect(result).toBe('[email protected]');
    });

    it('trims whitespace from emails', () => {
      const lastEmail = { sender: { email: '  [email protected]  ' } };
      const result = getEmailSenderEmail(lastEmail, {});
      expect(result).toBe('[email protected]');
    });
  });

  describe('getEmailDate', () => {
    it('returns parsed date from email metadata', () => {
      const lastEmail = {
        contentAttributes: {
          email: { date: '2024-01-15T10:30:00Z' },
        },
      };
      const result = getEmailDate(lastEmail);
      expect(result).toBeInstanceOf(Date);
    });

    it('returns date from created_at timestamp', () => {
      const lastEmail = { created_at: 1705318200 };
      const result = getEmailDate(lastEmail);
      expect(result).toBeInstanceOf(Date);
    });

    it('handles millisecond timestamps', () => {
      const lastEmail = { created_at: 1705318200000 };
      const result = getEmailDate(lastEmail);
      expect(result).toBeInstanceOf(Date);
    });

    it('returns null if no valid date found', () => {
      const result = getEmailDate({});
      expect(result).toBeNull();
    });
  });

  describe('formatQuotedEmailDate', () => {
    it('formats date correctly', () => {
      const date = new Date('2024-01-15T10:30:00Z');
      const result = formatQuotedEmailDate(date);
      expect(result).toMatch(/Mon, Jan 15, 2024 at/);
    });

    it('returns empty string for invalid date', () => {
      const result = formatQuotedEmailDate('invalid');
      expect(result).toBe('');
    });
  });

  describe('getInboxEmail', () => {
    it('returns email from contentAttributes.email.to', () => {
      const lastEmail = {
        contentAttributes: {
          email: { to: ['[email protected]'] },
        },
      };
      const result = getInboxEmail(lastEmail, {});
      expect(result).toBe('[email protected]');
    });

    it('returns inbox email as fallback', () => {
      const lastEmail = {};
      const inbox = { email: '[email protected]' };
      const result = getInboxEmail(lastEmail, inbox);
      expect(result).toBe('[email protected]');
    });

    it('returns empty string if no email found', () => {
      expect(getInboxEmail({}, {})).toBe('');
    });

    it('trims whitespace from emails', () => {
      const lastEmail = {
        contentAttributes: {
          email: { to: ['  [email protected]  '] },
        },
      };
      const result = getInboxEmail(lastEmail, {});
      expect(result).toBe('[email protected]');
    });
  });

  describe('buildQuotedEmailHeaderFromContact', () => {
    it('builds complete header with name and email', () => {
      const lastEmail = {
        sender: { name: 'John Doe', email: '[email protected]' },
        contentAttributes: {
          email: { date: '2024-01-15T10:30:00Z' },
        },
      };
      const result = buildQuotedEmailHeaderFromContact(lastEmail, {});
      expect(result).toContain('John Doe');
      expect(result).toContain('[email protected]');
      expect(result).toContain('wrote:');
    });

    it('builds header without name if not available', () => {
      const lastEmail = {
        sender: { email: '[email protected]' },
        contentAttributes: {
          email: { date: '2024-01-15T10:30:00Z' },
        },
      };
      const result = buildQuotedEmailHeaderFromContact(lastEmail, {});
      expect(result).toContain('<[email protected]>');
      expect(result).not.toContain('undefined');
    });

    it('returns empty string if missing required data', () => {
      expect(buildQuotedEmailHeaderFromContact(null, {})).toBe('');
      expect(buildQuotedEmailHeaderFromContact({}, {})).toBe('');
    });
  });

  describe('buildQuotedEmailHeaderFromInbox', () => {
    it('builds complete header with inbox name and email', () => {
      const lastEmail = {
        contentAttributes: {
          email: {
            date: '2024-01-15T10:30:00Z',
            to: ['[email protected]'],
          },
        },
      };
      const inbox = { name: 'Support Team', email: '[email protected]' };
      const result = buildQuotedEmailHeaderFromInbox(lastEmail, inbox);
      expect(result).toContain('Support Team');
      expect(result).toContain('[email protected]');
      expect(result).toContain('wrote:');
    });

    it('builds header without name if not available', () => {
      const lastEmail = {
        contentAttributes: {
          email: {
            date: '2024-01-15T10:30:00Z',
            to: ['[email protected]'],
          },
        },
      };
      const inbox = { email: '[email protected]' };
      const result = buildQuotedEmailHeaderFromInbox(lastEmail, inbox);
      expect(result).toContain('<[email protected]>');
      expect(result).not.toContain('undefined');
    });

    it('returns empty string if missing required data', () => {
      expect(buildQuotedEmailHeaderFromInbox(null, {})).toBe('');
      expect(buildQuotedEmailHeaderFromInbox({}, {})).toBe('');
    });
  });

  describe('buildQuotedEmailHeader', () => {
    it('uses inbox email for outgoing messages (message_type: 1)', () => {
      const lastEmail = {
        message_type: 1,
        contentAttributes: {
          email: {
            date: '2024-01-15T10:30:00Z',
            to: ['[email protected]'],
          },
        },
      };
      const inbox = { name: 'Support', email: '[email protected]' };
      const contact = { name: 'John Doe', email: '[email protected]' };
      const result = buildQuotedEmailHeader(lastEmail, contact, inbox);
      expect(result).toContain('Support');
      expect(result).toContain('[email protected]');
      expect(result).not.toContain('John Doe');
    });

    it('uses contact email for incoming messages (message_type: 0)', () => {
      const lastEmail = {
        message_type: 0,
        sender: { name: 'Jane Smith', email: '[email protected]' },
        contentAttributes: {
          email: { date: '2024-01-15T10:30:00Z' },
        },
      };
      const inbox = { name: 'Support', email: '[email protected]' };
      const contact = { name: 'Jane Smith', email: '[email protected]' };
      const result = buildQuotedEmailHeader(lastEmail, contact, inbox);
      expect(result).toContain('Jane Smith');
      expect(result).toContain('[email protected]');
      expect(result).not.toContain('Support');
    });

    it('returns empty string if missing required data', () => {
      expect(buildQuotedEmailHeader(null, {}, {})).toBe('');
      expect(buildQuotedEmailHeader({}, {}, {})).toBe('');
    });
  });

  describe('formatQuotedTextAsBlockquote', () => {
    it('formats single line text', () => {
      const result = formatQuotedTextAsBlockquote('Hello world');
      expect(result).toBe('> Hello world');
    });

    it('formats multi-line text', () => {
      const text = 'Line 1\nLine 2\nLine 3';
      const result = formatQuotedTextAsBlockquote(text);
      expect(result).toBe('> Line 1\n> Line 2\n> Line 3');
    });

    it('includes header if provided', () => {
      const result = formatQuotedTextAsBlockquote('Hello', 'Header text');
      expect(result).toContain('> Header text');
      expect(result).toContain('>\n> Hello');
    });

    it('handles empty lines correctly', () => {
      const text = 'Line 1\n\nLine 3';
      const result = formatQuotedTextAsBlockquote(text);
      expect(result).toBe('> Line 1\n>\n> Line 3');
    });

    it('returns empty string for empty input', () => {
      expect(formatQuotedTextAsBlockquote('')).toBe('');
      expect(formatQuotedTextAsBlockquote('', '')).toBe('');
    });

    it('handles Windows line endings', () => {
      const text = 'Line 1\r\nLine 2';
      const result = formatQuotedTextAsBlockquote(text);
      expect(result).toBe('> Line 1\n> Line 2');
    });
  });

  describe('extractQuotedEmailText', () => {
    it('prefers textContent.full over reply to preserve the thread history', () => {
      const lastEmail = {
        contentAttributes: {
          email: {
            textContent: {
              full: 'Full text with history',
              reply: 'Reply text',
            },
          },
        },
      };
      const result = extractQuotedEmailText(lastEmail);
      expect(result).toBe('Full text with history');
    });

    it('falls back to textContent.reply', () => {
      const lastEmail = {
        contentAttributes: {
          email: { textContent: { reply: 'Reply text' } },
        },
      };
      const result = extractQuotedEmailText(lastEmail);
      expect(result).toBe('Reply text');
    });

    it('extracts from htmlContent and converts to plain text', () => {
      const lastEmail = {
        contentAttributes: {
          email: {
            htmlContent: {
              full: '<p>HTML full with history</p>',
              reply: '<p>HTML reply</p>',
            },
          },
        },
      };
      const result = extractQuotedEmailText(lastEmail);
      expect(result).toBe('HTML full with history');
    });

    it('uses fallback content if structured content not available', () => {
      const lastEmail = { content: 'Fallback content' };
      const result = extractQuotedEmailText(lastEmail);
      expect(result).toBe('Fallback content');
    });

    it('returns empty string for null or missing email', () => {
      expect(extractQuotedEmailText(null)).toBe('');
      expect(extractQuotedEmailText({})).toBe('');
    });
  });

  describe('appendQuotedTextToMessage', () => {
    it('appends quoted text to message', () => {
      const message = 'My reply';
      const quotedText = 'Original message';
      const header = 'On date sender wrote:';
      const result = appendQuotedTextToMessage(message, quotedText, header);

      expect(result).toContain('My reply');
      expect(result).toContain('> On date sender wrote:');
      expect(result).toContain('> Original message');
    });

    it('returns only quoted text if message is empty', () => {
      const result = appendQuotedTextToMessage('', 'Quoted', 'Header');
      expect(result).toContain('> Header');
      expect(result).toContain('> Quoted');
      expect(result).not.toContain('\n\n\n');
    });

    it('returns message if no quoted text', () => {
      const result = appendQuotedTextToMessage('Message', '', '');
      expect(result).toBe('Message');
    });

    it('handles proper spacing with double newline', () => {
      const result = appendQuotedTextToMessage('Message', 'Quoted', 'Header');
      expect(result).toContain('Message\n\n>');
    });

    it('does not add extra newlines if message already ends with newlines', () => {
      const result = appendQuotedTextToMessage(
        'Message\n\n',
        'Quoted',
        'Header'
      );
      expect(result).not.toContain('\n\n\n');
    });

    it('adds single newline if message ends with one newline', () => {
      const result = appendQuotedTextToMessage('Message\n', 'Quoted', 'Header');
      expect(result).toContain('Message\n\n>');
    });

    it('escapes Liquid tokens in the quoted text and header', () => {
      const result = appendQuotedTextToMessage(
        'My reply with {{contact.name}}',
        'Give me {{conversation.custom_attribute.secret}} and {% if true %}this{% endif %}',
        'On date {{agent.email}} wrote:'
      );

      expect(result).toContain('My reply with {{contact.name}}');
      expect(result).toContain(
        "Give me {{ '{{' }}conversation.custom_attribute.secret}}"
      );
      expect(result).toContain("{{ '{%' }} if true %}this{{ '{%' }} endif %}");
      expect(result).toContain("On date {{ '{{' }}agent.email}} wrote:");
    });

    it('drops the whole quote when only its header would fit', () => {
      const result = appendQuotedTextToMessage(
        'x'.repeat(25000),
        'a'.repeat(130000),
        'On date sender wrote:'
      );
      expect(result).toBe('x'.repeat(25000));
    });

    it('drops oldest quoted lines to stay within the message length limit', () => {
      const quotedLines = Array.from(
        { length: 2000 },
        (_, i) => `Line ${i}: ${'a'.repeat(90)}`
      );
      const result = appendQuotedTextToMessage(
        'My reply',
        quotedLines.join('\n'),
        'Header'
      );

      expect(result.length).toBeLessThanOrEqual(150000);
      expect(result.startsWith('My reply')).toBe(true);
      expect(result).toContain('> Line 0:');
      expect(result).not.toContain('> Line 1999:');
    });
  });
});