Add test for account-tag and voice modes with extra colon

This perfectly finds the regression caused by 2fea6c4
which intended to fix issues with the extra ":".

Broken: 1.10.1
Valid: 1.10.0 and latest HEAD because of gotmode() using parse_irc now

Author: thommey

tests/README.md

@@ -173,10 +173,34 @@ drive_registration(mock_ircd, isupport_tokens=[
 ])
 ```
 
+To influence which IRCv3 caps the bot negotiates, override the
+`mock_ircd` fixture for the test and construct the IRCd with the cap
+list. The bot sends `CAP LS 302` the moment TCP connects, before the
+test body runs, so the cap list has to be set at construction time:
+
+```python
+@pytest.fixture
+def mock_ircd():
+    ircd = MockIrcd(advertised_caps=["account-tag"]).start()
+    try:
+        yield ircd
+    finally:
+        with contextlib.suppress(Exception):
+            ircd.stop()
+
+def test_account_tag_negotiated(eggdrop_proc, mock_ircd, tcl_bridge):
+    drive_registration(mock_ircd)
+    assert "account-tag" in tcl_bridge.eval_ok("cap enabled").split()
+```
+
+The bot only `REQ`s caps it has enabled in config (e.g. `account-tag`
+is opt-in via `set account-tag 1` in the rendered eggdrop.conf — pass
+`extra_tcl="set account-tag 1\n"` to `eggdrop_config.render`).
+
 After this returns, Eggdrop has processed 005 and is about to JOIN
 configured channels.
 
-### `drive_join_with_names(mock_ircd, members_with_prefix, nick="TestBot", server="mock.test") -> str`
+### `drive_join_with_names(mock_ircd, members_with_prefix, nick="TestBot", server="mock.test", member_accounts=None) -> str`
 
 Mimics a real IRCd's full post-JOIN dance for the bot:
 
@@ -187,19 +211,32 @@ Mimics a real IRCd's full post-JOIN dance for the bot:
    like `"@TestBot ~bigboss +regular"`) and `366` end-of-NAMES.
 4. Drains the post-join queries Eggdrop fires off:
    - `MODE +b/+e/+I` → empty `368/349/347` end-of-list replies
-   - `WHO #chan` → one `352` per member (prefix symbols passed through to
-     the WHO flags field, so `opchars`-based op detection picks them up)
-     followed by `315` end-of-WHO
+   - `WHO #chan ...` → if the bot sent a WHOX-style request (the
+     `c%chnufat,222` form, used when `WHOX` ISUPPORT is on), reply with
+     one `354` per member carrying the per-member account from
+     `member_accounts` (default `*` = not logged in). Otherwise reply
+     with one `352` per member (prefix symbols passed through to the WHO
+     flags field, so `opchars`-based op detection picks them up). Either
+     form ends with `315`.
 5. Leaves `MODE #chan` (no list flag) **unanswered** so individual tests
    can send their own `324` mode reply if they need to.
 
+`member_accounts` is a `dict[str, str]` mapping member nick → account
+name. Only consulted on the WHOX path; ignored for plain WHO.
+
 Returns the channel name. Quiesces when no new lines arrive for ~300 ms
 (or after a 5 s hard cap).
 
 ```python
 chan = drive_join_with_names(mock_ircd, "@TestBot alice +bob")
 # bot is now fully joined to chan; alice is a plain member, bob is voiced
 mock_ircd.send(f":mock.test 324 TestBot {chan} +ntk secret")  # custom 324
+
+# WHOX flavour (bot is on a network that advertised WHOX in 005):
+chan = drive_join_with_names(
+    mock_ircd, "@op alice", member_accounts={"op": "op"}
+)
+# op's account is now "op" via 354 → got354 → setaccount
 ```
 
 ### `wait_for_isupport(bridge, key, expected, timeout=5.0)`
@@ -233,6 +270,13 @@ The fixtures wire to each other: pulling in `tcl_bridge` is enough — it
 depends on `eggdrop_proc` which depends on `eggdrop_config` and
 `mock_ircd`, all of which depend on `tmp_eggdir`.
 
