@remit/imap-worker 0.0.89 → 0.0.91

package/src/handlers/append-sent-message.ts

@@ -1,264 +0,0 @@
-import { getClient } from "@remit/backend/client";
-import {
-	APPENDED_UID_NONE,
-	APPENDED_UID_UNREPORTED,
-	isSentCopyFiled,
-} from "@remit/data-ports";
-import { isNotFoundError } from "@remit/data-ports/errors";
-import { OutboxMessageStatus } from "@remit/domain-enums";
-import type { Logger } from "@remit/logger";
-import { OutboxAttachmentUnavailableError } from "@remit/mailbox-service/outbox-attachment-content";
-import {
-	buildMailMessage,
-	renderRawMessage,
-} from "@remit/smtp-service/message-builder";
-import { attemptBudget } from "@remit/sqs-client/attempt-budget";
-import { isAccountDeleted } from "../account-check.js";
-import { createConnectionScopeWithCredentials } from "../connection-scope.js";
-import type { AppendSentMessageEvent } from "../events.js";
-import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
-import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
-
-const UNFILED_NO_SENT_MAILBOX =
-	"Sent, but not filed: this account has no folder appointed to the Sent role and none that a Sent folder could be recognised by. Appoint one in the account's folder settings and later messages will be filed there.";
-
-const UNFILED_SIGNED_OUT =
-	"Sent, but not filed: this account has to be signed in again before a copy can be stored in Sent.";
-
-const ROW_SURVIVED_ITS_DELETE =
-	"Sent message was filed but its outbox row survived its delete and stays hidden until the boot-time repair";
-
-const unfiledAppendRefused = (fullPath: string, error: unknown): string =>
-	error instanceof OutboxAttachmentUnavailableError
-		? `Sent, but not filed: the copy for ${fullPath} could not be built because ${error.message}.`
-		: `Sent, but not filed: the mail server refused to store a copy in ${fullPath} (${error instanceof Error ? error.message : String(error)}).`;
-
-export const getAppendSentMaxAttempts = (
-	processEnv: NodeJS.ProcessEnv = process.env,
-): number => attemptBudget("APPEND_SENT_MAX_ATTEMPTS", 3, processEnv);
-
-export const APPEND_SENT_MAX_ATTEMPTS = getAppendSentMaxAttempts();
-
-export const handleAppendSentMessage = async (
-	event: AppendSentMessageEvent,
-	log: Logger,
-	/**
-	 * SQS's own delivery count for this record. The APPEND is the last step of a
-	 * message the user has already had delivered, so exhausting the redrive
-	 * budget must settle the row rather than dead-letter it: a DLQ'd record
-	 * leaves the row at `sent`, which no view shows.
-	 */
-	receiveCount = 1,
-	createConnectionScope = createConnectionScopeWithCredentials,
-): Promise<void> => {
-	const {
-		account: accountService,
-		outboxMessage: outboxMessageService,
-		outboxAttachment: outboxAttachmentService,
-		mailboxSpecialUse: mailboxSpecialUseService,
-		secrets,
-	} = await getClient();
-
-	const { accountId, outboxMessageId } = event;
-
-	log.info({ event: event.type, accountId, outboxMessageId }, "Handling event");
-
-	const account = await accountService.get(accountId);
-	if (isAccountDeleted(account, log)) {
-		return;
-	}
-
-	// A row this event names can be gone by the time the event is redelivered:
-	// its own last attempt deleted it, or the boot repair dropped it on the
-	// strength of a recorded uid. Either way the work is done, and re-throwing
-	// the same NotFoundError on every redelivery only dead-letters it.
-	const outbox = await outboxMessageService
-		.get(account.accountConfigId, outboxMessageId)
-		.catch((error: unknown) => {
-			if (isNotFoundError(error)) return null;
-			throw error;
-		});
-	if (!outbox) {
-		log.warn(
-			{ accountId, outboxMessageId },
-			"Skipping APPEND_SENT_MESSAGE: the outbox row is already gone",
-		);
-		return;
-	}
-	if (outbox.status !== OutboxMessageStatus.sent) {
-		log.info(
-			{ outboxMessageId, status: outbox.status },
-			"Outbox message not in sent status, skipping APPEND",
-		);
-		return;
-	}
-
-	// The message left over SMTP; only the filing can still fail. Settling the
-	// row as `unfiled` keeps it in the Outbox list rather than deleting it, so a
-	// delivered message stays readable somewhere. Every path out of this handler
-	// that is not a confirmed APPEND ends here.
-	const settleUnfiled = async (reason: string): Promise<void> => {
-		log.error(
-			{ accountId, outboxMessageId, reason },
-			"Sent message could not be filed, settling the outbox row as unfiled",
-		);
-		await outboxMessageService.update(
-			account.accountConfigId,
-			outboxMessageId,
-			{
-				status: OutboxMessageStatus.unfiled,
-				lastError: reason,
-			},
-		);
-	};
-
-	// The copy is in Sent, so the row is a leftover and deleting it is all that
-	// is left to do. Both steps are idempotent against a row that is already
-	// gone, so nothing here needs to know how far the last attempt got.
-	//
-	// Files first, row second, the same order outbox-queue.ts discards a draft
-	// in. Nothing but this row points at those objects: a row that outlives its
-	// files is hidden and the boot repair drops it, while files that outlive
-	// their row name a message nothing can reach and are vouched for forever.
-	const dropOutboxRow = async (): Promise<void> => {
-		await outboxAttachmentService.discardAll(
-			account.accountConfigId,
-			accountId,
-			outboxMessageId,
-		);
-		await outboxMessageService.delete(account.accountConfigId, outboxMessageId);
-		log.info(
-			{ outboxMessageId },
-			"Deleted outbox row after successful APPEND to Sent",
-		);
-	};
-
-	// Everything this recovers from happened after the copy reached Sent, so
-	// re-appending is off the table and the delete is the only step left to
-	// retry. Below the redrive budget that retry is worth having; at it the
-	// record would dead-letter, so the row is left at `sent` for the repair.
-	const retryDropWithinBudget = (error: unknown): void => {
-		if (receiveCount < APPEND_SENT_MAX_ATTEMPTS) throw error;
-		log.error({ accountId, outboxMessageId, error }, ROW_SURVIVED_ITS_DELETE);
-	};
-
-	// A redelivery of an event whose APPEND already landed. The copy is in the
-	// user's Sent folder and the only step still owed is the delete that failed
-	// last time; starting from the top would file a second copy of a message the
-	// user sent once (#858). Ahead of the Sent-mailbox lookup on purpose — a
-	// message that is already filed does not need one, and an account that lost
-	// its Sent appointment in between must not settle as unfiled.
-	if (isSentCopyFiled(outbox)) {
-		log.info(
-			{ outboxMessageId, appendedUid: outbox.appendedUid },
-			"Sent copy was already filed by an earlier attempt, skipping the APPEND",
-		);
-		await dropOutboxRow().catch(retryDropWithinBudget);
-		return;
-	}
-
-	const sentMailbox = await mailboxSpecialUseService.findSentMailbox(accountId);
-	if (!sentMailbox) {
-		await settleUnfiled(UNFILED_NO_SENT_MAILBOX);
-		return;
-	}
-
-	let appendedUid = APPENDED_UID_NONE;
-
-	const failure = await withOAuthLifecycle(
-		buildLifecycleDeps(secrets, accountService),
-		account,
-		log,
-		async (credentials) => {
-			// Inside the retried unit: a file that cannot be read is retried below
-			// the budget and settles `unfiled` at it, rather than dead-lettering a
-			// delivered message out of every view.
-			const attachments = await outboxAttachmentService.contentsFor(
-				account.accountConfigId,
-				accountId,
-				outboxMessageId,
-			);
-			const scope = createConnectionScope(account, credentials);
-
-			await scope
-				.getConnection()
-				.then(async (connection) => {
-					const rawMessage = await renderRawMessage(
-						buildMailMessage(outbox, attachments),
-					);
-
-					const result = await connection.append(
-						sentMailbox.fullPath,
-						rawMessage,
-						["\\Seen"],
-					);
-
-					log.info(
-						{
-							outboxMessageId,
-							sentMailbox: sentMailbox.fullPath,
-							uid: result.uid,
-							uidValidity: result.uidValidity,
-						},
-						"Appended sent message to Sent mailbox",
-					);
-
-					// A server without UIDPLUS files the copy and names no uid for
-					// it, which is still a filed copy and has to read as one.
-					appendedUid = result.uid > 0 ? result.uid : APPENDED_UID_UNREPORTED;
-				})
-				.finally(() => scope.disconnect());
-
-			// The idempotency key, and the only reason a redelivery is safe. It is
-			// written before the delete and never after it: from here on every step
-			// can fail and be retried without the user gaining a second copy, and
-			// the one window that still can is this single row update.
-			await outboxMessageService.update(
-				account.accountConfigId,
-				outboxMessageId,
-				{ appendedUid },
-			);
-
-			// The message now lives in the IMAP Sent folder. Drop the outbox row so
-			// the user does not see it twice in the UI (Outbox + Sent). Issue #178.
-			await dropOutboxRow();
-		},
-	).then(
-		() => null,
-		(error: unknown) => {
-			// Below the redrive budget this is an ordinary retry — connections
-			// drop, servers go away, and the row is still `sent` for the next
-			// attempt to pick up. At the budget the record would dead-letter, and a
-			// dead-lettered APPEND is exactly how a delivered message goes missing.
-			//
-			// The budget still binds after a landed APPEND, though no longer to
-			// hold off a duplicate: the recorded uid does that, and the retries
-			// the budget allows re-drive the delete alone.
-			if (receiveCount < APPEND_SENT_MAX_ATTEMPTS) throw error;
-			return error;
-		},
-	);
-
-	// The APPEND landed: the copy is in Sent whatever failed after it, so there
-	// is nothing to settle as unfiled. A row that outlives its delete holds
-	// `sent`, which every view hides, until the migrator's boot-time stranded-row
-	// repair drops it — the next container start, not sooner (#824).
-	if (isSentCopyFiled({ appendedUid })) {
-		if (failure) {
-			log.error(
-				{ accountId, outboxMessageId, reason: String(failure) },
-				ROW_SURVIVED_ITS_DELETE,
-			);
-		}
-		return;
-	}
-
-	// A terminal auth failure returns here without throwing — withOAuthLifecycle
-	// flips the account to reauth_required and ACKs the record, which without
-	// this would leave the row at `sent` and the message nowhere.
-	await settleUnfiled(
-		failure
-			? unfiledAppendRefused(sentMailbox.fullPath, failure)
-			: UNFILED_SIGNED_OUT,
-	);
-};

