upstream-rocketchat/apps/meteor/client/lib/utils/normalizeMessagePreview/getMessagePreview.spec.ts

import type { TFunction } from 'i18next';

import { getMessagePreview } from './getMessagePreview';
import { normalizeMessagePreview } from './normalizeMessagePreview';
import { createFakeSubscription, createFakeMessage } from '../../../../tests/mocks/data';

jest.mock('./normalizeMessagePreview');

const mockNormalizeMessagePreview = normalizeMessagePreview as jest.MockedFunction<typeof normalizeMessagePreview>;

describe('getMessagePreview', () => {
	const mockT = jest.fn((key: string) => key) as unknown as TFunction;

	beforeEach(() => {
		jest.clearAllMocks();
		mockNormalizeMessagePreview.mockReturnValue('normalized message');
	});

	describe('when room has a draft', () => {
		it('should return "Draft: content" taking precedence over the last message', () => {
			const room = createFakeSubscription({ draft: 'unfinished text' });
			const message = createFakeMessage();

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Draft: unfinished text');
			expect(mockT).toHaveBeenCalledWith('Draft');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});

		it('should escape HTML in the draft content', () => {
			const room = createFakeSubscription({ draft: '<img src=x onerror=alert(1)>' });

			const result = getMessagePreview(room, undefined, mockT);

			expect(result).toBe('Draft: &lt;img src=x onerror=alert(1)&gt;');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});

		it('should fall back to a thread-composer draft when there is no main draft', () => {
			const room = createFakeSubscription({ draft: undefined, threadDrafts: { 'thread-id': 'unfinished thread reply' } });
			const message = createFakeMessage();

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Draft: unfinished thread reply');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});

		it('should prefer the main draft over thread-composer drafts', () => {
			const room = createFakeSubscription({ draft: 'main draft', threadDrafts: { 'thread-id': 'thread draft' } });

			const result = getMessagePreview(room, undefined, mockT);

			expect(result).toBe('Draft: main draft');
		});
	});

	describe('when lastMessage is undefined', () => {
		it('should return translation for No_messages_yet', () => {
			const room = createFakeSubscription();
			const result = getMessagePreview(room, undefined, mockT);

			expect(result).toBe('No_messages_yet');
			expect(mockT).toHaveBeenCalledWith('No_messages_yet');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});
	});

	describe('when message is a video conference message', () => {
		it('should return translation for Call_started', () => {
			const room = createFakeSubscription();
			const message = createFakeMessage({ t: 'videoconf' });
			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Call_started');
			expect(mockT).toHaveBeenCalledWith('Call_started');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});
	});

	describe('when message is E2EE', () => {
		it('should return encrypted message preview when e2e is not done', () => {
			const room = createFakeSubscription();
			const message = createFakeMessage({ t: 'e2e', e2e: 'pending' });
			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Encrypted_message_preview_unavailable');
			expect(mockT).toHaveBeenCalledWith('Encrypted_message_preview_unavailable');
			expect(mockNormalizeMessagePreview).not.toHaveBeenCalled();
		});

		it('should proceed to normalization when e2e is done', () => {
			const room = createFakeSubscription({ t: 'c' });
			const message = createFakeMessage({ t: 'e2e', e2e: 'done', u: { _id: 'user-id', username: 'testuser', name: 'Test User' } });
			mockNormalizeMessagePreview.mockReturnValue('decrypted message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Test User: decrypted message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});

	describe('when message has no user', () => {
		it('should return normalized message directly', () => {
			const room = createFakeSubscription();
			const message = createFakeMessage({ u: undefined });
			mockNormalizeMessagePreview.mockReturnValue('normalized message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('normalized message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});

	describe('when message is from current user', () => {
		it('should return "You: normalized message" when usernames match', () => {
			const room = createFakeSubscription({ u: { _id: 'user-id', username: 'testuser', name: 'Test User' } });
			const message = createFakeMessage({ u: { _id: 'user-id', username: 'testuser', name: 'Test User' } });
			mockNormalizeMessagePreview.mockReturnValue('my message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('You: my message');
			expect(mockT).toHaveBeenCalledWith('You');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});

	describe('when room is a direct message room', () => {
		it('should return normalized message without sender name for single DM', () => {
			const room = createFakeSubscription({
				t: 'd',
				uids: ['user1', 'user2'],
			});
			const message = createFakeMessage({
				u: { _id: 'other-user-id', username: 'otheruser', name: 'Other User' },
			});
			mockNormalizeMessagePreview.mockReturnValue('direct message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('direct message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});

		it('should return sender name and message for multiple DM', () => {
			const room = createFakeSubscription({
				t: 'd',
				uids: ['user1', 'user2', 'user3'],
			});
			const message = createFakeMessage({
				u: { _id: 'other-user-id', username: 'otheruser', name: 'Other User' },
			});
			mockNormalizeMessagePreview.mockReturnValue('group message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Other User: group message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});

	describe('when room is a group or channel', () => {
		it('should return sender name and message when user has name', () => {
			const room = createFakeSubscription({ t: 'c' });
			const message = createFakeMessage({
				u: { _id: 'other-user-id', username: 'otheruser', name: 'Other User' },
			});
			mockNormalizeMessagePreview.mockReturnValue('channel message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('Other User: channel message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});

		it('should return username and message when user has no name', () => {
			const room = createFakeSubscription({ t: 'p' });
			const message = createFakeMessage({
				u: { _id: 'other-user-id', username: 'otheruser' },
			});
			mockNormalizeMessagePreview.mockReturnValue('private message');

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('otheruser: private message');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});

	describe('when message has no preview', () => {
		it('should return empty string', () => {
			const room = createFakeSubscription();
			const message = createFakeMessage();
			mockNormalizeMessagePreview.mockReturnValue(undefined);

			const result = getMessagePreview(room, message, mockT);

			expect(result).toBe('');
			expect(mockNormalizeMessagePreview).toHaveBeenCalledWith(message, mockT);
		});
	});
});