Skip to content

Email for professionals and teams

15.0 KB
Raw Blame
import assert from "node:assert/strict";
import { mkdtempSync, rmSync } from "node:fs";
import { dirname, join } from "node:path";
import test, { after } from "node:test";
import { fileURLToPath, pathToFileURL } from "node:url";
import { build } from "esbuild";

const root = join(dirname(fileURLToPath(import.meta.url)), "..");
const directory = mkdtempSync(join(root, "node_modules", "mailbox-settings-test-"));
after(() => rmSync(directory, { recursive: true, force: true }));
await build({
	stdin: {
		contents: `
			export { SqliteDatabase } from "./server/runtime/sqlite-database.ts";
			export { applyMigrations } from "./server/runtime/migrate.ts";
			export { getDb } from "./src/db/index.ts";
			export { createSession } from "./src/lib/auth/session.ts";
			export { getMailboxAccessLevel, listAccessibleMailboxIds } from "./src/lib/mailboxes/access.ts";
			export { getAuthorizedSenderAddress } from "./src/lib/email/sender.ts";
			export * as detail from "./src/app/api/mailboxes/[id]/route.ts";
			export * as aliases from "./src/app/api/mailboxes/[id]/aliases/route.ts";
			export * as avatar from "./src/app/api/mailboxes/[id]/avatar/route.ts";
			export * as accountMailboxes from "./src/app/api/accounts/[id]/mailboxes/route.ts";
		`,
		resolveDir: root,
		sourcefile: "mailbox-settings-test-entry.ts",
	},
	outfile: join(directory, "entry.mjs"),
	bundle: true,
	platform: "node",
	format: "esm",
	target: "node24",
	tsconfig: join(root, "tsconfig.json"),
	packages: "external",
	alias: { "next/headers": "next/headers.js", "next/server": "next/server.js", "cloudflare:workers": "./server/runtime/cloudflare-workers.ts" },
	logLevel: "silent",
});
const { SqliteDatabase, applyMigrations, getDb, createSession, getMailboxAccessLevel, listAccessibleMailboxIds,
	getAuthorizedSenderAddress, detail, aliases, avatar, accountMailboxes } = await import(pathToFileURL(join(directory, "entry.mjs")).href);
const context = id => ({ params: Promise.resolve({ id }) });

