@remit/mailbox-service 0.0.111 → 0.0.112

package/src/mailbox-rename-subtree.test.ts

@@ -1,408 +1,191 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { AccountItem, MailboxItem } from "@remit/data-ports";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import { MailboxManagementService } from "./mailbox-management.js";
+import { FolderGoneUpstreamError } from "./mailbox-upstream.js";
 import {
-	FolderGoneUpstreamError,
-	FolderRenameSettleError,
-} from "./mailbox-upstream.js";
-import type { IImapConnection } from "./types.js";
-
-/**
- * A folder mid-rename: the confirmed path the server still holds, and the
- * target the intent recorded (D2). The settle's row set is exactly the rows
- * carrying such a target, which is what makes it independent of whatever the
- * subtree looks like by the time the RENAME lands (D15).
- */
-const renaming = (
-	mailboxId: string,
-	fullPath: string,
-	pendingPath: string,
-): MailboxItem =>
-	({
-		mailboxId,
-		accountId: "acc-1",
-		fullPath,
-		hierarchyDelimiter: "/",
-		namespacePrefix: "",
-		syncStatus: MailboxSyncStatus.pending,
-		pendingPath,
-	}) as MailboxItem;
-
-const settled = (
-	mailboxId: string,
+	type FakeImapConnection,
+	FakeImapServer,
+} from "./test-helpers/fake-imap.js";
+import {
+	beforeNext,
+	openStore,
+	type Store,
+	seedAccount,
+	seedMailbox,
+} from "./test-helpers/test-store.js";
+
+let store: Store;
+let imap: FakeImapServer;
+let account: AccountItem;
+
+beforeEach(async () => {
+	store = await openStore();
+	imap = new FakeImapServer();
+	account = await seedAccount(store);
+});
+
+afterEach(() => store.close());
+
+const folder = async (
 	fullPath: string,
-	syncStatus: MailboxItem["syncStatus"] = MailboxSyncStatus.synced,
-): MailboxItem =>
-	({
-		mailboxId,
-		accountId: "acc-1",
-		fullPath,
-		hierarchyDelimiter: "/",
-		namespacePrefix: "",
-		syncStatus,
-	}) as MailboxItem;
-
-const store = (rows: MailboxItem[], vanishBeforeSettle: string[] = []) => {
-	const byId = new Map(rows.map((r) => [r.mailboxId, { ...r }]));
-
-	const repo: Pick<
-		IMailboxRepository,
-		"get" | "update" | "transition" | "findBySyncStatus"
-	> = {
-		get: (async (_accountId: string, mailboxId: string) => {
-			const found = byId.get(mailboxId as string);
-			if (!found) {
-				throw Object.assign(new Error(`Mailbox not found: ${mailboxId}`), {
-					name: "NotFoundError",
-				});
-			}
-			return found;
-		}) as IMailboxRepository["get"],
-		update: async (_accountId, mailboxId, patch) => {
-			const existing = byId.get(mailboxId);
-			if (!existing) {
-				throw Object.assign(new Error(`Mailbox not found: ${mailboxId}`), {
-					name: "NotFoundError",
-				});
-			}
-			const next = { ...existing, ...patch } as MailboxItem;
-			byId.set(mailboxId, next);
-			return next;
-		},
-		transition: async (_accountId, mailboxId, intent) => {
-			const existing = byId.get(mailboxId);
-			if (!existing) return null;
-			if (!intent.from.includes(existing.syncStatus)) return null;
-			if (
-				intent.wherePendingPath !== undefined &&
-				(intent.wherePendingPath ?? undefined) !== existing.pendingPath
-			) {
-				return null;
-			}
-			const keepsTarget =
-				intent.to === MailboxSyncStatus.pending ||
-				intent.to === MailboxSyncStatus.failed;
-			const next = {
-				...existing,
-				...(intent.set?.fullPath !== undefined
-					? { fullPath: intent.set.fullPath }
-					: {}),
-				syncStatus: intent.to,
-			} as MailboxItem;
-			if (!keepsTarget) delete (next as { pendingPath?: string }).pendingPath;
-			byId.set(mailboxId, next);
-			return next;
-		},
-		findBySyncStatus: async (_accountId, syncStatus) => {
-			const found = [...byId.values()].filter(
-				(r) => r.syncStatus === syncStatus,
-			);
-			for (const mailboxId of vanishBeforeSettle) byId.delete(mailboxId);
-			return found;
+	pendingPath?: string,
+	overrides: Partial<MailboxItem> = {},
+): Promise<MailboxItem> => {
+	imap.addFolder(fullPath);
+	const mailbox = await seedMailbox(store, account, fullPath, { overrides });
+	if (!pendingPath) return mailbox;
+	const recorded = await store.mailbox.transition(
+		account.accountId,
+		mailbox.mailboxId,
+		{
+			from: [MailboxSyncStatus.synced],
+			to: MailboxSyncStatus.pending,
+			set: { pendingPath },
 		},
-	};
+	);
+	if (!recorded) throw new Error(`could not record a rename on ${fullPath}`);
+	return recorded;
+};
 
-	return {
-		repo: repo as IMailboxRepository,
-		rowOf: (mailboxId: string) => byId.get(mailboxId),
-	};
+const current = (mailbox: MailboxItem) =>
+	store.mailbox.get(account.accountId, mailbox.mailboxId);
+
+const management = () => new MailboxManagementService(store.mailbox);
+
+const renameWork = (connection: FakeImapConnection = imap.connection()) =>
+	management().syncRename(
+		account.accountId,
+		workId as string,
+		"Work",
+		"Projects",
+		async () => connection,
+	);
+
+let workId: string | undefined;
+
+const work = async (
+	pendingPath: string | null = "Projects",
+	overrides: Partial<MailboxItem> = {},
+) => {
+	const mailbox = await folder("Work", pendingPath ?? undefined, overrides);
+	workId = mailbox.mailboxId;
+	return mailbox;
 };
 
-const connection = (newPath?: string): IImapConnection =>
-	({
-		renameMailbox: async (_old: string, requested: string) => ({
-			path: _old,
-			newPath: newPath ?? requested,
-		}),
-		listMailboxes: async () => [],
-	}) as unknown as IImapConnection;
-
-const refusing = (
-	error: Error,
-	listed: string[] | "unreadable" = [],
-): IImapConnection =>
-	({
-		renameMailbox: async () => {
-			throw error;
-		},
-		listMailboxes: async () => {
-			if (listed === "unreadable") throw new Error("IMAP connection lost");
-			return listed.map((fullPath) => ({ fullPath, delimiter: "/" }));
-		},
-	}) as unknown as IImapConnection;
+const assertAt = async (
+	mailbox: MailboxItem,
+	fullPath: string,
+	syncStatus: MailboxItem["syncStatus"],
+	pendingPath?: string,
+) => {
+	const row = await current(mailbox);
+	assert.equal(row.fullPath, fullPath);
+	assert.equal(row.syncStatus, syncStatus);
+	assert.equal(row.pendingPath, pendingPath);
+};
 
-const nonexistent = (): Error =>
-	Object.assign(new Error("Command failed"), {
-		serverResponseCode: "NONEXISTENT",
-		responseText: "Mailbox doesn't exist: Work",
-	});
+describe("MailboxManagementService.syncRename settles one intent", () => {
+	it("adopts the path the server resolved over the one requested", async () => {
+		const parent = await work();
+		const child = await folder("Work/2026", "Projects/2026");
+		imap.namespacePrefix = "INBOX/";
 
-describe("MailboxManagementService.syncRename — settling one intent", () => {
-	it("adopts the confirmed path on the folder and every row that carried the intent", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-child", "Work/2026", "Projects/2026"),
-			renaming("mbx-grandchild", "Work/2026/Q1", "Projects/2026/Q1"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
+		await renameWork();
 
-		assert.equal(result.success, true);
-		for (const [id, path] of [
-			["mbx-parent", "Projects"],
-			["mbx-child", "Projects/2026"],
-			["mbx-grandchild", "Projects/2026/Q1"],
-		] as const) {
-			assert.equal(rowOf(id)?.fullPath, path);
-			assert.equal(rowOf(id)?.syncStatus, MailboxSyncStatus.synced);
-			assert.equal(rowOf(id)?.pendingPath, undefined);
-		}
+		await assertAt(parent, "INBOX/Projects", MailboxSyncStatus.synced);
+		await assertAt(child, "INBOX/Projects/2026", MailboxSyncStatus.synced);
 	});
 
-	it("adopts the path ImapFlow resolved in preference to the requested one", async () => {
-		// Not the server echoing a name back — IMAP's RENAME reply carries none.
-		// It is ImapFlow's own normalization, with the namespace prefix applied,
-		// and adopting it is what stops the row and the server drifting apart.
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-child", "Work/2026", "Projects/2026"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection("INBOX/Projects"),
+	it("leaves rows it must not claim alone", async () => {
+		const parent = await work();
+		const interloper = await folder("Projects/Fresh");
+		const elsewhere = await folder("Admin", "Beheer");
+		const sameBranch = await folder("Other", "Projects/Old");
+		const offRebase = await folder("Work/2026", "Projects/Archief");
+
+		await renameWork();
+
+		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
+		await assertAt(interloper, "Projects/Fresh", MailboxSyncStatus.synced);
+		await assertAt(elsewhere, "Admin", MailboxSyncStatus.pending, "Beheer");
+		await assertAt(
+			sameBranch,
+			"Other",
+			MailboxSyncStatus.pending,
+			"Projects/Old",
 		);
-
-		assert.equal(rowOf("mbx-parent")?.fullPath, "INBOX/Projects");
-		assert.equal(rowOf("mbx-child")?.fullPath, "INBOX/Projects/2026");
-	});
-
-	it("leaves a folder the sweep inserted under the branch after the intent alone", async () => {
-		// D15: the settle applies to the rows that recorded the intent, and those
-		// rows identify themselves. Re-resolving the subtree would either throw —
-		// poisoning the account's FIFO group — or leave every row pending forever.
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			settled("mbx-interloper", "Projects/Fresh"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
+		await assertAt(
+			offRebase,
+			"Work/2026",
+			MailboxSyncStatus.pending,
+			"Projects/Archief",
 		);
-
-		assert.equal(result.success, true);
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.synced);
-		assert.equal(rowOf("mbx-interloper")?.fullPath, "Projects/Fresh");
-		assert.equal(rowOf("mbx-interloper")?.syncStatus, MailboxSyncStatus.synced);
 	});
 
-	it("settles the rest when a descendant is deleted after the intent", async () => {
-		const { repo, rowOf } = store(
-			[
-				renaming("mbx-parent", "Work", "Projects"),
-				renaming("mbx-gone", "Work/Gone", "Projects/Gone"),
-				renaming("mbx-child", "Work/2026", "Projects/2026"),
-			],
-			["mbx-gone"],
+	it("settles the rest when a descendant is deleted mid-settle", async () => {
+		const parent = await work();
+		const gone = await folder("Work/Gone", "Projects/Gone");
+		const child = await folder("Work/2026", "Projects/2026");
+		beforeNext(store.mailbox, "transition", () =>
+			store.mailbox.delete(account.accountId, gone.mailboxId),
 		);
-		const service = new MailboxManagementService(repo);
 
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
+		const result = await renameWork();
 
 		assert.equal(result.success, true);
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Projects");
-		assert.equal(rowOf("mbx-child")?.fullPath, "Projects/2026");
+		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
+		await assertAt(child, "Projects/2026", MailboxSyncStatus.synced);
 	});
 
-	it("does not touch a folder whose own rename is aimed somewhere else", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-other", "Admin", "Beheer"),
-		]);
-		const service = new MailboxManagementService(repo);
+	for (const [label, pendingPath] of [
+		["already settled", null],
+		["pending for another target", "Beheer"],
+	] as const) {
+		it(`issues no RENAME when the row is ${label}`, async () => {
+			await work(pendingPath);
 
-		await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
-
-		assert.equal(rowOf("mbx-other")?.fullPath, "Admin");
-		assert.equal(rowOf("mbx-other")?.pendingPath, "Beheer");
-		assert.equal(rowOf("mbx-other")?.syncStatus, MailboxSyncStatus.pending);
-	});
-
-	it("issues no RENAME when the row has already settled", async () => {
-		const { repo } = store([settled("mbx-parent", "Projects")]);
-		const service = new MailboxManagementService(repo);
-		let issued = 0;
-
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () =>
-				({
-					renameMailbox: async () => {
-						issued += 1;
-						return { path: "Work", newPath: "Projects" };
-					},
-				}) as unknown as IImapConnection,
-		);
+			const result = await renameWork();
 
-		assert.equal(result.success, true);
-		assert.equal(issued, 0, "a redelivery must not re-issue the rename");
-	});
-
-	it("issues no RENAME when the row is pending for a different target", async () => {
-		// A redelivered MAILBOX_RENAME against a folder a second rename has since
-		// claimed. `pending` alone passes; the recorded target is what refuses it,
-		// and re-issuing from a path that has already moved is what that prevents.
-		const { repo, rowOf } = store([renaming("mbx-parent", "Work", "Beheer")]);
-		const service = new MailboxManagementService(repo);
-		let issued = 0;
-
-		await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () =>
-				({
-					renameMailbox: async () => {
-						issued += 1;
-						return { path: "Work", newPath: "Projects" };
-					},
-				}) as unknown as IImapConnection,
-		);
-
-		assert.equal(issued, 0);
-		assert.equal(rowOf("mbx-parent")?.pendingPath, "Beheer");
-	});
+			assert.equal(result.success, true);
+			assert.ok(imap.hasFolder("Work"));
+			assert.equal(imap.hasFolder("Projects"), false);
+		});
+	}
 });
 
-describe("MailboxManagementService.syncRename — rows it must not claim", () => {
-	it("leaves a row a different rename recorded under the same branch alone", async () => {
-		// Two renames aimed under one path. Matching on the recorded target alone
-		// stamps `Other` onto a path this rename never asked for, leaves its own
-		// rename with nothing left to settle, and hands the sweep two rows
-		// claiming one path to reap and re-insert.
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-other", "Other", "Projects/Old"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
-
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Projects");
-		assert.equal(rowOf("mbx-other")?.fullPath, "Other");
-		assert.equal(rowOf("mbx-other")?.pendingPath, "Projects/Old");
-		assert.equal(rowOf("mbx-other")?.syncStatus, MailboxSyncStatus.pending);
-	});
+describe("MailboxManagementService.syncRename reads a NONEXISTENT answer", () => {
+	it("settles when the source has moved because the rename already landed", async () => {
+		const parent = await work();
+		await imap.connection().renameMailbox("Work", "Projects");
 
-	it("leaves a descendant whose recorded target is not this rename's rebase", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-child", "Work/2026", "Projects/Archief"),
-		]);
-		const service = new MailboxManagementService(repo);
+		const result = await renameWork();
 
-		await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
-
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Projects");
-		assert.equal(rowOf("mbx-child")?.fullPath, "Work/2026");
-		assert.equal(rowOf("mbx-child")?.syncStatus, MailboxSyncStatus.pending);
+		assert.equal(result.success, true);
+		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
 	});
 
-	it("fails only the rows this rename recorded", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-other", "Other", "Projects/Old"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		await service.failRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			"Permission denied",
-		);
-
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.failed);
-		assert.equal(rowOf("mbx-other")?.syncStatus, MailboxSyncStatus.pending);
-	});
-});
+	it("reads the target through the account's namespace prefix", async () => {
+		const parent = await work("Projects", {
+			hierarchyDelimiter: ".",
+			namespacePrefix: "INBOX.",
+		});
+		imap.removeFolder("Work");
+		imap.addFolder("INBOX.Projects");
 
-describe("MailboxManagementService.syncRename — a rename that already landed", () => {
-	it("settles rather than deleting when NONEXISTENT means the source has moved", async () => {
-		// A redelivery after a lost settle re-issues RENAME from a path that has
-		// moved. Reading that NONEXISTENT as an upstream delete drops the folder
-		// and its mail while the folder is alive at the target.
-		const { repo, rowOf } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
-
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => refusing(nonexistent(), ["Projects"]),
-		);
+		const result = await renameWork();
 
 		assert.equal(result.success, true);
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Projects");
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.synced);
+		assert.equal((await current(parent)).syncStatus, MailboxSyncStatus.synced);
 	});
 
-	it("reports the folder as gone, carrying what the server said, when neither path is listed", async () => {
-		const { repo } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
+	it("reports the folder gone, carrying the server's answer, when neither path is listed", async () => {
+		await work();
+		imap.removeFolder("Work");
 
 		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				refusing(nonexistent(), ["Andere"]),
-			),
+			renameWork(),
 			(error: unknown) =>
 				error instanceof FolderGoneUpstreamError &&
 				(error.cause as { serverResponseCode?: string })?.serverResponseCode ===
@@ -410,144 +193,17 @@ describe("MailboxManagementService.syncRename — a rename that already landed",
 		);
 	});
 
-	it("raises a settle failure as its own kind, never as a refused rename", async () => {
-		// The server executed the rename. Marking the rows failed here would offer
-		// a retry of work already done, on a `fullPath` the server no longer holds.
-		const { repo, rowOf } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const broken = {
-			...repo,
-			transition: async () => {
-				throw new Error("database is locked");
-			},
-		} as unknown as IMailboxRepository;
-		const service = new MailboxManagementService(broken);
-
-		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				connection(),
-			),
-			(error: unknown) => error instanceof FolderRenameSettleError,
-		);
-
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.pending);
-		assert.equal(
-			rowOf("mbx-parent")?.pendingPath,
-			"Projects",
-			"the intent stands, so the redelivery finishes the settle",
-		);
-	});
-});
-
-describe("MailboxManagementService.syncRename — a settle that dies part-way", () => {
-	/**
-	 * The named folder's row is the redelivery's only witness: the guard reads
-	 * it and nothing else. Settling it before its descendants would ack a run
-	 * that stopped half way, and those rows would stay `pending` forever —
-	 * skipped by message sync, and with no route out, because an intent may only
-	 * be recorded from `synced` or `failed`.
-	 */
-	it("leaves the named folder carrying the intent when a descendant's write fails", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-child", "Work/2026", "Projects/2026"),
-		]);
-		let broken = true;
-		const flaky = {
-			...repo,
-			transition: async (
-				accountId: string,
-				mailboxId: string,
-				intent: Parameters<IMailboxRepository["transition"]>[2],
-			) => {
-				if (broken && mailboxId === "mbx-child") {
-					throw new Error("database is locked");
-				}
-				return repo.transition(accountId, mailboxId, intent);
-			},
-		} as unknown as IMailboxRepository;
-		const service = new MailboxManagementService(flaky);
-
-		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				connection(),
-			),
-			(error: unknown) => error instanceof FolderRenameSettleError,
-		);
-
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.pending);
-		assert.equal(rowOf("mbx-parent")?.pendingPath, "Projects");
-		assert.equal(rowOf("mbx-child")?.syncStatus, MailboxSyncStatus.pending);
-
-		// The redelivery re-enters against an intent still standing and finishes.
-		broken = false;
-		const redelivered = new MailboxManagementService(flaky);
-		const result = await redelivered.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => connection(),
-		);
-
-		assert.equal(result.success, true);
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Projects");
-		assert.equal(rowOf("mbx-child")?.fullPath, "Projects/2026");
-		assert.equal(rowOf("mbx-child")?.syncStatus, MailboxSyncStatus.synced);
-	});
-});
-
-describe("MailboxManagementService.syncRename — reading NONEXISTENT", () => {
-	const prefixed = (): MailboxItem =>
-		({
-			mailboxId: "mbx-parent",
-			accountId: "acc-1",
-			fullPath: "Work",
-			hierarchyDelimiter: ".",
-			namespacePrefix: "INBOX.",
-			syncStatus: MailboxSyncStatus.pending,
-			pendingPath: "Projects",
-		}) as MailboxItem;
-
-	it("reads the target through the account's namespace prefix", async () => {
-		// The requested string and the path the server keeps are not the same:
-		// a Dovecot INBOX namespace stores `Projects` as `INBOX.Projects`.
-		// Comparing the raw request against the listing reads a folder that is
-		// plainly there as absent — and that answer deletes the user's mail.
-		const { repo, rowOf } = store([prefixed()]);
-		const service = new MailboxManagementService(repo);
-
-		const result = await service.syncRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			async () => refusing(nonexistent(), ["INBOX.Projects"]),
-		);
-
-		assert.equal(result.success, true);
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("raises the confirmed kind only when the listing holds neither path", async () => {
-		const { repo } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
-
-		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				refusing(nonexistent(), ["Andere"]),
-			),
-			(error: unknown) => error instanceof FolderGoneUpstreamError,
-		);
-	});
-
-	it("refuses the rename rather than confirming a delete when the source is still listed", async () => {
-		const { repo } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
+	it("refuses rather than confirming a delete when the source is still listed", async () => {
+		await work();
+		const connection = imap.connection();
+		connection.renameMailbox = async () => {
+			throw Object.assign(new Error("Command failed"), {
+				serverResponseCode: "NONEXISTENT",
+			});
+		};
 
 		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				refusing(nonexistent(), ["Work"]),
-			),
+			renameWork(connection),
 			(error: unknown) =>
 				!(error instanceof FolderGoneUpstreamError) &&
 				(error as { serverResponseCode?: string }).serverResponseCode ===
@@ -555,110 +211,77 @@ describe("MailboxManagementService.syncRename — reading NONEXISTENT", () => {
 		);
 	});
 
-	it("refuses the rename when the listing cannot be read at all", async () => {
-		// A probe that answers nothing decides nothing. A refused rename costs a
-		// retry; reading an unclear answer as a delete costs the folder's mail.
-		const { repo } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
+	it("refuses rather than confirming a delete when the listing cannot be read", async () => {
+		await work();
+		imap.removeFolder("Work");
+		const connection = imap.connection();
+		connection.listMailboxes = async () => {
+			throw new Error("IMAP connection lost");
+		};
 
 		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				refusing(nonexistent(), "unreadable"),
-			),
+			renameWork(connection),
 			(error: unknown) => !(error instanceof FolderGoneUpstreamError),
 		);
 	});
 });
 
 describe("MailboxManagementService.failRename", () => {
-	it("marks every intent-carrying row failed, keeping its path and its target", async () => {
-		const { repo, rowOf } = store([
-			renaming("mbx-parent", "Work", "Projects"),
-			renaming("mbx-child", "Work/2026", "Projects/2026"),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		await service.failRename(
-			"acc-1",
-			"mbx-parent",
+	const fail = () =>
+		management().failRename(
+			account.accountId,
+			workId as string,
 			"Work",
 			"Projects",
 			"Permission denied",
 		);
 
-		for (const [id, path, target] of [
-			["mbx-parent", "Work", "Projects"],
-			["mbx-child", "Work/2026", "Projects/2026"],
-		] as const) {
-			assert.equal(rowOf(id)?.syncStatus, MailboxSyncStatus.failed);
-			assert.equal(rowOf(id)?.fullPath, path, "nothing is restored (D2)");
-			assert.equal(
-				rowOf(id)?.pendingPath,
-				target,
-				"the target is kept so the client can name it and offer a retry",
-			);
-		}
+	it("marks every row this rename recorded failed, keeping path and target", async () => {
+		const parent = await work();
+		const child = await folder("Work/2026", "Projects/2026");
+		const other = await folder("Other", "Projects/Old");
+
+		await fail();
+
+		await assertAt(parent, "Work", MailboxSyncStatus.failed, "Projects");
+		await assertAt(
+			child,
+			"Work/2026",
+			MailboxSyncStatus.failed,
+			"Projects/2026",
+		);
+		await assertAt(other, "Other", MailboxSyncStatus.pending, "Projects/Old");
 	});
 
-	it("raises a NotFoundError when the folder row itself is gone", async () => {
-		const { repo } = store([]);
-		const service = new MailboxManagementService(repo);
+	it("raises a NotFoundError when the folder row is gone", async () => {
+		workId = "mbx-gone";
 
 		await assert.rejects(
-			service.failRename(
-				"acc-1",
-				"mbx-parent",
-				"Work",
-				"Projects",
-				"Permission denied",
-			),
+			fail(),
 			(error: unknown) => (error as Error).name === "NotFoundError",
 		);
 	});
 
-	it("records nothing, quietly, when the row is there but carries no intent", async () => {
-		// Never a NotFoundError: the caller reads that as the user having deleted
-		// the folder and acks the message, which would swallow the IMAP failure
-		// that brought us here and leave the subtree `pending` with no retry.
-		const { repo } = store([settled("mbx-parent", "Work")]);
-		const service = new MailboxManagementService(repo);
-
-		await assert.doesNotReject(
-			service.failRename(
-				"acc-1",
-				"mbx-parent",
-				"Work",
-				"Projects",
-				"Permission denied",
-			),
-		);
+	it("records nothing, quietly, for a row that carries no intent", async () => {
+		const parent = await work(null);
+
+		await fail();
+
+		await assertAt(parent, "Work", MailboxSyncStatus.synced);
 	});
 
-	it("settles a rename ImapFlow never issued as a refusal, not a TypeError", async () => {
-		// `mailboxRename` resolves `undefined` when the connection is not
-		// AUTHENTICATED or SELECTED. The settle reads the resolved path, so an
-		// unguarded dereference would raise a TypeError the rename cannot classify.
-		const { repo, rowOf } = store([renaming("mbx-parent", "Work", "Projects")]);
-		const service = new MailboxManagementService(repo);
-		const notReady = new Error(
-			'Rename of "Work" was not issued: the IMAP connection is not ready',
-		);
+	it("fails a rename the connection never issued as a refusal", async () => {
+		const parent = await work();
+		const connection = imap.connection();
+		connection.renameMailbox = async () => {
+			throw new Error(
+				'Rename of "Work" was not issued: the IMAP connection is not ready',
+			);
+		};
 
-		await assert.rejects(
-			service.syncRename("acc-1", "mbx-parent", "Work", "Projects", async () =>
-				refusing(notReady),
-			),
-			/not ready/,
-		);
+		await assert.rejects(renameWork(connection), /not ready/);
+		await fail();
 
-		await service.failRename(
-			"acc-1",
-			"mbx-parent",
-			"Work",
-			"Projects",
-			"Permission denied",
-		);
-		assert.equal(rowOf("mbx-parent")?.syncStatus, MailboxSyncStatus.failed);
-		assert.equal(rowOf("mbx-parent")?.fullPath, "Work");
+		await assertAt(parent, "Work", MailboxSyncStatus.failed, "Projects");
 	});
 });