@remit/mailbox-service 0.0.111 → 0.0.112

package/src/body-sync.test.ts

@@ -0,0 +1,925 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { DEFAULT_CALENDAR_URL_SEGMENT } from "@remit/calendar-service";
+import type {
+	AccountItem,
+	AddressFlags,
+	MailboxItem,
+	UpdateMessageInput,
+} from "@remit/data-ports";
+import {
+	MessageGoneFromServerError,
+	MessagePlacementUnsettledError,
+} from "@remit/data-ports/errors";
+import { deriveAddressId } from "@remit/data-ports/id";
+import {
+	CalendarInviteMethod,
+	CalendarSource,
+	CalendarSuggestionState,
+	FilterClauseField,
+	FilterScope,
+	MessageCategory,
+	MessageClassificationState,
+} from "@remit/domain-enums";
+import type { StorageService } from "@remit/storage-service";
+import { type BodySyncFolder, BodySyncService } from "./body-sync.js";
+import { NO_ACTION } from "./filters/match.js";
+import { FlagPushService } from "./flag-push.js";
+import { FlagQueueService } from "./flag-queue.js";
+import { PlacementMoveService } from "./placement-move.js";
+import { QuarantineService } from "./quarantine.js";
+import { SyncWarningService } from "./sync-warning.js";
+import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
+import {
+	captureQueue,
+	messageAtUid,
+	openStore,
+	type QueueCapture,
+	type Store,
+	seedAccount,
+	seedMailbox,
+	silentLog,
+	syncFolder,
+} from "./test-helpers/test-store.js";
+
+const LINKEDIN = eml(
+	{
+		From: "LinkedIn <messages-noreply@linkedin.com>",
+		Subject: "You have a new invitation",
+		"List-Id": "LinkedIn Invitations <invitations.linkedin.com>",
+		"List-Unsubscribe": "<https://www.linkedin.com/e/unsub>",
+	},
+	"invitation body text",
+);
+
+const PERSONAL = eml(
+	{ From: "Alex <alex@example.com>", Subject: "Dinner Friday?" },
+	"Are you free Friday night?",
+);
+
+const DEMOTE = eml({
+	From: "Support <support@evil-mimic.example>",
+	Subject: "Verify your account",
+	"Authentication-Results": "mx.example.com; dmarc=fail",
+	"DKIM-Signature": "v=1; a=rsa-sha256; d=relay.example.net; s=sel; b=xxx",
+	"X-Spam-Status": "No, score=0.1",
+});
+
+const SPAM_FLAGGED_DMARC_PASS = eml({
+	From: "Sender <someone@example.com>",
+	"Authentication-Results": "mx.example.com; dmarc=pass",
+	"X-Spam-Status": "Yes, score=6.0",
+});
+
+const FROM_SOMEONE = eml({ From: "Sender <someone@example.com>" });
+
+const TRAVEL_INVITATION = eml({
+	From: "Someone <someone@example.com>",
+	Subject: "You have a new invitation to Travel",
+});
+
+const ICAL_UID = "invite-4711@example.test";
+
+const invitation = (
+	sequence = 0,
+	method = "REQUEST",
+	start = "DTSTART:20260901T080000Z",
+): Buffer =>
+	Buffer.from(
+		[
+			"From: Organizer <organizer@example.test>",
+			"To: user@example.test",
+			"Subject: Quarterly review",
+			'Content-Type: multipart/alternative; boundary="bnd"',
+			"",
+			"--bnd",
+			"Content-Type: text/plain",
+			"",
+			"You are invited.",
+			"--bnd",
+			`Content-Type: text/calendar; method=${method}; charset="UTF-8"`,
+			"",
+			"BEGIN:VCALENDAR",
+			"VERSION:2.0",
+			"PRODID:-//Example Corp//Scheduler//EN",
+			`METHOD:${method}`,
+			"BEGIN:VEVENT",
+			`UID:${ICAL_UID}`,
+			"DTSTAMP:20260801T090000Z",
+			`SEQUENCE:${sequence}`,
+			start,
+			"SUMMARY:Quarterly review",
+			"ORGANIZER:mailto:organizer@example.test",
+			"END:VEVENT",
+			"END:VCALENDAR",
+			"--bnd--",
+			"",
+		].join("\r\n"),
+	);
+
+const MISSING_BODY = "file:///nonexistent/remit/body.eml";
+
+interface World {
+	store: Store;
+	imap: FakeImapServer;
+	queue: QueueCapture;
+	account: AccountItem;
+	inbox: MailboxItem;
+	junk: MailboxItem;
+	archive: MailboxItem;
+	travel: MailboxItem;
+}
+
+let world: World;
+
+beforeEach(async () => {
+	const store = await openStore();
+	const account = await seedAccount(store);
+	const imap = new FakeImapServer();
+	for (const path of ["INBOX", "Junk", "Archive", "Travel"])
+		imap.addFolder(path);
+	world = {
+		store,
+		imap,
+		queue: captureQueue(),
+		account,
+		inbox: await seedMailbox(store, account, "INBOX"),
+		junk: await seedMailbox(store, account, "Junk", { specialUse: "Junk" }),
+		archive: await seedMailbox(store, account, "Archive", {
+			specialUse: "Archive",
+		}),
+		travel: await seedMailbox(store, account, "Travel"),
+	};
+});
+
+afterEach(async () => {
+	world.queue.restore();
+	await world.store.close();
+});
+
+interface Wiring {
+	storage?: StorageService;
+	placement?: boolean;
+	filters?: boolean;
+	quarantine?: boolean;
+	unsubscribe?: boolean;
+	calendar?: boolean;
+}
+
+const bodySync = (wiring: Wiring = {}): BodySyncService => {
+	const { store } = world;
+	const placementMoveService = new PlacementMoveService({
+		messageService: store.message,
+		threadMessageService: store.threadMessage,
+		markerService: store.placementMove,
+		addressService: store.address,
+		mailboxSpecialUseService: store.mailboxSpecialUse,
+		mailboxService: store.mailbox,
+		sqsQueueUrl: "https://sqs.test/message-mgmt",
+	});
+	const flagQueueService = new FlagQueueService({
+		messageFlagService: store.messageFlag,
+		messageService: store.message,
+		threadMessageService: store.threadMessage,
+		flagPushService: new FlagPushService({
+			markerService: store.flagPush,
+			sqsQueueUrl: "https://sqs.test/flags",
+		}),
+	});
+	return new BodySyncService(
+		store.message,
+		wiring.storage ?? store.storage(),
+		store.threadMessage,
+		store.address,
+		store.envelope,
+		new SyncWarningService(store.syncWarning),
+		silentLog,
+		wiring.placement
+			? {
+					mailboxSpecialUseService: store.mailboxSpecialUse,
+					placementMoveService,
+				}
+			: undefined,
+		wiring.filters
+			? {
+					filterService: store.filter,
+					messageLabelService: store.messageLabel,
+					mailboxService: store.mailbox,
+					placementMoveService,
+				}
+			: undefined,
+		wiring.quarantine
+			? {
+					quarantineService: new QuarantineService(
+						store.quarantine,
+						store.mailboxSpecialUse,
+						"sha-test",
+						silentLog,
+					),
+					mailboxId: world.inbox.mailboxId,
+					uidValidity: world.inbox.uidValidity,
+					attempts: 1,
+				}
+			: undefined,
+		wiring.unsubscribe ? { flagQueueService } : undefined,
+		wiring.calendar
+			? {
+					calendarSuggestionService: store.calendarSuggestion,
+					calendarStore: store.calendarStore,
+					filterService: store.filter,
+				}
+			: undefined,
+	);
+};
+
+const placementOf = (mailbox: MailboxItem): BodySyncFolder => ({
+	mailboxId: mailbox.mailboxId,
+	fullPath: mailbox.fullPath,
+	placement:
+		mailbox === world.inbox
+			? "inbox"
+			: mailbox === world.junk
+				? "junk"
+				: "other",
+});
+
+const arrive = async (
+	raw: Buffer,
+	mailbox: MailboxItem = world.inbox,
+	update: UpdateMessageInput = {},
+): Promise<string> => {
+	const uid = world.imap.deliver(mailbox.fullPath, raw);
+	await syncFolder(world.store, world.account, mailbox, world.imap);
+	const { messageId } = await messageAtUid(world.store, mailbox, uid);
+	await world.store.message.update(messageId, update);
+	return messageId;
+};
+
+const read = (
+	service: BodySyncService,
+	messageId: string,
+	mailbox: MailboxItem = world.inbox,
+) =>
+	service.fetchAndGetBody(
+		messageId,
+		world.account.accountId,
+		world.account.accountConfigId,
+		placementOf(mailbox),
+		async () => world.imap.connection(),
+	);
+
+const sync = (
+	service: BodySyncService,
+	messageIds: string[],
+	options: { force?: boolean; mailbox?: MailboxItem } = {},
+) =>
+	service.syncBodies(
+		messageIds,
+		world.account.accountId,
+		world.account.accountConfigId,
+		{
+			...placementOf(options.mailbox ?? world.inbox),
+			uidValidity: (options.mailbox ?? world.inbox).uidValidity,
+		},
+		async () => world.imap.connection(),
+		options.force ?? false,
+	);
+
+const flagSender = async (email: string, flags: AddressFlags) => {
+	const [localPart, domain] = email.split("@");
+	const addressId = deriveAddressId(world.account.accountConfigId, email);
+	await world.store.address.upsertAddress({
+		addressId,
+		accountConfigId: world.account.accountConfigId,
+		localPart,
+		domain,
+		normalizedEmail: email,
+		normalizedCompound: email,
+	});
+	await world.store.address.updateAddress(
+		world.account.accountConfigId,
+		addressId,
+		{ flags },
+	);
+};
+
+const messageRow = (messageId: string) => world.store.message.get(messageId);
+
+const threadRows = (messageId: string) =>
+	world.store.threadMessage.findAllByMessageId(
+		world.account.accountConfigId,
+		messageId,
+	);
+
+const addFilter = (
+	clauses: Array<{ field: string; value: string }>,
+	actionMailboxId: string = NO_ACTION,
+	actionLabelId: string = NO_ACTION,
+) =>
+	world.store.filter.create({
+		accountConfigId: world.account.accountConfigId,
+		name: "rule",
+		scope: FilterScope.Standing,
+		literalClauses: clauses as never,
+		actionMailboxId,
+		actionLabelId,
+	});
+
+describe("classification is decided on the pass that first stores a body", () => {
+	it("writes the category, the examined mark and every denormalized field", async () => {
+		const messageId = await arrive(LINKEDIN);
+		await world.store.threadMessage.create({
+			...(await threadRows(messageId))[0],
+			threadId: "drifted-root",
+		});
+
+		await sync(bodySync(), [messageId]);
+
+		const row = await messageRow(messageId);
+		assert.equal(row.category, MessageCategory.social);
+		assert.equal(row.classificationState, MessageClassificationState.Examined);
+		assert.ok(row.bodyStorageKey);
+		const rows = await threadRows(messageId);
+		assert.equal(rows.length, 2);
+		for (const thread of rows) {
+			assert.equal(thread.category, MessageCategory.social);
+			assert.equal(thread.listId, "invitations.linkedin.com");
+			assert.equal(thread.snippet, "invitation body text");
+		}
+	});
+
+	it("examines a body the classifier has nothing to say about once", async () => {
+		const messageId = await arrive(PERSONAL);
+		const service = bodySync();
+
+		await sync(service, [messageId]);
+		const second = await sync(service, [messageId]);
+
+		assert.equal(second.skippedCount, 1);
+		const row = await messageRow(messageId);
+		assert.equal(row.classificationState, MessageClassificationState.Examined);
+	});
+
+	it("leaves mail stored before the classifier ran for the backfill to find", async () => {
+		const messageId = await arrive(LINKEDIN, world.inbox, {
+			bodyStorageKey: MISSING_BODY,
+			classificationState: MessageClassificationState.NotExamined,
+		});
+
+		const result = await sync(bodySync(), [messageId]);
+
+		assert.equal(result.skippedCount, 1);
+		const row = await messageRow(messageId);
+		assert.equal(
+			row.classificationState,
+			MessageClassificationState.NotExamined,
+		);
+		assert.equal(row.category, MessageCategory.uncategorized);
+	});
+
+	it("classifies by the sender's category override instead of the headers", async () => {
+		await flagSender("messages-noreply@linkedin.com", {
+			category: { value: MessageCategory.personal, setAt: 1 },
+		});
+		const messageId = await arrive(LINKEDIN);
+
+		await read(bodySync(), messageId);
+
+		assert.equal(
+			(await messageRow(messageId)).category,
+			MessageCategory.personal,
+		);
+		assert.equal(
+			(await threadRows(messageId))[0].category,
+			MessageCategory.personal,
+		);
+	});
+
+	it("does not reach back to examined mail when the sender is reclassified later", async () => {
+		const messageId = await arrive(LINKEDIN, world.inbox, {
+			bodyStorageKey: MISSING_BODY,
+			classificationState: MessageClassificationState.Examined,
+		});
+		await flagSender("messages-noreply@linkedin.com", {
+			category: { value: MessageCategory.transactional, setAt: 1 },
+		});
+
+		await sync(bodySync(), [messageId]);
+
+		assert.equal(
+			(await messageRow(messageId)).category,
+			MessageCategory.uncategorized,
+		);
+	});
+});
+
+describe("a re-store re-fetches bytes and re-decides nothing", () => {
+	const decidedRow = (
+		overrides: UpdateMessageInput = {},
+	): UpdateMessageInput => ({
+		bodyStorageKey: MISSING_BODY,
+		category: MessageCategory.marketing,
+		classificationState: MessageClassificationState.Examined,
+		placementDecidedAt: 500,
+		...overrides,
+	});
+
+	for (const path of ["the missing-object read", "a forced sync"] as const) {
+		const restore = (
+			service: BodySyncService,
+			messageId: string,
+			mailbox: MailboxItem = world.inbox,
+		) =>
+			path === "a forced sync"
+				? sync(service, [messageId], { force: true, mailbox })
+				: read(service, messageId, mailbox);
+
+		it(`keeps category, placement and read state through ${path}`, async () => {
+			await flagSender("support@evil-mimic.example", {
+				category: { value: MessageCategory.personal, setAt: 1 },
+				unsubscribed: { value: true, setAt: 1 },
+			});
+			const messageId = await arrive(DEMOTE, world.inbox, decidedRow());
+
+			await restore(
+				bodySync({ placement: true, filters: true, unsubscribe: true }),
+				messageId,
+			);
+
+			const row = await messageRow(messageId);
+			assert.notEqual(row.bodyStorageKey, MISSING_BODY);
+			assert.equal(row.category, MessageCategory.marketing);
+			assert.equal(row.mailboxId, world.inbox.mailboxId);
+			assert.equal(row.movedByRemit, false);
+			assert.equal(row.placementDecidedAt, 500);
+			assert.equal((await threadRows(messageId))[0].isRead, false);
+			assert.deepEqual(world.queue.sent, []);
+		});
+
+		it(`does not re-fire a standing filter through ${path}`, async () => {
+			await addFilter(
+				[{ field: FilterClauseField.Subject, value: "invitation" }],
+				world.junk.mailboxId,
+			);
+			const messageId = await arrive(
+				TRAVEL_INVITATION,
+				world.travel,
+				decidedRow(),
+			);
+
+			await restore(bodySync({ filters: true }), messageId, world.travel);
+
+			const row = await messageRow(messageId);
+			assert.equal(row.mailboxId, world.travel.mailboxId);
+			assert.equal(row.filterMove, undefined);
+		});
+	}
+
+	it("first-stores the never-stored message of a forced batch with the full pass", async () => {
+		await addFilter(
+			[{ field: FilterClauseField.Subject, value: "invitation" }],
+			world.travel.mailboxId,
+		);
+		const stored = await arrive(DEMOTE, world.inbox, decidedRow());
+		const fresh = await arrive(TRAVEL_INVITATION);
+
+		const result = await sync(
+			bodySync({ placement: true, filters: true }),
+			[stored, fresh],
+			{ force: true },
+		);
+
+		assert.deepEqual(result.syncedMessageIds.sort(), [fresh, stored].sort());
+		assert.equal((await messageRow(stored)).mailboxId, world.inbox.mailboxId);
+		const filed = await messageRow(fresh);
+		assert.equal(filed.mailboxId, world.travel.mailboxId);
+		assert.equal(filed.movedByRemit, true);
+	});
+});
+
+describe("placement follows the sender's flags", () => {
+	it("files a blocked sender's inbox mail to Junk with no authentication signal", async () => {
+		await flagSender("someone@example.com", {
+			blocked: { value: true, setAt: 1_000 },
+		});
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ placement: true }), messageId);
+
+		const row = await messageRow(messageId);
+		assert.equal(row.mailboxId, world.junk.mailboxId);
+		assert.equal(row.movedByRemit, true);
+		assert.ok(row.placementDecidedAt);
+		assert.equal(
+			(await world.store.placementMove.find(messageId))?.state,
+			"queued",
+		);
+		assert.deepEqual(
+			world.queue.sent.map((event) => event.body.type),
+			["PLACEMENT_MOVE_PUSH"],
+		);
+	});
+
+	it("leaves an unflagged sender's inbox mail where it is", async () => {
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ placement: true }), messageId);
+
+		assert.equal(
+			(await messageRow(messageId)).mailboxId,
+			world.inbox.mailboxId,
+		);
+		assert.equal(await world.store.placementMove.find(messageId), null);
+	});
+
+	it("rescues from Junk when vip was set after blocked", async () => {
+		await flagSender("someone@example.com", {
+			blocked: { value: true, setAt: 1_000 },
+			vip: { value: true, setAt: 5_000 },
+		});
+		const messageId = await arrive(SPAM_FLAGGED_DMARC_PASS, world.junk);
+
+		await read(bodySync({ placement: true }), messageId, world.junk);
+
+		assert.equal(
+			(await messageRow(messageId)).mailboxId,
+			world.inbox.mailboxId,
+		);
+	});
+
+	it("files an autoArchive sender's inbox mail to Archive", async () => {
+		await flagSender("someone@example.com", {
+			autoArchive: { value: true, setAt: 1_000 },
+		});
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ placement: true }), messageId);
+
+		assert.equal(
+			(await messageRow(messageId)).mailboxId,
+			world.archive.mailboxId,
+		);
+	});
+
+	it("lets a blocked demote win over autoArchive", async () => {
+		await flagSender("someone@example.com", {
+			blocked: { value: true, setAt: 1_000 },
+			autoArchive: { value: true, setAt: 1_000 },
+		});
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ placement: true }), messageId);
+
+		assert.equal((await messageRow(messageId)).mailboxId, world.junk.mailboxId);
+	});
+
+	it("does not auto-archive mail out of Junk", async () => {
+		await flagSender("someone@example.com", {
+			autoArchive: { value: true, setAt: 1_000 },
+		});
+		const messageId = await arrive(SPAM_FLAGGED_DMARC_PASS, world.junk);
+
+		await read(bodySync({ placement: true }), messageId, world.junk);
+
+		assert.equal((await messageRow(messageId)).mailboxId, world.junk.mailboxId);
+	});
+
+	it("does not re-file mail Remit already placed", async () => {
+		await flagSender("someone@example.com", {
+			autoArchive: { value: true, setAt: 1_000 },
+		});
+		const messageId = await arrive(FROM_SOMEONE, world.inbox, {
+			movedByRemit: true,
+		});
+
+		await read(bodySync({ placement: true }), messageId);
+
+		assert.equal(
+			(await messageRow(messageId)).mailboxId,
+			world.inbox.mailboxId,
+		);
+	});
+});
+
+describe("a standing filter runs on the first store", () => {
+	it("moves the message and records where it came from", async () => {
+		const filter = await addFilter(
+			[{ field: FilterClauseField.Subject, value: "invitation" }],
+			world.travel.mailboxId,
+		);
+		const messageId = await arrive(TRAVEL_INVITATION);
+
+		await read(bodySync({ filters: true }), messageId);
+
+		const row = await messageRow(messageId);
+		assert.equal(row.mailboxId, world.travel.mailboxId);
+		assert.equal(row.movedByRemit, true);
+		assert.deepEqual(
+			{
+				filterId: row.filterMove?.filterId,
+				sourceMailboxId: row.filterMove?.sourceMailboxId,
+				destinationMailboxId: row.filterMove?.destinationMailboxId,
+			},
+			{
+				filterId: filter.filterId,
+				sourceMailboxId: world.inbox.mailboxId,
+				destinationMailboxId: world.travel.mailboxId,
+			},
+		);
+	});
+
+	it("records no move for a message already in the filter's destination", async () => {
+		await addFilter(
+			[{ field: FilterClauseField.Subject, value: "invitation" }],
+			world.travel.mailboxId,
+		);
+		const messageId = await arrive(TRAVEL_INVITATION, world.travel);
+
+		await read(bodySync({ filters: true }), messageId, world.travel);
+
+		const row = await messageRow(messageId);
+		assert.equal(row.filterMove, undefined);
+		assert.equal(row.movedByRemit, false);
+	});
+});
+
+describe("an unsubscribed sender's mail is marked read once", () => {
+	it("marks it read on the first store", async () => {
+		await flagSender("someone@example.com", {
+			unsubscribed: { value: true, setAt: 1 },
+		});
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ unsubscribe: true }), messageId);
+
+		assert.equal((await threadRows(messageId))[0].isRead, true);
+		assert.ok(
+			await world.store.flagPush.find(messageId, "\\Seen"),
+			"the read owes IMAP a \\Seen push",
+		);
+	});
+
+	it("leaves read state alone once the flag is unset", async () => {
+		await flagSender("someone@example.com", {
+			unsubscribed: { value: false, setAt: 1 },
+		});
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await read(bodySync({ unsubscribe: true }), messageId);
+
+		assert.equal((await threadRows(messageId))[0].isRead, false);
+	});
+});
+
+describe("reading a message the mail server no longer holds", () => {
+	const gone = async (inFlight = false) => {
+		const messageId = await arrive(FROM_SOMEONE);
+		const { uid } = await messageRow(messageId);
+		if (inFlight) {
+			await world.store.message.transitionPlacement(
+				messageId,
+				{ status: "active" },
+				{ status: "moving", syncStatus: "pending" },
+			);
+		}
+		world.imap.expunge("INBOX", uid);
+		const outcome = await read(bodySync(), messageId).then(
+			() => assert.fail("expected the read to be refused"),
+			(error: unknown) => error,
+		);
+		return { messageId, outcome };
+	};
+
+	it("answers 404 and removes the settled row with its thread entries", async () => {
+		const { messageId, outcome } = await gone();
+
+		assert.ok(outcome instanceof MessageGoneFromServerError);
+		assert.equal(outcome.statusCode, 404);
+		await assert.rejects(messageRow(messageId));
+		assert.deepEqual(await threadRows(messageId), []);
+	});
+
+	it("answers 409 and deletes nothing while our own move is in flight", async () => {
+		const { messageId, outcome } = await gone(true);
+
+		assert.ok(outcome instanceof MessagePlacementUnsettledError);
+		assert.equal(outcome.statusCode, 409);
+		assert.equal((await threadRows(messageId)).length, 1);
+	});
+
+	it("answers 409 when another writer moved the row while the server was asked", async () => {
+		const messageId = await arrive(FROM_SOMEONE);
+		const { uid } = await messageRow(messageId);
+		world.imap.expunge("INBOX", uid);
+		world.imap.onFetchBody = async () => {
+			await world.store.message.transitionPlacement(
+				messageId,
+				{ status: "active" },
+				{ mailboxId: world.travel.mailboxId, uid: 99 },
+			);
+		};
+
+		await assert.rejects(
+			read(bodySync(), messageId),
+			MessagePlacementUnsettledError,
+		);
+		assert.equal((await threadRows(messageId)).length, 1);
+	});
+
+	it("fails loudly and deletes nothing when the server still lists the UID", async () => {
+		const messageId = await arrive(FROM_SOMEONE);
+		const connection = world.imap.connection();
+		connection.fetchMessageBody = async () => null;
+
+		await assert.rejects(
+			bodySync().fetchAndGetBody(
+				messageId,
+				world.account.accountId,
+				world.account.accountConfigId,
+				placementOf(world.inbox),
+				async () => connection,
+			),
+			/which the server still lists/,
+		);
+		assert.ok(await messageRow(messageId));
+	});
+});
+
+describe("body sync and the quarantine", () => {
+	it("skips a uid already set aside without fetching it", async () => {
+		const messageId = await arrive(FROM_SOMEONE);
+		const { uid } = await messageRow(messageId);
+		await new QuarantineService(
+			world.store.quarantine,
+			world.store.mailboxSpecialUse,
+			"sha-test",
+			silentLog,
+		).record(
+			{
+				accountId: world.account.accountId,
+				accountConfigId: world.account.accountConfigId,
+				mailboxId: world.inbox.mailboxId,
+				mailboxPath: "INBOX",
+				uidValidity: world.inbox.uidValidity,
+				attempts: 3,
+			},
+			uid,
+			{ stage: "BodyParse", code: "UnreadableBody", message: "boundary" },
+		);
+
+		const result = await bodySync({ quarantine: true }).syncBodies(
+			[messageId],
+			world.account.accountId,
+			world.account.accountConfigId,
+			{ ...placementOf(world.inbox), uidValidity: world.inbox.uidValidity },
+			async () => assert.fail("a quarantined message is not fetched"),
+		);
+
+		assert.equal(result.skippedCount, 1);
+		assert.equal((await messageRow(messageId)).bodyStorageKey, undefined);
+	});
+
+	it("requeues a storage failure rather than calling the message unreadable", async () => {
+		const messageId = await arrive(FROM_SOMEONE);
+
+		await assert.rejects(
+			sync(
+				bodySync({ quarantine: true, storage: world.store.brokenStorage() }),
+				[messageId],
+			),
+		);
+
+		assert.deepEqual(
+			await world.store.quarantine.listByAccountConfigId(
+				world.account.accountConfigId,
+			),
+			[],
+		);
+		assert.equal((await messageRow(messageId)).bodyStorageKey, undefined);
+	});
+});
+
+describe("mail-derived calendar suggestions", () => {
+	const suggestions = (messageId: string) =>
+		world.store.calendarSuggestion.listByMessage(
+			world.account.accountConfigId,
+			messageId,
+		);
+
+	it("offers an invitation as one Pending card carrying its bytes", async () => {
+		const messageId = await arrive(invitation());
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		const [row, ...rest] = await suggestions(messageId);
+		assert.deepEqual(rest, []);
+		assert.equal(row.state, CalendarSuggestionState.Pending);
+		assert.equal(row.icalUid, ICAL_UID);
+		assert.equal(row.method, CalendarInviteMethod.Request);
+		assert.equal(row.organizer, "organizer@example.test");
+		assert.match(row.icalData, /UID:invite-4711@example\.test/);
+	});
+
+	it("reads a floating start in the collection's own zone", async () => {
+		await world.store.calendarCollection.create({
+			accountConfigId: world.account.accountConfigId,
+			urlSegment: DEFAULT_CALENDAR_URL_SEGMENT,
+			displayName: "Calendar",
+			source: CalendarSource.Default,
+			timezone: "Europe/Amsterdam",
+		});
+		const messageId = await arrive(
+			invitation(0, "REQUEST", "DTSTART:20260901T100000"),
+		);
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		const [row] = await suggestions(messageId);
+		assert.equal(row.dtStart, "2026-09-01T10:00:00+02:00");
+		assert.equal(row.zoneCertainty, "Local");
+	});
+
+	it("offers no card for a sender the user muted", async () => {
+		await addFilter([
+			{ field: FilterClauseField.From, value: "organizer@example.test" },
+		]);
+		const messageId = await arrive(invitation());
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		assert.deepEqual(await suggestions(messageId), []);
+	});
+
+	it("still offers a card when the rule about this sender files its mail", async () => {
+		await addFilter(
+			[{ field: FilterClauseField.From, value: "organizer@example.test" }],
+			world.travel.mailboxId,
+		);
+		const messageId = await arrive(invitation());
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		assert.equal((await suggestions(messageId)).length, 1);
+	});
+
+	it("offers nothing on a re-store", async () => {
+		const messageId = await arrive(invitation(), world.inbox, {
+			bodyStorageKey: MISSING_BODY,
+		});
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		assert.deepEqual(await suggestions(messageId), []);
+	});
+
+	it("supersedes the earlier revision when a higher SEQUENCE arrives", async () => {
+		const service = bodySync({ calendar: true });
+		const first = await arrive(invitation(0));
+		const second = await arrive(invitation(1));
+
+		await read(service, first);
+		await read(service, second);
+
+		assert.equal(
+			(await suggestions(first))[0].state,
+			CalendarSuggestionState.Superseded,
+		);
+		assert.equal(
+			(await suggestions(second))[0].state,
+			CalendarSuggestionState.Pending,
+		);
+	});
+
+	it("offers a cancellation as its own card", async () => {
+		const messageId = await arrive(invitation(1, "CANCEL"));
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		const [row] = await suggestions(messageId);
+		assert.equal(row.method, CalendarInviteMethod.Cancel);
+		assert.equal(row.acceptedCalendarObjectId, "");
+	});
+
+	it("stores the body when the iCalendar is unreadable", async () => {
+		const messageId = await arrive(
+			Buffer.from(
+				[
+					"From: Organizer <organizer@example.test>",
+					'Content-Type: multipart/alternative; boundary="bnd"',
+					"",
+					"--bnd",
+					"Content-Type: text/calendar",
+					"",
+					"BEGIN:VCALENDAR",
+					"--bnd--",
+					"",
+				].join("\r\n"),
+			),
+		);
+
+		await read(bodySync({ calendar: true }), messageId);
+
+		assert.ok((await messageRow(messageId)).bodyStorageKey);
+		assert.deepEqual(await suggestions(messageId), []);
+	});
+});