async function fixture(t, plan = "team") {
	const database = new SqliteDatabase(":memory:");
	t.after(() => database.db.close());
	await applyMigrations(database, join(root, "drizzle/migrations"));
	const sql = database.db;
	const addUser = sql.prepare(`INSERT INTO users
		(id, email, password_hash, name, role, is_primary_admin, can_manage_users, can_manage_mailboxes, created_by_user_id, deleted_at, created_at)
		VALUES (?, ?, 'hash', ?, ?, ?, ?, ?, ?, ?, 1)`);
	for (const row of [
		["primary", "[email protected]", "Owner", "admin", 1, 0, 0, null, null],
		["manager", "[email protected]", "Manager", "admin", 0, 1, 0, "primary", null],
		["mailbox-admin", "[email protected]", "Limited", "admin", 0, 0, 1, "primary", null],
		["other-admin", "[email protected]", "Other admin", "admin", 0, 0, 0, "primary", null],
		["sam", "[email protected]", "Sam", "user", 0, 0, 1, "manager", null],
		["remote", "[email protected]", "Remote", "user", 0, 0, 0, "other-admin", null],
		["deleted", "[email protected]", "Deleted", "user", 0, 0, 0, "primary", 1],
	]) addUser.run(...row);
	sql.exec(`
		INSERT INTO domains (id, user_id, hostname, zone_id, status, created_at) VALUES
			('one', 'primary', 'one.test', 'zone-one', 'active', 1),
			('two', 'other-admin', 'two.test', 'zone-two', 'active', 1);
		INSERT INTO mailboxes (id, user_id, domain_id, local_part, display_name, type, use_all_domains, disabled, created_at) VALUES
			('m-owner', 'primary', 'one', 'owner', 'Owner', 'personal', 0, 0, 1),
			('m-sam', 'sam', 'one', 'sam', 'Stale name', 'personal', 0, 0, 1),
			('m-sales', 'sam', 'one', 'sales', 'Sales', 'personal', 0, 0, 1),
			('m-other', 'other-admin', 'two', 'other', 'Other admin', 'personal', 0, 0, 1),
			('m-remote', 'remote', 'two', 'remote', 'Remote', 'personal', 0, 0, 1),
			('m-deleted', 'deleted', 'one', 'deleted', 'Deleted', 'personal', 0, 0, 1),
			('m-disabled', 'sam', 'one', 'disabled', 'Disabled', 'personal', 0, 1, 1),
			('m-shared', 'primary', 'one', 'support', 'Support', 'shared', 0, 0, 1),
			('m-other-shared', 'other-admin', 'two', 'team', 'Team', 'shared', 0, 0, 1);
		UPDATE users SET avatar_key='avatars/sam' WHERE id='sam';
		INSERT INTO license_settings (id, instance_id, plan, state, features, updated_at)
			VALUES ('default', 'settings-test', 'team', 'active', '[]', 1);
	`);
	sql.prepare("UPDATE license_settings SET plan=?, state=? WHERE id='default'").run(plan, plan === "community" ? "inactive" : "active");
	const objects = new Map([["avatars/sam", new Uint8Array([1, 2, 3])]]);
	const env = {
		DB: database, MAILFLARE_RUNTIME: "node", CF_TOKEN: "test-only",
		BUCKET: {
			async put(key, data) { objects.set(key, new Uint8Array(data)); },
			async get(key) {
				const bytes = objects.get(key);
				return bytes ? { body: bytes, httpMetadata: { contentType: "image/webp" }, httpEtag: '"test"' } : null;
			},
		},
	};
	globalThis.__mailflareNodeEnv = env;
	t.after(() => { delete globalThis.__mailflareNodeEnv; });
	const sessions = new Map();
	for (const id of ["primary", "manager", "mailbox-admin", "other-admin", "sam", "remote"]) {
		sessions.set(id, await createSession(env, id));
	}
	const calls = [];
	const rules = [];
	t.mock.method(globalThis, "fetch", async (url, init = {}) => {
		const parsed = new URL(url);
		assert.equal(parsed.origin, "https://api.cloudflare.com", "tests must not contact real services");
		assert.match(parsed.pathname, /\/email\/routing\/rules/);
		const method = init.method ?? "GET";
		const body = init.body ? JSON.parse(init.body) : null;
		calls.push({ method, body });
		if (method === "GET") return Response.json({ success: true, result: rules });
		if (method === "DELETE") return Response.json({ success: true, result: {} });
		const rule = { ...body, id: `rule-${rules.length}` };
		rules.push(rule);
		return Response.json({ success: true, result: rule });
	});
	const request = (actor, path, method = "GET", body) => new Request(`https://mail.test${path}`, {
		method, headers: { Authorization: `Bearer ${sessions.get(actor)}`, Origin: "https://mail.test", ...(body instanceof FormData ? {} : { "Content-Type": "application/json" }) },
		...(body === undefined ? {} : { body: body instanceof FormData ? body : JSON.stringify(body) }),
	});
	const read = (actor, id) => detail.GET(request(actor, `/api/mailboxes/${id}`), context(id));
	const patch = (actor, id, body) => detail.PATCH(request(actor, `/api/mailboxes/${id}`, "PATCH", body), context(id));
	return { sql, env, db: getDb(env), objects, calls, request, read, patch };
}

test("primary admin can open indirectly created accounts and edit their primary mailbox identity", async t => {
	const f = await fixture(t);
	const listed = await accountMailboxes.GET(f.request("primary", "/api/accounts/sam/mailboxes"), context("sam"));
	assert.equal(listed.status, 200);
	assert.deepEqual((await listed.json()).mailboxes.map(row => row.id).sort(), ["m-disabled", "m-sales", "m-sam"]);
	const response = await f.read("primary", "m-sam");
	assert.equal(response.status, 200);
	const { mailbox } = await response.json();
	assert.equal(mailbox.displayName, "Sam");
	assert.equal(mailbox.hasAvatar, true);
	assert.equal(mailbox.isPrimary, true);
	assert.equal(mailbox.permission, null);
	assert.equal("ownerEmail" in mailbox, false);
	const saved = await f.patch("primary", "m-sam", { displayName: "Sam Updated", signature: "Thanks", useAllDomains: true });
	assert.equal(saved.status, 200);
	assert.equal((await saved.json()).mailbox.displayName, "Sam Updated");
	assert.deepEqual({ ...f.sql.prepare("SELECT name, avatar_key FROM users WHERE id='sam'").get() }, { name: "Sam Updated", avatar_key: "avatars/sam" });
	assert.equal(f.sql.prepare("SELECT signature FROM mailboxes WHERE id='m-sam'").get().signature, "Thanks");
	assert.equal(f.sql.prepare("SELECT display_name FROM mailboxes WHERE id='m-sales'").get().display_name, "Sales");
	assert.equal(f.sql.prepare("SELECT name FROM users WHERE id='primary'").get().name, "Owner");
	assert.ok(f.calls.some(call => call.method === "POST"));
});