package/src/handlers/delete-account-objects.test.ts

@@ -1,128 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import {
-	DeleteObjectsCommand,
-	ListObjectsV2Command,
-	S3Client,
-} from "@aws-sdk/client-s3";
-import {
-	type RecordingQueue,
-	recordingQueue,
-} from "@remit/data-ports/recording-queue";
-import { noopLogger } from "@remit/logger";
-import { mockClient } from "aws-sdk-client-mock";
-import type { DeleteAccountObjectsEvent } from "../events.js";
-import { setWorkerQueues } from "../queues.js";
-import { handleDeleteAccountObjects } from "./delete-account-objects.js";
-
-const s3Mock = mockClient(S3Client);
-let queue: RecordingQueue;
-
-const event: DeleteAccountObjectsEvent = {
-	type: "DELETE_ACCOUNT_OBJECTS",
-	accountConfigId: "cfg-1",
-};
-
-describe("handleDeleteAccountObjects", () => {
-	beforeEach(() => {
-		queue = recordingQueue();
-		setWorkerQueues({
-			mailboxes: queue,
-			messages: queue,
-			flags: queue,
-			body: queue,
-			mailboxManagement: queue,
-			messageManagement: queue,
-		});
-	});
-
-	afterEach(() => {
-		s3Mock.reset();
-	});
-
-	it("lists and deletes every object under the account prefix in one page", async () => {
-		s3Mock.on(ListObjectsV2Command).resolves({
-			Contents: [
-				{ Key: "accounts/cfg-1/a.eml" },
-				{ Key: "accounts/cfg-1/b.eml" },
-			],
-			IsTruncated: false,
-		});
-		s3Mock.on(DeleteObjectsCommand).resolves({});
-
-		await handleDeleteAccountObjects(event, noopLogger);
-
-		const listCall = s3Mock.commandCalls(ListObjectsV2Command)[0];
-		assert.equal(listCall.args[0].input.Prefix, "accounts/cfg-1/");
-
-		const deleteCall = s3Mock.commandCalls(DeleteObjectsCommand)[0];
-		assert.deepEqual(deleteCall.args[0].input.Delete?.Objects, [
-			{ Key: "accounts/cfg-1/a.eml" },
-			{ Key: "accounts/cfg-1/b.eml" },
-		]);
-		assert.equal(queue.sent.length, 0);
-	});
-
-	it("follows the continuation token across truncated pages", async () => {
-		s3Mock
-			.on(ListObjectsV2Command)
-			.resolvesOnce({
-				Contents: [{ Key: "accounts/cfg-1/p1.eml" }],
-				IsTruncated: true,
-				NextContinuationToken: "tok-2",
-			})
-			.resolvesOnce({
-				Contents: [{ Key: "accounts/cfg-1/p2.eml" }],
-				IsTruncated: false,
-			});
-		s3Mock.on(DeleteObjectsCommand).resolves({});
-
-		await handleDeleteAccountObjects(event, noopLogger);
-
-		const listCalls = s3Mock.commandCalls(ListObjectsV2Command);
-		assert.equal(listCalls.length, 2);
-		assert.equal(listCalls[1]?.args[0].input.ContinuationToken, "tok-2");
-		assert.equal(s3Mock.commandCalls(DeleteObjectsCommand).length, 2);
-	});
-
-	it("skips the delete call when a page holds no keys", async () => {
-		s3Mock.on(ListObjectsV2Command).resolves({ IsTruncated: false });
-
-		await handleDeleteAccountObjects(event, noopLogger);
-
-		assert.equal(s3Mock.commandCalls(DeleteObjectsCommand).length, 0);
-	});
-
-	it("re-enqueues with the continuation token when time is nearly up", async () => {
-		s3Mock.on(ListObjectsV2Command).resolves({ IsTruncated: false });
-
-		await handleDeleteAccountObjects(
-			{ ...event, continuationToken: "tok-mid" },
-			noopLogger,
-			() => 5_000,
-		);
-
-		assert.equal(
-			s3Mock.commandCalls(ListObjectsV2Command).length,
-			0,
-			"bails before starting a new page",
-		);
-		const body = queue.sent[0]?.body;
-		assert.equal(body?.type, "DELETE_ACCOUNT_OBJECTS");
-		assert.equal(body?.accountConfigId, "cfg-1");
-		assert.equal(body?.continuationToken, "tok-mid");
-	});
-
-	it("keeps paging while time remains", async () => {
-		s3Mock.on(ListObjectsV2Command).resolves({
-			Contents: [{ Key: "accounts/cfg-1/x.eml" }],
-			IsTruncated: false,
-		});
-		s3Mock.on(DeleteObjectsCommand).resolves({});
-
-		await handleDeleteAccountObjects(event, noopLogger, () => 120_000);
-
-		assert.equal(s3Mock.commandCalls(ListObjectsV2Command).length, 1);
-		assert.equal(queue.sent.length, 0);
-	});
-});

