@remit/imap-worker 0.0.89 → 0.0.91

package/src/handlers/placement-push.sqlite.test.ts

@@ -1,298 +0,0 @@
-/**
- * The two pushes body sync leaves behind: a placement move (Junk, a filter's
- * folder) and a flag (auto-mark-read). They ride different queues, so either
- * can reach the server first, and the flag must never land on the uid of a
- * move that has not settled (#496).
- */
-import assert from "node:assert/strict";
-import { after, before, describe, it, mock } from "node:test";
-import type { MailboxItem } from "@remit/data-ports";
-import {
-	MailboxCursorState,
-	MailboxSpecialUse,
-	MessageStatus,
-} from "@remit/domain-enums";
-import { PlacementMoveService } from "@remit/mailbox-service";
-import type { FlagPushEvent, PlacementMovePushEvent } from "../events.js";
-import {
-	openStore,
-	type SeededMessage,
-	type World,
-} from "../test-helpers/test-world.js";
-import { FLAG_PUSH_DEFER_MAX_MS, handleFlagPush } from "./flag-push.js";
-import { handlePlacementMovePush } from "./placement-move-push.js";
-
-const SEEN = "\\Seen";
-
-let store: Awaited<ReturnType<typeof openStore>>;
-
-before(async () => {
-	store = await openStore();
-});
-
-after(() => store.close());
-
-interface Arranged {
-	w: World;
-	inbox: MailboxItem;
-	junk: MailboxItem;
-	message: SeededMessage;
-	placement: PlacementMoveService;
-}
-
-const arrange = async (): Promise<Arranged> => {
-	const w = await store.world();
-	const inbox = await w.folder("INBOX");
-	const junk = await w.folder("Junk", { specialUse: MailboxSpecialUse.Junk });
-	const message = await w.message(inbox);
-	const placement = new PlacementMoveService({
-		messageService: w.client.message,
-		threadMessageService: w.client.threadMessage,
-		markerService: w.client.placementMove,
-		addressService: w.client.address,
-		mailboxSpecialUseService: w.client.mailboxSpecialUse,
-		mailboxService: w.client.mailbox,
-		queue: w.client.queues.messageManagement,
-	});
-	return { w, inbox, junk, message, placement };
-};
-
-const queuedOf = <T>(w: World, type: string): T => {
-	const event = w
-		.queued()
-		.filter((body) => body.type === type)
-		.at(-1) as T | undefined;
-	assert.ok(event, `a ${type} was enqueued`);
-	return event;
-};
-
-const markAsRead = async (a: Arranged): Promise<FlagPushEvent> => {
-	await a.w.client.flagQueue.markAsRead(
-		a.w.account.accountConfigId,
-		a.message.messageId,
-		a.w.account.accountId,
-	);
-	return queuedOf<FlagPushEvent>(a.w, "FLAG_PUSH");
-};
-
-const moveToJunk = async (a: Arranged): Promise<PlacementMovePushEvent> => {
-	await a.placement.moveMessage(
-		a.w.account.accountConfigId,
-		a.message.messageId,
-		a.junk.mailboxId,
-		a.w.account.accountId,
-	);
-	return queuedOf<PlacementMovePushEvent>(a.w, "PLACEMENT_MOVE_PUSH");
-};
-
-const pushFlag = (a: Arranged, event: FlagPushEvent, receiveCount = 1) =>
-	handleFlagPush(event, a.w.log, receiveCount, a.w.scope);
-
-const pushMove = (
-	a: Arranged,
-	event: PlacementMovePushEvent,
-	receiveCount = 1,
-) => handlePlacementMovePush(event, a.w.log, receiveCount, a.w.scope);
-
-const seenOnServer = (a: Arranged, path: string): boolean[] =>
-	a.w.imap
-		.messages(path)
-		.filter((m) => m.messageIdHeader === a.message.messageIdHeader)
-		.map((m) => m.flags.includes(SEEN));
-
-describe("a flag push", () => {
-	it("stores the flag on the server and clears its marker", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-
-		await pushFlag(a, event);
-
-		assert.deepEqual(seenOnServer(a, "INBOX"), [true]);
-		assert.equal(
-			await a.w.client.flagPush.find(a.message.messageId, SEEN),
-			null,
-		);
-	});
-
-	it("waits, without connecting, while the message's placement move has not settled", async () => {
-		const a = await arrange();
-		await moveToJunk(a);
-		const event = await markAsRead(a);
-
-		await pushFlag(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			(await a.w.client.flagPush.find(a.message.messageId, SEEN))?.state,
-			"pending",
-		);
-		assert.deepEqual(seenOnServer(a, "INBOX"), [false]);
-	});
-
-	it("lands on the moved message once the placement move has settled", async () => {
-		const a = await arrange();
-		const move = await moveToJunk(a);
-		const flag = await markAsRead(a);
-		await pushFlag(a, flag);
-
-		await pushMove(a, move);
-		await pushFlag(a, flag);
-
-		assert.deepEqual(a.w.imap.uids("INBOX"), []);
-		assert.deepEqual(seenOnServer(a, "Junk"), [true]);
-		assert.equal(
-			await a.w.client.flagPush.find(a.message.messageId, SEEN),
-			null,
-		);
-	});
-
-	// A move that never settles would otherwise park the flag forever, one
-	// queue round trip per sync tick.
-	it("drops the marker without connecting once the move has been stuck past the window", async (t) => {
-		const a = await arrange();
-		await moveToJunk(a);
-		const event = await markAsRead(a);
-		mock.timers.enable({
-			apis: ["Date"],
-			now: Date.now() + FLAG_PUSH_DEFER_MAX_MS + 1,
-		});
-		t.after(() => mock.timers.reset());
-
-		await pushFlag(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			await a.w.client.flagPush.find(a.message.messageId, SEEN),
-			null,
-		);
-		assert.deepEqual(seenOnServer(a, "INBOX"), [false]);
-	});
-
-	it("drops the marker without connecting when the mailbox was deleted", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-		await a.w.client.mailbox.delete(a.w.account.accountId, a.inbox.mailboxId);
-
-		await pushFlag(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			await a.w.client.flagPush.find(a.message.messageId, SEEN),
-			null,
-		);
-	});
-
-	it("drops the marker without connecting when the message row is gone", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-		await a.w.client.message.delete(a.message.messageId);
-
-		await pushFlag(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			await a.w.client.flagPush.find(a.message.messageId, SEEN),
-			null,
-		);
-	});
-
-	it("keeps the marker and stores nothing while the cursor is rebuilding", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-		await a.w.client.mailbox.update(a.w.account.accountId, a.inbox.mailboxId, {
-			cursorState: MailboxCursorState.rebuilding,
-		});
-
-		await pushFlag(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
-	});
-
-	it("stores nothing when the mailbox's UIDVALIDITY changed under it", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-		a.w.imap.setUidValidity("INBOX", 2);
-
-		await pushFlag(a, event);
-
-		assert.deepEqual(a.w.imap.commands("STORE"), []);
-		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
-	});
-
-	it("keeps the marker and redelivers when the connection drops", async () => {
-		const a = await arrange();
-		const event = await markAsRead(a);
-		a.w.imap.failNext.STORE = new Error("Connection reset");
-
-		await assert.rejects(pushFlag(a, event), /Connection reset/);
-
-		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
-	});
-});
-
-describe("a placement move push", () => {
-	it("moves the message on the server, settles the row and clears the marker", async () => {
-		const a = await arrange();
-		const event = await moveToJunk(a);
-
-		await pushMove(a, event);
-
-		const [junkUid] = a.w.imap.uids("Junk", a.message.messageIdHeader);
-		const row = await a.w.row(a.message.messageId);
-		assert.equal(row?.mailboxId, a.junk.mailboxId);
-		assert.equal(row?.uid, junkUid);
-		assert.equal(row?.status, MessageStatus.active);
-		assert.equal(
-			await a.w.client.placementMove.find(a.message.messageId),
-			null,
-		);
-	});
-
-	it("drops the marker without connecting when a newer move took the message elsewhere", async () => {
-		const a = await arrange();
-		const event = await moveToJunk(a);
-		const archive = await a.w.folder("Archive");
-		await a.w.client.message.transitionPlacement(
-			a.message.messageId,
-			{ mailboxId: a.junk.mailboxId },
-			{ mailboxId: archive.mailboxId },
-		);
-
-		await pushMove(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			await a.w.client.placementMove.find(a.message.messageId),
-			null,
-		);
-	});
-
-	it("drops the marker without connecting when the destination mailbox was deleted", async () => {
-		const a = await arrange();
-		const event = await moveToJunk(a);
-		await a.w.client.mailbox.delete(a.w.account.accountId, a.junk.mailboxId);
-
-		await pushMove(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.equal(
-			await a.w.client.placementMove.find(a.message.messageId),
-			null,
-		);
-	});
-
-	it("keeps the marker and moves nothing while the source cursor is rebuilding", async () => {
-		const a = await arrange();
-		const event = await moveToJunk(a);
-		await a.w.client.mailbox.update(a.w.account.accountId, a.inbox.mailboxId, {
-			cursorState: MailboxCursorState.rebuilding,
-		});
-
-		await pushMove(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.ok(await a.w.client.placementMove.find(a.message.messageId));
-		assert.deepEqual(a.w.imap.uids("INBOX"), [a.message.uid]);
-	});
-});

package/src/handlers/probe-message-id.sqlite.test.ts

@@ -1,192 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it, mock } from "node:test";
-import type { MailboxItem } from "@remit/data-ports";
-import { recordingQueue } from "@remit/data-ports/recording-queue";
-import {
-	AccountAuthType,
-	ConnectionState,
-	MailboxCursorState,
-} from "@remit/domain-enums";
-import {
-	createSqliteRepositories,
-	type DrizzleMessageRepository,
-	type DrizzleThreadMessageRepository,
-	type MailboxRepo,
-	type SqliteRepositories,
-} from "@remit/drizzle-service";
-import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import {
-	type IImapConnection,
-	type ManagedConnectionFactory,
-	MessageMoveService,
-	MessageSyncService,
-	SyncWarningService,
-} from "@remit/mailbox-service";
-import type { ImapMessage } from "@remit/mailbox-service/types";
-import { probeableMessageIdHeader } from "./probe-message-id.js";
-
-const ACCOUNT_CONFIG_ID = "cfg-msgid";
-const UID_VALIDITY = 7;
-
-const inboxHolding = (messageIdHeader: string): ImapMessage => ({
-	uid: 3,
-	seq: 1,
-	flags: [],
-	internalDate: new Date(0),
-	size: 100,
-	envelope: {
-		date: new Date(0).toISOString(),
-		messageId: messageIdHeader,
-		subject: "Quarterly report",
-		from: [{ name: "Sender", mailbox: "sender", host: "example.com" }],
-		sender: [],
-		replyTo: [],
-		to: [],
-		cc: [],
-		bcc: [],
-		inReplyTo: "",
-	},
-});
-
-const serverWithInbox = (message: ImapMessage): IImapConnection =>
-	({
-		openBox: async (path: string) => ({
-			name: path,
-			readOnly: false,
-			uidvalidity: UID_VALIDITY,
-			uidnext: message.uid + 1,
-			flags: [],
-			permFlags: [],
-			persistentUIDs: true,
-			messages: { total: 1, new: 0 },
-			newKeywords: false,
-		}),
-		getMailboxStatus: async () => ({
-			messages: 1,
-			recent: 0,
-			unseen: 0,
-			uidNext: message.uid + 1,
-			uidValidity: UID_VALIDITY,
-			highestModseq: "0",
-			deletedCount: 0,
-		}),
-		supportsCondstore: () => false,
-		search: async () => [message.uid],
-		fetchMessages: async () => [message],
-	}) as unknown as IImapConnection;
-
-describe("the Message-ID the move, delete and copy probes ask with", () => {
-	let close: () => void;
-	let repos: SqliteRepositories;
-	let accountId: string;
-	let mailboxes: MailboxRepo;
-	let messages: DrizzleMessageRepository;
-	let threadMessages: DrizzleThreadMessageRepository;
-
-	const createMailbox = async (fullPath: string): Promise<MailboxItem> => {
-		const created = await mailboxes.create({
-			accountId,
-			namespacePrefix: "",
-			hierarchyDelimiter: "/",
-			fullPath,
-			uidValidity: UID_VALIDITY,
-			uidNext: 1,
-			highestModseq: "0",
-			messageCount: 0,
-			unseenCount: 0,
-			deletedCount: 0,
-			totalSize: 0,
-			lastSyncUid: 0,
-			highWaterMarkUid: 0,
-			lastMessageSyncAt: 0,
-			cursorState: MailboxCursorState.normal,
-		} as Parameters<MailboxRepo["create"]>[0]);
-		if (created.outcome !== "Created") throw new Error(`${fullPath} taken`);
-		return created.mailbox;
-	};
-
-	const syncInbox = async (messageIdHeader: string): Promise<string> => {
-		const inbox = await createMailbox("INBOX");
-		const connection = serverWithInbox(inboxHolding(messageIdHeader));
-		const factory: ManagedConnectionFactory = {
-			getConnection: () => connection,
-			close: async () => {},
-		};
-		await new MessageSyncService(
-			factory,
-			mailboxes,
-			repos.mailboxSpecialUse,
-			messages,
-			repos.envelope,
-			repos.address,
-			threadMessages,
-			new SyncWarningService(repos.syncWarning),
-		).syncMessages(inbox.mailboxId, accountId, ACCOUNT_CONFIG_ID);
-		const [synced] = await messages.listAllByMailbox(inbox.mailboxId);
-		if (!synced) throw new Error("sync stored no message");
-		return synced.messageId;
-	};
-
-	const probeable = (messageId: string): Promise<string | undefined> =>
-		probeableMessageIdHeader(threadMessages, ACCOUNT_CONFIG_ID, messageId);
-
-	beforeEach(async () => {
-		const store = createShippedSqliteDb();
-		close = store.close;
-		repos = createSqliteRepositories({
-			app: store.db,
-			mail: store.db,
-			search: store.db,
-		});
-		mailboxes = repos.mailbox;
-		messages = repos.message;
-		threadMessages = repos.threadMessage;
-		const account = await repos.account.create({
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			username: "person@example.com",
-			email: "person@example.com",
-			authType: AccountAuthType.Password,
-			passwordHash: '{"ciphertext":"x"}',
-			imapHost: "imap.example.com",
-			imapPort: 993,
-			imapTls: true,
-			imapStartTls: false,
-			isActive: true,
-			connectionState: ConnectionState.Authenticated,
-		});
-		accountId = account.accountId;
-	});
-
-	afterEach(() => {
-		mock.restoreAll();
-		close();
-	});
-
-	it("reads the Message-ID a real sync stored", async () => {
-		const messageId = await syncInbox("<report@example.com>");
-
-		assert.equal(await probeable(messageId), "<report@example.com>");
-	});
-
-	it("reads the source's Message-ID for a copy", async () => {
-		const sourceId = await syncInbox("<report@example.com>");
-		const archive = await createMailbox("Archive");
-		const copyId = await new MessageMoveService({
-			messageService: messages,
-			mailboxService: mailboxes,
-			mailboxSpecialUseService: repos.mailboxSpecialUse,
-			threadMessageService: threadMessages,
-			addressService: repos.address,
-			queue: recordingQueue(),
-		}).copyMessage(ACCOUNT_CONFIG_ID, sourceId, archive.mailboxId, accountId);
-
-		assert.notEqual(copyId, sourceId);
-		assert.equal(await probeable(copyId), "<report@example.com>");
-	});
-
-	it("answers unprobeable for a bounce whose Message-ID is <>", async () => {
-		const messageId = await syncInbox("<>");
-
-		assert.equal(await probeable(messageId), undefined);
-	});
-});

package/src/handlers/probe-message-id.ts

@@ -1,15 +0,0 @@
-import type { IThreadMessageRepository } from "@remit/data-ports";
-import { isValidMessageId } from "@remit/data-ports/id";
-
-export const probeableMessageIdHeader = async (
-	threadMessageService: Pick<IThreadMessageRepository, "findByMessageId">,
-	accountConfigId: string,
-	messageId: string,
-): Promise<string | undefined> => {
-	const row = await threadMessageService.findByMessageId(
-		accountConfigId,
-		messageId,
-	);
-	const header = row?.messageIdHeader;
-	return isValidMessageId(header) ? header : undefined;
-};

package/src/handlers/sync-mailboxes.test.ts

@@ -1,183 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	DEFAULT_MAILBOX_FRESHNESS_MS,
-	emitSyncMessagesEvents,
-	MAILBOX_FRESHNESS_MS,
-	mailboxNeedsSync,
-	resolveMailboxFreshnessMs,
-	splitInboxFirst,
-} from "./sync-mailboxes.js";
-
-const NOW = 1_700_000_000_000;
-
-const askedForByName = { explicitRequest: true } as const;
-const sideEffect = {} as const;
-
-describe("mailboxNeedsSync", () => {
-	// Issue #37: the gate this replaces applied to every trigger, so a refresh
-	// that landed just after a side-effect sync did nothing at all. A sync
-	// asked for by name (POST /sync) is never gated, however recently one ran.
-	it("syncs a mailbox synced a moment ago when the sync was asked for by name", () => {
-		const mailbox = { lastMessageSyncAt: NOW - 1_000 };
-
-		assert.equal(mailboxNeedsSync(mailbox, askedForByName, NOW), true);
-	});
-
-	// Without this, `GET /config` — which fires a trigger per account on every
-	// call — re-enumerates every folder an account owns on every page load.
-	it("skips a freshly-synced mailbox for a side-effect trigger", () => {
-		const mailbox = { lastMessageSyncAt: NOW - 1_000 };
-
-		assert.equal(mailboxNeedsSync(mailbox, sideEffect, NOW), false);
-	});
-
-	it("syncs a stale mailbox for a side-effect trigger", () => {
-		const mailbox = { lastMessageSyncAt: NOW - MAILBOX_FRESHNESS_MS - 1 };
-
-		assert.equal(mailboxNeedsSync(mailbox, sideEffect, NOW), true);
-	});
-
-	it("syncs exactly at the freshness threshold", () => {
-		const mailbox = { lastMessageSyncAt: NOW - MAILBOX_FRESHNESS_MS };
-
-		assert.equal(mailboxNeedsSync(mailbox, sideEffect, NOW), true);
-	});
-
-	it("always syncs a mailbox that has never synced", () => {
-		assert.equal(mailboxNeedsSync({}, sideEffect, NOW), true);
-		assert.equal(
-			mailboxNeedsSync({ lastMessageSyncAt: 0 }, sideEffect, NOW),
-			true,
-		);
-	});
-});
-
-describe("resolveMailboxFreshnessMs", () => {
-	it("defaults to the production window when unset", () => {
-		assert.equal(resolveMailboxFreshnessMs({}), DEFAULT_MAILBOX_FRESHNESS_MS);
-	});
-
-	it("honors a valid override", () => {
-		assert.equal(resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "0" }), 0);
-		assert.equal(
-			resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "1000" }),
-			1000,
-		);
-	});
-
-	it("falls back to the default for a non-numeric or negative value", () => {
-		assert.equal(
-			resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "" }),
-			DEFAULT_MAILBOX_FRESHNESS_MS,
-		);
-		assert.equal(
-			resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "abc" }),
-			DEFAULT_MAILBOX_FRESHNESS_MS,
-		);
-		assert.equal(
-			resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "-5" }),
-			DEFAULT_MAILBOX_FRESHNESS_MS,
-		);
-		assert.equal(
-			resolveMailboxFreshnessMs({ MAILBOX_FRESHNESS_MS: "1.5" }),
-			DEFAULT_MAILBOX_FRESHNESS_MS,
-		);
-	});
-});
-
-describe("splitInboxFirst", () => {
-	it("pulls INBOX out of the list whatever case it is spelled in", () => {
-		const { inbox, rest } = splitInboxFirst([
-			{ mailboxId: "mb-sent", fullPath: "Sent" },
-			{ mailboxId: "mb-inbox", fullPath: "Inbox" },
-			{ mailboxId: "mb-junk", fullPath: "Junk" },
-		]);
-
-		assert.equal(inbox?.mailboxId, "mb-inbox");
-		assert.deepEqual(
-			rest.map((mailbox) => mailbox.mailboxId),
-			["mb-sent", "mb-junk"],
-		);
-	});
-
-	it("leaves an account without an INBOX intact", () => {
-		const { inbox, rest } = splitInboxFirst([
-			{ mailboxId: "mb-sent", fullPath: "Sent" },
-		]);
-
-		assert.equal(inbox, undefined);
-		assert.deepEqual(
-			rest.map((mailbox) => mailbox.mailboxId),
-			["mb-sent"],
-		);
-	});
-});
-
-describe("emitSyncMessagesEvents", () => {
-	// Every event of an account shares one FIFO group, so arrival order is
-	// service order. pMap only bounds concurrency: it used to race all the
-	// emits, letting INBOX queue behind up to nineteen other folders while a
-	// person waited for their new mail.
-	it("emits INBOX before any other folder", async () => {
-		const emitted: string[] = [];
-		const mailboxes = Array.from({ length: 25 }, (_, index) => ({
-			mailboxId: `mb-${index}`,
-			fullPath: `Folder ${index}`,
-		}));
-		mailboxes.push({ mailboxId: "mb-inbox", fullPath: "INBOX" });
-
-		await emitSyncMessagesEvents("acc-1", mailboxes, async (event) => {
-			emitted.push(event.mailboxId);
-		});
-
-		assert.equal(emitted[0], "mb-inbox");
-		assert.equal(emitted.length, 26);
-	});
-
-	// Emitting INBOX and awaiting it is the whole fix: a fire-and-forget emit
-	// would leave it racing the fan-out again.
-	it("waits for the INBOX emit to resolve before emitting the rest", async () => {
-		const emitted: string[] = [];
-		let releaseInbox: () => void = () => {};
-		const inboxEmitted = new Promise<void>((resolve) => {
-			releaseInbox = resolve;
-		});
-
-		const done = emitSyncMessagesEvents(
-			"acc-1",
-			[
-				{ mailboxId: "mb-inbox", fullPath: "INBOX" },
-				{ mailboxId: "mb-sent", fullPath: "Sent" },
-			],
-			async (event) => {
-				emitted.push(event.mailboxId);
-				if (event.mailboxId === "mb-inbox") await inboxEmitted;
-			},
-		);
-
-		await new Promise((resolve) => setImmediate(resolve));
-		assert.deepEqual(emitted, ["mb-inbox"]);
-
-		releaseInbox();
-		await done;
-		assert.deepEqual(emitted, ["mb-inbox", "mb-sent"]);
-	});
-
-	it("emits every folder for an account with no INBOX", async () => {
-		const emitted: string[] = [];
-
-		await emitSyncMessagesEvents(
-			"acc-1",
-			[
-				{ mailboxId: "mb-sent", fullPath: "Sent" },
-				{ mailboxId: "mb-junk", fullPath: "Junk" },
-			],
-			async (event) => {
-				emitted.push(event.mailboxId);
-			},
-		);
-
-		assert.deepEqual(emitted.sort(), ["mb-junk", "mb-sent"]);
-	});
-});