test("secondary mailbox name and avatar remain independent of the account", async t => {
	const f = await fixture(t);
	const response = await f.patch("primary", "m-sales", { displayName: "Billing" });
	assert.equal(response.status, 200);
	const { mailbox } = await response.json();
	assert.equal(mailbox.isPrimary, false);
	assert.equal(mailbox.displayName, "Billing");
	assert.equal(f.sql.prepare("SELECT name FROM users WHERE id='sam'").get().name, "Sam");
	assert.equal((await f.patch("primary", "m-sam", { displayName: " " })).status, 400);
});

test("user managers can configure ordinary accounts but cannot manage administrators", async t => {
	const f = await fixture(t);
	for (const id of ["m-sam", "m-remote"]) {
		assert.equal((await f.read("manager", id)).status, 200);
		assert.equal((await f.patch("manager", id, { displayName: "Managed" })).status, 200);
	}
	assert.equal((await accountMailboxes.GET(f.request("manager", "/api/accounts/remote/mailboxes"), context("remote"))).status, 200);
	for (const id of ["m-owner", "m-other", "m-shared"]) {
		assert.equal((await f.read("manager", id)).status, 404);
		assert.equal((await f.patch("manager", id, { displayName: "Denied" })).status, 404);
	}
	assert.equal((await f.patch("primary", "m-other", { displayName: "Other Updated" })).status, 200);
});

test("mailbox-only admins and ordinary users cannot configure other users' mailboxes", async t => {
	const f = await fixture(t);
	for (const actor of ["mailbox-admin", "other-admin", "remote"]) {
		assert.equal((await f.read(actor, "m-sam")).status, 404);
		assert.equal((await f.patch(actor, "m-sam", { displayName: "Denied" })).status, 404);
		assert.equal((await aliases.GET(f.request(actor, "/api/mailboxes/m-sam/aliases"), context("m-sam"))).status, 404);
		assert.equal((await aliases.POST(f.request(actor, "/api/mailboxes/m-sam/aliases", "POST", { localPart: "denied", domainId: "one" }), context("m-sam"))).status, 404);
		assert.equal((await aliases.DELETE(f.request(actor, "/api/mailboxes/m-sam/aliases?aliasId=missing", "DELETE"), context("m-sam"))).status, 404);
		assert.equal((await avatar.GET(f.request(actor, "/api/mailboxes/m-sam/avatar"), context("m-sam"))).status, 404);
		assert.equal((await avatar.POST(f.request(actor, "/api/mailboxes/m-sam/avatar", "POST", new FormData()), context("m-sam"))).status, 404);
	}
	for (const id of ["missing", "m-disabled", "m-deleted"]) {
		assert.equal((await f.read("primary", id)).status, 404);
		assert.equal((await f.patch("primary", id, { displayName: "Denied" })).status, 404);
	}
});

test("owners and shared mailbox grants keep their existing settings permissions", async t => {
	const f = await fixture(t);
	assert.equal((await f.patch("sam", "m-sales", { displayName: "My Sales" })).status, 200);
	f.sql.exec("INSERT INTO mailbox_access (id,mailbox_id,user_id,permission,created_by_user_id,created_at) VALUES ('grant','m-shared','sam','read_only','primary',1)");
	assert.equal((await f.read("sam", "m-shared")).status, 200);
	assert.equal((await f.patch("sam", "m-shared", { displayName: "Denied" })).status, 404);
	f.sql.exec("UPDATE mailbox_access SET permission='full_access' WHERE id='grant'");
	assert.equal((await f.patch("sam", "m-shared", { displayName: "Shared Updated" })).status, 200);
});

