/**
* mysql-mcp - Progress Reporter Unit Tests
*
* Tests for ProgressReporter and ProgressReporterFactory functionality
* including progress notifications, completion states, and error handling.
*/
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { ProgressReporter } from "../ProgressReporter.js";
describe("ProgressReporter", () => {
let mockServer: {
server: {
notification: ReturnType<typeof vi.fn>;
};
};
beforeEach(() => {
vi.clearAllMocks();
mockServer = {
server: {
notification: vi.fn(),
},
};
});
describe("Construction", () => {
it("should create reporter with token", () => {
const reporter = new ProgressReporter(mockServer as never, "token-123");
expect(reporter.getToken()).toBe("token-123");
});
it("should accept numeric token", () => {
const reporter = new ProgressReporter(mockServer as never, 42);
expect(reporter.getToken()).toBe(42);
});
it("should start in active state", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
expect(reporter.isActive()).toBe(true);
});
});
describe("report()", () => {
it("should send progress notification", () => {
const reporter = new ProgressReporter(mockServer as never, "token-123");
reporter.report(50, 100, "Processing...");
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: {
progressToken: "token-123",
progress: 50,
total: 100,
message: "Processing...",
},
});
});
it("should work without total", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.report(25);
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: expect.objectContaining({
progress: 25,
total: undefined,
}),
});
});
it("should work without message", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.report(75, 100);
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: expect.objectContaining({
progress: 75,
total: 100,
message: undefined,
}),
});
});
it("should not report after completion", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.complete();
mockServer.server.notification.mockClear();
reporter.report(50);
expect(mockServer.server.notification).not.toHaveBeenCalled();
});
});
describe("complete()", () => {
it("should send completion notification with default message", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.complete();
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: {
progressToken: "token",
progress: 1,
total: 1,
message: "Complete",
},
});
});
it("should send completion notification with custom message", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.complete("All done!");
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: expect.objectContaining({
message: "All done!",
}),
});
});
it("should set reporter to inactive", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
expect(reporter.isActive()).toBe(true);
reporter.complete();
expect(reporter.isActive()).toBe(false);
});
it("should only complete once", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.complete("First");
reporter.complete("Second");
expect(mockServer.server.notification).toHaveBeenCalledTimes(1);
});
});
describe("error()", () => {
it("should send error notification", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.error("Something went wrong");
expect(mockServer.server.notification).toHaveBeenCalledWith({
method: "notifications/progress",
params: {
progressToken: "token",
progress: 0,
message: "Error: Something went wrong",
},
});
});
it("should set reporter to inactive", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.error("Failed");
expect(reporter.isActive()).toBe(false);
});
it("should not error after completion", () => {
const reporter = new ProgressReporter(mockServer as never, "token");
reporter.complete();
mockServer.server.notification.mockClear();
reporter.error("Should not send");
expect(mockServer.server.notification).not.toHaveBeenCalled();
});
});
describe("Error Handling", () => {
it("should handle notification errors gracefully", () => {
mockServer.server.notification.mockImplementation(() => {
throw new Error("Transport error");
});
const reporter = new ProgressReporter(mockServer as never, "token");
// Should not throw
expect(() => reporter.report(50)).not.toThrow();
expect(() => reporter.complete()).not.toThrow();
});
});
});
describe("ProgressReporterFactory", () => {
let mockServer: {
server: {
notification: ReturnType<typeof vi.fn>;
};
};
beforeEach(() => {
vi.clearAllMocks();
vi.resetModules();
mockServer = {
server: {
notification: vi.fn(),
},
};
});
afterEach(() => {
vi.resetModules();
});
describe("Availability", () => {
it("should report unavailable before server set", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
expect(factory.isAvailable()).toBe(false);
});
it("should report available after server set", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
factory.setServer(mockServer as never);
expect(factory.isAvailable()).toBe(true);
});
});
describe("create()", () => {
it("should return null when no server set", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
const reporter = factory.create("token");
expect(reporter).toBeNull();
});
it("should return null when no token provided", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
factory.setServer(mockServer as never);
const reporter = factory.create(undefined);
expect(reporter).toBeNull();
});
it("should create reporter when server and token available", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
factory.setServer(mockServer as never);
const reporter = factory.create("my-token");
expect(reporter).not.toBeNull();
expect(reporter?.getToken()).toBe("my-token");
});
it("should create functional reporter", async () => {
const { progressFactory: factory } =
await import("../ProgressReporter.js");
factory.setServer(mockServer as never);
const reporter = factory.create("test-token");
reporter?.report(10, 100, "Testing");
expect(mockServer.server.notification).toHaveBeenCalledWith(
expect.objectContaining({
method: "notifications/progress",
}),
);
});
});
});
