Skip to content

Email for professionals and teams

7.6 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";
import { JSDOM } from "jsdom";

const root = join(dirname(fileURLToPath(import.meta.url)), "..");
const outDir = mkdtempSync(join(root, "tests", ".tmp-send-view-status-"));
const outfile = join(outDir, "hook.mjs");
after(() => rmSync(outDir, { recursive: true, force: true }));

const dom = new JSDOM("<!doctype html><html><body></body></html>", { url: "https://mail.example/" });
for (const key of ["window", "document", "HTMLElement", "Element", "Node", "Event"]) {
	globalThis[key] = key === "window" ? dom.window : dom.window[key];
}
globalThis.IS_REACT_ACT_ENVIRONMENT = true;

const mocks = new Map([
	["next/navigation", `
		const router = {
			replace(destination) { globalThis.__sendViewReplace(destination); },
			push() {},
			refresh() {},
			back() {},
			forward() {},
			prefetch() {},
		};
		export function usePathname() { return globalThis.__sendViewPathname; }
		export function useRouter() { return router; }
	`],
	["@/lib/auth/client", `
		export function authFetch(...args) { return globalThis.__sendViewFetch(...args); }
	`],
	["@/lib/messages/detail-cache", `
		export function clearMessageDetailCache() { globalThis.__sendViewClearCache(); }
	`],
]);

await build({
	stdin: {
		contents: `
			import { createElement } from "react";
			import { createRoot } from "react-dom/client";
			import { act } from "react";
			import { useSendViewStatus } from "@/components/messages/use-send-view-status";

			async function flushTurns() {
				for (let turn = 0; turn < 3; turn++) {
					await new Promise(resolve => setImmediate(resolve));
				}
			}
			async function settle() {
				await act(async () => { await flushTurns(); });
			}

			export async function mountReader(messageId) {
				document.body.replaceChildren();
				const container = document.createElement("div");
				document.body.appendChild(container);
				const root = createRoot(container);
				function Reader() {
					useSendViewStatus(messageId);
					return null;
				}
				await act(async () => { root.render(createElement(Reader)); });
				await settle();
				return {
					async unmount() { await act(async () => { root.unmount(); }); },
				};
			}

			export async function messagesChanged() {
				await act(async () => {
					window.dispatchEvent(new window.Event("mailflare:messages-changed"));
				});
				await settle();
			}
		`,
		resolveDir: root,
		loader: "tsx",
	},
	outfile,
	bundle: true,
	platform: "browser",
	format: "esm",
	target: "es2022",
	tsconfig: join(root, "tsconfig.json"),
	external: ["react", "react-dom", "react-dom/client", "jsdom"],
	alias: { "@": join(root, "src") },
	banner: { js: 'import { createRequire } from "node:module"; const require = createRequire(import.meta.url);' },
	plugins: [{
		name: "send-view-status-mocks",
		setup(builder) {
			builder.onResolve({ filter: /.*/ }, args => {
				if (mocks.has(args.path)) return { path: args.path, namespace: "send-view-status-mock" };
				return undefined;
			});
			builder.onLoad({ filter: /.*/, namespace: "send-view-status-mock" }, args => ({ contents: mocks.get(args.path), loader: "js" }));
		},
	}],
	logLevel: "silent",
});

const { mountReader, messagesChanged } = await import(pathToFileURL(outfile).href);

function statusResponse(status, ok = true) {
	return { ok, status: ok ? 200 : 500, json: async () => ({ status }) };
}

/** Installs mutable pathname, stable-router replace spy, controlled fetch and cache-clear spy. */
function prepare({ pathname, responses = [] }) {
	const calls = [];
	const replacements = [];
	const cleared = [];
	const queue = [...responses];
	globalThis.__sendViewPathname = pathname;
	globalThis.__sendViewReplace = destination => { replacements.push(destination); };
	globalThis.__sendViewFetch = async (url, init) => {
		calls.push({ url: String(url), cache: init?.cache });
		if (queue.length === 0) throw new Error(`unexpected status request for ${url}`);
		const next = queue.shift();
		return typeof next === "function" ? next() : next;
	};
	globalThis.__sendViewClearCache = () => { cleared.push(true); };
	return { calls, replacements, cleared, queue };
}

