Add extban tests

Author: thommey

tests/README.md

@@ -253,6 +253,88 @@ def test_with_custom_nick(eggdrop_config, eggdrop_proc, mock_ircd, tcl_bridge):
 If you don't call `render()`, the `eggdrop_proc` fixture renders with
 defaults from `EggdropConfig.context()`.
 
+`render()` only takes effect *before* the proc fixture evaluates. If your
+test parameter list pulls in `eggdrop_proc` directly, the proc has already
+spawned by the time the test body runs. To customise after the dataclass
+exists but before the bot starts, take `eggdrop_config` + `request:
+pytest.FixtureRequest`, render, then lazy-load the rest:
+
+```python
+def test_loads_my_userfile(eggdrop_config, request: pytest.FixtureRequest):
+    eggdrop_config.render(...)
+    eggdrop_config.userfile_path.write_text(...)  # tweak files post-render
+    proc = request.getfixturevalue("eggdrop_proc")
+    bridge = request.getfixturevalue("tcl_bridge")
+```
+
+### Pre-populating the userfile
+
+Two template variables (rendered by `templates/userfile.j2`) inject
+already-formatted ban-record lines into the userfile that's written
+before the bot starts:
+
+- `userfile_ban_lines` — list of strings, written under `*ban - -`.
+- `userfile_chan_ban_lines` — dict of `chan-name → list of strings`,
+  each list written under `::<chan-name> bans`. The channel must be
+  configured before the userfile is read; the default eggdrop.conf
+  `channels` list handles this for `#test` automatically (see
+  `chanprog.c:452` for the order: conf load → HOOK_REHASH →
+  `readuserfile`).
+
+Build the strings with `support.userfile_helpers.format_userfile_ban`,
+which takes every field as a required keyword argument (`mask`, `perm`,
+`sticky`, `expire`, `added`, `lastactive`, `creator`, `desc`) and
+hex-escapes `:` / `\\` in the mask per `src/misc.c:str_escape`. The
+template itself is a flat iteration; all formatting lives in Python.
+
+```python
+from support.userfile_helpers import format_userfile_ban
+
+eggdrop_config.render(
+    userfile_ban_lines=[
+        format_userfile_ban(
+            mask="a:storedacct", perm=True, sticky=False, expire=0,
+            added=1700000000, lastactive=0, creator="owner",
+            desc="from disk",
+        ),
+    ],
+    userfile_chan_ban_lines={
+        "#test": [
+            format_userfile_ban(
+                mask="~a:chanonlyacct", perm=True, sticky=False, expire=0,
+                added=1700000000, lastactive=0, creator="owner",
+                desc="per-chan",
+            ),
+        ],
+    },
+)
+```
+
+The chanfile is rendered from `templates/chanfile.j2`. Pass
+`chanfile_channels=[{"name": "#chan", "options": "..."}]` if you need
+to register channels at chanfile-load time (rather than via
+`channels` in the conf). Default is empty — most tests use the
+conf-level `channel add` instead.
+
+### Selecting which modules to load
+
+The `modules` template variable controls the `loadmodule` lines and gates
+the server-related conf block (`set net-type`, `server add`, `set
+msg-rate`, ...) on whether `server` is in the list. Default is the full
+chain needed for IRC behaviour: `["pbkdf2", "channels", "server", "ctcp",
+"irc", "console", "notes"]`.
+
+Override to test channels-mod-only scenarios (e.g. behaviour when
+server.mod is absent — irc.mod and ctcp.mod will fail to load alongside
+since they `module_depend` on server):
+
+```python
+eggdrop_config.render(modules=["pbkdf2", "channels", "console", "notes"])
+```
+
+`extra_modules` still appends in addition to `modules`, so it's the right
+knob for opting into share/transfer/etc. without changing the base list.
+
 ## Layout
 
 ```

tests/conftest.py

@@ -86,8 +86,20 @@ def context(self) -> dict[str, Any]:
             mod_path=str(REPO_ROOT) + "/",
             help_path=str(REPO_ROOT / "help") + "/",
             bridge_tcl_path=str(BRIDGE_TCL),
+            modules=[
+                "pbkdf2",
+                "channels",
+                "server",
+                "ctcp",
+                "irc",
+                "console",
+                "notes",
+            ],
             extra_modules=[],
             channels=[{"name": "#test", "chanmode": "+nt"}],
+            chanfile_channels=[],
+            userfile_ban_lines=[],
+            userfile_chan_ban_lines={},
             extra_tcl="",
             server_cycle_wait=10,
             server_timeout=30,
@@ -111,8 +123,12 @@ def render(self, **overrides: Any) -> None:
         self.userfile_path.write_text(
             _jinja_env.get_template("userfile.j2").render(**ctx)
         )
-        # channels module wants to fopen the chanfile read-write; touch it.
-        self.chanfile_path.touch()
+        # channels.mod wants to fopen the chanfile read-write; rendering
+        # an empty `chanfile_channels` list produces an empty file, same
+        # as touching it would.
+        self.chanfile_path.write_text(
+            _jinja_env.get_template("chanfile.j2").render(**ctx)
+        )
         self.rendered = True
 
 

tests/support/userfile_helpers.py

@@ -0,0 +1,43 @@
+"""Helpers for building userfile content programmatically.
+
+Tests inject pre-populated ban records into the userfile via the
+`userfile_ban_lines` (global) and `userfile_chan_ban_lines` (per-channel)
+context variables of `templates/userfile.j2`. The template just emits
+the strings verbatim — all formatting and escaping happens here so the
+template stays a flat iteration.
+"""
+
+from __future__ import annotations
+
+
+def format_userfile_ban(
+    *,
+    mask: str,
+    perm: bool,
+    sticky: bool,
+    expire: int,
+    added: int,
+    lastactive: int,
+    creator: str,
+    desc: str,
+) -> str:
+    """Format one ban record for the userfile.
+
+    Mirrors the line written by `write_bans` in
+    `src/mod/channels.mod/userchan.c`:
+
+        - <mask>:<perm-prefix><expire><sticky-suffix>:+<added>:<lastactive>:<creator>:<desc>
+
+    `:` and `\\` in the mask are hex-escaped per `src/misc.c:str_escape`
+    (the parser uses `\\xy` as a hex byte; a literal `\\:` would yield NUL
+    via strtol of ":?" base 16 and silently truncate the mask). All
+    arguments are required — no defaults — so each test states exactly
+    what it's pinning.
+    """
+    escaped = mask.replace("\\", "\\5c").replace(":", "\\3a")
+    perm_prefix = "+" if perm else ""
+    sticky_suffix = "*" if sticky else ""
+    return (
+        f"- {escaped}:{perm_prefix}{expire}{sticky_suffix}:"
+        f"+{added}:{lastactive}:{creator}:{desc}"
+    )

tests/templates/chanfile.j2

@@ -0,0 +1,15 @@
+{#- Chanfile template.
+
+   Tests pass `chanfile_channels` as a list of {"name": ..., "options": ...}
+   records. `options` is a Tcl-syntax options block (verbatim) — defaults to
+   the empty block `{}`, which is enough to make findchan_by_dname() return
+   the channel during userfile load. By default the list is empty and the
+   chanfile is empty.
+
+   Channels added via the eggdrop.conf `channels` template variable are
+   *also* registered (via `channel add` lines in the conf) and run before
+   the chanfile, so most tests don't need to populate this file at all.
+-#}
+{%- for ch in chanfile_channels -%}
+channel add {{ ch.name }} { {{ ch.options | default('') }} }
+{% endfor -%}

tests/templates/eggdrop.conf.j2

@@ -3,13 +3,9 @@
 set mod-path "{{ mod_path }}"
 set help-path "{{ help_path }}"
 
-loadmodule pbkdf2
-loadmodule channels
-loadmodule server
-loadmodule ctcp
-loadmodule irc
-loadmodule console
-loadmodule notes
+{% for m in modules %}
+loadmodule {{ m }}
+{% endfor %}
 {% for m in extra_modules %}
 loadmodule "{{ m }}"
 {% endfor %}
@@ -27,6 +23,7 @@ set userfile "{{ userfile_path }}"
 set chanfile "{{ chanfile_path }}"
 set pidfile  "{{ pidfile_path }}"
 
+{% if 'server' in modules %}
 set net-type "Other"
 set default-port "{{ mock_ircd_port }}"
 set servers [list]
@@ -37,6 +34,7 @@ set server-timeout "{{ server_timeout }}"
 set msg-rate 0
 set flood-msg 0
 set flood-ctcp 0
+{% endif %}
 
 set raw-log 1
 logfile {{ log_flags }} * "{{ logfile_path }}"

tests/templates/userfile.j2

@@ -1,3 +1,29 @@
+{#- Userfile template.
+
+   Tests inject pre-formatted ban-record lines via:
+     userfile_ban_lines       — list of strings, written under `*ban - -`.
+     userfile_chan_ban_lines  — dict of chan-name -> list of strings,
+                                each written under `::<chan-name> bans`.
+
+   Build the strings in Python with `support.userfile_helpers.format_userfile_ban`.
+
+   The `*ban - -` section header is what `write_bans` (channels.mod/userchan.c)
+   emits and what the parser needs — `newsplit` (src/misc.c:255) splits on
+   literal ' ' only, so `*ban\n` keeps the trailing newline glued to the
+   token and `rfc_casecmp("*ban\n", "*ban")` fails to match.
+-#}
 #4v: eggdrop test harness -- {{ botnet_nick }} -- generated
 {{ owner_handle }} - {{ owner_flags }}
 - {{ owner_hostmask }}
+{% if userfile_ban_lines -%}
+*ban - -
+{% for line in userfile_ban_lines -%}
+{{ line }}
+{% endfor -%}
+{% endif -%}
+{% for chan_name, lines in userfile_chan_ban_lines.items() -%}
+::{{ chan_name }} bans
+{% for line in lines -%}
+{{ line }}
+{% endfor -%}
+{% endfor -%}