+### Markers
+
+| Marker | Effect |
+| --- | --- |
+| `@pytest.mark.partyline` | `eggdrop_proc` spawns with `-nt`; HQ partyline available on stdin |
+| `@pytest.mark.slow` | Tag for end-to-end / reconnect / timeout-driven tests |
+
 ## Customising a test's eggdrop.conf
 
 Render with overrides before the proc starts:

tests/pyproject.toml

@@ -20,8 +20,8 @@ markers = [
     "slow: end-to-end tests that exercise reconnect/timeouts",
     "partyline: spawns eggdrop with -nt so stdin is the HQ partyline",
 ]
-# Keep tmpdir only when a test fails; pytest sweeps it on session exit.
-tmp_path_retention_policy = "failed"
+# pytest sweeps it on session exit.
+tmp_path_retention_policy = "all"
 tmp_path_retention_count = 3
 
 [tool.ruff]

tests/support/irc_helpers.py

@@ -47,6 +47,12 @@ def drive_registration(
     Waits for the TCP connect, drains the bot's NICK + USER, then sends the
     welcome sequence (001-004 + optional 005 with `isupport_tokens` + 376).
     Returns once the welcome is on the wire.
+
+    To influence which IRCv3 caps the bot negotiates, construct the IRCd with
+    `MockIrcd(advertised_caps=[...])` (typically via a local `mock_ircd`
+    fixture override). The cap list has to be set at construction time
+    because the bot sends `CAP LS 302` immediately on TCP connect — before
+    this helper runs.
     """
     mock_ircd.wait_for_connect(timeout=10.0)
     for _ in range(2):  # NICK and USER
@@ -59,6 +65,7 @@ def drive_join_with_names(
     members_with_prefix: str,
     nick: str = "TestBot",
     server: str = "mock.test",
+    member_accounts: dict[str, str] | None = None,
 ) -> str:
     """Drive a realistic post-registration channel JOIN to completion.
 
@@ -68,10 +75,16 @@ def drive_join_with_names(
       3. send NAMES (353) with `members_with_prefix` + end (366)
       4. drain the bot's post-join queries:
          * `MODE #chan +b/+e/+I` → empty 368/349/347 end-of-list replies
-         * `WHO #chan` → one 352 per member (prefix symbols passed through to
-           the flags field so opchars-based op detection works) + 315
+         * `WHO #chan ...` → if the bot sent a WHOX-style request (the
+           `c%chnufat,222` form, used when WHOX ISUPPORT is on), reply with
+           one 354 per member carrying the per-member account from
+           `member_accounts` (default "*" = not logged in). Otherwise reply
+           with one 352 per member. Either form ends with 315.
       5. leave `MODE #chan` (no list flag) unanswered so tests can send
          their own 324 reply
+
+    `member_accounts` maps member nick → account name; nicks not in the dict
+    get "*". Only consulted on the WHOX path; ignored for plain WHO.
     Returns the channel name. Quiesces when no new lines arrive for ~300 ms
     or after a 5 s hard cap.
     """
@@ -86,16 +99,26 @@ def drive_join_with_names(
     members: list[tuple[str, str]] = [
         split_member_prefix(t) for t in members_with_prefix.split() if t
     ]
+    accounts = member_accounts or {}
 
-    def reply_who() -> None:
+    def reply_who(whox: bool) -> None:
         for member_nick, prefix_syms in members:
             ident = "u"
             host = "h.example.com"
             flags = "H" + prefix_syms  # H = here (not away)
-            mock_ircd.send(
-                f":{server} 352 {nick} {chan} {ident} {host} {server} "
-                f"{member_nick} {flags} :0 {member_nick}"
-            )
+            if whox:
+                # 354 format from chan.c:got354:
+                # ":<srv> 354 <botnick> 222 <chan> <user> <host> <nick> <flags> <account>"
+                acct = accounts.get(member_nick, "*")
+                mock_ircd.send(
+                    f":{server} 354 {nick} 222 {chan} {ident} {host} "
+                    f"{member_nick} {flags} {acct}"
+                )
+            else:
+                mock_ircd.send(
+                    f":{server} 352 {nick} {chan} {ident} {host} {server} "
+                    f"{member_nick} {flags} :0 {member_nick}"
+                )
         mock_ircd.send(f":{server} 315 {nick} {chan} :End of /WHO list.")
 
     deadline = time.monotonic() + 5.0
@@ -116,7 +139,9 @@ def reply_who() -> None:
                 f":{server} 347 {nick} {chan} :End of Channel Invite List"
             )
         elif line.startswith(f"WHO {chan}"):
-            reply_who()
+            # WHOX form is `WHO #chan c%chnufat,222`; eggdrop emits this when
+            # use_354 (WHOX ISUPPORT) is on and parses replies from got354.
+            reply_who(whox=",222" in line)
         # MODE #chan (no list flag) — left for the test to answer with 324.
         # Anything else is silently drained.
     return chan

tests/support/mock_ircd.py

@@ -48,17 +48,25 @@ def __init__(
         allow_reconnect: bool = False,
         auto_cap: bool = True,
         server_name: str = "mock.test",
+        advertised_caps: Iterable[str] | None = None,
     ) -> None:
         """Configure (but do not start) a mock IRCd.
 
         `allow_reconnect`: if False, a second client connection during the
             test is treated as a hard error at `stop()` time.
-        `auto_cap`: auto-respond to `CAP LS`/`REQ`/`LIST` with empty caps.
+        `auto_cap`: auto-respond to `CAP LS`/`REQ`/`LIST`. `CAP REQ` is
+            always ACKed for whatever the bot asks for.
         `server_name`: source prefix for synthetic numerics (`:server 001 ...`).
+        `advertised_caps`: caps offered in `CAP LS` replies. Default empty.
+            Tests that need specific caps construct their own MockIrcd
+            (typically via a local `mock_ircd` fixture override) — by the
+            time the test body runs the bot has already sent `CAP LS 302`,
+            so the cap list must be set at construction time.
         """
         self._allow_reconnect = allow_reconnect
         self._auto_cap = auto_cap
         self._server_name = server_name
+        self._advertised_caps = " ".join(advertised_caps or [])
         self._loop = asyncio.new_event_loop()
         self._thread = threading.Thread(
             target=self._loop.run_forever, name="MockIrcd", daemon=True
@@ -158,15 +166,16 @@ async def _on_client(
     def _handle_cap(self, text: str, writer: asyncio.StreamWriter) -> None:
         """Auto-respond to client CAP commands so tests don't have to.
 
-        Strategy: advertise no capabilities. Eggdrop sees nothing it wants,
-        sends `CAP END`, and proceeds with NICK/USER.
+        Replies to `CAP LS` with the caps the IRCd was constructed with
+        (default empty), and ACKs whatever the bot then asks for in
+        `CAP REQ`.
         """
         parts = text.split(maxsplit=2)
         sub = parts[1].upper() if len(parts) >= 2 else ""
         srv = self._server_name
         # Use "*" as the unregistered nick placeholder per RFC.
         if sub == "LS":
-            writer.write(f":{srv} CAP * LS :\r\n".encode())
+            writer.write(f":{srv} CAP * LS :{self._advertised_caps}\r\n".encode())
         elif sub == "REQ":
             cap = parts[2] if len(parts) >= 3 else ":"
             if cap.startswith(":"):

tests/tests/test_account_tag_voice_mode.py

@@ -0,0 +1,101 @@
+"""Account-tag CAP + WHOX + tagged MODE: regression for the full account-aware
+path through CAP negotiation, WHOX-driven account learning, and an IRCv3-tagged
+mode change.
+
+End-to-end shape:
+  - CAP LS advertises `account-tag`; bot REQ/server ACK; bot enables it.
+  - 005 carries `WHOX` so eggdrop sets `use_354` (chan.c:3053) and emits
+    `WHO #chan c%chnufat,222` after JOIN; the helper replies with 354s
+    carrying op's account name "op".
+  - The IRCd then sends a MODE +vv with an `@account=op` IRCv3 tag. Eggdrop
+    parses the MODE (via standard mode handling) and the tag (via
+    chan.c:gotrawt → setaccount).
+  - Result: test1 and test2 are voiced; op's account is "op".
+"""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Iterator
+
+import pytest
+
+from support.bridge_client import BridgeClient
+from support.eggdrop_proc import EggdropProc
+from support.irc_helpers import (
+    drive_join_with_names,
+    drive_registration,
+    wait_for_isupport,
+)
+from support.mock_ircd import MockIrcd
+from support.waiters import wait_for
+
+
+@pytest.fixture
+def mock_ircd() -> Iterator[MockIrcd]:
+    """Override the default fixture to advertise `account-tag` in CAP LS.
+
+    The cap list is fixed at construction time because the bot sends
+    `CAP LS 302` immediately on TCP connect, before the test body runs.
+    """
+    ircd = MockIrcd(advertised_caps=["account-tag"]).start()
+    try:
+        yield ircd
+    finally:
+        with contextlib.suppress(Exception):
+            ircd.stop()
+
+
+def test_isvoice_after_tagged_mode_with_whox_and_account_tag(
+    eggdrop_config,
+    request: pytest.FixtureRequest,
+) -> None:
+    # account-tag is disabled by default in server.mod (servmsg.c:44); the
+    # bot only adds it to the CAP REQ list when the Tcl var is 1. Set it via
+    # extra_tcl so the assignment runs after server.mod's loadmodule.
+    eggdrop_config.render(extra_tcl="set account-tag 1\n")
+    mock_ircd: MockIrcd = request.getfixturevalue("mock_ircd")
+    eggdrop_proc: EggdropProc = request.getfixturevalue("eggdrop_proc")  # noqa: F841 — proc must spawn before bridge
+    tcl_bridge: BridgeClient = request.getfixturevalue("tcl_bridge")
+
+    drive_registration(mock_ircd, isupport_tokens=["WHOX"])
+    wait_for_isupport(tcl_bridge, "WHOX", "")  # bare token: value stored as ""
+
+    # CAP negotiation must have completed (welcome only fires after CAP END);
+    # account-tag must be in the enabled list.
+    enabled = tcl_bridge.eval_ok("cap enabled").split()
+    assert "account-tag" in enabled, f"expected account-tag enabled, got {enabled}"
+
+    chan = drive_join_with_names(
+        mock_ircd,
+        "@op test1 test2 @TestBot",
+        member_accounts={"op": "op"},
+    )
+
+    # WHOX populated op's account via 354 (chan.c:got354 → got352or4 → setaccount).
+    wait_for(
+        lambda: tcl_bridge.eval_ok(f'getaccount op "{chan}"') == "op",
+        timeout=5.0,
+        description="WHOX 354 to set op's account to 'op'",
+    )
+
+    # Pre-MODE sanity: nobody has voice yet.
+    assert tcl_bridge.eval_ok(f'onchan test1 "{chan}"') == "1"
+    assert tcl_bridge.eval_ok(f'onchan test2 "{chan}"') == "1"
+    assert tcl_bridge.eval_ok(f'isvoice test1 "{chan}"') == "0"
+    assert tcl_bridge.eval_ok(f'isvoice test2 "{chan}"') == "0"
+
+    mock_ircd.send(f"@account=op :op!op@127.0.0.1 MODE {chan} +vv test1 :test2")
+
+    wait_for(
+        lambda: (
+            tcl_bridge.eval_ok(f'isvoice test1 "{chan}"') == "1"
+            and tcl_bridge.eval_ok(f'isvoice test2 "{chan}"') == "1"
+        ),
+        timeout=5.0,
+        description="MODE +vv test1 test2 to voice both members",
+    )
+
+    # And op's account survived the tag-driven setaccount call (no-op since
+    # it was already "op", but we want to be sure gotrawt didn't clobber it).
+    assert tcl_bridge.eval_ok(f'getaccount op "{chan}"') == "op"