@remit/mailbox-service 0.0.111 → 0.0.112

package/src/flag-push-terminal.test.ts

@@ -1,209 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	IMessageRepository,
-	IThreadMessageRepository,
-} from "@remit/data-ports";
-import type { FlagPushLogger } from "./flag-push.js";
-import {
-	type ResolveExhaustedFlagPushDeps,
-	resolveExhaustedFlagPushFailure,
-} from "./flag-push-terminal.js";
-import type { IImapConnection } from "./types.js";
-
-interface LogEntry {
-	obj: Record<string, unknown>;
-	msg: string;
-}
-
-const buildLogger = (): {
-	log: FlagPushLogger;
-	infos: LogEntry[];
-	errors: LogEntry[];
-} => {
-	const infos: LogEntry[] = [];
-	const errors: LogEntry[] = [];
-	return {
-		log: {
-			info: (obj, msg) => infos.push({ obj, msg }),
-			error: (obj, msg) => errors.push({ obj, msg }),
-		},
-		infos,
-		errors,
-	};
-};
-
-const buildConnection = (
-	present: Set<number>,
-	fetchDrops: Set<number> = new Set(),
-): IImapConnection =>
-	({
-		openBox: async () => ({}) as never,
-		fetchMessages: async (uids: number[]) =>
-			uids
-				.filter((uid) => present.has(uid) && !fetchDrops.has(uid))
-				.map((uid) => ({ uid }) as unknown as never),
-		search: async (criteria: unknown[]) => {
-			const [, value] = (criteria as Array<[string, string]>)[0];
-			const uid = Number(value);
-			return present.has(uid) ? [uid] : [];
-		},
-	}) as unknown as IImapConnection;
-
-describe("resolveExhaustedFlagPushFailure — the two terminal outcomes (mirrors #1289/#1270 for flag pushes)", () => {
-	it("RECONCILED (expected): the message is gone from its mailbox — marker dropped, stale row reconciled, no alarm", async () => {
-		const deletedMessages: string[] = [];
-		const deletedThreadMessages: Array<{
-			accountConfigId: string;
-			threadMessageId: string;
-		}> = [];
-		const markerDeletes: Array<{ messageId: string; flagName: string }> = [];
-		const { log, infos, errors } = buildLogger();
-
-		const deps: ResolveExhaustedFlagPushDeps = {
-			markerService: {
-				delete: async (messageId: string, flagName: string) => {
-					markerDeletes.push({ messageId, flagName });
-				},
-			},
-			messageService: {
-				delete: async (id: string) => {
-					deletedMessages.push(id);
-				},
-			} as unknown as Pick<IMessageRepository, "delete">,
-			threadMessageService: {
-				findAllByMessageId: async (
-					accountConfigId: string,
-					messageId: string,
-				) => [{ accountConfigId, threadMessageId: `tm-${messageId}` }],
-				deleteMany: async (
-					keys: Array<{ accountConfigId: string; threadMessageId: string }>,
-				) => {
-					deletedThreadMessages.push(...keys);
-				},
-			} as unknown as Pick<
-				IThreadMessageRepository,
-				"findAllByMessageId" | "deleteMany"
-			>,
-			log,
-		};
-
-		const result = await resolveExhaustedFlagPushFailure(deps, {
-			accountId: "acc-1",
-			accountConfigId: "cfg-1",
-			messageId: "msg-gone",
-			flagName: "\\Seen",
-			uid: 101,
-			mailboxPath: "INBOX",
-			getConnection: async () => buildConnection(new Set()),
-		});
-
-		assert.equal(result.outcome, "reconciled");
-		assert.deepEqual(markerDeletes, [
-			{ messageId: "msg-gone", flagName: "\\Seen" },
-		]);
-		assert.deepEqual(deletedMessages, ["msg-gone"]);
-		assert.equal(deletedThreadMessages.length, 1);
-
-		assert.equal(errors.length, 0, "reconciled outcome must not log an alert");
-		const metricLog = infos.find(
-			(entry) => entry.obj.metric === "flag_push_stale_row_reconciled",
-		);
-		assert.ok(metricLog, "expected a routine reconciliation metric log");
-	});
-
-	it("a dropped FETCH row is not absence: the message is still in the mailbox — marker and local rows survive", async () => {
-		const markerDeletes: Array<{ messageId: string; flagName: string }> = [];
-		const { log, errors } = buildLogger();
-
-		const deps: ResolveExhaustedFlagPushDeps = {
-			markerService: {
-				delete: async (messageId: string, flagName: string) => {
-					markerDeletes.push({ messageId, flagName });
-				},
-			},
-			messageService: {
-				delete: async () => {
-					throw new Error("must not be called — the message still exists");
-				},
-			} as unknown as Pick<IMessageRepository, "delete">,
-			threadMessageService: {
-				findAllByMessageId: async () => {
-					throw new Error("must not be called — the message still exists");
-				},
-				deleteMany: async () => {
-					throw new Error("must not be called — the message still exists");
-				},
-			} as unknown as Pick<
-				IThreadMessageRepository,
-				"findAllByMessageId" | "deleteMany"
-			>,
-			log,
-		};
-
-		const result = await resolveExhaustedFlagPushFailure(deps, {
-			accountId: "acc-1",
-			accountConfigId: "cfg-1",
-			messageId: "msg-live",
-			flagName: "\\Seen",
-			uid: 303,
-			mailboxPath: "INBOX",
-			getConnection: async () =>
-				buildConnection(new Set([303]), new Set([303])),
-		});
-
-		assert.equal(result.outcome, "broken");
-		assert.deepEqual(markerDeletes, []);
-		assert.ok(errors.some((e) => e.obj.alert === "flag_push_failed"));
-	});
-
-	it("BROKEN (should never happen): the message still exists — marker left in place, alert logged", async () => {
-		const markerDeletes: Array<{ messageId: string; flagName: string }> = [];
-		const { log, errors } = buildLogger();
-
-		const deps: ResolveExhaustedFlagPushDeps = {
-			markerService: {
-				delete: async (messageId: string, flagName: string) => {
-					markerDeletes.push({ messageId, flagName });
-				},
-			},
-			messageService: {
-				delete: async () => {
-					throw new Error("must not be called — message still exists");
-				},
-			} as unknown as Pick<IMessageRepository, "delete">,
-			threadMessageService: {
-				findAllByMessageId: async () => {
-					throw new Error("must not be called — message still exists");
-				},
-				deleteMany: async () => {
-					throw new Error("must not be called — message still exists");
-				},
-			} as unknown as Pick<
-				IThreadMessageRepository,
-				"findAllByMessageId" | "deleteMany"
-			>,
-			log,
-		};
-
-		const result = await resolveExhaustedFlagPushFailure(deps, {
-			accountId: "acc-1",
-			accountConfigId: "cfg-1",
-			messageId: "msg-still-here",
-			flagName: "\\Flagged",
-			uid: 202,
-			mailboxPath: "INBOX",
-			getConnection: async () => buildConnection(new Set([202])),
-		});
-
-		assert.equal(result.outcome, "broken");
-		assert.deepEqual(
-			markerDeletes,
-			[],
-			"marker must be left in place — resync never reverts a pending flag while it is",
-		);
-
-		const alerted = errors.find((e) => e.obj.alert === "flag_push_failed");
-		assert.ok(alerted, "expected an alertable flag_push_failed log");
-	});
-});

