snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/hooks/useAppSlashCommands.spec.ts

@@ -0,0 +1,285 @@
+import type { SlashCommand } from '@rocket.chat/core-typings';
+import { mockAppRoot, type StreamControllerRef } from '@rocket.chat/mock-providers';
+import { QueryClient } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+
+import { useAppSlashCommands } from './useAppSlashCommands';
+import { appsQueryKeys } from '../lib/queryKeys';
+import { slashCommands } from '../lib/slashCommand';
+
+const mockSlashCommands: SlashCommand[] = [
+	{
+		command: '/test',
+		description: 'Test command',
+		params: 'param1 param2',
+		clientOnly: false,
+		providesPreview: false,
+		appId: 'test-app-1',
+		permission: undefined,
+	},
+	{
+		command: '/weather',
+		description: 'Get weather information',
+		params: 'city',
+		clientOnly: false,
+		providesPreview: true,
+		appId: 'weather-app',
+		permission: undefined,
+	},
+];
+
+const mockApiResponse = {
+	commands: mockSlashCommands,
+	total: mockSlashCommands.length,
+	appsLoaded: true,
+};
+
+describe('useAppSlashCommands', () => {
+	let mockGetSlashCommands: jest.Mock;
+	let queryClient: QueryClient;
+
+	beforeEach(() => {
+		mockGetSlashCommands = jest.fn().mockResolvedValue(mockApiResponse);
+		queryClient = new QueryClient({
+			defaultOptions: {
+				queries: { retry: false },
+				mutations: { retry: false },
+			},
+		});
+
+		jest.spyOn(queryClient, 'invalidateQueries');
+
+		slashCommands.commands = {};
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should not fetch data when user ID is not available', () => {
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot().withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands).build(),
+		});
+
+		expect(mockGetSlashCommands).not.toHaveBeenCalled();
+		expect(slashCommands.commands).toEqual({});
+	});
+
+	it('should fetch slash commands when user ID is available', async () => {
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot().withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands).withJohnDoe().build(),
+		});
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+	});
+
+	it('should handle command/removed event by invalidating queries', async () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot()
+				.withJohnDoe()
+				.withQueryClient(queryClient)
+				.withStream('apps', streamRef)
+				.withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands)
+				.build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+
+		streamRef.controller?.emit('apps', [['command/removed', ['/test']]]);
+
+		expect(slashCommands.commands['/test']).toBeUndefined();
+
+		await waitFor(() => {
+			expect(queryClient.invalidateQueries).toHaveBeenCalledWith(expect.objectContaining({ queryKey: appsQueryKeys.slashCommands() }));
+		});
+	});
+
+	it('should handle command/disabled event by invalidating queries', async () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot()
+				.withJohnDoe()
+				.withQueryClient(queryClient)
+				.withStream('apps', streamRef)
+				.withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands)
+				.build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+
+		streamRef.controller?.emit('apps', [['command/disabled', ['/test']]]);
+
+		expect(slashCommands.commands['/test']).toBeUndefined();
+
+		await waitFor(() => {
+			expect(queryClient.invalidateQueries).toHaveBeenCalledWith(expect.objectContaining({ queryKey: appsQueryKeys.slashCommands() }));
+		});
+	});
+
+	it('should handle command/added event by invalidating queries', async () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot()
+				.withJohnDoe()
+				.withStream('apps', streamRef)
+				.withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands)
+				.build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+
+		mockGetSlashCommands.mockResolvedValue({
+			commands: [
+				...mockSlashCommands,
+				{
+					command: '/newcommand',
+					description: 'New command',
+					params: 'param1 param2',
+					clientOnly: false,
+				},
+			],
+			total: mockSlashCommands.length + 1,
+			appsLoaded: true,
+		});
+
+		streamRef.controller?.emit('apps', [['command/added', ['/newcommand']]]);
+
+		await waitFor(() => {
+			expect(slashCommands.commands['/newcommand']).toBeDefined();
+		});
+
+		expect(slashCommands.commands['/test']).toBeDefined();
+		expect(slashCommands.commands['/weather']).toBeDefined();
+	});
+
+	it('should handle command/updated event by invalidating queries', async () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot()
+				.withJohnDoe()
+				.withQueryClient(queryClient)
+				.withStream('apps', streamRef)
+				.withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands)
+				.build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+
+		streamRef.controller?.emit('apps', [['command/updated', ['/test']]]);
+
+		await waitFor(() => {
+			expect(queryClient.invalidateQueries).toHaveBeenCalledWith(expect.objectContaining({ queryKey: appsQueryKeys.slashCommands() }));
+		});
+
+		expect(slashCommands.commands['/test']).toBeDefined();
+		expect(slashCommands.commands['/weather']).toBeDefined();
+	});
+
+	it('should ignore events that do not start with command/', async () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot()
+				.withJohnDoe()
+				.withQueryClient(queryClient)
+				.withStream('apps', streamRef)
+				.withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands)
+				.build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(mockSlashCommands.length);
+		});
+
+		// @ts-expect-error - testing invalid event
+		streamRef.controller?.emit('apps', [['some/random/event', ['/test']]]);
+
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		expect(queryClient.invalidateQueries).not.toHaveBeenCalled();
+	});
+
+	it('should not set up stream listener when user ID is not available', () => {
+		const streamRef: StreamControllerRef<'apps'> = {};
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot().withStream('apps', streamRef).build(),
+		});
+
+		expect(streamRef.controller).toBeDefined();
+		expect(streamRef.controller?.has('apps')).toBe(false);
+	});
+
+	it('should fetch all commands in batches if total exceeds count', async () => {
+		const largeMockCommands: SlashCommand[] = Array.from({ length: 120 }, (_, i) => ({
+			command: `/command${i + 1}`,
+			description: `Description for command ${i + 1}`,
+			params: '',
+			clientOnly: false,
+			providesPreview: false,
+			appId: `app-${i + 1}`,
+			permission: undefined,
+		}));
+
+		mockGetSlashCommands.mockImplementation(({ offset, count }) => {
+			return Promise.resolve({
+				commands: largeMockCommands.slice(offset, offset + count),
+				total: largeMockCommands.length,
+				appsLoaded: true,
+			});
+		});
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot().withJohnDoe().withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands).build(),
+		});
+
+		await waitFor(() => {
+			expect(Object.keys(slashCommands.commands)).toHaveLength(largeMockCommands.length);
+		});
+	});
+
+	it('should not load commands when apps are not loaded', async () => {
+		mockGetSlashCommands.mockResolvedValue({
+			commands: [],
+			total: 0,
+			appsLoaded: false,
+		});
+
+		expect(Object.keys(slashCommands.commands)).toHaveLength(0);
+
+		renderHook(() => useAppSlashCommands(), {
+			wrapper: mockAppRoot().withJohnDoe().withEndpoint('GET', '/v1/commands.list', mockGetSlashCommands).build(),
+		});
+
+		await waitFor(() => {
+			expect(mockGetSlashCommands).toHaveBeenCalled();
+		});
+
+		expect(Object.keys(slashCommands.commands)).toHaveLength(0);
+	});
+});