import { describe, it, expect, jest } from '@jest/globals';
import { createProgressReporter } from '../../src/services/progress.js';
import type { ProgressReporter } from '../../src/services/progress.js';
describe('createProgressReporter', () => {
it('should return a disabled no-op reporter when progressToken is undefined', () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter(undefined, sendNotification);
expect(reporter.enabled).toBe(false);
});
it('should not call sendNotification when progressToken is undefined', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter(undefined, sendNotification);
await reporter.report(1, 10, 'test');
expect(sendNotification).not.toHaveBeenCalled();
});
it('should return an enabled reporter when progressToken is a string', () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter('token-123', sendNotification);
expect(reporter.enabled).toBe(true);
});
it('should return an enabled reporter when progressToken is a number', () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter(42, sendNotification);
expect(reporter.enabled).toBe(true);
});
it('should send a progress notification with correct method and params', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter('my-token', sendNotification);
await reporter.report(3, 10, 'Processing step 3');
expect(sendNotification).toHaveBeenCalledTimes(1);
expect(sendNotification).toHaveBeenCalledWith({
method: 'notifications/progress',
params: {
progressToken: 'my-token',
progress: 3,
total: 10,
message: 'Processing step 3',
},
});
});
it('should omit message field when message is undefined', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter('tok', sendNotification);
await reporter.report(1, 5);
expect(sendNotification).toHaveBeenCalledWith({
method: 'notifications/progress',
params: {
progressToken: 'tok',
progress: 1,
total: 5,
},
});
});
it('should send multiple progress notifications for successive reports', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter('tok', sendNotification);
await reporter.report(1, 3, 'A done');
await reporter.report(2, 3, 'B done');
await reporter.report(3, 3, 'C done');
expect(sendNotification).toHaveBeenCalledTimes(3);
// Verify increasing progress values
const calls = sendNotification.mock.calls as unknown as Array<[{ params: { progress: number } }]>;
expect(calls[0][0].params.progress).toBe(1);
expect(calls[1][0].params.progress).toBe(2);
expect(calls[2][0].params.progress).toBe(3);
});
it('should use a numeric progressToken correctly', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
const reporter = createProgressReporter(99, sendNotification);
await reporter.report(1, 1);
expect(sendNotification).toHaveBeenCalledWith({
method: 'notifications/progress',
params: {
progressToken: 99,
progress: 1,
total: 1,
},
});
});
it('should swallow sendNotification errors without throwing', async () => {
const sendNotification = jest.fn<() => Promise<void>>().mockRejectedValue(new Error('client disconnected'));
const reporter = createProgressReporter('tok', sendNotification);
// Should NOT throw — progress is best-effort
await expect(reporter.report(1, 5, 'step')).resolves.toBeUndefined();
expect(sendNotification).toHaveBeenCalledTimes(1);
});
it('should continue reporting after a notification error', async () => {
const sendNotification = jest.fn<() => Promise<void>>()
.mockRejectedValueOnce(new Error('transient error'))
.mockResolvedValueOnce(undefined);
const reporter = createProgressReporter('tok', sendNotification);
await reporter.report(1, 2, 'first');
await reporter.report(2, 2, 'second');
expect(sendNotification).toHaveBeenCalledTimes(2);
});
});
describe('ProgressReporter interface', () => {
it('should be easy to create a mock for testing tools', async () => {
// This tests the pattern tool tests will use
const mockReporter: ProgressReporter = {
enabled: true,
report: jest.fn<ProgressReporter['report']>().mockResolvedValue(undefined),
};
await mockReporter.report(1, 3, 'step 1');
expect(mockReporter.report).toHaveBeenCalledWith(1, 3, 'step 1');
});
});