package/src/flag-queue-stars.test.ts

@@ -1,171 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import type {
-	IMessageFlagRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	ThreadMessageItem,
-	UpdateThreadMessageInput,
-} from "@remit/data-ports";
-import { MessageSystemFlag } from "@remit/domain-enums";
-import type { FlagPushService } from "./flag-push.js";
-import { FlagQueueService } from "./flag-queue.js";
-
-// #44: `hasStars` is the boolean of record and `star` its presentation colour.
-// The UI's star toggle sends only `isStarred`, so a star that left `star` at
-// the `none` sentinel disagreed with `hasStars` and every read site that
-// consulted the colour rejected the row. The colour now follows the boolean.
-
-const ACCOUNT_CONFIG_ID = "cfg-1";
-const ACCOUNT_ID = "acct-1";
-const MESSAGE_ID = "msg-1";
-const MAILBOX_ID = "mbx-1";
-const THREAD_MESSAGE_ID = "tm-1";
-
-const threadMessage = {
-	threadMessageId: THREAD_MESSAGE_ID,
-	accountConfigId: ACCOUNT_CONFIG_ID,
-	mailboxId: MAILBOX_ID,
-	sentDate: 1,
-	isRead: false,
-	isDeleted: false,
-	hasStars: false,
-	hasAttachment: false,
-} as unknown as ThreadMessageItem;
-
-const buildService = ({
-	alreadyFlagged = false,
-}: {
-	alreadyFlagged?: boolean;
-} = {}): {
-	service: FlagQueueService;
-	updates: UpdateThreadMessageInput[];
-	flips: Array<{ flagName: string; operation: string }>;
-} => {
-	const updates: UpdateThreadMessageInput[] = [];
-	const flips: Array<{ flagName: string; operation: string }> = [];
-
-	const messageService = {
-		get: async () => ({ mailboxId: MAILBOX_ID }) as unknown as MessageItem,
-	} as unknown as IMessageRepository;
-
-	const messageFlagService = {
-		hasFlag: async (_messageId: string, flagName: string) =>
-			flagName === MessageSystemFlag.Flagged ? alreadyFlagged : false,
-		addFlag: async () => {},
-		removeFlag: async () => {},
-	} as unknown as IMessageFlagRepository;
-
-	const threadMessageService = {
-		findAllByMessageId: async () => [threadMessage],
-		update: async (
-			_accountConfigId: string,
-			_threadMessageId: string,
-			input: UpdateThreadMessageInput,
-		) => {
-			updates.push(input);
-			return threadMessage;
-		},
-	} as unknown as IThreadMessageRepository;
-
-	const flagPushService = {
-		flip: async (event: { flagName: string; operation: string }) => {
-			flips.push({ flagName: event.flagName, operation: event.operation });
-		},
-	} as unknown as FlagPushService;
-
-	const service = new FlagQueueService({
-		messageFlagService,
-		messageService,
-		threadMessageService,
-		flagPushService,
-	});
-
-	return { service, updates, flips };
-};
-
-describe("updateFlags keeps hasStars and the star colour in step", () => {
-	test("starring without a colour sets both the boolean and a visible colour", async () => {
-		const { service, updates } = buildService();
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			isStarred: true,
-		});
-
-		assert.deepEqual(updates, [{ hasStars: true, star: "yellow" }]);
-	});
-
-	test("unstarring clears the colour back to the none sentinel", async () => {
-		const { service, updates } = buildService({ alreadyFlagged: true });
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			isStarred: false,
-		});
-
-		assert.deepEqual(updates, [{ hasStars: false, star: "none" }]);
-	});
-
-	test("an explicit colour wins over the default", async () => {
-		const { service, updates } = buildService();
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			isStarred: true,
-			starColor: "red",
-		});
-
-		assert.deepEqual(updates, [{ hasStars: true, star: "red" }]);
-	});
-
-	// A colour-only request is legal on the wire. Before, it wrote the colour
-	// and left `hasStars` alone, so a coloured-but-unstarred row rendered
-	// unstarred, stayed out of Starred, and never pushed \Flagged.
-	test("a colour alone stars the message and pushes the flag", async () => {
-		const { service, updates, flips } = buildService();
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			starColor: "blue",
-		});
-
-		assert.deepEqual(updates, [{ hasStars: true, star: "blue" }]);
-		assert.deepEqual(flips, [
-			{ flagName: MessageSystemFlag.Flagged, operation: "add" },
-		]);
-	});
-
-	test("the none colour unstars the message", async () => {
-		const { service, updates, flips } = buildService({ alreadyFlagged: true });
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			starColor: "none",
-		});
-
-		assert.deepEqual(updates, [{ hasStars: false, star: "none" }]);
-		assert.deepEqual(flips, [
-			{ flagName: MessageSystemFlag.Flagged, operation: "remove" },
-		]);
-	});
-
-	test("isStarred decides the boolean when both fields are sent", async () => {
-		const { service, updates } = buildService();
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			isStarred: true,
-			starColor: "none",
-		});
-
-		assert.deepEqual(updates, [{ hasStars: true, star: "none" }]);
-	});
-
-	test("starring pushes the Flagged keyword", async () => {
-		const { service, flips } = buildService();
-
-		await service.updateFlags(ACCOUNT_CONFIG_ID, MESSAGE_ID, ACCOUNT_ID, {
-			isStarred: true,
-		});
-
-		assert.deepEqual(flips, [
-			{ flagName: MessageSystemFlag.Flagged, operation: "add" },
-		]);
-	});
-});