test("administrative mailbox settings preserve the account license requirement", async t => {
	for (const plan of ["community", "pro"]) {
		const f = await fixture(t, plan);
		assert.equal((await f.read("primary", "m-sam")).status, plan === "pro" ? 200 : 404);
		assert.equal((await f.patch("primary", "m-sam", { displayName: "Licensed" })).status, plan === "pro" ? 200 : 404);
		assert.equal((await f.patch("sam", "m-sales", { displayName: "My Sales" })).status, 200);
	}
});

test("administrators can manage aliases within the mailbox's domain-owner scope", async t => {
	const f = await fixture(t);
	const path = "/api/mailboxes/m-sam/aliases";
	const read = await aliases.GET(f.request("primary", path), context("m-sam"));
	assert.equal(read.status, 200);
	assert.deepEqual((await read.json()).availableDomains.map(row => row.id), ["one"]);
	assert.equal((await aliases.POST(f.request("primary", path, "POST", { localPart: "billing", domainId: "two" }), context("m-sam"))).status, 404);
	const created = await aliases.POST(f.request("primary", path, "POST", { localPart: "billing", domainId: "one" }), context("m-sam"));
	assert.equal(created.status, 200);
	const [alias] = (await created.json()).aliases;
	assert.equal(alias.localPart, "billing");
	assert.equal((await aliases.DELETE(f.request("primary", `${path}?aliasId=${alias.id}`, "DELETE"), context("m-sam"))).status, 200);
	assert.equal(f.sql.prepare("SELECT count(*) AS count FROM mailbox_aliases").get().count, 0);
	assert.ok(f.calls.some(call => call.method === "DELETE"));
});

test("administrative avatar edits follow the mailbox owner's primary identity", async t => {
	const f = await fixture(t);
	const response = await avatar.GET(f.request("primary", "/api/mailboxes/m-sam/avatar"), context("m-sam"));
	assert.equal(response.status, 200);
	assert.deepEqual([...new Uint8Array(await response.arrayBuffer())], [1, 2, 3]);
	for (const id of ["m-sam", "m-sales"]) {
		const form = new FormData();
		form.set("file", new File([new Uint8Array([4, 5])], "avatar.webp", { type: "image/webp" }));
		form.set("preview", new File([new Uint8Array([6])], "preview.webp", { type: "image/webp" }));
		assert.equal((await avatar.POST(f.request("primary", `/api/mailboxes/${id}/avatar`, "POST", form), context(id))).status, 200);
	}
	assert.equal(f.sql.prepare("SELECT avatar_key FROM users WHERE id='sam'").get().avatar_key, "avatars/sam");
	assert.equal(f.sql.prepare("SELECT avatar_key FROM mailboxes WHERE id='m-sam'").get().avatar_key, "avatars/sam");
	assert.equal(f.sql.prepare("SELECT avatar_key FROM mailboxes WHERE id='m-sales'").get().avatar_key, "mailbox-avatars/m-sales");
	assert.deepEqual([...f.objects.get("avatars/sam")], [4, 5]);
	assert.equal(f.objects.has("mailbox-avatars/m-sales:preview"), true);
});

test("configuration access does not grant message access, sending rights or shared membership management", async t => {
	const f = await fixture(t);
	for (const actor of ["primary", "manager"]) {
		assert.equal((await f.patch(actor, "m-sam", { signature: "Managed signature" })).status, 200);
		const row = f.sql.prepare("SELECT id, role FROM users WHERE id=?").get(actor);
		assert.equal(await getMailboxAccessLevel(f.db, row, "m-sam"), null);
		assert.equal((await listAccessibleMailboxIds(f.db, { ...row, email: `${actor}@one.test` })).includes("m-sam"), false);
		await assert.rejects(getAuthorizedSenderAddress(f.env, { userId: actor, mailboxId: "m-sam", from: "[email protected]" }), /permission to send/);
	}
	const shared = await f.read("primary", "m-shared");
	assert.equal((await shared.json()).mailbox.canManageSharing, true);
	const foreign = await f.patch("primary", "m-other-shared", { displayName: "Managed Team" });
	assert.equal(foreign.status, 200);
	const { mailbox } = await foreign.json();
	assert.equal(mailbox.canManageSharing, false);
	assert.equal(mailbox.permission, null);
	assert.equal(mailbox.displayName, "Managed Team");
	assert.equal(await getMailboxAccessLevel(f.db, { id: "primary", role: "admin" }, "m-other-shared"), null);
});