Best,
Me
Best,
Me
Best,
Me
hi
", "text": ""}, + ) + ctx.session.add(draft) + await ctx.session.commit() + return draft.id + + +async def test_push_draft_appends_with_draft_flag_and_replaces(ctx: Ctx, monkeypatch) -> None: # type: ignore[no-untyped-def] + did = await _make_draft(ctx) + fake = FakeProvider() + monkeypatch.setattr(draft_sync, "build_provider", lambda _a: fake) + + await draft_sync.push_draft_to_imap_job({}, str(did)) + + # appended once to DRAFTS with the \Draft flag; UID recorded on the draft + assert len(fake.appended) == 1 + assert fake.appended[0][0] == "DRAFTS" + assert "\\Draft" in fake.appended[0][1] + assert fake.deleted == [] # nothing to replace yet + async with session_scope() as s: + assert (await s.get(Draft, did)).imap_uid == 42 # type: ignore[union-attr] + + # A second push (edit) appends a new copy and expunges the previous UID. + await draft_sync.push_draft_to_imap_job({}, str(did)) + assert len(fake.appended) == 2 + assert fake.deleted == [("DRAFTS", [42])] + async with session_scope() as s: + assert (await s.get(Draft, did)).imap_uid == 43 # type: ignore[union-attr] + + +async def test_draft_messages_are_not_threaded(ctx: Ctx) -> None: + from datetime import UTC, datetime + from email.message import EmailMessage + + from app.indexer.indexer import persist_message + from app.providers.base import RemoteMessage + + m = EmailMessage() + m["Subject"] = "A draft reply" + m["From"] = "me@example.com" + m["To"] = "bob@example.com" + m["Message-ID"] = "hi
", "text": ""}, ) - raw, _from, _to = build_mime( + raw, _sent, _from, _to = build_mime( account, draft, None, [("report.pdf", "application/pdf", b"%PDF-1.4 data")] ) msg = email.message_from_bytes(raw, policy=default_policy) @@ -219,6 +223,79 @@ async def test_draft_crud(ctx: Ctx) -> None: assert deleted.status_code == 200 +async def test_remote_drafts_listed_and_adopted(ctx: Ctx) -> None: + from datetime import UTC, datetime + + from app.models import BodyPart + + # A "foreign" draft (as if created in another client) in the Drafts folder. + drafts_mb = Mailbox( + account_id=ctx.account_id, user_id=ctx.user_id, path="DRAFTS", special_use="drafts" + ) + ctx.session.add(drafts_mb) + await ctx.session.flush() + msg = Message( + user_id=ctx.user_id, + account_id=ctx.account_id, + mailbox_id=drafts_mb.id, + uid=94, + subject="Home draft", + to_addr=[{"name": "", "email": "bob@example.com"}], + cc_addr=[], + bcc_addr=[], + internal_date=datetime.now(UTC), + blob_sha256="x" * 64, + snippet="hello there", + ) + ctx.session.add(msg) + await ctx.session.flush() + ctx.session.add(BodyPart(message_id=msg.id, kind="html_sanitized", content="hello
")) + ctx.session.add(BodyPart(message_id=msg.id, kind="text", content="hello there")) + await ctx.session.commit() + + # It shows in the remote drafts list. + listing = await ctx.client.get("/api/drafts/remote") + assert listing.status_code == 200 + assert any(i["message_id"] == str(msg.id) and i["imap_uid"] == 94 for i in listing.json()) + + # Adopting turns it into an editable local draft (linked by UID). + adopted = await ctx.client.post(f"/api/drafts/adopt/{msg.id}", headers=_hdr()) + assert adopted.status_code == 200, adopted.text + draft = adopted.json() + assert draft["payload"]["subject"] == "Home draft" + assert draft["payload"]["to"] == ["bob@example.com"] + assert draft["payload"]["html"] == "hello
" + + # Now it's excluded from the remote list (we own that UID)... + listing2 = await ctx.client.get("/api/drafts/remote") + assert all(i["message_id"] != str(msg.id) for i in listing2.json()) + # ...and adopting again returns the same local draft (idempotent). + again = await ctx.client.post(f"/api/drafts/adopt/{msg.id}", headers=_hdr()) + assert again.json()["id"] == draft["id"] + + +async def test_publish_draft_enqueues_imap_mirror(ctx: Ctx) -> None: + did = (await ctx.client.post("/api/drafts", json=_draft_body(ctx), headers=_hdr())).json()["id"] + ctx.enqueued.clear() + resp = await ctx.client.post(f"/api/drafts/{did}/publish", headers=_hdr()) + assert resp.status_code == 200 + assert ctx.enqueued[-1][0] == ("push_draft_to_imap_job", did) + + +async def test_delete_draft_expunges_mirror_when_present(ctx: Ctx) -> None: + did = (await ctx.client.post("/api/drafts", json=_draft_body(ctx), headers=_hdr())).json()["id"] + # Simulate a previously mirrored copy (imap_uid set). + draft = await ctx.session.get(Draft, uuid.UUID(did)) + assert draft is not None + draft.imap_uid = 88 + await ctx.session.commit() + + ctx.enqueued.clear() + resp = await ctx.client.request("DELETE", f"/api/drafts/{did}", headers=_hdr()) + assert resp.status_code == 200 + assert ctx.enqueued[-1][0] == ("remove_imap_draft_job", str(ctx.account_id), 88) + + async def test_upload_and_list_compose_attachment(ctx: Ctx) -> None: resp = await ctx.client.post( "/api/attachments", @@ -332,6 +409,17 @@ async def test_send_job_success(ctx: Ctx, monkeypatch) -> None: # type: ignore[ ctx.session.expunge_all() async with session_scope() as verify: assert await verify.get(Draft, draft_id) is None + # The sent copy is persisted into the Sent mailbox (append UID 99). + sent_mb = await verify.scalar( + select(Mailbox).where( + Mailbox.account_id == ctx.account_id, Mailbox.special_use == "sent" + ) + ) + assert sent_mb is not None + sent_msg = await verify.scalar( + select(Message).where(Message.mailbox_id == sent_mb.id, Message.uid == 99) + ) + assert sent_msg is not None and sent_msg.subject == "Re: Hi" kr = await ctx.session.scalar( select(KnownRecipient).where( KnownRecipient.user_id == ctx.user_id, KnownRecipient.email == "bob@example.com" diff --git a/backend/tests/sync/test_secondary_poll.py b/backend/tests/sync/test_secondary_poll.py new file mode 100644 index 0000000..5a389a4 --- /dev/null +++ b/backend/tests/sync/test_secondary_poll.py @@ -0,0 +1,99 @@ +"""Secondary (non-INBOX) folder polling — multi-folder CONDSTORE sync (SPEC §6.3).""" + +from __future__ import annotations + +import uuid +from datetime import UTC, datetime +from email.message import EmailMessage + +from sqlalchemy import delete, func, select +from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine +from sqlalchemy.pool import NullPool + +from app.config import get_settings +from app.db import session_scope +from app.identity.passwords import hash_password +from app.models import Account, Mailbox, Message, User +from app.providers.base import MailboxDelta, RemoteMessage +from app.sync import engine as sync_engine + + +def _raw(subject: str, mid: str) -> bytes: + m = EmailMessage() + m["Subject"] = subject + m["From"] = "me@example.com" + m["To"] = "bob@example.com" + m["Message-ID"] = mid + m["Date"] = "Mon, 09 Mar 2026 08:36:37 +0100" + m.set_content("body") + return m.as_bytes() + + +async def test_secondary_poll_syncs_special_folders_not_inbox(monkeypatch) -> None: # type: ignore[no-untyped-def] + engine = create_async_engine(get_settings().database_url, poolclass=NullPool) + sm = async_sessionmaker(engine, expire_on_commit=False) + session = sm() + user = User(handle=f"sec{uuid.uuid4().hex[:8]}@test.local", password_hash=hash_password("pw")) + session.add(user) + await session.flush() + account = Account( + user_id=user.id, + email="me@example.com", + imap_config={}, + smtp_config={}, + secret_ct=b"", + discovery_src="manual", + ) + session.add(account) + await session.flush() + inbox = Mailbox(account_id=account.id, user_id=user.id, path="INBOX", special_use="inbox") + sent = Mailbox(account_id=account.id, user_id=user.id, path="SENT", special_use="sent") + custom = Mailbox(account_id=account.id, user_id=user.id, path="Notes", special_use=None) + session.add_all([inbox, sent, custom]) + await session.commit() + + polled: list[str] = [] + + class FakeProvider: + async def poll(self, mailbox: str, *, last_seen_uid: int, highestmodseq: int | None): # type: ignore[no-untyped-def] + polled.append(mailbox) + if mailbox == "SENT": + return MailboxDelta( + [ + RemoteMessage( + uid=5, + raw=_raw("Sent one", "${quoteHtml}` + `
${quoteHtml}