package/src/handlers/delete-account-objects.ts

@@ -1,94 +0,0 @@
-import {
-	DeleteObjectsCommand,
-	ListObjectsV2Command,
-	S3Client,
-} from "@aws-sdk/client-s3";
-import type { Logger } from "@remit/logger";
-import { env } from "expect-env";
-import type { DeleteAccountObjectsEvent } from "../events.js";
-import { workerQueues } from "../queues.js";
-
-const s3 = new S3Client({});
-
-const BATCH_SIZE = 1_000;
-const MIN_REMAINING_MS = 30_000;
-
-export const handleDeleteAccountObjects = async (
-	event: DeleteAccountObjectsEvent,
-	log: Logger,
-	getRemainingTimeMs?: () => number,
-): Promise<void> => {
-	const BUCKET_NAME = env.S3_BUCKET_NAME;
-	const { accountConfigId, continuationToken } = event;
-	const prefix = `accounts/${accountConfigId}/`;
-
-	log.info(
-		{ accountConfigId, prefix, hasContinuation: !!continuationToken },
-		"Deleting account objects from S3",
-	);
-
-	let currentToken = continuationToken;
-	let totalDeleted = 0;
-
-	while (true) {
-		// Check remaining time before starting a new page
-		if (getRemainingTimeMs && getRemainingTimeMs() < MIN_REMAINING_MS) {
-			log.info(
-				{ accountConfigId, totalDeleted, continuationToken: currentToken },
-				"Near timeout, re-enqueuing with continuation token",
-			);
-			await reenqueue(accountConfigId, currentToken);
-			return;
-		}
-
-		const listResult = await s3.send(
-			new ListObjectsV2Command({
-				Bucket: BUCKET_NAME,
-				Prefix: prefix,
-				MaxKeys: BATCH_SIZE,
-				ContinuationToken: currentToken,
-			}),
-		);
-
-		const keys = (listResult.Contents ?? [])
-			.map((obj) => obj.Key)
-			.filter((k): k is string => k !== undefined);
-
-		if (keys.length > 0) {
-			await s3.send(
-				new DeleteObjectsCommand({
-					Bucket: BUCKET_NAME,
-					Delete: {
-						Objects: keys.map((Key) => ({ Key })),
-						Quiet: true,
-					},
-				}),
-			);
-			totalDeleted += keys.length;
-		}
-
-		if (!listResult.IsTruncated) {
-			break;
-		}
-
-		currentToken = listResult.NextContinuationToken;
-	}
-
-	log.info(
-		{ accountConfigId, totalDeleted },
-		"Finished deleting account objects",
-	);
-};
-
-const reenqueue = async (
-	accountConfigId: string,
-	continuationToken: string | undefined,
-): Promise<void> => {
-	const event: DeleteAccountObjectsEvent = {
-		type: "DELETE_ACCOUNT_OBJECTS",
-		accountConfigId,
-		continuationToken,
-	};
-
-	await workerQueues().messageManagement.send({ body: event });
-};

