Reset master to testing content

tests/native_thunderbird.py

@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+"""Local Thunderbird folders, message lists and composition with a private reader."""
+import argparse
+from email.message import EmailMessage
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+sys.dont_write_bytecode = True
+from native_echo_preview import PreviewSpeechServer
+from native_mozilla import walk, write_profile
+from native_x11 import wait_for
+from native_test_session import run_private_session
+
+
+SUBJECTS = ["First test message", "Second test message"]
+APPLICATIONS = ("thunderbird", "org.mozilla.thunderbird", "xdg-desktop-portal-gtk")
+
+
+def seed_mailbox(profile, html):
+    write_profile(profile, "thunderbird")
+    with (profile / "user.js").open("a") as stream:
+        stream.write(f'user_pref("mail.identity.id1.compose_html", {str(html).lower()});\n')
+        stream.write('user_pref("mailnews.default_sort_order", 1);\n')
+        stream.write('user_pref("mailnews.default_view_flags", 0);\n')
+        stream.write('user_pref("mail.openMessageBehavior", 2);\n')
+        stream.write('user_pref("mail.forward_message_mode", 2);\n')
+    for folder, subjects in {"Inbox": SUBJECTS, "Archive": ["Archived test message"]}.items():
+        messages = []
+        for index, subject in enumerate(subjects):
+            message = EmailMessage()
+            message["From"] = "Sender <sender@example.invalid>"
+            message["To"] = "Username <username@example.invalid>"
+            message["Cc"] = "Other Recipient <other@example.invalid>"
+            message["Subject"] = subject
+            message["Date"] = f"Sat, 17 Oct 2026 12:0{index}:00 +0000"
+            message["Message-ID"] = f"<{folder}-{index}@example.invalid>"
+            message.set_content(f"Body of {subject}.\n")
+            if folder == "Inbox" and index == 0:
+                message.add_attachment("Synthetic attachment contents.\n", subtype="plain",
+                                       filename="test-attachment.txt")
+            messages.append("From sender@example.invalid Sat Oct 17 12:00:00 2026\n"
+                            + message.as_string() + "\n")
+        (profile / "Mail" / "Local Folders" / folder).write_text("".join(messages))
+
+
+def run_inside(html):
+    import pyatspi
+    from gi.repository import GLib
+    directory = Path(os.environ["CTHULHU_THUNDERBIRD_EVIDENCE"])
+    executable = shutil.which("thunderbird")
+    if not executable:
+        raise RuntimeError("Thunderbird executable missing")
+    profile = directory / "profile"
+    seed_mailbox(profile, html)
+    config = directory / "settings.toml"
+    config.write_text('''schema-version = 2
+active-profile = "default"
+[profiles.default.speech]
+output-module = "main"
+[profiles.default.braille]
+enabled = false
+[profiles.default.sound]
+enabled = false
+[profiles.default.key-echo]
+enabled = true
+''')
+    wmConfig = directory / "i3.config"
+    wmConfig.write_text(f"font pango:monospace 10\nipc-socket {directory / 'i3.sock'}\n")
+    server = PreviewSpeechServer(directory / "speech.sock")
+    processes, report = [], []
+    logPath = directory / "reader.log"
+
+    def key(chord):
+        subprocess.run(["xdotool", "key", "--clearmodifiers", chord], check=True)
+
+    def type_text(text):
+        subprocess.run(["xdotool", "type", "--clearmodifiers", "--delay", "35", "--", text], check=True)
+
+    def find_node(role, name=None, focused=False):
+        for app in pyatspi.Registry.getDesktop(0):
+            try:
+                if app.name.lower() not in APPLICATIONS:
+                    continue
+                for node in walk(app):
+                    if (node.getRoleName() == role and (name is None or name in node.name)
+                            and node.getState().contains(pyatspi.STATE_SHOWING)
+                            and (not focused or node.getState().contains(pyatspi.STATE_FOCUSED))):
+                        return node
+            except GLib.Error:
+                # A closing portal dialog can retire a child during traversal.
+                # The caller's bounded wait retries against the current tree.
+                continue
+
+    def expect_focus(role, name=None):
+        return wait_for(lambda: find_node(role, name, focused=True),
+                        f"native focus missing: {role} {name!r}", timeout=8)
+
+    def check(action, operation, expected, role=None, name=None, exact=False, selected=False):
+        offset = len(server.snapshot())
+        operation()
+        node = expect_focus(role, name) if role else None
+        wait_for(lambda: any((expected == row["text"] if exact else expected in row["text"])
+                             for row in server.snapshot()[offset:]),
+                 f"{action}: missing speech {expected!r}", timeout=8)
+        wait_for(lambda: server.snapshot()[-1]["finished"], f"{action}: speech did not settle")
+        rows = server.snapshot()[offset:]
+        assert not any("Could not" in row["text"] for row in rows), (action, rows)
+        if node and role in ("tree item", "list item"):
+            if selected or role == "tree item":
+                assert node.getState().contains(pyatspi.STATE_SELECTED), (action, "native selection missing")
+            assert any(row["text"] == role for row in rows), (action, "spoken row role missing", rows)
+        report.append({"action": action, "expected": expected,
+                       "focus": {"role": node.getRoleName(), "name": node.name} if node else None,
+                       "speech": rows})
+        print(f"PASS: {action}", flush=True)
+        return node
+
+    def read_text(node):
+        # HTML editors expose their paragraphs as children; plain text can be
+        # exposed directly on the document. Ignore embedded-object placeholders.
+        try:
+            text = node.queryText().getText(0, -1).replace("\ufffc", "")
+        except NotImplementedError:
+            text = ""
+        if text.strip():
+            return text
+        return "\n".join(read_text(child) for child in node)
+
+    def selected_text(node):
+        for child in walk(node):
+            try:
+                text = child.queryText()
+                if text.getNSelections():
+                    start, end = text.getSelection(0)
+                    selected = text.getText(start, end).replace("\ufffc", "")
+                    if selected.strip():
+                        return selected
+            except NotImplementedError:
+                continue
+        return ""
+
+    def selected_messages():
+        return [subject for subject in SUBJECTS
+                if (node := find_node("list item", subject)) is not None
+                and node.getState().contains(pyatspi.STATE_SELECTED)]
+
+    def discard_composer():
+        key("ctrl+w")
+        discard = wait_for(lambda: find_node("button", "Discard changes"),
+                           "discard confirmation missing")
+        check("focus discard button", lambda: discard.queryComponent().grabFocus(),
+              "Discard changes", "button", "Discard changes")
+        check("discard unsent message", lambda: key("Return"), SUBJECTS[1],
+              "list item", SUBJECTS[1], selected=True)
+
+    try:
+        processes.append(subprocess.Popen(["i3", "-c", str(wmConfig)],
+                         stdout=subprocess.DEVNULL, stderr=(directory / "wm.log").open("w")))
+        wait_for(lambda: "0x" in subprocess.check_output(
+            ["xprop", "-root", "_NET_SUPPORTING_WM_CHECK"], text=True), "private WM missing")
+        processes.append(subprocess.Popen([
+            os.environ["CTHULHU_BINARY"], "--config", str(config), "--no-tentacles",
+            "--speech-socket", str(directory / "speech.sock"), "--debug-file", str(logPath)],
+            stdout=subprocess.DEVNULL, stderr=(directory / "reader-stderr.log").open("w")))
+        wait_for(lambda: logPath.exists() and "remote D-Bus service ready" in logPath.read_text(),
+                 "private reader missing")
+        processes.append(subprocess.Popen([
+            executable, "--no-remote", "--profile", str(profile)],
+            env=dict(os.environ, MOZ_ACCESSIBILITY_ENABLED="1"),
+            stdout=subprocess.DEVNULL, stderr=(directory / "application.log").open("w")))
+        root = wait_for(lambda: find_node("tree item", "Local Folders"), "folder tree missing", timeout=25)
+        window = subprocess.check_output([
+            "xdotool", "search", "--onlyvisible", "--name", "Local Folders - Mozilla Thunderbird"],
+            text=True).splitlines()[0]
+        subprocess.run(["xdotool", "windowactivate", "--sync", window], check=True)
+        check("focus folder tree", lambda: root.queryComponent().grabFocus(),
+              "Local Folders", "tree item", "Local Folders")
+        key("Right")
+        check("next folder", lambda: key("Down"), "Inbox", "tree item", "Inbox")
+        check("last folder", lambda: key("End"), "Archive", "tree item", "Archive")
+        check("first folder", lambda: key("Home"), "Local Folders", "tree item", "Local Folders")
+        check("return to Inbox", lambda: key("Down"), "Inbox", "tree item", "Inbox")
+        check("folder to messages", lambda: key("F6"), SUBJECTS[0], "list item", SUBJECTS[0])
+        check("next message", lambda: key("Down"), SUBJECTS[1], "list item", SUBJECTS[1], selected=True)
+        check("previous message", lambda: key("Up"), SUBJECTS[0], "list item", SUBJECTS[0], selected=True)
+        check("extend message selection", lambda: key("shift+Down"), SUBJECTS[1],
+              "list item", SUBJECTS[1], selected=True)
+        wait_for(lambda: selected_messages() == SUBJECTS, "two-message selection missing")
+        report[-1]["selectedMessages"] = selected_messages()
+        check("shrink message selection", lambda: key("shift+Up"), SUBJECTS[0],
+              "list item", SUBJECTS[0], selected=True)
+        wait_for(lambda: selected_messages() == SUBJECTS[:1], "selection did not shrink")
+        report[-1]["selectedMessages"] = selected_messages()
+        check("move without extending selection", lambda: key("ctrl+Down"), SUBJECTS[1],
+              "list item", SUBJECTS[1])
+        wait_for(lambda: selected_messages() == SUBJECTS[:1], "Ctrl+Down changed selection")
+        check("add focused message to selection", lambda: key("ctrl+space"), "selected", exact=True)
+        wait_for(lambda: selected_messages() == SUBJECTS, "Ctrl+Space did not add message")
+        report[-1]["selectedMessages"] = selected_messages()
+        check("remove focused message from selection", lambda: key("ctrl+space"), "not selected", exact=True)
+        wait_for(lambda: selected_messages() == SUBJECTS[:1], "Ctrl+Space did not remove message")
+        report[-1]["selectedMessages"] = selected_messages()
+        check("return to first selected message", lambda: key("Up"), SUBJECTS[0],
+              "list item", SUBJECTS[0], selected=True)
+        check("messages to folders", lambda: key("shift+F6"), "Inbox", "tree item", "Inbox")
+        check("folders to retained message", lambda: key("F6"), SUBJECTS[0], "list item", SUBJECTS[0])
+
+        check("open selected message", lambda: key("Return"), SUBJECTS[0])
+        check("read opened message", lambda: key("ctrl+Home"), f"Body of {SUBJECTS[0]}.")
+        check("focus received attachment bar", lambda: key("Tab"),
+              "test-attachment.txt", "button", "1 attachment")
+        check("expand received attachments", lambda: key("Return"), "test-attachment.txt",
+              "list item", "test-attachment", selected=True)
+        check("received attachment menu", lambda: key("shift+F10"), "menu", "menu")
+        check("attachment open menu item", lambda: key("Down"), "Open", "menu item", "Open")
+        check("attachment save menu item", lambda: key("Down"), "Save As", "menu item", "Save As")
+        check("open attachment save dialog", lambda: key("Return"), "Save Attachment")
+        key("ctrl+l")
+        location = expect_focus("text")
+        savedAttachment = directory / "saved-attachment.txt"
+        key("ctrl+a")
+        type_text(str(savedAttachment))
+        wait_for(lambda: str(savedAttachment) in location.queryText().getText(0, -1),
+                 "save attachment location missing")
+        check("save received attachment", lambda: key("Return"), "test-attachment",
+              "list item", "test-attachment", selected=True)
+        wait_for(savedAttachment.exists, "attachment was not saved")
+        assert savedAttachment.read_text().strip() == "Synthetic attachment contents."
+        check("return to message list", lambda: key("ctrl+w"), SUBJECTS[0],
+              "list item", SUBJECTS[0], selected=True)
+        check("next message after return", lambda: key("Down"), SUBJECTS[1],
+              "list item", SUBJECTS[1], selected=True)
+
+        for action, chord, prefix in (("reply", "ctrl+r", "Re: "),
+                                      ("reply all", "ctrl+shift+r", "Re: "),
+                                      ("forward", "ctrl+l", "Fwd: ")):
+            replying = action != "forward"
+            check(f"open {action}", lambda: key(chord), "Message body" if replying else "To",
+                  "document web" if replying else "entry",
+                  "Message body" if replying else "To")
+            subject = find_node("entry", "Subject")
+            assert subject.queryText().getText(0, -1) == prefix + SUBJECTS[1], (action, "subject")
+            report[-1]["subject"] = subject.queryText().getText(0, -1)
+            if replying:
+                assert find_node("section", "Sender <sender@example.invalid>: press Enter"), (action, "recipient")
+                if action == "reply all":
+                    assert find_node("section", "Other Recipient <other@example.invalid>: press Enter"), (action, "Cc")
+            if action == "forward":
+                type_text("recipient@example.invalid")
+                check("commit forward recipient", lambda: key("Tab"), "recipient@example.invalid",
+                      "entry", "To")
+                check("forward recipient to subject", lambda: key("Tab"), "Subject", "entry", "Subject")
+                check("forward subject to body", lambda: key("Tab"), "Message body",
+                      "document web", "Message body")
+            body = expect_focus("document web", "Message body")
+            wait_for(lambda: f"Body of {SUBJECTS[1]}." in read_text(body), f"{action}: quoted body missing")
+            originalText = read_text(body)
+            check(f"{action} character echo", lambda: key("x"), "x", exact=True)
+            wait_for(lambda: read_text(body) != originalText, f"{action}: typed text missing")
+            discard_composer()
+
+        check("open composer", lambda: key("ctrl+m"), "To", "entry", "To")
+        recipient = expect_focus("entry", "To")
+        type_text("recipient@example.invalid")
+        wait_for(lambda: recipient.queryText().getText(0, -1) == "recipient@example.invalid",
+                 "recipient text did not reach Thunderbird")
+        check("commit recipient", lambda: key("Tab"), "recipient@example.invalid", "entry", "To")
+        subject = check("recipient to subject", lambda: key("Tab"), "Subject", "entry", "Subject")
+        offset = len(server.snapshot())
+        type_text("Draft subject")
+        wait_for(lambda: subject.queryText().getText(0, -1) == "Draft subject", "subject typing missing")
+        # Let the title coalescer and SSIP recorder drain after the last key.
+        # The check must include the final title, not just the typing interval.
+        time.sleep(0.4)
+        rows = server.snapshot()[offset:]
+        assert any(row["text"] == "D" for row in rows), ("subject character echo missing", rows)
+        assert not any(row["text"].startswith("Write:") for row in rows), ("subject title echo", rows)
+        report.append({"action": "subject typing without title echo", "speech": rows})
+        print("PASS: subject typing without title echo", flush=True)
+        offset = len(server.snapshot())
+        check("subject character deletion", lambda: key("BackSpace"), "t", exact=True)
+        wait_for(lambda: subject.queryText().getText(0, -1) == "Draft subjec", "subject deletion missing")
+        time.sleep(0.4)
+        rows = server.snapshot()[offset:]
+        assert not any(row["text"].startswith("Write:") for row in rows), ("subject deletion title echo", rows)
+        type_text("t")
+        check("subject to body", lambda: key("Tab"), "Message body", "document web", "Message body")
+        body = expect_focus("document web")
+        assert body.getState().contains(pyatspi.STATE_EDITABLE), "body is not editable"
+        check("body character echo", lambda: key("h"), "h", exact=True)
+        check("body character deletion", lambda: key("BackSpace"), "h", exact=True)
+        wait_for(lambda: not read_text(body).strip(), "body character deletion missing")
+        type_text("Draft first line.")
+        key("Return")
+        type_text("Draft second line.")
+        wait_for(lambda: "Draft first line." in read_text(body) and "Draft second line." in read_text(body),
+                 "body text did not reach Thunderbird")
+        check("body first line", lambda: key("ctrl+Home"), "Draft first line.")
+        check("body next line", lambda: key("Down"), "Draft second line.")
+        check("select body word", lambda: (key("Home"), key("ctrl+shift+Right")), "Draft selected", exact=True)
+        wait_for(lambda: selected_text(body).strip() == "Draft", "native body word selection missing")
+        check("delete selected word", lambda: key("BackSpace"), "Draft")
+        wait_for(lambda: "Draft second line." not in read_text(body) and "second line." in read_text(body),
+                 "body selection/deletion did not reach Thunderbird")
+        check("body back to subject", lambda: key("shift+Tab"), "Subject", "entry", "Subject")
+        check("subject back to body", lambda: key("Tab"), "Message body", "document web", "Message body")
+        attachment = directory / "outgoing-attachment.txt"
+        attachment.write_text("Unsent synthetic attachment.\n")
+        check("open attachment picker", lambda: key("ctrl+shift+a"), "Attach File")
+        key("ctrl+l")
+        location = expect_focus("text")
+        type_text(str(attachment))
+        wait_for(lambda: str(attachment) in location.queryText().getText(0, -1),
+                 "attachment picker location missing")
+        check("attach local file", lambda: key("Return"), attachment.name,
+              "list item", attachment.stem, selected=True)
+        check("clear attachment selection", lambda: key("Escape"), "not selected", exact=True)
+        wait_for(lambda: not find_node("list item", attachment.stem).getState().contains(pyatspi.STATE_SELECTED),
+                 "attachment selection did not clear")
+        check("attachment back to body", lambda: key("Escape"), "Message body",
+              "document web", "Message body")
+        # No send command is used. Termination below leaves the unsent editor
+        # in this disposable profile without interacting with a real mailbox.
+        print(f"PASS: Thunderbird {'HTML' if html else 'plain-text'} local mail workflow", flush=True)
+    finally:
+        tree = []
+        try:
+            try:
+                for app in pyatspi.Registry.getDesktop(0):
+                    if app.name.lower() in APPLICATIONS:
+                        for node in walk(app):
+                            tree.append({"role": node.getRoleName(), "name": node.name,
+                                         "showing": node.getState().contains(pyatspi.STATE_SHOWING),
+                                         "focused": node.getState().contains(pyatspi.STATE_FOCUSED),
+                                         "selected": node.getState().contains(pyatspi.STATE_SELECTED)})
+            except Exception as error:
+                tree.append({"error": str(error)})
+            (directory / "tree.json").write_text(json.dumps(tree, indent=2))
+            (directory / "report.json").write_text(json.dumps(report, indent=2))
+            (directory / "speech.json").write_text(json.dumps(server.snapshot(), indent=2))
+        finally:
+            for process in reversed(processes):
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=5)
+            server.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--format", choices=("html", "plain", "both"), default="both")
+    parser.add_argument("--inside", action="store_true", help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if not os.environ.get("CTHULHU_BINARY"):
+        parser.error("Set CTHULHU_BINARY to a freshly built reader")
+    if args.inside:
+        run_inside(args.format == "html")
+        return
+    formats = ("html", "plain") if args.format == "both" else (args.format,)
+    for composeFormat in formats:
+        directory = Path(tempfile.mkdtemp(prefix=f"cthulhu-thunderbird-{composeFormat}-"))
+        print(f"Thunderbird {composeFormat} evidence: {directory}", flush=True)
+        environment = dict(os.environ, XDG_SESSION_TYPE="x11", CTHULHU_THUNDERBIRD_EVIDENCE=str(directory))
+        for name in ("DBUS_SESSION_BUS_ADDRESS", "AT_SPI_BUS_ADDRESS", "WAYLAND_DISPLAY"):
+            environment.pop(name, None)
+        with (directory / "session.log").open("w") as log:
+            run_private_session(["xvfb-run", "-a", "-s", "-screen 0 1280x900x24", "dbus-run-session", "--",
+                            sys.executable, str(Path(__file__).resolve()), "--format", composeFormat, "--inside"],
+                           env=environment, stderr=log, check=True, timeout=120)
+
+
+if __name__ == "__main__":
+    main()