claude-code/src/utils/__tests__/queueProcessor.test.ts

import { afterEach, beforeEach, describe, expect, test } from 'bun:test'

import {
	resetCommandQueue,
	enqueue,
	enqueuePendingNotification,
} from '../messageQueueManager.js'
import { hasQueuedCommands, processQueueIfReady } from '../queueProcessor.js'

beforeEach(() => {
	resetCommandQueue()
})

afterEach(() => {
	resetCommandQueue()
})

describe('processQueueIfReady', () => {
	test('returns processed:false when queue empty', () => {
		const result = processQueueIfReady({
			executeInput: async () => {},
		})
		expect(result.processed).toBe(false)
	})

	test('processes single slash command individually', () => {
		const executed: string[][] = []
		enqueue({ value: '/help', mode: 'prompt' } as any)

		const result = processQueueIfReady({
			executeInput: async cmds => {
				executed.push(cmds.map(c => c.value as string))
			},
		})

		expect(result.processed).toBe(true)
		expect(executed).toHaveLength(1)
		expect(executed[0]).toEqual(['/help'])
	})

	test('processes bash mode command individually', () => {
		const executed: string[][] = []
		enqueue({ value: 'git status', mode: 'bash' } as any)

		const result = processQueueIfReady({
			executeInput: async cmds => {
				executed.push(cmds.map(c => c.value as string))
			},
		})

		expect(result.processed).toBe(true)
		expect(executed).toHaveLength(1)
		expect(executed[0]).toEqual(['git status'])
	})

	test('batches commands with same mode', () => {
		const executed: string[][] = []
		enqueuePendingNotification({ value: '<task1/>', mode: 'task-notification' } as any)
		enqueuePendingNotification({ value: '<task2/>', mode: 'task-notification' } as any)

		const result = processQueueIfReady({
			executeInput: async cmds => {
				executed.push(cmds.map(c => c.value as string))
			},
		})

		expect(result.processed).toBe(true)
		expect(executed).toHaveLength(1)
		expect(executed[0]).toEqual(['<task1/>', '<task2/>'])
	})

	test('does not mix different modes in same batch', () => {
		const executed: string[][] = []
		enqueue({ value: 'hello', mode: 'prompt' } as any)
		enqueuePendingNotification({ value: '<task/>', mode: 'task-notification' } as any)

		const result = processQueueIfReady({
			executeInput: async cmds => {
				executed.push(cmds.map(c => c.value as string))
			},
		})

		expect(result.processed).toBe(true)
		// Only the 'prompt' mode command should be processed (higher priority than task-notification)
		expect(executed).toHaveLength(1)
		expect(executed[0]).toEqual(['hello'])

		// The task-notification is still in queue
		expect(hasQueuedCommands()).toBe(true)
	})

	test('skips commands with agentId set (subagent notifications)', () => {
		// This simulates the v2.1.119 fix: subagent task-notification with agentId
		// should not be processed by the main thread queue processor
		enqueuePendingNotification({
			value: '<task-notification>subagent result</task-notification>',
			mode: 'task-notification',
			agentId: 'agent-123',
		} as any)

		const result = processQueueIfReady({
			executeInput: async () => {},
		})

		// Should not process — it's a subagent notification
		expect(result.processed).toBe(false)
	})

	test('returns processed:false when only subagent commands in queue', () => {
		enqueuePendingNotification({
			value: '<task-notification/>',
			mode: 'task-notification',
			agentId: 'agent-456',
		} as any)
		enqueuePendingNotification({
			value: '<task-notification/>',
			mode: 'task-notification',
			agentId: 'agent-789',
		} as any)

		const result = processQueueIfReady({
			executeInput: async () => {},
		})

		expect(result.processed).toBe(false)
		expect(hasQueuedCommands()).toBe(true)
	})

	test('processes main-thread command but skips subagent command', () => {
		const executed: string[][] = []
		enqueuePendingNotification({ value: '<main-task/>', mode: 'task-notification' } as any)
		enqueuePendingNotification({
			value: '<sub-task/>',
			mode: 'task-notification',
			agentId: 'agent-123',
		} as any)

		const result = processQueueIfReady({
			executeInput: async cmds => {
				executed.push(cmds.map(c => c.value as string))
			},
		})

		expect(result.processed).toBe(true)
		expect(executed).toHaveLength(1)
		expect(executed[0]).toEqual(['<main-task/>'])

		// Subagent command still in queue
		expect(hasQueuedCommands()).toBe(true)
	})
})

describe('hasQueuedCommands', () => {
	test('returns false when queue empty', () => {
		expect(hasQueuedCommands()).toBe(false)
	})

	test('returns true when commands in queue', () => {
		enqueue({ value: 'hello', mode: 'prompt' } as any)
		expect(hasQueuedCommands()).toBe(true)
	})
})