package/src/handlers/empty-trash.sqlite.test.ts

@@ -1,209 +0,0 @@
-import assert from "node:assert/strict";
-import { after, before, describe, it } from "node:test";
-import type { MailboxItem } from "@remit/data-ports";
-import {
-	MailboxCursorState,
-	MailboxSpecialUse,
-	MessageStatus,
-} from "@remit/domain-enums";
-import type { EmptyTrashEvent } from "../events.js";
-import {
-	openStore,
-	type SeededMessage,
-	type World,
-} from "../test-helpers/test-world.js";
-import { handleEmptyTrash } from "./empty-trash.js";
-
-let store: Awaited<ReturnType<typeof openStore>>;
-
-before(async () => {
-	store = await openStore();
-});
-
-after(() => store.close());
-
-interface Arranged {
-	w: World;
-	inbox: MailboxItem;
-	trash: MailboxItem;
-	trashed: SeededMessage[];
-}
-
-const arrange = async (count = 2): Promise<Arranged> => {
-	const w = await store.world();
-	const inbox = await w.folder("INBOX");
-	const trash = await w.folder("Trash", {
-		specialUse: MailboxSpecialUse.Trash,
-	});
-	const trashed: SeededMessage[] = [];
-	for (let i = 0; i < count; i += 1) trashed.push(await w.message(trash));
-	return { w, inbox, trash, trashed };
-};
-
-/** Empty Trash through the service the API calls, and hand back its event. */
-const emptyTrash = async (a: Arranged): Promise<EmptyTrashEvent> => {
-	await a.w.client.messageMove.emptyTrash(
-		a.w.account.accountConfigId,
-		a.w.account.accountId,
-	);
-	const event = a.w
-		.queued()
-		.find((body) => body.type === "EMPTY_TRASH") as unknown as EmptyTrashEvent;
-	assert.ok(event, "Empty Trash enqueued an EMPTY_TRASH");
-	return event;
-};
-
-const run = (a: Arranged, event: EmptyTrashEvent) =>
-	handleEmptyTrash(event, a.w.log, a.w.scope);
-
-const visible = async (a: Arranged): Promise<boolean[]> =>
-	Promise.all(
-		a.trashed.map(async (message) => {
-			const row = await a.w.row(message.messageId);
-			const listing = await a.w.threadRows(message.messageId);
-			return (
-				row?.status === MessageStatus.active &&
-				listing.length > 0 &&
-				listing.every((tm) => !tm.isDeleted)
-			);
-		}),
-	);
-
-describe("Empty Trash", () => {
-	it("expunges every message on the server and removes both local rows", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-
-		await run(a, event);
-
-		assert.deepEqual(a.w.imap.uids("Trash"), []);
-		for (const message of a.trashed) {
-			assert.equal(await a.w.row(message.messageId), undefined);
-			assert.deepEqual(await a.w.threadRows(message.messageId), []);
-		}
-	});
-
-	it("hands every row back when another client emptied the Trash first", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		a.w.imap.empty("Trash");
-
-		await run(a, event);
-
-		assert.deepEqual(await visible(a), [true, true]);
-	});
-
-	it("keeps the row of a message the expunge never reached", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		const [kept, gone] = a.trashed;
-		a.w.imap.expunge("Trash", kept?.uid as number);
-
-		await run(a, event);
-
-		assert.equal(await a.w.row(gone?.messageId ?? ""), undefined);
-		assert.equal(
-			(await a.w.row(kept?.messageId ?? ""))?.status,
-			MessageStatus.active,
-		);
-	});
-
-	// A move into Trash that has not settled names Trash while still carrying
-	// INBOX's uid. Matching it against the expunge would delete whatever Trash
-	// holds at that number.
-	it("leaves a message whose move into Trash has not settled", async () => {
-		const a = await arrange(1);
-		const moving = await a.w.message(a.inbox);
-		await a.w.client.messageMove.deleteMessage(
-			a.w.account.accountConfigId,
-			moving.messageId,
-			a.w.account.accountId,
-		);
-		const event = await emptyTrash(a);
-
-		await run(a, event);
-
-		const row = await a.w.row(moving.messageId);
-		assert.equal(row?.status, MessageStatus.moving);
-		assert.deepEqual(a.w.imap.uids("INBOX"), [moving.uid]);
-		assert.equal(await a.w.row(a.trashed[0]?.messageId ?? ""), undefined);
-	});
-
-	it("expunges nothing and hands the rows back when the folder at the path is not the one emptied", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		a.w.imap.setUidValidity("Trash", 99);
-
-		await run(a, event);
-
-		assert.deepEqual(a.w.imap.commands("EXPUNGE"), []);
-		assert.deepEqual(await visible(a), [true, true]);
-	});
-
-	it("expunges nothing when the Trash role no longer rests on confirmed evidence", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		await a.w.client.mailboxSpecialUse.deleteByMailboxId(a.trash.mailboxId);
-
-		await run(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.deepEqual(await visible(a), [true, true]);
-	});
-
-	it("hands the rows back without connecting while the cursor is rebuilding", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		await a.w.client.mailbox.update(a.w.account.accountId, a.trash.mailboxId, {
-			cursorState: MailboxCursorState.rebuilding,
-		});
-
-		await run(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.deepEqual(await visible(a), [true, true]);
-	});
-
-	it("refuses an event minted under an unknown contract and hands the rows back", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-
-		await run(a, { ...event, schemaVersion: 99 } as unknown as EmptyTrashEvent);
-
-		assert.equal(a.w.imap.connections, 0);
-		assert.deepEqual(await visible(a), [true, true]);
-	});
-
-	it("acks without connecting when the Trash mailbox was deleted", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		await a.w.client.mailbox.delete(a.w.account.accountId, a.trash.mailboxId);
-
-		await run(a, event);
-
-		assert.equal(a.w.imap.connections, 0);
-	});
-
-	it("empties Trash under its current path when the folder was renamed after enqueue", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		a.w.imap.renameFolder("Trash", "Deleted Items");
-		await a.w.client.mailbox.update(a.w.account.accountId, a.trash.mailboxId, {
-			fullPath: "Deleted Items",
-		});
-
-		await run(a, event);
-
-		assert.deepEqual(a.w.imap.uids("Deleted Items"), []);
-	});
-
-	it("rethrows a failed expunge so the event is retried", async () => {
-		const a = await arrange();
-		const event = await emptyTrash(a);
-		a.w.imap.failNext.EXPUNGE = new Error("Connection reset");
-
-		await assert.rejects(run(a, event), /Connection reset/);
-
-		assert.equal(a.w.imap.uids("Trash").length, 2);
-	});
-});