function trackMessagesChanged(t) {
	const seen = [];
	const listener = () => { seen.push("changed"); };
	window.addEventListener("mailflare:messages-changed", listener);
	t.after(() => window.removeEventListener("mailflare:messages-changed", listener));
	return seen;
}

test("a scheduled reader navigates to the sent reader after confirmed delivery and clears its cache", async t => {
	const view = prepare({ pathname: "/scheduled/msg-1", responses: [statusResponse("sent")] });
	const changes = trackMessagesChanged(t);
	const reader = await mountReader("msg-1");
	t.after(() => reader.unmount());

	assert.deepEqual(view.calls, [{ url: "/api/messages/msg-1/send-status", cache: "no-store" }]);
	assert.deepEqual(view.replacements, ["/sent/msg-1"]);
	assert.equal(view.cleared.length, 1, "the reader's detail cache is cleared before the move");
	assert.deepEqual(changes, ["changed"], "listeners learn the message list needs to refresh");
	assert.equal(view.calls.length, 1, "the emitted change event does not fetch again after moving");
});

test("a messages-changed event re-checks a scheduled reader until delivery is confirmed", async t => {
	const view = prepare({
		pathname: "/scheduled/msg-2",
		responses: [statusResponse("queued"), statusResponse("sent")],
	});
	const reader = await mountReader("msg-2");
	t.after(() => reader.unmount());

	assert.equal(view.calls.length, 1);
	assert.deepEqual(view.replacements, [], "a queued message stays in the scheduled reader");

	await messagesChanged();

	assert.equal(view.calls.length, 2);
	assert.deepEqual(view.replacements, ["/sent/msg-2"]);
	assert.equal(view.cleared.length, 1);
});

for (const [pathname, destination] of [
	["/scheduled/msg-draft", "/scheduled"],
	["/sent/msg-draft", "/sent"],
]) {
	test(`a draft status closes the ${pathname.startsWith("/scheduled/") ? "scheduled" : "sent"} reader`, async t => {
		const view = prepare({ pathname, responses: [statusResponse("draft")] });
		const changes = trackMessagesChanged(t);
		const reader = await mountReader("msg-draft");
		t.after(() => reader.unmount());

		assert.deepEqual(view.replacements, [destination]);
		assert.equal(view.cleared.length, 1);
		assert.deepEqual(changes, ["changed"]);
	});
}

test("folder lists and unrelated message routes never request status or navigate", async () => {
	for (const pathname of ["/scheduled", "/sent", "/inbox", "/scheduled/other-id", "/sent/other-id", "/inbox/msg-3"]) {
		const view = prepare({ pathname, responses: [] });
		const reader = await mountReader("msg-3");
		await reader.unmount();

		assert.equal(view.calls.length, 0, `${pathname} does not poll`);
		assert.deepEqual(view.replacements, [], `${pathname} does not navigate`);
		assert.equal(view.cleared.length, 0, `${pathname} does not clear a cache`);
	}
});

test("a status response resolved after unmount cannot navigate or clear the cache", async t => {
	let resolveFetch;
	const view = prepare({
		pathname: "/scheduled/msg-inflight",
		responses: [() => new Promise(resolve => { resolveFetch = resolve; })],
	});
	const changes = trackMessagesChanged(t);
	const reader = await mountReader("msg-inflight");
	assert.equal(view.calls.length, 1);

	await reader.unmount();
	resolveFetch(statusResponse("sent"));
	await new Promise(resolve => setImmediate(resolve));
	await new Promise(resolve => setImmediate(resolve));

	assert.deepEqual(view.replacements, []);
	assert.equal(view.cleared.length, 0);
	assert.deepEqual(changes, []);
});