import { type Mock, beforeEach, describe, expect, it, vi } from "vitest";
import type { ConnectionPoolConfig } from "../src/services/ConnectionPool.js";
import { EmailService } from "../src/services/EmailService.js";
import type { LocalCache } from "../src/types/cache.types.js";
import type {
EmailComposition,
EmailFolder,
EmailMessage,
EmailSearchOptions,
ImapConnection,
ImapConnectionWrapper,
} from "../src/types/email.types.js";
// Test helper interface for accessing private methods
interface TestableEmailService extends EmailService {
isConnectionError(error: unknown): boolean;
getDefaultFolders(): EmailFolder[];
formatAddressesForHeader(
addresses: Array<{ name?: string; address: string }>,
): string;
buildEmailContent(composition: EmailComposition): string;
tryGetStaleCache<T>(key: string): T | null;
clearFolderCache(folder: string): void;
parseAddressesFromEnvelope(
addresses: unknown,
): Array<{ name?: string; address: string }>;
parseAddressesFromParsed(
addresses: unknown,
): Array<{ name?: string; address: string }>;
}
// Mock factories
const createMockCache = (): LocalCache => ({
get: vi.fn(),
getStale: vi.fn(),
set: vi.fn(),
delete: vi.fn(),
clear: vi.fn(),
cleanup: vi.fn(),
has: vi.fn(),
size: vi.fn(),
destroy: vi.fn(),
getStats: vi.fn(),
cleanupWithStaleRetention: vi.fn(),
});
const createMockConnection = (
overrides: Partial<ImapConnection> = {},
): ImapConnection => ({
user: "test@example.com",
password: "password",
host: "imap.example.com",
port: 993,
secure: true,
...overrides,
});
const createMockConnectionWrapper = (
overrides: Partial<ImapConnectionWrapper> = {},
): ImapConnectionWrapper => ({
connection: {
mailboxOpen: vi.fn(),
messageMove: vi.fn(),
messageFlagsAdd: vi.fn(),
messageFlagsRemove: vi.fn(),
append: vi.fn(),
mailboxCreate: vi.fn(),
list: vi.fn(),
} as any,
folder: "INBOX",
...overrides,
});
// Mock IMAP functions
const mockConnect = vi.fn();
const mockLogout = vi.fn();
const mockMailboxOpen = vi.fn();
const mockMessageMove = vi.fn();
const mockMessageFlagsAdd = vi.fn();
const mockMessageFlagsRemove = vi.fn();
const mockAppend = vi.fn();
const mockMailboxCreate = vi.fn();
const mockList = vi.fn();
// Mock the imapflow module
vi.mock("imapflow", () => {
return {
ImapFlow: vi.fn(function () {
return {
connect: mockConnect,
logout: mockLogout,
mailboxOpen: mockMailboxOpen,
messageMove: mockMessageMove,
messageFlagsAdd: mockMessageFlagsAdd,
messageFlagsRemove: mockMessageFlagsRemove,
append: mockAppend,
mailboxCreate: mockMailboxCreate,
list: mockList,
on: vi.fn(),
};
}),
};
});
// Mock OfflineService
const mockOfflineService = {
getOfflineCapabilities: vi.fn(),
searchEmailsOffline: vi.fn(),
getEmailOffline: vi.fn(),
getFoldersOffline: vi.fn(),
};
vi.mock("../src/services/OfflineService.js", () => ({
OfflineService: vi.fn(function () {
return mockOfflineService;
}),
}));
// Mock ImapConnectionPool
const mockPool = {
acquire: vi.fn(),
acquireForFolder: vi.fn(),
release: vi.fn(),
releaseFromFolder: vi.fn(),
invalidateFolderConnections: vi.fn(),
getImapMetrics: vi.fn(),
getMetrics: vi.fn(),
};
vi.mock("../src/services/ImapConnectionPool.js", () => ({
ImapConnectionPool: vi.fn(function () {
return mockPool;
}),
}));
// Mock Logger
const mockLogger = {
info: vi.fn(),
warning: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
};
vi.mock("../src/services/Logger.js", () => ({
createLogger: vi.fn(function () {
return mockLogger;
}),
}));
describe("EmailService - Advanced Coverage", () => {
let service: TestableEmailService;
let mockCache: LocalCache;
let mockImapConnection: ImapConnection;
let poolConfig: ConnectionPoolConfig;
beforeEach(() => {
vi.clearAllMocks();
mockCache = createMockCache();
mockImapConnection = createMockConnection();
poolConfig = {
minConnections: 1,
maxConnections: 5,
acquireTimeoutMs: 5000,
idleTimeoutMs: 30000,
};
service = new EmailService(
mockImapConnection,
poolConfig,
mockCache,
) as TestableEmailService;
// Reset mock implementations
mockPool.getMetrics.mockReturnValue({
totalConnections: 2,
activeConnections: 1,
idleConnections: 1,
totalErrors: 0,
});
});
describe("isConnectionError", () => {
it("should return false for non-Error objects", () => {
expect(service.isConnectionError("string error")).toBe(false);
expect(service.isConnectionError(null)).toBe(false);
expect(service.isConnectionError(undefined)).toBe(false);
expect(service.isConnectionError(42)).toBe(false);
expect(service.isConnectionError({})).toBe(false);
});
it("should return true for error with 'connection' in message", () => {
const error = new Error("Connection failed");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return true for error with 'timeout' in message", () => {
const error = new Error("Request timeout");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return true for error with 'econnreset' in message", () => {
const error = new Error("Network error: ECONNRESET");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return true for error with 'enotfound' in message", () => {
const error = new Error("Host ENOTFOUND");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return true for error with 'econnrefused' in message", () => {
const error = new Error("ECONNREFUSED by server");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return true for error with 'circuit breaker is open' in message", () => {
const error = new Error("Circuit breaker is open");
expect(service.isConnectionError(error)).toBe(true);
});
it("should return false for other error messages", () => {
const error = new Error("Invalid credentials");
expect(service.isConnectionError(error)).toBe(false);
});
it("should be case insensitive", () => {
const error = new Error("CONNECTION FAILED");
expect(service.isConnectionError(error)).toBe(true);
});
});
describe("getDefaultFolders", () => {
it("should return standard IMAP folders", () => {
const folders = service.getDefaultFolders();
expect(folders).toHaveLength(4);
expect(folders.map(f => f.name)).toEqual([
"INBOX",
"Sent",
"Drafts",
"Trash",
]);
});
it("should have correct special use flags", () => {
const folders = service.getDefaultFolders();
const folderMap = Object.fromEntries(
folders.map(f => [f.name, f.specialUse]),
);
expect(folderMap.INBOX).toBeUndefined();
expect(folderMap.Sent).toBe("\\Sent");
expect(folderMap.Drafts).toBe("\\Drafts");
expect(folderMap.Trash).toBe("\\Trash");
});
it("should use standard delimiter", () => {
const folders = service.getDefaultFolders();
for (const folder of folders) {
expect(folder.delimiter).toBe("/");
expect(folder.flags).toEqual([]);
}
});
});
describe("formatAddressesForHeader", () => {
it("should format addresses with names", () => {
const addresses = [
{ name: "John Doe", address: "john@example.com" },
{ name: "Jane Smith", address: "jane@example.com" },
];
const result = service.formatAddressesForHeader(addresses);
expect(result).toBe(
'"John Doe" <john@example.com>, "Jane Smith" <jane@example.com>',
);
});
it("should format addresses without names", () => {
const addresses = [
{ address: "john@example.com" },
{ address: "jane@example.com" },
];
const result = service.formatAddressesForHeader(addresses);
expect(result).toBe("john@example.com, jane@example.com");
});
it("should handle mixed addresses with and without names", () => {
const addresses = [
{ name: "John Doe", address: "john@example.com" },
{ address: "jane@example.com" },
];
const result = service.formatAddressesForHeader(addresses);
expect(result).toBe('"John Doe" <john@example.com>, jane@example.com');
});
it("should handle empty array", () => {
const result = service.formatAddressesForHeader([]);
expect(result).toBe("");
});
});
describe("buildEmailContent", () => {
it("should build basic email content with plain text", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Test Subject",
text: "Hello, World!",
};
const content = service.buildEmailContent(composition);
expect(content).toContain("To: recipient@example.com");
expect(content).toContain("Subject: Test Subject");
expect(content).toContain("Content-Type: text/plain; charset=utf-8");
expect(content).toContain("Hello, World!");
});
it("should build email content with HTML", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Test Subject",
html: "<p>Hello, World!</p>",
};
const content = service.buildEmailContent(composition);
expect(content).toContain("Content-Type: text/html; charset=utf-8");
expect(content).toContain("<p>Hello, World!</p>");
});
it("should include CC recipients", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
cc: [{ address: "cc@example.com" }],
subject: "Test Subject",
text: "Test",
};
const content = service.buildEmailContent(composition);
expect(content).toContain("CC: cc@example.com");
});
it("should include BCC recipients", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
bcc: [{ address: "bcc@example.com" }],
subject: "Test Subject",
text: "Test",
};
const content = service.buildEmailContent(composition);
expect(content).toContain("BCC: bcc@example.com");
});
it("should generate Date header", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Test Subject",
text: "Test",
};
const content = service.buildEmailContent(composition);
expect(content).toMatch(/Date: .+/);
});
it("should generate Message-ID header", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Test Subject",
text: "Test",
};
const content = service.buildEmailContent(composition);
expect(content).toMatch(/Message-ID: <.+@mailbox\.org>/);
});
it("should handle empty content", () => {
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Test Subject",
};
const content = service.buildEmailContent(composition);
expect(content).toContain("Subject: Test Subject");
expect(content.endsWith("\r\n\r\n")).toBe(true);
});
});
describe("tryGetStaleCache", () => {
it("should return stale cache data when available", () => {
const staleData = { value: "stale" };
const mockGetStale = vi.fn().mockReturnValue(staleData);
(service as any).cache.getStale = mockGetStale;
const result = service.tryGetStaleCache<typeof staleData>("test-key");
expect(result).toEqual(staleData);
expect(mockGetStale).toHaveBeenCalledWith("test-key");
});
it("should return null when no stale data available", () => {
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.getStale = mockGetStale;
const result = service.tryGetStaleCache<any>("test-key");
expect(result).toBeNull();
});
});
describe("clearFolderCache", () => {
it("should clear cache entries matching folder pattern", () => {
const mockHas = vi.fn();
const mockDelete = vi.fn();
// Mock cache.has to return Map-like iterator
mockHas.mockReturnValue(true);
mockCache.has = mockHas;
mockCache.delete = mockDelete;
// We need to mock the internal cache keys iteration
// This is a bit tricky since we don't have direct access to internal cache
// For now, we'll just verify the method can be called without error
service.clearFolderCache("INBOX");
// The method should execute without throwing
expect(true).toBe(true);
});
it("should handle cache without has() method", () => {
// Create cache without has method
const cacheWithoutHas = { ...mockCache };
delete (cacheWithoutHas as any).has;
// Should not throw
expect(() => service.clearFolderCache("INBOX")).not.toThrow();
});
});
describe("delegation methods", () => {
describe("getPoolMetrics", () => {
it("should delegate to pool.getImapMetrics()", () => {
const metrics = {
folderDistribution: { INBOX: 2 },
circuitBreakerState: "closed" as const,
};
mockPool.getImapMetrics.mockReturnValue(metrics);
const result = service.getPoolMetrics();
expect(result).toEqual(metrics);
expect(mockPool.getImapMetrics).toHaveBeenCalledTimes(1);
});
});
describe("getOfflineCapabilities", () => {
it("should delegate to offlineService", () => {
const capabilities = {
searchOffline: true,
getEmailOffline: true,
getFoldersOffline: true,
};
mockOfflineService.getOfflineCapabilities.mockReturnValue(capabilities);
const result = service.getOfflineCapabilities();
expect(result).toEqual(capabilities);
expect(mockOfflineService.getOfflineCapabilities).toHaveBeenCalledTimes(
1,
);
});
});
describe("searchEmailsOffline", () => {
it("should delegate to offlineService with correct options", async () => {
const options: EmailSearchOptions = {
folder: "INBOX",
query: "test",
};
const results: EmailMessage[] = [
{
id: "msg-1",
uid: 1,
subject: "Test",
from: [{ address: "test@example.com" }],
to: [{ address: "recipient@example.com" }],
date: new Date(),
flags: [],
folder: "INBOX",
},
];
mockOfflineService.searchEmailsOffline.mockResolvedValue(results);
const result = await service.searchEmailsOffline(options);
expect(result).toEqual(results);
expect(mockOfflineService.searchEmailsOffline).toHaveBeenCalledWith(
options,
);
});
});
describe("getEmailOffline", () => {
it("should fetch email by UID from offline cache", async () => {
const email: EmailMessage = {
id: "msg-1",
uid: 123,
subject: "Test",
from: [{ address: "test@example.com" }],
to: [{ address: "recipient@example.com" }],
date: new Date(),
flags: [],
folder: "INBOX",
};
mockOfflineService.getEmailOffline.mockResolvedValue(email);
const result = await service.getEmailOffline(123, "INBOX");
expect(result).toEqual(email);
expect(mockOfflineService.getEmailOffline).toHaveBeenCalledWith(
123,
"INBOX",
);
});
it("should return null if not found", async () => {
mockOfflineService.getEmailOffline.mockResolvedValue(null);
const result = await service.getEmailOffline(999);
expect(result).toBeNull();
});
});
describe("getFoldersOffline", () => {
it("should return offline folder list", async () => {
const folders: EmailFolder[] = [
{
name: "INBOX",
path: "INBOX",
delimiter: "/",
flags: [],
},
];
mockOfflineService.getFoldersOffline.mockResolvedValue(folders);
const result = await service.getFoldersOffline();
expect(result).toEqual(folders);
expect(mockOfflineService.getFoldersOffline).toHaveBeenCalledTimes(1);
});
});
});
describe("validatePoolHealth", () => {
it("should return true for healthy pool", async () => {
mockPool.getMetrics.mockReturnValue({
totalConnections: 3,
activeConnections: 1,
idleConnections: 2,
totalErrors: 1,
});
const result = await service.validatePoolHealth();
expect(result).toBe(true);
});
it("should return false when errors >= connections", async () => {
mockPool.getMetrics.mockReturnValue({
totalConnections: 2,
activeConnections: 1,
idleConnections: 1,
totalErrors: 2,
});
const result = await service.validatePoolHealth();
expect(result).toBe(false);
});
it("should return false when no connections exist", async () => {
mockPool.getMetrics.mockReturnValue({
totalConnections: 0,
activeConnections: 0,
idleConnections: 0,
totalErrors: 0,
});
const result = await service.validatePoolHealth();
expect(result).toBe(false);
});
it("should return false and log error on exception", async () => {
mockPool.getMetrics.mockImplementation(() => {
throw new Error("Pool error");
});
const result = await service.validatePoolHealth();
expect(result).toBe(false);
expect(mockLogger.error).toHaveBeenCalledWith(
"Error checking pool health",
expect.objectContaining({
operation: "isHealthy",
service: "EmailService",
}),
expect.objectContaining({
error: "Pool error",
}),
);
});
});
// PHASE 2: Core IMAP Operations
describe("moveEmail", () => {
it("should move email successfully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
mockPool.invalidateFolderConnections.mockResolvedValue(undefined);
const result = await service.moveEmail(123, "INBOX", "Archive");
expect(result.success).toBe(true);
expect(result.message).toContain("moved from INBOX to Archive");
expect(mockWrapper.connection.messageMove).toHaveBeenCalledWith(
"123:123",
"Archive",
{ uid: true },
);
expect(mockPool.invalidateFolderConnections).toHaveBeenCalledWith(
"INBOX",
);
expect(mockPool.invalidateFolderConnections).toHaveBeenCalledWith(
"Archive",
);
});
it("should clear cache for both source and destination folders", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
// Spy on clearFolderCache
const clearSpy = vi.spyOn(service as any, "clearFolderCache");
await service.moveEmail(123, "INBOX", "Archive");
expect(clearSpy).toHaveBeenCalledWith("INBOX");
expect(clearSpy).toHaveBeenCalledWith("Archive");
});
it("should handle move failure and return error result", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageMove = vi
.fn()
.mockRejectedValue(new Error("Move failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.moveEmail(123, "INBOX", "Archive");
expect(result.success).toBe(false);
expect(result.message).toContain("Failed to move email");
expect(mockLogger.error).toHaveBeenCalled();
});
it("should release connection even on error", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageMove = vi
.fn()
.mockRejectedValue(new Error("Move failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
await service.moveEmail(123, "INBOX", "Archive");
expect(mockPool.releaseFromFolder).toHaveBeenCalledWith(mockWrapper);
});
});
describe("markEmail", () => {
it("should add flags successfully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.markEmail(123, "INBOX", ["\\Seen"], "add");
expect(result.success).toBe(true);
expect(mockWrapper.connection.messageFlagsAdd).toHaveBeenCalledWith(
"123:123",
["\\Seen"],
{ uid: true },
);
});
it("should remove flags successfully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.markEmail(
123,
"INBOX",
["\\Flagged"],
"remove",
);
expect(result.success).toBe(true);
expect(mockWrapper.connection.messageFlagsRemove).toHaveBeenCalledWith(
"123:123",
["\\Flagged"],
{ uid: true },
);
});
it("should clear cache after flag change", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
const clearSpy = vi.spyOn(service as any, "clearFolderCache");
await service.markEmail(123, "INBOX", ["\\Seen"], "add");
expect(clearSpy).toHaveBeenCalledWith("INBOX");
});
it("should handle errors gracefully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageFlagsAdd = vi
.fn()
.mockRejectedValue(new Error("Flag operation failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.markEmail(123, "INBOX", ["\\Seen"], "add");
expect(result.success).toBe(false);
expect(result.message).toContain("Failed to mark email");
expect(mockLogger.error).toHaveBeenCalled();
});
it("should handle multiple flags at once", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
await service.markEmail(
123,
"INBOX",
["\\Seen", "\\Flagged", "\\Important"],
"add",
);
expect(mockWrapper.connection.messageFlagsAdd).toHaveBeenCalledWith(
"123:123",
["\\Seen", "\\Flagged", "\\Important"],
{ uid: true },
);
});
});
describe("deleteEmail", () => {
it("should permanently delete email with \\Deleted flag", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.deleteEmail(123, "INBOX", true);
expect(result.success).toBe(true);
expect(result.message).toBe("Email permanently deleted");
expect(mockWrapper.connection.messageFlagsAdd).toHaveBeenCalledWith(
"123:123",
["\\Deleted"],
{ uid: true },
);
});
it("should move to Trash folder for soft delete", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.deleteEmail(123, "INBOX", false);
expect(result.success).toBe(true);
expect(result.message).toBe("Email moved to trash");
expect(mockWrapper.connection.messageMove).toHaveBeenCalledWith(
"123:123",
"Trash",
{ uid: true },
);
});
it("should try alternative trash folder names if Trash doesn't exist", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageMove = vi
.fn()
.mockRejectedValueOnce(new Error("Trash not found"))
.mockResolvedValueOnce(undefined); // Succeeds on "Deleted Items"
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.deleteEmail(123, "INBOX", false);
expect(result.success).toBe(true);
expect(mockWrapper.connection.messageMove).toHaveBeenCalledTimes(2);
expect(mockWrapper.connection.messageMove).toHaveBeenNthCalledWith(
1,
"123:123",
"Trash",
{ uid: true },
);
expect(mockWrapper.connection.messageMove).toHaveBeenNthCalledWith(
2,
"123:123",
"Deleted Items",
{ uid: true },
);
});
it("should mark as deleted if no trash folder found", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageMove = vi
.fn()
.mockRejectedValue(new Error("No trash folder"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.deleteEmail(123, "INBOX", false);
expect(result.success).toBe(true);
// Should have tried: Trash, Deleted Items, Deleted, INBOX.Trash (4 attempts)
// Then add \\Deleted flag as fallback
expect(mockWrapper.connection.messageFlagsAdd).toHaveBeenCalledWith(
"123:123",
["\\Deleted"],
{ uid: true },
);
});
it("should clear cache after deletion", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
const clearSpy = vi.spyOn(service as any, "clearFolderCache");
await service.deleteEmail(123, "INBOX", true);
expect(clearSpy).toHaveBeenCalledWith("INBOX");
});
it("should handle errors and return failure result", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.messageFlagsAdd = vi
.fn()
.mockRejectedValue(new Error("Delete failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const result = await service.deleteEmail(123, "INBOX", true);
expect(result.success).toBe(false);
expect(result.message).toContain("Failed to delete email");
expect(mockLogger.error).toHaveBeenCalled();
});
});
describe("createDraft", () => {
it("should create draft with plain text in default Drafts folder", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi.fn().mockResolvedValue({ uid: 456 });
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
const result = await service.createDraft(composition);
expect(result.success).toBe(true);
expect(result.uid).toBe(456);
const appendCall = mockWrapper.connection.append.mock.calls[0];
expect(appendCall[0]).toBe("Drafts");
expect(appendCall[1]).toContain("Draft Subject");
expect(appendCall[1]).toContain("Draft content");
expect(appendCall[2]).toEqual(["\\Draft"]);
});
it("should create draft with HTML content", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi.fn().mockResolvedValue({ uid: 456 });
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
html: "<p>HTML content</p>",
};
const result = await service.createDraft(composition);
expect(result.success).toBe(true);
const appendCall = mockWrapper.connection.append.mock.calls[0];
expect(appendCall[1]).toContain("Content-Type: text/html");
expect(appendCall[1]).toContain("<p>HTML content</p>");
});
it("should create draft in custom folder", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi.fn().mockResolvedValue({ uid: 456 });
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
await service.createDraft(composition, "Custom Drafts");
const appendCall = mockWrapper.connection.append.mock.calls[0];
expect(appendCall[0]).toBe("Custom Drafts");
expect(appendCall[2]).toEqual(["\\Draft"]);
});
it("should include CC and BCC recipients", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi.fn().mockResolvedValue({ uid: 456 });
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "to@example.com" }],
cc: [{ address: "cc@example.com" }],
bcc: [{ address: "bcc@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
await service.createDraft(composition);
const appendCall = mockWrapper.connection.append.mock.calls[0];
expect(appendCall[1]).toContain("CC: cc@example.com");
expect(appendCall[1]).toContain("BCC: bcc@example.com");
});
it("should clear cache after creating draft", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi.fn().mockResolvedValue({ uid: 456 });
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
const clearSpy = vi.spyOn(service as any, "clearFolderCache");
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
await service.createDraft(composition);
expect(clearSpy).toHaveBeenCalledWith("Drafts");
});
it("should handle errors gracefully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi
.fn()
.mockRejectedValue(new Error("Append failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
const result = await service.createDraft(composition);
expect(result.success).toBe(false);
expect(result.message).toContain("Failed to create draft");
expect(mockLogger.error).toHaveBeenCalled();
});
it("should release connection even on error", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.append = vi
.fn()
.mockRejectedValue(new Error("Append failed"));
mockPool.acquireForFolder.mockResolvedValue(mockWrapper);
mockPool.releaseFromFolder.mockResolvedValue(undefined);
const composition: EmailComposition = {
to: [{ address: "recipient@example.com" }],
subject: "Draft Subject",
text: "Draft content",
};
await service.createDraft(composition);
expect(mockPool.releaseFromFolder).toHaveBeenCalledWith(mockWrapper);
});
});
// PHASE 3: Folder & Cache Management
describe("getFolders", () => {
it("should return cached folders when available", async () => {
const cachedFolders: EmailFolder[] = [
{ name: "INBOX", path: "INBOX", delimiter: "/", flags: [] },
];
const mockGet = vi.fn().mockReturnValue(cachedFolders);
(service as any).cache.get = mockGet;
const result = await service.getFolders();
expect(result).toEqual(cachedFolders);
expect(mockGet).toHaveBeenCalledWith("email_folders");
expect(mockPool.acquire).not.toHaveBeenCalled();
});
it("should fetch folders from IMAP when not cached", async () => {
const mockGet = vi.fn().mockReturnValue(null);
const mockSet = vi.fn();
(service as any).cache.get = mockGet;
(service as any).cache.set = mockSet;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi.fn().mockResolvedValue([
{
name: "INBOX",
path: "INBOX",
delimiter: "/",
flags: ["\\NoSelect"],
specialUse: undefined,
},
{
name: "Sent",
path: "Sent",
delimiter: "/",
flags: [],
specialUse: "\\Sent",
},
]);
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.getFolders();
expect(result).toHaveLength(2);
expect(result[0].name).toBe("INBOX");
expect(result[1].name).toBe("Sent");
expect(mockSet).toHaveBeenCalledWith("email_folders", result, 900000);
});
it("should handle non-array flags gracefully", async () => {
const mockGet = vi.fn().mockReturnValue(null);
const mockSet = vi.fn();
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
(service as any).cache.set = mockSet;
(service as any).cache.getStale = mockGetStale;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi.fn().mockResolvedValue([
{
name: "INBOX",
path: "INBOX",
delimiter: "/",
flags: "not-an-array" as any, // Invalid flags
},
]);
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.getFolders();
expect(result[0].flags).toEqual([]);
});
it("should use default delimiter when none provided", async () => {
const mockGet = vi.fn().mockReturnValue(null);
const mockSet = vi.fn();
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
(service as any).cache.set = mockSet;
(service as any).cache.getStale = mockGetStale;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi.fn().mockResolvedValue([
{
name: "INBOX",
path: "INBOX",
delimiter: null,
},
]);
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.getFolders();
expect(result[0].delimiter).toBe("/");
});
it("should return stale cache on connection error", async () => {
const mockGet = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi
.fn()
.mockRejectedValue(new Error("Connection timeout"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const staleFolders: EmailFolder[] = [
{ name: "INBOX", path: "INBOX", delimiter: "/", flags: [] },
];
const mockGetStale = vi.fn().mockReturnValue(staleFolders);
(service as any).cache.getStale = mockGetStale;
const result = await service.getFolders();
expect(result).toEqual(staleFolders);
expect(mockLogger.warning).toHaveBeenCalledWith(
"Returning stale cached folders due to connection failure",
expect.any(Object),
expect.any(Object),
);
});
it("should return default folders on connection error without cache", async () => {
const mockGet = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi
.fn()
.mockRejectedValue(new Error("Connection timeout"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.getStale = mockGetStale;
const result = await service.getFolders();
expect(result).toHaveLength(4); // INBOX, Sent, Drafts, Trash
expect(result.map(f => f.name)).toEqual([
"INBOX",
"Sent",
"Drafts",
"Trash",
]);
expect(mockLogger.warning).toHaveBeenCalledWith(
"Returning default folders due to connection failure",
expect.any(Object),
);
});
it("should throw non-connection errors", async () => {
const mockGet = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi
.fn()
.mockRejectedValue(new Error("Invalid credentials"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.getStale = mockGetStale;
await expect(service.getFolders()).rejects.toThrow("Invalid credentials");
});
it("should release connection even on error", async () => {
const mockGet = vi.fn().mockReturnValue(null);
(service as any).cache.get = mockGet;
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.list = vi
.fn()
.mockRejectedValue(new Error("Invalid credentials"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const mockGetStale = vi.fn().mockReturnValue(null);
(service as any).cache.getStale = mockGetStale;
try {
await service.getFolders();
} catch (error) {
// Expected
}
expect(mockPool.release).toHaveBeenCalledWith(mockWrapper);
});
});
describe("createDirectory", () => {
it("should create top-level folder", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.createDirectory("NewFolder");
expect(result.success).toBe(true);
expect(result.message).toContain("NewFolder");
expect(mockWrapper.connection.mailboxCreate).toHaveBeenCalledWith(
"NewFolder",
);
});
it("should create nested folder with parent path", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.createDirectory("SubFolder", "INBOX");
expect(result.success).toBe(true);
expect(mockWrapper.connection.mailboxCreate).toHaveBeenCalledWith(
"INBOX/SubFolder",
);
});
it("should use standard delimiter", async () => {
const mockWrapper = createMockConnectionWrapper();
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
await service.createDirectory("SubFolder", "Parent/Nested");
expect(mockWrapper.connection.mailboxCreate).toHaveBeenCalledWith(
"Parent/Nested/SubFolder",
);
});
it("should handle errors gracefully", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.mailboxCreate = vi
.fn()
.mockRejectedValue(new Error("Folder already exists"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
const result = await service.createDirectory("Existing");
expect(result.success).toBe(false);
expect(result.message).toContain("Failed to create directory");
expect(mockLogger.error).toHaveBeenCalled();
});
it("should release connection even on error", async () => {
const mockWrapper = createMockConnectionWrapper();
mockWrapper.connection.mailboxCreate = vi
.fn()
.mockRejectedValue(new Error("Folder already exists"));
mockPool.acquire.mockResolvedValue(mockWrapper);
mockPool.release.mockResolvedValue(undefined);
await service.createDirectory("Existing");
expect(mockPool.release).toHaveBeenCalledWith(mockWrapper);
});
});
describe("parseAddressesFromParsed - branch coverage", () => {
it.each([
["null addresses", null, []],
["undefined addresses", undefined, []],
[
"array of addresses",
[
{ name: "Alice Brown", address: "alice@example.com" },
{ name: "Bob Wilson", address: "bob@example.com" },
],
[
{ name: "Alice Brown", address: "alice@example.com" },
{ name: "Bob Wilson", address: "bob@example.com" },
],
],
[
"single address object with name",
{ name: "Alice Brown", address: "alice@example.com" },
[{ name: "Alice Brown", address: "alice@example.com" }],
],
[
"single address object without name",
{ address: "alice@example.com" },
[{ name: undefined, address: "alice@example.com" }],
],
[
"single address object without address field",
{ name: "Alice Brown" },
[],
],
["empty array", [], []],
])(
"should parse %s",
(
_description: string,
input: unknown,
expected: Array<{ name?: string; address: string }>,
) => {
const testableService = service as TestableEmailService;
const result = testableService.parseAddressesFromParsed(input);
expect(result).toEqual(expected);
},
);
});
});
