Add test for mode +C ('no ctcp')

.github/deploy_to_netlify.py

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import os
-import pprint
-import re
-import subprocess
-import sys
-import urllib.request
-
-event_name = os.environ["GITHUB_EVENT_NAME"]
-
-is_pull_request = is_push = False
-if event_name.startswith("pull_request"):
-    is_pull_request = True
-elif event_name.startswith("push"):
-    is_push = True
-elif event_name.startswith("schedule"):
-    # Don't publish; scheduled workflows run against the latest commit of every
-    # implementation, so they are likely to have failed tests for the wrong reasons
-    sys.exit(0)
-else:
-    print("Unexpected event name:", event_name)
-
-with open(os.environ["GITHUB_EVENT_PATH"]) as fd:
-    github_event = json.load(fd)
-
-pprint.pprint(github_event)
-
-context_suffix = ""
-
-command = ["netlify", "deploy", "--dir=dashboard/"]
-if is_pull_request:
-    pr_number = github_event["number"]
-    sha = github_event.get("after") or github_event["pull_request"]["head"]["sha"]
-    # Aliases can't exceed 37 chars
-    command.extend(["--alias", f"pr-{pr_number}-{sha[0:10]}"])
-    context_suffix = " (pull_request)"
-elif is_push:
-    ref = github_event["ref"]
-    m = re.match("refs/heads/(.*)", ref)
-    if m:
-        branch = m.group(1)
-        sha = github_event["head_commit"]["id"]
-
-        if branch in ("main", "master"):
-            command.extend(["--prod"])
-        else:
-            command.extend(["--alias", f"br-{branch[0:23]}-{sha[0:10]}"])
-            context_suffix = " (push)"
-    else:
-        # TODO
-        pass
-
-
-print("Running", command)
-proc = subprocess.run(command, capture_output=True)
-
-output = proc.stdout.decode()
-assert proc.returncode == 0, (output, proc.stderr.decode())
-print(output)
-
-m = re.search("https://[^ ]*--[^ ]*netlify.app", output)
-assert m
-netlify_site_url = m.group(0)
-target_url = f"{netlify_site_url}/index.xhtml"
-
-print("Published to", netlify_site_url)
-
-
-def send_status() -> None:
-    statuses_url = github_event["repository"]["statuses_url"].format(sha=sha)
-
-    payload = {
-        "state": "success",
-        "context": f"Dashboard{context_suffix}",
-        "description": "Table of all test results",
-        "target_url": target_url,
-    }
-    request = urllib.request.Request(
-        statuses_url,
-        data=json.dumps(payload).encode(),
-        headers={
-            "Authorization": f'token {os.environ["GITHUB_TOKEN"]}',
-            "Content-Type": "text/json",
-            "Accept": "application/vnd.github+json",
-        },
-    )
-
-    response = urllib.request.urlopen(request)
-
-    assert response.status == 201, response.read()
-
-
-send_status()
-
-
-def send_pr_comment() -> None:
-    comments_url = github_event["pull_request"]["_links"]["comments"]["href"]
-
-    payload = {
-        "body": f"[Test results]({target_url})",
-    }
-    request = urllib.request.Request(
-        comments_url,
-        data=json.dumps(payload).encode(),
-        headers={
-            "Authorization": f'token {os.environ["GITHUB_TOKEN"]}',
-            "Content-Type": "text/json",
-            "Accept": "application/vnd.github+json",
-        },
-    )
-
-    response = urllib.request.urlopen(request)
-
-    assert response.status == 201, response.read()
-
-
-if is_pull_request:
-    send_pr_comment()

.github/workflows/lint.yml

@@ -13,10 +13,10 @@ jobs:
 
     - uses: actions/checkout@v2
 
-    - name: Set up Python 3.11
+    - name: Set up Python 3.7
       uses: actions/setup-python@v2
       with:
-        python-version: 3.11
+        python-version: 3.7
 
     - name: Cache dependencies
       uses: actions/cache@v2

.github/workflows/test-devel_release.yml

@@ -3,57 +3,53 @@
 
 jobs:
   build-anope:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
+    - uses: actions/checkout@v2
     - name: Create directories
       run: cd ~/; mkdir -p .local/ go/
-    - name: Cache dependencies
+    - name: Cache Anope
-      uses: actions/cache@v4
+      uses: actions/cache@v2
       with:
-        key: 3-${{ runner.os }}-anope-devel_release
+        key: 3-${{ runner.os }}-anope-2.0.9
         path: '~/.cache
 
-          ${ github.workspace }/anope
+          ${{ github.workspace }}/anope
 
           '
-    - uses: actions/checkout@v4
-    - name: Set up Python 3.11
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.11
     - name: Checkout Anope
-      uses: actions/checkout@v4
+      uses: actions/checkout@v2
       with:
         path: anope
-        ref: '2.0'
+        ref: 2.0.9
         repository: anope/anope
     - name: Build Anope
-      run: |
+      run: |-
         cd $GITHUB_WORKSPACE/anope/
-        sudo apt-get install ninja-build --no-install-recommends
+        cp $GITHUB_WORKSPACE/data/anope/* .
-        mkdir build && cd build
+        CFLAGS=-O0 ./Config -quick
-        cmake -DCMAKE_INSTALL_PREFIX=$HOME/.local/ -DPROGRAM_NAME=anope -DUSE_PCH=ON -GNinja ..
+        make -C build -j 4
-        ninja install
+        make -C build install
     - name: Make artefact tarball
       run: cd ~; tar -czf artefacts-anope.tar.gz .local/ go/
     - name: Upload build artefacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
         name: installed-anope
         path: ~/artefacts-*.tar.gz
         retention-days: 1
   build-inspircd:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
     - name: Create directories
       run: cd ~/; mkdir -p .local/ go/
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
-    - name: Set up Python 3.11
+    - name: Set up Python 3.7
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
-        python-version: 3.11
+        python-version: 3.7
     - name: Checkout InspIRCd
-      uses: actions/checkout@v4
+      uses: actions/checkout@v2
       with:
         path: inspircd
         ref: insp3
@@ -61,152 +57,154 @@ jobs:
     - name: Build InspIRCd
       run: |
         cd $GITHUB_WORKSPACE/inspircd/
+        patch src/inspircd.cpp < $GITHUB_WORKSPACE/patches/inspircd_mainloop.patch
         ./configure --prefix=$HOME/.local/inspircd --development
-        CXXFLAGS=-DINSPIRCD_UNLIMITED_MAINLOOP make -j 4
+        make -j 4
         make install
     - name: Make artefact tarball
       run: cd ~; tar -czf artefacts-inspircd.tar.gz .local/ go/
     - name: Upload build artefacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
         name: installed-inspircd
         path: ~/artefacts-*.tar.gz
         retention-days: 1
   publish-test-results:
     if: success() || failure()
-    name: Publish Dashboard
+    name: Publish Unit Tests Results
     needs:
     - test-inspircd
     - test-inspircd-anope
     - test-inspircd-atheme
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
     - name: Download Artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v2
       with:
         path: artifacts
-    - name: Install dashboard dependencies
+    - if: github.event_name == 'pull_request'
-      run: |-
+      name: Publish Unit Test Results
-        python -m pip install --upgrade pip
+      uses: actions/github-script@v4
-        pip install defusedxml docutils -r requirements.txt
+      with:
-    - name: Generate dashboard
+        result-encoding: string
-      run: |-
+        script: |
-        shopt -s globstar
+          let body = '';
-        python3 -m irctest.dashboard.format dashboard/ artifacts/**/*.xml
+          const options = {};
-        echo '/ /index.xhtml' > dashboard/_redirects
+          options.listeners = {
-    - name: Install netlify-cli
+              stdout: (data) => {
-      run: npm i -g netlify-cli
+                  body += data.toString();
-    - env:
+              }
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          };
-        NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+          await exec.exec('bash', ['-c', 'shopt -s globstar; python3 report.py artifacts/**/*.xml'], options);
-        NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
+          github.issues.createComment({
-      name: Deploy to Netlify
+            issue_number: context.issue.number,
-      run: ./.github/deploy_to_netlify.py
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body,
+          });
+          return body;
   test-inspircd:
     needs:
     - build-inspircd
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
-    - name: Set up Python 3.11
+    - name: Set up Python 3.7
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
-        python-version: 3.11
+        python-version: 3.7
     - name: Download build artefacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v2
       with:
         name: installed-inspircd
         path: '~'
     - name: Unpack artefacts
       run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
-    - name: Install system dependencies
+    - name: Install Atheme
-      run: sudo apt-get install atheme-services faketime
+      run: sudo apt-get install atheme-services
     - name: Install irctest dependencies
       run: |-
         python -m pip install --upgrade pip
-        pip install pytest pytest-xdist pytest-timeout -r requirements.txt
+        pip install pytest pytest-xdist -r requirements.txt
     - name: Test with pytest
-      run: PYTEST_ARGS='--junit-xml pytest.xml --timeout 300' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:~/.local/inspircd:$PATH
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH
         make inspircd
-      timeout-minutes: 30
     - if: always()
       name: Publish results
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: pytest-results_inspircd_devel_release
+        name: pytest results inspircd (devel_release)
         path: pytest.xml
   test-inspircd-anope:
     needs:
     - build-inspircd
     - build-anope
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
-    - name: Set up Python 3.11
+    - name: Set up Python 3.7
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
-        python-version: 3.11
+        python-version: 3.7
     - name: Download build artefacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v2
       with:
         name: installed-inspircd
         path: '~'
     - name: Download build artefacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v2
       with:
         name: installed-anope
         path: '~'
     - name: Unpack artefacts
       run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
-    - name: Install system dependencies
+    - name: Install Atheme
-      run: sudo apt-get install atheme-services faketime
+      run: sudo apt-get install atheme-services
     - name: Install irctest dependencies
       run: |-
         python -m pip install --upgrade pip
-        pip install pytest pytest-xdist pytest-timeout -r requirements.txt
+        pip install pytest pytest-xdist -r requirements.txt
     - name: Test with pytest
-      run: PYTEST_ARGS='--junit-xml pytest.xml --timeout 300' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:~/.local/inspircd:$PATH  make
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH  make
         inspircd-anope
-      timeout-minutes: 30
     - if: always()
       name: Publish results
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: pytest-results_inspircd-anope_devel_release
+        name: pytest results inspircd-anope (devel_release)
         path: pytest.xml
   test-inspircd-atheme:
     needs:
     - build-inspircd
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
-    - name: Set up Python 3.11
+    - name: Set up Python 3.7
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
-        python-version: 3.11
+        python-version: 3.7
     - name: Download build artefacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v2
       with:
         name: installed-inspircd
         path: '~'
     - name: Unpack artefacts
       run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
-    - name: Install system dependencies
+    - name: Install Atheme
-      run: sudo apt-get install atheme-services faketime
+      run: sudo apt-get install atheme-services
     - name: Install irctest dependencies
       run: |-
         python -m pip install --upgrade pip
-        pip install pytest pytest-xdist pytest-timeout -r requirements.txt
+        pip install pytest pytest-xdist -r requirements.txt
     - name: Test with pytest
-      run: PYTEST_ARGS='--junit-xml pytest.xml --timeout 300' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:~/.local/inspircd:$PATH
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH
         make inspircd-atheme
-      timeout-minutes: 30
     - if: always()
       name: Publish results
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: pytest-results_inspircd-atheme_devel_release
+        name: pytest results inspircd-atheme (devel_release)
         path: pytest.xml
 name: irctest with devel_release versions
 'on':

.pre-commit-config.yaml

@@ -2,23 +2,22 @@ exclude: ^irctest/scram
 
 repos:
   - repo: https://github.com/psf/black
-    rev: 23.1.0
+    rev: 20.8b1
     hooks:
       - id: black
         language_version: python3
 
   - repo: https://github.com/PyCQA/isort
-    rev: 5.11.5
+    rev: 5.5.2
     hooks:
       - id: isort
 
-  - repo: https://github.com/PyCQA/flake8
+  - repo: https://gitlab.com/pycqa/flake8
-    rev: 5.0.4
+    rev: 3.8.3
     hooks:
       - id: flake8
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.0.1
+    rev: v0.812
     hooks:
       - id: mypy
-        additional_dependencies: [types-PyYAML, types-docutils]

Makefile

@@ -7,56 +7,113 @@ PYTEST_ARGS ?=
 # Will be appended at the end of the -k argument to pytest
 EXTRA_SELECTORS ?=
 
+# testPlainLarge fails because it doesn't handle split AUTHENTICATE (reported on IRC)
+ANOPE_SELECTORS := \
+	and not testPlainLarge
+
+# buffering tests cannot pass because of issues with UTF-8 handling: https://github.com/DALnet/bahamut/issues/196
+# mask tests in test_who.py fail because they are not implemented.
+# some HelpTestCase::*[HELP] tests fail because Bahamut forwards /HELP to HelpServ (but not /HELPOP)
+# testWhowasMultiTarget fails because Bahamut returns the results in query order instead of chronological order
 BAHAMUT_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
 	and not IRCv3 \
+	and not buffering \
+	and not (testWho and not whois and mask) \
+	and not testWhoStar \
+	and (not HelpTestCase or HELPOP) \
+	and not testWhowasMultiTarget \
 	$(EXTRA_SELECTORS)
 
+# testQuitErrors is very flaky
+# AccountTagTestCase.testInvite fails because https://github.com/solanum-ircd/solanum/issues/166
+# testKickDefaultComment fails because it uses the nick of the kickee rather than the kicker.
+# testWhoisNumerics[oper] fails because charybdis uses RPL_WHOISSPECIAL instead of RPL_WHOISOPERATOR
+# testWhowasNoSuchNick fails because of a typo (solved in https://github.com/solanum-ircd/solanum/commit/08b7b6bd7e60a760ad47b58cbe8075b45d66166f)
 CHARYBDIS_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not testQuitErrors \
+	and not testKickDefaultComment \
+	and not (AccountTagTestCase and testInvite) \
+	and not (testWhoisNumerics and oper) \
+	and not testWhowasNoSuchNick \
 	$(EXTRA_SELECTORS)
 
+# testInfoNosuchserver does not apply to Ergo: Ergo ignores the optional <target> argument
 ERGO_SELECTORS := \
 	not deprecated \
+	and not testInfoNosuchserver \
 	$(EXTRA_SELECTORS)
 
+# testInviteUnopped is the only strict test that Hybrid fails
 HYBRID_SELECTORS := \
 	not Ergo \
+	and not testInviteUnopped \
 	and not deprecated \
 	$(EXTRA_SELECTORS)
 
+# testBotPrivateMessage and testBotChannelMessage fail because https://github.com/inspircd/inspircd/pull/1910 is not released yet
+# WHOWAS tests fail because https://github.com/inspircd/inspircd/pull/1967 and https://github.com/inspircd/inspircd/pull/1968 are not released yet
 INSPIRCD_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not testNoticeNonexistentChannel \
+	and not testBotPrivateMessage and not testBotChannelMessage \
+	and not whowas \
 	$(EXTRA_SELECTORS)
 
+# buffering tests fail because ircu2 discards the whole buffer on long lines (TODO: refine how we exclude these tests)
+# testQuit and testQuitErrors fail because ircu2 does not send ERROR or QUIT
+# lusers "full" tests fail because they depend on Modern behavior, not just RFC2812
+# statusmsg tests fail because STATUSMSG is present in ISUPPORT, but it not actually supported as PRIVMSG target
+# testKeyValidation[empty] fails because ircu2 returns ERR_NEEDMOREPARAMS on empty keys: https://github.com/UndernetIRC/ircu2/issues/13
+# testKickDefaultComment fails because it uses the nick of the kickee rather than the kicker.
+# testEmptyRealname fails because it uses a default value instead of ERR_NEEDMOREPARAMS.
+# HelpTestCase fails because it returns NOTICEs instead of numerics
+# testWhowasCountZero fails: https://github.com/UndernetIRC/ircu2/pull/19
 IRCU2_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not buffering \
+	and not testQuit \
+	and not (lusers and full) \
+	and not statusmsg \
+	and not (testKeyValidation and empty) \
+	and not testKickDefaultComment \
+	and not testEmptyRealname \
+	and not HelpTestCase \
+	and not testWhowasCountZero \
 	$(EXTRA_SELECTORS)
 
-NEFARIOUS_SELECTORS := \
+# same justification as ircu2
-	not Ergo \
-	and not deprecated \
-	and not strict \
-	$(EXTRA_SELECTORS)
-
 SNIRCD_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not buffering \
+	and not testQuit \
+	and not (lusers and full) \
+	and not statusmsg \
 	$(EXTRA_SELECTORS)
 
+# testListEmpty and testListOne fails because irc2 deprecated LIST
+# testKickDefaultComment fails because it uses the nick of the kickee rather than the kicker.
+# testWallopsPrivileges fails because it ignores the command instead of replying ERR_UNKNOWNCOMMAND
+# HelpTestCase fails because it returns NOTICEs instead of numerics
 IRC2_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not testListEmpty and not testListOne \
+	and not testKickDefaultComment \
+	and not testWallopsPrivileges \
+	and not HelpTestCase \
 	$(EXTRA_SELECTORS)
 
 MAMMON_SELECTORS := \
@@ -65,14 +122,28 @@ MAMMON_SELECTORS := \
 	and not strict \
 	$(EXTRA_SELECTORS)
 
+# testKeyValidation[spaces] and testKeyValidation[empty] fail because ngIRCd does not validate them https://github.com/ngircd/ngircd/issues/290
+# testStarNick: wat
+# testEmptyRealname fails because it uses a default value instead of ERR_NEEDMOREPARAMS.
+# chathistory tests fail because they need nicks longer than 9 chars
+# HelpTestCase::*[HELP] fails because it returns NOTICEs instead of numerics
 NGIRCD_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not (testKeyValidation and (spaces or empty)) \
+	and not testStarNick \
+	and not testEmptyRealname \
+	and not chathistory \
+	and (not HelpTestCase or HELPOP) \
 	$(EXTRA_SELECTORS)
 
+# testInviteUnopped is the only strict test that Plexus4 fails
+# testInviteInviteOnly fails because Plexus4 allows non-op to invite if (and only if) the channel is not invite-only
 PLEXUS4_SELECTORS := \
 	not Ergo \
+	and not testInviteUnopped \
+	and not testInviteInviteOnly \
 	and not deprecated \
 	$(EXTRA_SELECTORS)
 
@@ -83,53 +154,51 @@ LIMNORIA_SELECTORS := \
 	(foo or not foo) \
 	$(EXTRA_SELECTORS)
 
-# Tests marked with arbitrary_client_tags or react_tag can't pass because Sable does not support client tags yet
+# testQuitErrors is too flaky for CI
-# Tests marked with private_chathistory can't pass because Sable does not implement CHATHISTORY for DMs
+# testKickDefaultComment fails because solanum uses the nick of the kickee rather than the kicker.
-
-SABLE_SELECTORS := \
-	not Ergo \
-	and not deprecated \
-	and not strict \
-	and not arbitrary_client_tags \
-	and not react_tag \
-	and not private_chathistory \
-	and not list and not lusers and not time and not info \
-	$(EXTRA_SELECTORS)
-
 SOLANUM_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not testQuitErrors \
+	and not testKickDefaultComment \
 	$(EXTRA_SELECTORS)
 
-# Same as Limnoria
 SOPEL_SELECTORS := \
-	(foo or not foo) \
+	not testPlainNotAvailable \
-	$(EXTRA_SELECTORS)
-
-# TheLounge can actually pass all the test so there is none to exclude.
-# `(foo or not foo)` serves as a `true` value so it doesn't break when
-# $(EXTRA_SELECTORS) is non-empty
-THELOUNGE_SELECTORS := \
-	(foo or not foo) \
 	$(EXTRA_SELECTORS)
 
+# testNoticeNonexistentChannel fails: https://bugs.unrealircd.org/view.php?id=5949
+# regressions::testTagCap fails: https://bugs.unrealircd.org/view.php?id=5948
+# messages::testLineTooLong fails: https://bugs.unrealircd.org/view.php?id=5947
+# testCapRemovalByClient and testNakWhole fail pending https://github.com/unrealircd/unrealircd/pull/148
 # Tests marked with arbitrary_client_tags can't pass because Unreal whitelists which tags it relays
 # Tests marked with react_tag can't pass because Unreal blocks +draft/react https://github.com/unrealircd/unrealircd/pull/149
 # Tests marked with private_chathistory can't pass because Unreal does not implement CHATHISTORY for DMs
-
+# testChathistory[BETWEEN] fails: https://bugs.unrealircd.org/view.php?id=5952
+# testChathistory[AROUND] fails: https://bugs.unrealircd.org/view.php?id=5953
+# testWhoAllOpers fails because Unreal skips results when the mask is too broad
+# HELP and HELPOP tests fail because Unreal uses custom numerics https://github.com/unrealircd/unrealircd/pull/184
 UNREALIRCD_SELECTORS := \
 	not Ergo \
 	and not deprecated \
 	and not strict \
+	and not testNoticeNonexistentChannel \
+	and not (regressions.py and testTagCap) \
+	and not (messages.py and testLineTooLong) \
+	and not (cap.py and (testCapRemovalByClient or testNakWhole)) \
+	and not (account_tag.py and testInvite) \
 	and not arbitrary_client_tags \
 	and not react_tag \
 	and not private_chathistory \
+	and not (testChathistory and (between or around)) \
+	and not testWhoAllOpers \
+	and not HelpTestCase \
 	$(EXTRA_SELECTORS)
 
-.PHONY: all flakes bahamut charybdis ergo inspircd ircu2 snircd irc2 mammon nefarious limnoria sable sopel solanum unrealircd
+.PHONY: all flakes bahamut charybdis ergo inspircd ircu2 snircd irc2 mammon limnoria sopel solanum unrealircd
 
-all: flakes bahamut charybdis ergo inspircd ircu2 snircd irc2 mammon nefarious limnoria sable sopel solanum unrealircd
+all: flakes bahamut charybdis ergo inspircd ircu2 snircd irc2 mammon limnoria sopel solanum unrealircd
 
 flakes:
 	find irctest/ -name "*.py" -not -path "irctest/scram/*" -print0 | xargs -0 pyflakes3
@@ -138,8 +207,7 @@ bahamut:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.bahamut \
 		-m 'not services' \
-		-n 4 \
+		-n 10 \
-		-vv -s \
 		-k '$(BAHAMUT_SELECTORS)'
 
 bahamut-atheme:
@@ -147,6 +215,7 @@ bahamut-atheme:
 		--controller=irctest.controllers.bahamut \
 		--services-controller=irctest.controllers.atheme_services \
 		-m 'services' \
+		-n 10 \
 		-k '$(BAHAMUT_SELECTORS)'
 
 bahamut-anope:
@@ -154,7 +223,8 @@ bahamut-anope:
 		--controller=irctest.controllers.bahamut \
 		--services-controller=irctest.controllers.anope_services \
 		-m 'services' \
-		-k '$(BAHAMUT_SELECTORS)'
+		-n 10 \
+		-k '$(BAHAMUT_SELECTORS) $(ANOPE_SELECTORS)'
 
 charybdis:
 	$(PYTEST) $(PYTEST_ARGS) \
@@ -191,34 +261,27 @@ inspircd-anope:
 		--controller=irctest.controllers.inspircd \
 		--services-controller=irctest.controllers.anope_services \
 		-m 'services' \
-		-k '$(INSPIRCD_SELECTORS)'
+		-k '$(INSPIRCD_SELECTORS) $(ANOPE_SELECTORS)'
 
 ircu2:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.ircu2 \
 		-m 'not services and not IRCv3' \
-		-n 4 \
+		-n 10 \
 		-k '$(IRCU2_SELECTORS)'
 
-nefarious:
-	$(PYTEST) $(PYTEST_ARGS) \
-		--controller=irctest.controllers.nefarious \
-		-m 'not services' \
-		-n 4 \
-		-k '$(NEFARIOUS_SELECTORS)'
-
 snircd:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.snircd \
 		-m 'not services and not IRCv3' \
-		-n 4 \
+		-n 10 \
 		-k '$(SNIRCD_SELECTORS)'
 
 irc2:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.irc2 \
 		-m 'not services and not IRCv3' \
-		-n 4 \
+		-n 10 \
 		-k '$(IRC2_SELECTORS)'
 
 limnoria:
@@ -241,7 +304,7 @@ ngircd:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller irctest.controllers.ngircd \
 		-m 'not services' \
-		-n 4 \
+		-n 10 \
 		-k "$(NGIRCD_SELECTORS)"
 
 ngircd-anope:
@@ -258,12 +321,6 @@ ngircd-atheme:
 		-m 'services' \
 		-k "$(NGIRCD_SELECTORS)"
 
-sable:
-	$(PYTEST) $(PYTEST_ARGS) \
-		--controller=irctest.controllers.sable \
-		-n 20 \
-		-k '$(SABLE_SELECTORS)'
-
 solanum:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.solanum \
@@ -275,11 +332,6 @@ sopel:
 		--controller=irctest.controllers.sopel \
 		-k '$(SOPEL_SELECTORS)'
 
-thelounge:
-	$(PYTEST) $(PYTEST_ARGS) \
-		--controller=irctest.controllers.thelounge \
-		-k '$(THELOUNGE_SELECTORS)'
-
 unrealircd:
 	$(PYTEST) $(PYTEST_ARGS) \
 		--controller=irctest.controllers.unrealircd \
@@ -300,11 +352,4 @@ unrealircd-anope:
 		--controller=irctest.controllers.unrealircd \
 		--services-controller=irctest.controllers.anope_services \
 		-m 'services' \
-		-k '$(UNREALIRCD_SELECTORS)'
+		-k '$(UNREALIRCD_SELECTORS) $(ANOPE_SELECTORS)'
-
-unrealircd-dlk:
-	pifpaf run mysql -- $(PYTEST) $(PYTEST_ARGS) \
-		--controller=irctest.controllers.unrealircd \
-		--services-controller=irctest.controllers.dlk_services \
-		-m 'services' \
-		-k '$(UNREALIRCD_SELECTORS)'

README.md

@@ -3,40 +3,26 @@
 This project aims at testing interoperability of software using the
 IRC protocol, by running them against common test suites.
 
-It is also used while editing [the "Modern" specification](https://modern.ircdocs.horse/)
-to check behavior of a large selection of servers at once.
-
 ## The big picture
 
 This project contains:
 
-* IRC protocol test cases, primarily checking conformance to
+* IRC protocol test cases
-  [the "Modern" specification](https://modern.ircdocs.horse/) and
+* small wrappers around existing software to run tests on them
-  [IRCv3 extensions](https://ircv3.net/irc/), but also
-  [RFC 1459](https://datatracker.ietf.org/doc/html/rfc1459) and
-  [RFC 2812](https://datatracker.ietf.org/doc/html/rfc2812).
-  Most of them are for servers but also some for clients.
-  Only the client-server protocol is tested; server-server protocols are out of scope.
-* Small wrappers around existing software to run tests on them.
-  So far this is restricted to headless software (servers, service packages,
-  and clients bots).
 
 Wrappers run software in temporary directories, so running `irctest` should
 have no side effect.
 
-Test results for the latest version of each supported software, and respective logs,
-are [published daily](https://dashboard.irctest.limnoria.net/).
-
 ## Prerequisites
 
 Install irctest and dependencies:
 
 ```
-sudo apt install faketime  # Optional, but greatly speeds up irctest/server_tests/list.py
 cd ~
-git clone https://github.com/progval/irctest.git
+git clone https://github.com/ProgVal/irctest.git
 cd irctest
 pip3 install --user -r requirements.txt
+python3 setup.py install --user
 ```
 
 Add `~/.local/bin/` (and/or `~/go/bin/` for Ergo)
@@ -54,23 +40,18 @@ You can usually invoke it with `python3 -m pytest` command; which can often
 be called by the `pytest` or `pytest-3` commands (if not, alias them if you
 are planning to use them often).
 
-After installing `pytest-xdist`, you can also pass `pytest` the `-n 10` option
-to run `10` tests in parallel.
-
 The rest of this README assumes `pytest` works.
 
 ## Test selection
 
 A major feature of pytest that irctest heavily relies on is test selection.
 Using the `-k` option, you can select and deselect tests based on their names
+and/or markers (listed in `pytest.ini`).
 For example, you can run `LUSERS`-related tests with `-k lusers`.
-
+Or only tests based on RFC1459 with `-k rfc1459`.
-Using the `-m` option, you can select and deselect and them based on their markers
-(listed in `pytest.ini`).
-For example, you can run only tests based on RFC1459 with `-m rfc1459`.
 
 By default, all tests run; even niche ones. So you probably always want to
-use these options: `-m 'not Ergo and not deprecated and not strict`.
+use these options: `-k 'not Ergo and not deprecated and not strict`.
 This excludes:
 
 * `Ergo`-specific tests (included as Ergo uses irctest as its official
@@ -82,10 +63,6 @@ This excludes:
 
 ## Running tests
 
-This list is non-exhaustive, see `workflows.yml` for software not listed here.
-If software you want to test is not listed their either, please open an issue
-or pull request to add support for it.
-
 ### Servers
 
 #### Ergo:
@@ -112,6 +89,20 @@ make install
 pytest --controller irctest.controllers.solanum -k 'not Ergo and not deprecated and not strict'
 ```
 
+#### Charybdis:
+
+```
+cd /tmp/
+git clone https://github.com/atheme/charybdis.git
+cd charybdis
+./autogen.sh
+./configure --prefix=$HOME/.local/
+make -j 4
+make install
+cd ~/irctest
+pytest --controller irctest.controllers.charybdis -k 'not Ergo and not deprecated and not strict'
+```
+
 #### InspIRCd:
 
 ```
@@ -119,11 +110,8 @@ cd /tmp/
 git clone https://github.com/inspircd/inspircd.git
 cd inspircd
 
-# Optional, makes tests run considerably faster. Pick one depending on the InspIRCd version:
+# optional, makes tests run considerably faster
-# on Insp3 <= 3.16.0 and Insp4 <= 4.0.0a21:
 patch src/inspircd.cpp < ~/irctest/patches/inspircd_mainloop.patch
-# on Insp3 >= 3.17.0 and Insp4 >= 4.0.0a22:
-export CXXFLAGS=-DINSPIRCD_UNLIMITED_MAINLOOP
 
 ./configure --prefix=$HOME/.local/ --development
 make -j 4
@@ -132,6 +120,14 @@ cd ~/irctest
 pytest --controller irctest.controllers.inspircd -k 'not Ergo and not deprecated and not strict'
 ```
 
+#### Mammon:
+
+```
+pip3 install --user git+https://github.com/mammon-ircd/mammon.git
+cd ~/irctest
+pytest --controller irctest.controllers.mammon -k 'not Ergo and not deprecated and not strict'
+```
+
 #### UnrealIRCd:
 
 ```
@@ -148,8 +144,8 @@ pytest --controller irctest.controllers.unreal -k 'not Ergo and not deprecated a
 
 ### Servers with services
 
-Besides Ergo (that has built-in services) and Sable (that ships its own services),
+Besides Ergo (that has built-in services), most server controllers can optionally run
-most server controllers can optionally run service packages.
+service packages.
 
 #### Atheme:
 

conftest.py

@@ -106,10 +106,13 @@ def pytest_collection_modifyitems(session, config, items):
         assert isinstance(item, _pytest.python.Function)
 
         # unittest-style test functions have the node of UnitTest class as parent
-        if tuple(map(int, _pytest.__version__.split("."))) >= (7,):
+        assert isinstance(
-            assert isinstance(item.parent, _pytest.python.Class)
+            item.parent,
-        else:
+            (
-            assert isinstance(item.parent, _pytest.python.Instance)
+                _pytest.python.Class,  # pytest >= 7.0.0
+                _pytest.python.Instance,  # pytest < 7.0.0
+            ),
+        )
 
         # and that node references the UnitTest class
         assert issubclass(item.parent.cls, _IrcTestCase)

data/anope/config.cache

@@ -0,0 +1,8 @@
+INSTDIR="$HOME/.local/"
+RUNGROUP=""
+UMASK=077
+DEBUG="yes"
+USE_PCH="yes"
+EXTRA_INCLUDE_DIRS=""
+EXTRA_LIB_DIRS=""
+EXTRA_CONFIG_ARGS=""

data/nefarious/ircd.pem

@@ -1,83 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIJRAIBADANBgkqhkiG9w0BAQEFAASCCS4wggkqAgEAAoICAQDT0URxi7/l7ZGe
-tkPv9Yh8h2s9BpbAR4Wq8sakgqETWg/nE/JQM5dPxroVbtZWWQXuJEFsgBKbASLa
-/eg5cyJv4Uu5WIZpG1LxdPEEIOSMWjzoAGwoLxbTRGrS7qNXsknB9RwDuq8lPQiK
-kiAahg1Cn1vRrQ4cRrG+AkQWpRHJEDoLjCSo8IcAsKAZlw/eGtAcmeNvkr5AujEw
-XjIwx2FoDyKaNGRH5Z7gLWvCKBNxQuJuMTzh8guLqdGbE4hH3rqyICbW5DGPaOZL
-LErWuJ7kEhLZG2HDW5JaXOr0QfFYAA8pl9/qCuFMdoxRUKRcYBoxoMmz6dlsmipN
-7vIj+TT6TemwcAT25pwMJIVS4WC4+BZilNH2eWKD9hZA8Kq7FDPu+1rxOJaLbE/b
-vpK8jZeRdqFzE1eBCgPkw8D8V0r7J18d+DsmgOe2kRycaia/t9M4rhqe0FXjX1X1
-lzQ52grxgc28Ejd1fGQXIJmdTh4BqKqTzxup0izS7dgFP1Ezm6Z4O+wklpL5uQF2
-Ex4X6QEj76iCxH+J/01/cvbxMe3iuGXECbO/y1FIrg7FKzZSrQo4aP63lS7Y7aq0
-t2t6kOS83ebhnpgHClgFs8/C3ayzYBBtbK63PYthwO8Rt6WamCIZFF5tA3XoI4Ak
-fZcWD18loZai+QznVzbLNINf++rTwwIDAQABAoICAQCs1tT3piZHU2yAyo9zLbJa
-kxGxcT/v1CzBSmtG8ATJyrKxRzhxszdj9HABbzjcqrXJFbKA+5yy+OFdOtSUlFtk
-Wb21lwPOnmo29sp4KPL1h+itEzMuMwZ4DBry1aFZvPSsnPpoHJwwUbY3hHdHzVzi
-oTCGTqT188Wzmxu+MqHppCEJLSj45ZPzvyxU1UwwW0a4H+ZTM7WlEYlzw1lHLlpQ
-VBFTLS8q77aNjOKiQptiz0X+zpS0dhJvu3l7BhwtMRS8prmqnffG4r0QWCsVPP8C
-cbEJkWtbwswQikN6Xpi1yw6UTQZ8brZa810aOSh07EJTfrU35rjxAndEspbJPd+4
-Zz6fKNnRA7A4fFap2hF4TSP/UF12b4ulQ8FfcMMTFszWko5M6fWFuCeWfNbyXML5
-fmn+NmSOboj7LkDqbpxtyaIVXXb2Y3F6A2fNllm/mxaGrRoEGNaH3o0qBgWRzJJB
-TDSvIQtJddzL+iMaqxz4ufXAREJernZmPa3vlkVGLINNQUC9JLrB5eFjLzPiZN2U
-8RgQ9YX5tjoJ+DtPWuMFDiCS1ZE20/UBOEYTeqIVuKdK3AjJDMFSjg8fRvsWRqZe
-zsHv6tCtIFZFxYRxtrRGTUPQF+1QD6zBjYxZZk1B4n3uYBGVQFM/LnNHUxRnJBx1
-PunD4ICOY97xd2hcPmGiCQKCAQEA8NCXYaHzhv6fg95H/iMuJVcOCKrJ5rVr4poG
-SD0KZtS7SLzUYat8WcuoSubh5Eb2hHtrsnLrSOTnwQUO61f4gCRm2sEqHYsOAd7+
-mNe1jfil0UBVqqL9GBcGYJkc5+DHgUlJQaxMV+4YLt8fD0KfZEnHaDAYX3kUdz+p
-be//YAKv+JmxWcUdBF60AUWPjbCJT/1pfJeY8nEBFiYtlYKKN24+4OiRdJ2yRGzt
-ZtNHaWy5EFF70yVgPX5MGQ7Z2JpejzK+lt+9nG4h1uJ4M2X4YrGVrRCn1W8jwqm/
-bXest3E6wkkLoWDm9EaeYj00DUgMOviPyP4ckyxilG+Fny4JbwKCAQEA4SyUV03X
-KEoL5sOD69sLu3TpnIQz73u9an9W/f2f7rsGwmCcR9RdYGV29ltwfBvOm0FnPQio
-GliN+3PTWAL6bb8VYo2IR53VKpVHKSQUlzDOD9PGObXw1CT/+0zoMP7FBA4dTJDf
-xQ63AQNpSCGdwbxZygPWzLV5O1WxMeXhnQRL1EBvMyJ52od0+HbajDXg5mNiBKNQ
-AtVhB9pEu47Blu/KBqWjfh/GeBLPZB7MHmGNBYbBGGskKRLG4sIbwShs9cx8UM0/
-9dxXkX2d8hjnSD/0ZBh54HHUaEvKAKfpz1L8AC0ll7biCAy0CZK23AoZu/KT8zJ+
-qvz3AuJcW3lo7QKCAQEAzfGltNJawPUamBzNttKBUV+s2c6tkkdO92C/xKGnNp/x
-dtg+TTTpyKV5zGy9fIsPoecnCFptS06vwAvCYZQ/Kd93stcFXHSiSwlY9H9tfffK
-XzTEzoRLLIHsa0omRUufcrqpEqf2NjChr9wS5OsWAx9xkHGpNmUHEqB4FlPsM0C5
-G0LdQCdplGYlTP0fMo5qL+VJhErle1kXE8kcrMMRzyvSTGe4lWGTph79vDUt2kQn
-1IPLAJzzPEO5cqiXtzz1Z0N/aOn5b0FkYTAWmeY30LeMiJA46Df+/ihLVKPHKq6E
-EMmFT8LeYMPQCbXLwRv/kaMm3D4tU9PejpD9Vk95swKCAQAtULBlxXeIVyaAAVba
-L1H0Hroo0n41MtzSwt+568G05JSep5yr4/QKw0CmoY5Im7v/iLEDGmviKXIhaZTd
-wHOvhGYEWGFVsFDG6hXRFL7EEoFVtBPPZ2sY9n1BkJ+lxI/XmhORZhJycNypaotU
-hddets4HFrCyr86+/ybS2OWHmOa9x13Zl5WYQexrWFfxIaKqGtQOBOPEPjbxwp5U
-dI1HF+i7X7hAWJqzbW2pQ31mm9EqjIztoho73diCp/e37q/G46kdBcFadEZ3NCWG
-JDbfVmeTgU19usq5Vo9HhINMQvIOAwfuuVJRtmTBDHKaY7n8FfxqU/4j4RbA0Ncv
-XYadAoIBAQC7yh4/UZCGhklUhhk/667OfchWvWGriCSaYGmQPdMzxjnIjAvvIUe9
-riOTBSZXYYLmZHsmY/jK7KMGB3AsLTypSa9+ddAWqWn2dvOYyxNiAaSJK/RZfA9A
-ocVfvvkhOfNAYIF+A+fyJ2pznsDkBf9tPkhN7kovl+mr/e25qZb1d09377770Pi7
-thzEi+JLrRgYVLrCrPi2j4l7/Va/UaAPz+Dtu2GCT9vXgnhZtpb8R1kTViZFryTv
-k+qbNYJzVm61Vit9mVAGe+WuzhlclJnN6LIZGG3zYHIulRAJrH1XDauHZfHzCKgi
-FnMesy4thDMH/MhUfRtbylZTq45gtvCA
------END PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIFazCCA1OgAwIBAgIUYHD08+9S32VTD9IEsr2Oe1dH3VEwDQYJKoZIhvcNAQEL
-BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
-GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMjA0MDQxODE2NTZaFw0yMzA0
-MDQxODE2NTZaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
-HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB
-AQUAA4ICDwAwggIKAoICAQDT0URxi7/l7ZGetkPv9Yh8h2s9BpbAR4Wq8sakgqET
-Wg/nE/JQM5dPxroVbtZWWQXuJEFsgBKbASLa/eg5cyJv4Uu5WIZpG1LxdPEEIOSM
-WjzoAGwoLxbTRGrS7qNXsknB9RwDuq8lPQiKkiAahg1Cn1vRrQ4cRrG+AkQWpRHJ
-EDoLjCSo8IcAsKAZlw/eGtAcmeNvkr5AujEwXjIwx2FoDyKaNGRH5Z7gLWvCKBNx
-QuJuMTzh8guLqdGbE4hH3rqyICbW5DGPaOZLLErWuJ7kEhLZG2HDW5JaXOr0QfFY
-AA8pl9/qCuFMdoxRUKRcYBoxoMmz6dlsmipN7vIj+TT6TemwcAT25pwMJIVS4WC4
-+BZilNH2eWKD9hZA8Kq7FDPu+1rxOJaLbE/bvpK8jZeRdqFzE1eBCgPkw8D8V0r7
-J18d+DsmgOe2kRycaia/t9M4rhqe0FXjX1X1lzQ52grxgc28Ejd1fGQXIJmdTh4B
-qKqTzxup0izS7dgFP1Ezm6Z4O+wklpL5uQF2Ex4X6QEj76iCxH+J/01/cvbxMe3i
-uGXECbO/y1FIrg7FKzZSrQo4aP63lS7Y7aq0t2t6kOS83ebhnpgHClgFs8/C3ayz
-YBBtbK63PYthwO8Rt6WamCIZFF5tA3XoI4AkfZcWD18loZai+QznVzbLNINf++rT
-wwIDAQABo1MwUTAdBgNVHQ4EFgQU+9eHi2eqy0f3fDS0GjqkijGDDocwHwYDVR0j
-BBgwFoAU+9eHi2eqy0f3fDS0GjqkijGDDocwDwYDVR0TAQH/BAUwAwEB/zANBgkq
-hkiG9w0BAQsFAAOCAgEAAJXO3qUc/PW75pI2dt1cKv20VqozkfEf7P0eeVisCDxn
-1p3QhVgI2lEe9kzdHp7t42g5xLkUhQEVmBcKm9xbl+k2D1X0+T8px1x6ZiWfbhXL
-ptc/qCIXjPCgVN3s+Kasii3hHkZxKGZz/ySmBmfDJZjQZtbZzQWpvvX6SD4s7sjo
-gWbZW3qvQ0bFTGdD1IjKYGaxK6aSrNkAIutiAX4RczJ1QSwb9Z2EIen+ABAvOZS9
-xv3LiiidWcuOT7WzXEa4QvOslCEkAF+jj6mGYB7NWtly0kj4AEPvI4IoYTi9dohS
-CA0zd1DTfjRwpAnT5P4sj4mpjLyRBumeeVGpCZhUxfKpFjIB2AnlgxrU+LPq5c9R
-ZZ9Q5oeLxjRPjpqBeWwgnbjXstQCL9g0U7SsEemsv+zmvG5COhAmG5Wce/65ILlg
-450H4bcn1ul0xvxz9hat6tqEZry3HcNE/CGDT+tXuhHpqOXkY1/c78C0QbWjWodR
-tCvlXW00a+7TlEhNr4XBNdqtIQfYS9K9yiVVNfZLPEsN/SA3BGXmrr+du1/E4Ria
-CkVpmBdJsVu5eMaUj1arsCqI4fwHzljtojJe/pCzZBVkOaSWQEQ+LL4iVnMas68m
-qyshtNf4KNiM55OQmyTiFHMTIxCtdEcHaR3mUxR7GrIhc/bxyxUUBtMAuUX0Kjs=
------END CERTIFICATE-----

data/unreal/config.settings

@@ -19,10 +19,6 @@ SHOWLISTMODES="1"
 NOOPEROVERRIDE=""
 OPEROVERRIDEVERIFY=""
 GENCERTIFICATE="1"
-
+EXTRAPARA=""
-# Use system argon to avoid getting SIGILLed if the build machine has a more recent
-# CPU than the one running the tests.
-EXTRAPARA="--with-system-argon2"
-
 ADVANCED=""
 

irctest/basecontrollers.py

@@ -1,23 +1,18 @@
 from __future__ import annotations
 
-import contextlib
 import dataclasses
-import json
 import os
-from pathlib import Path
 import shutil
 import socket
 import subprocess
 import tempfile
-import textwrap
 import time
-from typing import IO, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type
+from typing import IO, Any, Callable, Dict, List, Optional, Set, Tuple, Type
 
 import irctest
 
 from . import authentication, tls
 from .client_mock import ClientMock
-from .irc_utils.filelock import FileLock
 from .irc_utils.junkdrawer import find_hostname_and_port
 from .irc_utils.message_parser import Message
 from .runner import NotImplementedByController
@@ -38,14 +33,6 @@ class TestCaseControllerConfig:
     chathistory: bool = False
     """Whether to enable chathistory features."""
 
-    account_registration_before_connect: bool = False
-    """Whether draft/account-registration should be allowed before completing
-    connection registration (NICK + USER + CAP END)"""
-
-    account_registration_requires_email: bool = False
-    """Whether an email address must be provided when using draft/account-registration.
-    This does not imply servers must validate it."""
-
     ergo_roleplay: bool = False
     """Whether to enable the Ergo role-play commands."""
 
@@ -67,47 +54,17 @@ class _BaseController:
 
     supports_sts: bool
     supported_sasl_mechanisms: Set[str]
-
     proc: Optional[subprocess.Popen]
 
-    _used_ports_path = Path(tempfile.gettempdir()) / "irctest_ports.json"
-    _port_lock = FileLock(Path(tempfile.gettempdir()) / "irctest_ports.json.lock")
-
     def __init__(self, test_config: TestCaseControllerConfig):
         self.test_config = test_config
         self.proc = None
-        self._own_ports: Set[Tuple[str, int]] = set()
-
-    @contextlib.contextmanager
-    def _used_ports(self) -> Iterator[Set[Tuple[str, int]]]:
-        with self._port_lock:
-            if not self._used_ports_path.exists():
-                self._used_ports_path.write_text("[]")
-            used_ports = {
-                (h, p) for (h, p) in json.loads(self._used_ports_path.read_text())
-            }
-            yield used_ports
-            self._used_ports_path.write_text(json.dumps(list(used_ports)))
-
-    def get_hostname_and_port(self) -> Tuple[str, int]:
-        with self._used_ports() as used_ports:
-            while True:
-                (hostname, port) = find_hostname_and_port()
-                if (hostname, port) not in used_ports:
-                    # double-checking in self._used_ports to prevent collisions
-                    # between controllers starting at the same time.
-                    break
-
-            used_ports.add((hostname, port))
-            self._own_ports.add((hostname, port))
-
-        return (hostname, port)
 
     def check_is_alive(self) -> None:
         assert self.proc
         self.proc.poll()
         if self.proc.returncode is not None:
-            raise ProcessStopped(f"process returned {self.proc.returncode}")
+            raise ProcessStopped()
 
     def kill_proc(self) -> None:
         """Terminates the controlled process, waits for it to exit, and
@@ -125,17 +82,12 @@ class _BaseController:
         if self.proc:
             self.kill_proc()
 
-        with self._used_ports() as used_ports:
-            for hostname, port in list(self._own_ports):
-                used_ports.remove((hostname, port))
-                self._own_ports.remove((hostname, port))
-
 
 class DirectoryBasedController(_BaseController):
     """Helper for controllers whose software configuration is based on an
     arbitrary directory."""
 
-    directory: Optional[Path]
+    directory: Optional[str]
 
     def __init__(self, test_config: TestCaseControllerConfig):
         super().__init__(test_config)
@@ -158,21 +110,22 @@ class DirectoryBasedController(_BaseController):
         """Open a file in the configuration directory."""
         assert self.directory
         if os.sep in name:
-            dir_ = self.directory / os.path.dirname(name)
+            dir_ = os.path.join(self.directory, os.path.dirname(name))
-            dir_.mkdir(parents=True, exist_ok=True)
+            if not os.path.isdir(dir_):
-            assert dir_.is_dir()
+                os.makedirs(dir_)
-        return (self.directory / name).open(mode)
+            assert os.path.isdir(dir_)
+        return open(os.path.join(self.directory, name), mode)
 
     def create_config(self) -> None:
         if not self.directory:
-            self.directory = Path(tempfile.mkdtemp())
+            self.directory = tempfile.mkdtemp()
 
     def gen_ssl(self) -> None:
         assert self.directory
-        self.csr_path = self.directory / "ssl.csr"
+        self.csr_path = os.path.join(self.directory, "ssl.csr")
-        self.key_path = self.directory / "ssl.key"
+        self.key_path = os.path.join(self.directory, "ssl.key")
-        self.pem_path = self.directory / "ssl.pem"
+        self.pem_path = os.path.join(self.directory, "ssl.pem")
-        self.dh_path = self.directory / "dh.pem"
+        self.dh_path = os.path.join(self.directory, "dh.pem")
         subprocess.check_output(
             [
                 self.openssl_bin,
@@ -203,18 +156,10 @@ class DirectoryBasedController(_BaseController):
             ],
             stderr=subprocess.DEVNULL,
         )
-        with self.dh_path.open("w") as fd:
+        subprocess.check_output(
-            fd.write(
+            [self.openssl_bin, "dhparam", "-out", self.dh_path, "128"],
-                textwrap.dedent(
+            stderr=subprocess.DEVNULL,
-                    """
+        )
-                    -----BEGIN DH PARAMETERS-----
-                    MIGHAoGBAJICSyQAiLj1fw8b5xELcnpqBQ+wvOyKgim4IetWOgZnRQFkTgOeoRZD
-                    HksACRFJL/EqHxDKcy/2Ghwr2axhNxSJ+UOBmraP3WfodV/fCDPnZ+XnI9fjHsIr
-                    rjisPMqomjXeiTB1UeAHvLUmCK4yx6lpAJsCYwJjsqkycUfHiy1bAgEC
-                    -----END DH PARAMETERS-----
-                    """
-                )
-            )
 
 
 class BaseClientController(_BaseController):
@@ -243,16 +188,9 @@ class BaseServerController(_BaseController):
     extban_mute_char: Optional[str] = None
     """Character used for the 'mute' extban"""
     nickserv = "NickServ"
-    sync_sleep_time = 0.0
-    """How many seconds to sleep before clients synchronously get messages.
 
-    This can be 0 for servers answering all commands in order (all but Sable as of
+    def get_hostname_and_port(self) -> Tuple[str, int]:
-    this writing), as irctest emits a PING, waits for a PONG, and captures all messages
+        return find_hostname_and_port()
-    between the two."""
-
-    def __init__(self, *args: Any, **kwargs: Any):
-        super().__init__(*args, **kwargs)
-        self.faketime_enabled = False
 
     def run(
         self,
@@ -262,7 +200,8 @@ class BaseServerController(_BaseController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]],
+        invalid_metadata_keys: Optional[Set[str]],
     ) -> None:
         raise NotImplementedError()
 
@@ -278,7 +217,6 @@ class BaseServerController(_BaseController):
             raise NotImplementedByController("account registration")
 
     def wait_for_port(self) -> None:
-        started_at = time.time()
         while not self.port_open:
             self.check_is_alive()
             time.sleep(self._port_wait_interval)
@@ -297,20 +235,15 @@ class BaseServerController(_BaseController):
                         time.sleep(0.01)
 
                         c.send(b" ")  # Triggers BrokenPipeError
-                except (BrokenPipeError, ConnectionResetError):
+                except BrokenPipeError:
                     # ircu2 cuts the connection without a message if registration
                     # is not complete.
                     pass
-                except socket.timeout:
-                    # irc2 just keeps it open
-                    pass
 
                 c.close()
                 self.port_open = True
-            except ConnectionRefusedError:
+            except Exception:
-                if time.time() - started_at >= 60:
+                continue
-                    # waited for 60 seconds, giving up
-                    raise
 
     def wait_for_services(self) -> None:
         assert self.services_controller
@@ -351,38 +284,25 @@ class BaseServicesController(_BaseController):
         c.connect(self.server_controller.hostname, self.server_controller.port)
         c.sendLine("NICK chkNS")
         c.sendLine("USER chk chk chk chk")
-        time.sleep(self.server_controller.sync_sleep_time)
+        for msg in c.getMessages(synchronize=False):
-        got_end_of_motd = False
+            if msg.command == "PING":
-        while not got_end_of_motd:
+                # Hi Unreal
-            for msg in c.getMessages(synchronize=False):
+                c.sendLine("PONG :" + msg.params[0])
-                if msg.command == "PING":
+        c.getMessages()
-                    # Hi Unreal
-                    c.sendLine("PONG :" + msg.params[0])
-                if msg.command in ("376", "422"):  # RPL_ENDOFMOTD / ERR_NOMOTD
-                    got_end_of_motd = True
 
-        timeout = time.time() + 10
+        timeout = time.time() + 5
         while True:
-            c.sendLine(f"PRIVMSG {self.server_controller.nickserv} :help")
+            c.sendLine(f"PRIVMSG {self.server_controller.nickserv} :HELP")
-
+            msgs = self.getNickServResponse(c)
-            msgs = self.getNickServResponse(c, timeout=1)
             for msg in msgs:
                 if msg.command == "401":
                     # NickServ not available yet
                     pass
-                elif msg.command in ("MODE", "221"):  # RPL_UMODEIS
-                    pass
-                elif msg.command == "396":  # RPL_VISIBLEHOST
-                    pass
                 elif msg.command == "NOTICE":
-                    assert msg.prefix is not None
+                    # NickServ is available
-                    if "!" not in msg.prefix and "." in msg.prefix:
+                    assert "nickserv" in (msg.prefix or "").lower(), msg
-                        # Server notice
+                    print("breaking")
-                        pass
+                    break
-                    else:
-                        # NickServ is available
-                        assert "nickserv" in (msg.prefix or "").lower(), msg
-                        break
                 else:
                     assert False, f"unexpected reply from NickServ: {msg}"
             else:
@@ -399,12 +319,11 @@ class BaseServicesController(_BaseController):
         c.disconnect()
         self.services_up = True
 
-    def getNickServResponse(self, client: Any, timeout: int = 0) -> List[Message]:
+    def getNickServResponse(self, client: Any) -> List[Message]:
         """Wrapper aroung getMessages() that waits longer, because NickServ
         is queried asynchronously."""
         msgs: List[Message] = []
-        start_time = time.time()
+        while not msgs:
-        while not msgs and (not timeout or start_time + timeout > time.time()):
             time.sleep(0.05)
             msgs = client.getMessages()
         return msgs

irctest/cases.py

@@ -69,30 +69,6 @@ TController = TypeVar("TController", bound=basecontrollers._BaseController)
 T = TypeVar("T")
 
 
-def retry(f: TCallable) -> TCallable:
-    """Retry the function if it raises ConnectionClosed; as a workaround for flaky
-    connection, such as::
-
-        1: connects to server.
-        1 -> S: NICK foo
-        1 -> S: USER username * * :Realname
-        S -> 1: :My.Little.Server NOTICE * :*** Found your hostname (cached)
-        S -> 1: :My.Little.Server NOTICE * :*** Checking Ident
-        S -> 1: :My.Little.Server NOTICE * :*** No Ident response
-        S -> 1: ERROR :Closing Link: cpu-pool.com (Use a different port)
-    """
-
-    @functools.wraps(f)
-    def newf(*args, **kwargs):  # type: ignore
-        try:
-            return f(*args, **kwargs)
-        except ConnectionClosed:
-            time.sleep(1)
-            return f(*args, **kwargs)
-
-    return newf  # type: ignore
-
-
 class ChannelJoinException(Exception):
     def __init__(self, code: str, params: List[str]):
         super().__init__(f"Failed to join channel ({code}): {params}")
@@ -160,7 +136,6 @@ class _IrcTestCase(Generic[TController]):
     def messageDiffers(
         self,
         msg: Message,
-        command: Union[str, None, patma.Operator] = None,
         params: Optional[List[Union[str, None, patma.Operator]]] = None,
         target: Optional[str] = None,
         tags: Optional[
@@ -174,7 +149,7 @@ class _IrcTestCase(Generic[TController]):
     ) -> Optional[str]:
         """Returns an error message if the message doesn't match the given arguments,
         or None if it matches."""
-        for key, value in kwargs.items():
+        for (key, value) in kwargs.items():
             if getattr(msg, key) != value:
                 fail_msg = (
                     fail_msg or "expected {param} to be {expects}, got {got}: {msg}"
@@ -187,14 +162,6 @@ class _IrcTestCase(Generic[TController]):
                     msg=msg,
                 )
 
-        if command is not None and not patma.match_string(msg.command, command):
-            fail_msg = (
-                fail_msg or "expected command to match {expects}, got {got}: {msg}"
-            )
-            return fail_msg.format(
-                *extra_format, got=msg.command, expects=command, msg=msg
-            )
-
         if prefix is not None and not patma.match_string(msg.prefix, prefix):
             fail_msg = (
                 fail_msg or "expected prefix to match {expects}, got {got}: {msg}"
@@ -223,7 +190,7 @@ class _IrcTestCase(Generic[TController]):
                     or "expected nick to be {expects}, got {got} instead: {msg}"
                 )
                 return fail_msg.format(
-                    *extra_format, got=got_nick, expects=nick, msg=msg
+                    *extra_format, got=got_nick, expects=nick, param=key, msg=msg
                 )
 
         return None
@@ -360,8 +327,8 @@ class BaseClientTestCase(_IrcTestCase[basecontrollers.BaseClientController]):
     nick: Optional[str] = None
     user: Optional[List[str]] = None
     server: socket.socket
-    protocol_version: Optional[str]
+    protocol_version = Optional[str]
-    acked_capabilities: Optional[Set[str]]
+    acked_capabilities = Optional[Set[str]]
 
     __new__ = object.__new__  # pytest won't collect Generic[] subclasses otherwise
 
@@ -457,9 +424,7 @@ class BaseClientTestCase(_IrcTestCase[basecontrollers.BaseClientController]):
             print("{:.3f} S: {}".format(time.time(), line.strip()))
 
     def readCapLs(
-        self,
+        self, auth: Optional[Authentication] = None, tls_config: tls.TlsConfig = None
-        auth: Optional[Authentication] = None,
-        tls_config: Optional[tls.TlsConfig] = None,
     ) -> None:
         (hostname, port) = self.server.getsockname()
         self.controller.run(
@@ -469,9 +434,9 @@ class BaseClientTestCase(_IrcTestCase[basecontrollers.BaseClientController]):
         m = self.getMessage()
         self.assertEqual(m.command, "CAP", "First message is not CAP LS.")
         if m.params == ["LS"]:
-            self.protocol_version = "301"
+            self.protocol_version = 301
         elif m.params == ["LS", "302"]:
-            self.protocol_version = "302"
+            self.protocol_version = 302
         elif m.params == ["END"]:
             self.protocol_version = None
         else:
@@ -538,15 +503,11 @@ class BaseServerTestCase(
 
     password: Optional[str] = None
     ssl = False
+    valid_metadata_keys: Set[str] = set()
+    invalid_metadata_keys: Set[str] = set()
     server_support: Optional[Dict[str, Optional[str]]]
     run_services = False
 
-    faketime: Optional[str] = None
-    """If not None and the controller supports it and libfaketime is available,
-    runs the server using faketime and this value set as the $FAKETIME env variable.
-    Tests must check ``self.controller.faketime_enabled`` is True before
-    relying on this."""
-
     __new__ = object.__new__  # pytest won't collect Generic[] subclasses otherwise
 
     def setUp(self) -> None:
@@ -557,9 +518,10 @@ class BaseServerTestCase(
             self.hostname,
             self.port,
             password=self.password,
+            valid_metadata_keys=self.valid_metadata_keys,
+            invalid_metadata_keys=self.invalid_metadata_keys,
             ssl=self.ssl,
             run_services=self.run_services,
-            faketime=self.faketime,
         )
         self.clients: Dict[TClientName, client_mock.ClientMock] = {}
 
@@ -594,13 +556,9 @@ class BaseServerTestCase(
         del self.clients[name]
 
     def getMessages(self, client: TClientName, **kwargs: Any) -> List[Message]:
-        if kwargs.get("synchronize", True):
-            time.sleep(self.controller.sync_sleep_time)
         return self.clients[client].getMessages(**kwargs)
 
     def getMessage(self, client: TClientName, **kwargs: Any) -> Message:
-        if kwargs.get("synchronize", True):
-            time.sleep(self.controller.sync_sleep_time)
         return self.clients[client].getMessage(**kwargs)
 
     def getRegistrationMessage(self, client: TClientName) -> Message:
@@ -696,11 +654,10 @@ class BaseServerTestCase(
         m = self.getRegistrationMessage(client)
         self.assertIn(m.command, ["900", "903"], str(m))
 
-    @retry
     def connectClient(
         self,
         nick: str,
-        name: Optional[TClientName] = None,
+        name: TClientName = None,
         capabilities: Optional[List[str]] = None,
         skip_if_cap_nak: bool = False,
         show_io: Optional[bool] = None,
@@ -715,7 +672,7 @@ class BaseServerTestCase(
         client = self.addClient(name, show_io=show_io)
         if capabilities:
             self.sendLine(client, "CAP LS 302")
-            self.getCapLs(client)
+            m = self.getRegistrationMessage(client)
             self.requestCapabilities(client, capabilities, skip_if_cap_nak)
         if password is not None:
             if "sasl" not in (capabilities or ()):
@@ -745,12 +702,6 @@ class BaseServerTestCase(
                         self.server_support[param] = None
             welcome.append(m)
 
-        self.targmax: Dict[str, Optional[str]] = dict(  # type: ignore[assignment]
-            item.split(":", 1)
-            for item in (self.server_support.get("TARGMAX") or "").split(",")
-            if item
-        )
-
         return welcome
 
     def joinClient(self, client: TClientName, channel: str) -> None:
@@ -781,58 +732,50 @@ class BaseServerTestCase(
                     raise ChannelJoinException(msg.command, msg.params)
 
 
-_TSelf = TypeVar("_TSelf", bound="_IrcTestCase")
+_TSelf = TypeVar("_TSelf", bound="OptionalityHelper")
 _TReturn = TypeVar("_TReturn")
 
 
-def skipUnlessHasMechanism(
+class OptionalityHelper(Generic[TController]):
-    mech: str,
+    controller: TController
-) -> Callable[[Callable[..., _TReturn]], Callable[..., _TReturn]]:
+
-    # Just a function returning a function that takes functions and
+    def checkSaslSupport(self) -> None:
-    # returns functions, nothing to see here.
+        if self.controller.supported_sasl_mechanisms:
-    # If Python didn't have such an awful syntax for callables, it would be:
+            return
-    # str -> ((TSelf -> TReturn) -> (TSelf -> TReturn))
+        raise runner.NotImplementedByController("SASL")
-    def decorator(f: Callable[..., _TReturn]) -> Callable[..., _TReturn]:
+
+    def checkMechanismSupport(self, mechanism: str) -> None:
+        if mechanism in self.controller.supported_sasl_mechanisms:
+            return
+        raise runner.OptionalSaslMechanismNotSupported(mechanism)
+
+    @staticmethod
+    def skipUnlessHasMechanism(
+        mech: str,
+    ) -> Callable[[Callable[..., _TReturn]], Callable[..., _TReturn]]:
+        # Just a function returning a function that takes functions and
+        # returns functions, nothing to see here.
+        # If Python didn't have such an awful syntax for callables, it would be:
+        # str -> ((TSelf -> TReturn) -> (TSelf -> TReturn))
+        def decorator(f: Callable[..., _TReturn]) -> Callable[..., _TReturn]:
+            @functools.wraps(f)
+            def newf(self: _TSelf, *args: Any, **kwargs: Any) -> _TReturn:
+                self.checkMechanismSupport(mech)
+                return f(self, *args, **kwargs)
+
+            return newf
+
+        return decorator
+
+    @staticmethod
+    def skipUnlessHasSasl(f: Callable[..., _TReturn]) -> Callable[..., _TReturn]:
         @functools.wraps(f)
         def newf(self: _TSelf, *args: Any, **kwargs: Any) -> _TReturn:
-            if mech not in self.controller.supported_sasl_mechanisms:
+            self.checkSaslSupport()
-                raise runner.OptionalSaslMechanismNotSupported(mech)
             return f(self, *args, **kwargs)
 
         return newf
 
-    return decorator
-
-
-def xfailIf(
-    condition: Callable[..., bool], reason: str
-) -> Callable[[Callable[..., _TReturn]], Callable[..., _TReturn]]:
-    # Works about the same as skipUnlessHasMechanism
-    def decorator(f: Callable[..., _TReturn]) -> Callable[..., _TReturn]:
-        @functools.wraps(f)
-        def newf(self: _TSelf, *args: Any, **kwargs: Any) -> _TReturn:
-            if condition(self, *args, **kwargs):
-                try:
-                    return f(self, *args, **kwargs)
-                except Exception:
-                    pytest.xfail(reason)
-                    assert False  # make mypy happy
-            else:
-                return f(self, *args, **kwargs)
-
-        return newf
-
-    return decorator
-
-
-def xfailIfSoftware(
-    names: List[str], reason: str
-) -> Callable[[Callable[..., _TReturn]], Callable[..., _TReturn]]:
-    def pred(testcase: _IrcTestCase, *args: Any, **kwargs: Any) -> bool:
-        return testcase.controller.software_name in names
-
-    return xfailIf(pred, reason)
-
 
 def mark_services(cls: TClass) -> TClass:
     cls.run_services = True

irctest/client_tests/cap.py

@@ -1,5 +1,3 @@
-"""Format of ``CAP LS`` sent by IRCv3 clients."""
-
 from irctest import cases
 from irctest.irc_utils.message_parser import Message
 

irctest/client_tests/sasl.py

@@ -1,8 +1,3 @@
-"""SASL authentication from clients, for all known mechanisms.
-
-For now, only `SASLv3.1 <https://ircv3.net/specs/extensions/sasl-3.1>`_
-is tested, not `SASLv3.2 <https://ircv3.net/specs/extensions/sasl-3.2>`_."""
-
 import base64
 
 import pytest
@@ -39,8 +34,8 @@ class IdentityHash:
         return self._data
 
 
-class SaslTestCase(cases.BaseClientTestCase):
+class SaslTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
     def testPlain(self):
         """Test PLAIN authentication with correct username/password."""
         auth = authentication.Authentication(
@@ -60,8 +55,7 @@ class SaslTestCase(cases.BaseClientTestCase):
         m = self.negotiateCapabilities(["sasl"], False)
         self.assertEqual(m, Message({}, None, "CAP", ["END"]))
 
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
-    @cases.xfailIfSoftware(["Sopel"], "Sopel requests SASL PLAIN even if not available")
     def testPlainNotAvailable(self):
         """`sasl=EXTERNAL` is advertized, whereas the client is configured
         to use PLAIN.
@@ -91,7 +85,7 @@ class SaslTestCase(cases.BaseClientTestCase):
         self.assertMessageMatch(m, command="CAP")
 
     @pytest.mark.parametrize("pattern", ["barbaz", "éèà"])
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
     def testPlainLarge(self, pattern):
         """Test the client splits large AUTHENTICATE messages whose payload
         is not a multiple of 400.
@@ -120,7 +114,7 @@ class SaslTestCase(cases.BaseClientTestCase):
         m = self.negotiateCapabilities(["sasl"], False)
         self.assertEqual(m, Message({}, None, "CAP", ["END"]))
 
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
     @pytest.mark.parametrize("pattern", ["quux", "éè"])
     def testPlainLargeMultiple(self, pattern):
         """Test the client splits large AUTHENTICATE messages whose payload
@@ -151,7 +145,7 @@ class SaslTestCase(cases.BaseClientTestCase):
         self.assertEqual(m, Message({}, None, "CAP", ["END"]))
 
     @pytest.mark.skipif(ecdsa is None, reason="python3-ecdsa is not available")
-    @cases.skipUnlessHasMechanism("ECDSA-NIST256P-CHALLENGE")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("ECDSA-NIST256P-CHALLENGE")
     def testEcdsa(self):
         """Test ECDSA authentication."""
         auth = authentication.Authentication(
@@ -185,7 +179,7 @@ class SaslTestCase(cases.BaseClientTestCase):
         m = self.negotiateCapabilities(["sasl"], False)
         self.assertEqual(m, Message({}, None, "CAP", ["END"]))
 
-    @cases.skipUnlessHasMechanism("SCRAM-SHA-256")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("SCRAM-SHA-256")
     def testScram(self):
         """Test SCRAM-SHA-256 authentication."""
         auth = authentication.Authentication(
@@ -227,8 +221,8 @@ class SaslTestCase(cases.BaseClientTestCase):
         self.assertEqual(m.command, "AUTHENTICATE", m)
         self.assertEqual(m.params, ["+"], m)
 
-    @cases.skipUnlessHasMechanism("SCRAM-SHA-256")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("SCRAM-SHA-256")
-    def testScramBadPassword(self, server_fakes_success=False, fake_response=None):
+    def testScramBadPassword(self):
         """Test SCRAM-SHA-256 authentication with a bad password."""
         auth = authentication.Authentication(
             mechanisms=[authentication.Mechanisms.scram_sha_256],
@@ -261,39 +255,9 @@ class SaslTestCase(cases.BaseClientTestCase):
         with self.assertRaises(scram.NotAuthorizedException):
             authenticator.response(msg)
 
-        if server_fakes_success:
-            self.sendLine(f"AUTHENTICATE :{fake_response}")
 
-            m = self.getMessage()
+class Irc302SaslTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
-            while m.command == "PING":
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
-                self.sendLine(f"PONG server. {m.params[-1]}")
-                m = self.getMessage()
-            self.assertMessageMatch(
-                m,
-                command="AUTHENTICATE",
-                params=["*"],
-                fail_msg="Client did not abort: {msg}",
-            )
-
-    @cases.skipUnlessHasMechanism("SCRAM-SHA-256")
-    @pytest.mark.parametrize(
-        "fake_response",
-        [
-            "",
-            "AAAA",
-            "dj1ubU1mM1FIV2NKUWk5cE1ndHFLU0tQclZueUk2c3FOTzZJN3BFLzBveUdjPQ==",
-        ],
-    )
-    def testScramMaliciousServer(self, fake_response):
-        """Test SCRAM-SHA-256 authentication to a server which pretends to know
-        the password"""
-        self.testScramBadPassword(
-            server_fakes_success=True, fake_response=fake_response
-        )
-
-
-class Irc302SaslTestCase(cases.BaseClientTestCase):
-    @cases.skipUnlessHasMechanism("PLAIN")
     def testPlainNotAvailable(self):
         """Test the client does not try to authenticate using a mechanism the
         server does not advertise.

irctest/client_tests/tls.py

@@ -1,5 +1,3 @@
-"""Clients should validate certificates; either with a CA or fingerprints."""
-
 import socket
 import ssl
 
@@ -140,7 +138,7 @@ class TlsTestCase(cases.BaseClientTestCase):
             self.getMessage()
 
 
-class StsTestCase(cases.BaseClientTestCase):
+class StsTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
     def setUp(self):
         super().setUp()
         self.insecure_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

irctest/controllers/anope_services.py

@@ -1,8 +1,7 @@
-import functools
+import os
-from pathlib import Path
 import shutil
 import subprocess
-from typing import Tuple, Type
+from typing import Type
 
 from irctest.basecontrollers import BaseServicesController, DirectoryBasedController
 
@@ -49,8 +48,6 @@ module {{
     client = "NickServ"
     forceemail = no
     passlen = 1000  # Some tests need long passwords
-    maxpasslen = 1000
-    minpasslen = 1
 }}
 command {{ service = "NickServ"; name = "HELP"; command = "generic/help"; }}
 
@@ -66,29 +63,16 @@ options {{
     warningtimeout = 4h
 }}
 
-module {{ name = "{module_prefix}sasl" }}
+module {{ name = "m_sasl" }}
-module {{ name = "enc_bcrypt" }}
+module {{ name = "enc_sha256" }}
 module {{ name = "ns_cert" }}
 
 """
 
 
-@functools.lru_cache()
-def installed_version() -> Tuple[int, ...]:
-    output = subprocess.run(
-        ["anope", "--version"], stdout=subprocess.PIPE, universal_newlines=True
-    ).stdout
-    (anope, version, *trailing) = output.split()[0].split("-")
-    assert anope == "Anope"
-    return tuple(map(int, version.split(".")))
-
-
 class AnopeController(BaseServicesController, DirectoryBasedController):
     """Collaborator for server controllers that rely on Anope"""
 
-    software_name = "Anope"
-    software_version = None
-
     def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
         self.create_config()
 
@@ -102,46 +86,35 @@ class AnopeController(BaseServicesController, DirectoryBasedController):
             "ngircd",
         )
 
-        assert self.directory
-        services_path = shutil.which("anope")
-        assert services_path
-
-        # Rewrite Anope 2.0 module names for 2.1
-        if not self.software_version:
-            self.software_version = installed_version()
-        if self.software_version >= (2, 1, 0):
-            if protocol == "charybdis":
-                protocol = "solanum"
-            elif protocol == "inspircd3":
-                protocol = "inspircd"
-            elif protocol == "unreal4":
-                protocol = "unrealircd"
-
         with self.open_file("conf/services.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
                     protocol=protocol,
                     server_hostname=server_hostname,
                     server_port=server_port,
-                    module_prefix="" if self.software_version >= (2, 1, 2) else "m_",
                 )
             )
 
         with self.open_file("conf/empty_file") as fd:
             pass
 
+        assert self.directory
+
         # Config and code need to be in the same directory, *obviously*
-        (self.directory / "lib").symlink_to(Path(services_path).parent.parent / "lib")
+        os.symlink(
-        (self.directory / "modules").symlink_to(
+            os.path.join(
-            Path(services_path).parent.parent / "modules"
+                os.path.dirname(shutil.which("services")), "..", "lib"  # type: ignore
+            ),
+            os.path.join(self.directory, "lib"),
         )
 
         self.proc = subprocess.Popen(
             [
-                "anope",
+                "services",
-                "--config=services.conf",  # can't be an absolute path in 2.0
+                "-n",  # don't fork
-                "--nofork",  # don't fork
+                "--config=services.conf",  # can't be an absolute path
-                "--nopid",  # don't write a pid
+                # "--logdir",
+                # f"/tmp/services-{server_port}.log",
             ],
             cwd=self.directory,
             # stdout=subprocess.DEVNULL,

irctest/controllers/atheme_services.py

@@ -1,3 +1,4 @@
+import os
 import subprocess
 from typing import Optional, Type
 
@@ -55,8 +56,6 @@ saslserv {{
 class AthemeController(BaseServicesController, DirectoryBasedController):
     """Mixin for server controllers that rely on Atheme"""
 
-    software_name = "Atheme"
-
     def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
         self.create_config()
 
@@ -80,11 +79,11 @@ class AthemeController(BaseServicesController, DirectoryBasedController):
                 "atheme-services",
                 "-n",  # don't fork
                 "-c",
-                self.directory / "services.conf",
+                os.path.join(self.directory, "services.conf"),
                 "-l",
                 f"/tmp/services-{server_port}.log",
                 "-p",
-                self.directory / "services.pid",
+                os.path.join(self.directory, "services.pid"),
                 "-D",
                 self.directory,
             ],

irctest/controllers/bahamut.py

@@ -1,9 +1,14 @@
-from pathlib import Path
+import os
 import shutil
 import subprocess
 from typing import Optional, Set, Type
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
 
 TEMPLATE_CONFIG = """
 global {{
@@ -75,19 +80,6 @@ oper {{
 """
 
 
-def initialize_entropy(directory: Path) -> None:
-    # https://github.com/DALnet/bahamut/blob/7fc039d403f66a954225c5dc4ad1fe683aedd794/include/dh.h#L35-L38
-    nb_rand_bytes = 512 // 8
-    # https://github.com/DALnet/bahamut/blob/7fc039d403f66a954225c5dc4ad1fe683aedd794/src/dh.c#L186
-    entropy_file_size = nb_rand_bytes * 4
-
-    # Not actually random; but we don't care.
-    entropy = b"\x00" * entropy_file_size
-
-    with (directory / ".ircd.entropy").open("wb") as fd:
-        fd.write(entropy)
-
-
 class BahamutController(BaseServerController, DirectoryBasedController):
     software_name = "Bahamut"
     supported_sasl_mechanisms: Set[str] = set()
@@ -107,14 +99,20 @@ class BahamutController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
         self.hostname = hostname
         self.create_config()
-        (unused_hostname, unused_port) = self.get_hostname_and_port()
+        (unused_hostname, unused_port) = find_hostname_and_port()
-        (services_hostname, services_port) = self.get_hostname_and_port()
+        (services_hostname, services_port) = find_hostname_and_port()
 
         password_field = "passwd {};".format(password) if password else ""
 
@@ -122,14 +120,9 @@ class BahamutController(BaseServerController, DirectoryBasedController):
 
         assert self.directory
 
-        # Bahamut reads some bytes from /dev/urandom on startup, which causes
-        # GitHub Actions to sometimes freeze and timeout.
-        # This initializes the entropy file so Bahamut does not need to do it itself.
-        initialize_entropy(self.directory)
-
         # they are hardcoded... thankfully Bahamut reads them from the CWD.
-        shutil.copy(self.pem_path, self.directory / "ircd.crt")
+        shutil.copy(self.pem_path, os.path.join(self.directory, "ircd.crt"))
-        shutil.copy(self.key_path, self.directory / "ircd.key")
+        shutil.copy(self.key_path, os.path.join(self.directory, "ircd.key"))
 
         with self.open_file("server.conf") as fd:
             fd.write(
@@ -143,21 +136,15 @@ class BahamutController(BaseServerController, DirectoryBasedController):
                     # pem_path=self.pem_path,
                 )
             )
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
+                # "strace", "-f", "-e", "file",
                 "ircd",
                 "-t",  # don't fork
                 "-f",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
             ],
+            # stdout=subprocess.DEVNULL,
         )
 
         if run_services:

irctest/controllers/base_hybrid.py

@@ -1,8 +1,13 @@
-import shutil
+import os
 import subprocess
-from typing import Optional
+from typing import Optional, Set
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
 
 TEMPLATE_SSL_CONFIG = """
     ssl_private_key = "{key_path}";
@@ -36,13 +41,18 @@ class BaseHybridController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
         self.hostname = hostname
         self.create_config()
-        (services_hostname, services_port) = self.get_hostname_and_port()
+        (services_hostname, services_port) = find_hostname_and_port()
         password_field = 'password = "{}";'.format(password) if password else ""
         if ssl:
             self.gen_ssl()
@@ -63,22 +73,14 @@ class BaseHybridController(BaseServerController, DirectoryBasedController):
                 )
             )
         assert self.directory
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 self.binary_name,
                 "-foreground",
                 "-configfile",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
                 "-pidfile",
-                self.directory / "server.pid",
+                os.path.join(self.directory, "server.pid"),
             ],
             # stderr=subprocess.DEVNULL,
         )

irctest/controllers/dlk_services.py

@@ -1,245 +0,0 @@
-import os
-from pathlib import Path
-import secrets
-import subprocess
-from typing import Optional, Type
-
-import irctest
-from irctest.basecontrollers import BaseServicesController, DirectoryBasedController
-import irctest.cases
-import irctest.runner
-
-TEMPLATE_DLK_CONFIG = """\
-info {{
-    SID "00A";
-    network-name "testnetwork";
-    services-name "services.example.org";
-    admin-email "admin@example.org";
-}}
-
-link {{
-    hostname "{server_hostname}";
-    port "{server_port}";
-    password "password";
-}}
-
-log {{
-    debug "yes";
-}}
-
-sql {{
-    port "3306";
-    username "pifpaf";
-    password "pifpaf";
-    database "pifpaf";
-    sockfile "{mysql_socket}";
-    prefix "{dlk_prefix}";
-}}
-
-wordpress {{
-    prefix "{wp_prefix}";
-}}
-
-"""
-
-TEMPLATE_DLK_WP_CONFIG = """
-<?php
-
-global $wpconfig;
-$wpconfig = [
-
-    "dbprefix" => "{wp_prefix}",
-
-
-    "default_avatar" => "https://valware.uk/wp-content/plugins/ultimate-member/assets/img/default_avatar.jpg",
-    "forumschan" => "#DLK-Support",
-
-];
-"""
-
-TEMPLATE_WP_CONFIG = """
-define( 'DB_NAME', 'pifpaf' );
-define( 'DB_USER', 'pifpaf' );
-define( 'DB_PASSWORD', 'pifpaf' );
-define( 'DB_HOST', 'localhost:{mysql_socket}' );
-define( 'DB_CHARSET', 'utf8' );
-define( 'DB_COLLATE', '' );
-
-define( 'AUTH_KEY',         'put your unique phrase here' );
-define( 'SECURE_AUTH_KEY',  'put your unique phrase here' );
-define( 'LOGGED_IN_KEY',    'put your unique phrase here' );
-define( 'NONCE_KEY',        'put your unique phrase here' );
-define( 'AUTH_SALT',        'put your unique phrase here' );
-define( 'SECURE_AUTH_SALT', 'put your unique phrase here' );
-define( 'LOGGED_IN_SALT',   'put your unique phrase here' );
-define( 'NONCE_SALT',       'put your unique phrase here' );
-
-$table_prefix = '{wp_prefix}';
-
-define( 'WP_DEBUG', false );
-
-if (!defined('ABSPATH')) {{
-    define( 'ABSPATH', '{wp_path}' );
-}}
-
-/* That's all, stop editing! Happy publishing. */
-
-/** Absolute path to the WordPress directory. */
-
-
-/** Sets up WordPress vars and included files. */
-require_once ABSPATH . 'wp-settings.php';
-"""
-
-
-class DlkController(BaseServicesController, DirectoryBasedController):
-    """Mixin for server controllers that rely on DLK"""
-
-    software_name = "Dlk-Services"
-
-    def run_sql(self, sql: str) -> None:
-        mysql_socket = os.environ["PIFPAF_MYSQL_SOCKET"]
-        subprocess.run(
-            ["mysql", "-S", mysql_socket, "pifpaf"],
-            input=sql.encode(),
-            check=True,
-        )
-
-    def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
-        self.create_config()
-
-        if protocol == "unreal4":
-            protocol = "unreal5"
-        assert protocol in ("unreal5",), protocol
-
-        mysql_socket = os.environ["PIFPAF_MYSQL_SOCKET"]
-
-        assert self.directory
-
-        try:
-            self.wp_cli_path = Path(os.environ["IRCTEST_WP_CLI_PATH"])
-            if not self.wp_cli_path.is_file():
-                raise KeyError()
-        except KeyError:
-            raise RuntimeError(
-                "$IRCTEST_WP_CLI_PATH must be set to a WP-CLI executable (eg. "
-                "downloaded from <https://raw.githubusercontent.com/wp-cli/builds/"
-                "gh-pages/phar/wp-cli.phar>)"
-            ) from None
-
-        try:
-            self.dlk_path = Path(os.environ["IRCTEST_DLK_PATH"])
-            if not self.dlk_path.is_dir():
-                raise KeyError()
-        except KeyError:
-            raise RuntimeError("$IRCTEST_DLK_PATH is not set") from None
-        self.dlk_path = self.dlk_path.resolve()
-
-        # Unpack a fresh Wordpress install in the temporary directory.
-        # In theory we could have a common Wordpress install and only wp-config.php
-        # in the temporary directory; but wp-cli assumes wp-config.php must be
-        # in a Wordpress directory, and fails in various places if it isn't.
-        # Rather than symlinking everything to make it work, let's just copy
-        # the whole code, it's not that big.
-        try:
-            wp_zip_path = Path(os.environ["IRCTEST_WP_ZIP_PATH"])
-            if not wp_zip_path.is_file():
-                raise KeyError()
-        except KeyError:
-            raise RuntimeError(
-                "$IRCTEST_WP_ZIP_PATH must be set to a Wordpress source zipball "
-                "(eg. downloaded from <https://wordpress.org/latest.zip>)"
-            ) from None
-        subprocess.run(
-            ["unzip", wp_zip_path, "-d", self.directory], stdout=subprocess.DEVNULL
-        )
-        self.wp_path = self.directory / "wordpress"
-
-        rand_hex = secrets.token_hex(6)
-        self.wp_prefix = f"wp{rand_hex}_"
-        self.dlk_prefix = f"dlk{rand_hex}_"
-        template_vars = dict(
-            protocol=protocol,
-            server_hostname=server_hostname,
-            server_port=server_port,
-            mysql_socket=mysql_socket,
-            wp_path=self.wp_path,
-            wp_prefix=self.wp_prefix,
-            dlk_prefix=self.dlk_prefix,
-        )
-
-        # Configure Wordpress
-        wp_config_path = self.directory / "wp-config.php"
-        with open(wp_config_path, "w") as fd:
-            fd.write(TEMPLATE_WP_CONFIG.format(**template_vars))
-
-        subprocess.run(
-            [
-                "php",
-                self.wp_cli_path,
-                "core",
-                "install",
-                "--url=http://localhost/",
-                "--title=irctest site",
-                "--admin_user=adminuser",
-                "--admin_email=adminuser@example.org",
-                f"--path={self.wp_path}",
-            ],
-            check=True,
-        )
-
-        # Configure Dlk
-        dlk_log_dir = self.directory / "logs"
-        dlk_conf_dir = self.directory / "conf"
-        dlk_conf_path = dlk_conf_dir / "dalek.conf"
-        os.mkdir(dlk_conf_dir)
-        with open(dlk_conf_path, "w") as fd:
-            fd.write(TEMPLATE_DLK_CONFIG.format(**template_vars))
-        dlk_wp_config_path = dlk_conf_dir / "wordpress.conf"
-        with open(dlk_wp_config_path, "w") as fd:
-            fd.write(TEMPLATE_DLK_WP_CONFIG.format(**template_vars))
-        (dlk_conf_dir / "modules.conf").symlink_to(self.dlk_path / "conf/modules.conf")
-
-        self.proc = subprocess.Popen(
-            [
-                "php",
-                "src/dalek",
-            ],
-            cwd=self.dlk_path,
-            env={
-                **os.environ,
-                "DALEK_CONF_DIR": str(dlk_conf_dir),
-                "DALEK_LOG_DIR": str(dlk_log_dir),
-            },
-        )
-
-    def terminate(self) -> None:
-        super().terminate()
-
-    def kill(self) -> None:
-        super().kill()
-
-    def registerUser(
-        self,
-        case: irctest.cases.BaseServerTestCase,
-        username: str,
-        password: Optional[str] = None,
-    ) -> None:
-        assert password
-        subprocess.run(
-            [
-                "php",
-                self.wp_cli_path,
-                "user",
-                "create",
-                username,
-                f"{username}@example.org",
-                f"--user_pass={password}",
-                f"--path={self.wp_path}",
-            ],
-            check=True,
-        )
-
-
-def get_irctest_controller_class() -> Type[DlkController]:
-    return DlkController

irctest/controllers/ergo.py

@@ -1,11 +1,14 @@
 import copy
 import json
 import os
-import shutil
 import subprocess
-from typing import Any, Dict, Optional, Type, Union
+from typing import Any, Dict, Optional, Set, Type, Union
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
 from irctest.cases import BaseServerTestCase
 
 BASE_CONFIG = {
@@ -14,7 +17,6 @@ BASE_CONFIG = {
         "name": "My.Little.Server",
         "listeners": {},
         "max-sendq": "16k",
-        "casemapping": "ascii",
         "connection-limits": {
             "enabled": True,
             "cidr-len-ipv4": 32,
@@ -58,11 +60,6 @@ BASE_CONFIG = {
             "enabled": True,
             "method": "strict",
         },
-        "login-throttling": {
-            "enabled": True,
-            "duration": "1m",
-            "max-attempts": 3,
-        },
     },
     "channels": {"registration": {"enabled": True}},
     "datastore": {"path": None},
@@ -132,7 +129,7 @@ def hash_password(password: Union[str, bytes]) -> str:
         ["ergo", "genpasswd"], stdin=subprocess.PIPE, stdout=subprocess.PIPE
     )
     out, _ = p.communicate(input_)
-    return out.decode("utf-8").strip()
+    return out.decode("utf-8")
 
 
 class ErgoController(BaseServerController, DirectoryBasedController):
@@ -155,9 +152,16 @@ class ErgoController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
         config: Optional[Any] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
+
         self.create_config()
         if config is None:
             config = copy.deepcopy(BASE_CONFIG)
@@ -172,16 +176,6 @@ class ErgoController(BaseServerController, DirectoryBasedController):
         if enable_roleplay:
             config["roleplay"] = {"enabled": True}
 
-        if self.test_config.account_registration_before_connect:
-            config["accounts"]["registration"]["allow-before-connect"] = True  # type: ignore
-        if self.test_config.account_registration_requires_email:
-            config["accounts"]["registration"]["email-verification"] = {  # type: ignore
-                "enabled": True,
-                "sender": "test@example.com",
-                "require-tls": True,
-                "helo-domain": "example.com",
-            }
-
         if self.test_config.ergo_config:
             self.test_config.ergo_config(config)
 
@@ -189,32 +183,27 @@ class ErgoController(BaseServerController, DirectoryBasedController):
         bind_address = "127.0.0.1:%s" % (port,)
         listener_conf = None  # plaintext
         if ssl:
-            self.key_path = self.directory / "ssl.key"
+            self.key_path = os.path.join(self.directory, "ssl.key")
-            self.pem_path = self.directory / "ssl.pem"
+            self.pem_path = os.path.join(self.directory, "ssl.pem")
             listener_conf = {"tls": {"cert": self.pem_path, "key": self.key_path}}
         config["server"]["listeners"][bind_address] = listener_conf  # type: ignore
 
-        config["datastore"]["path"] = str(self.directory / "ircd.db")  # type: ignore
+        config["datastore"]["path"] = os.path.join(  # type: ignore
+            self.directory, "ircd.db"
+        )
 
         if password is not None:
             config["server"]["password"] = hash_password(password)  # type: ignore
 
         assert self.proc is None
 
-        self._config_path = self.directory / "server.yml"
+        self._config_path = os.path.join(self.directory, "server.yml")
         self._config = config
         self._write_config()
         subprocess.call(["ergo", "initdb", "--conf", self._config_path, "--quiet"])
         subprocess.call(["ergo", "mkcerts", "--conf", self._config_path, "--quiet"])
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
-            [*faketime_cmd, "ergo", "run", "--conf", self._config_path, "--quiet"]
+            ["ergo", "run", "--conf", self._config_path, "--quiet"]
         )
 
     def wait_for_services(self) -> None:
@@ -227,6 +216,9 @@ class ErgoController(BaseServerController, DirectoryBasedController):
         username: str,
         password: Optional[str] = None,
     ) -> None:
+        # XXX: Move this somewhere else when
+        # https://github.com/ircv3/ircv3-specifications/pull/152 becomes
+        # part of the specification
         if not case.run_services:
             # Ergo does not actually need this, but other controllers do, so we
             # are checking it here as well for tests that aren't tested with other

irctest/controllers/external_server.py

@@ -1,5 +1,5 @@
 import os
-from typing import Optional, Tuple, Type
+from typing import Optional, Set, Tuple, Type
 
 from irctest.basecontrollers import BaseServerController
 
@@ -39,7 +39,9 @@ class ExternalServerController(BaseServerController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
         pass
 

irctest/controllers/inspircd.py

@@ -1,9 +1,13 @@
-import functools
+import os
-import shutil
 import subprocess
-from typing import Optional, Type
+from typing import Optional, Set, Type
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
 
 TEMPLATE_CONFIG = """
 # Clients:
@@ -48,15 +52,15 @@ TEMPLATE_CONFIG = """
     sendpass="password"
     >
 <module name="spanningtree">
+<module name="services_account">
 <module name="hidechans">  # Anope errors when missing
+<module name="svshold">  # Atheme raises a warning when missing
 <sasl requiressl="no"
       target="services.example.org">
 
 # Protocol:
-<module name="banexception">
 <module name="botmode">
 <module name="cap">
-<module name="inviteexception">
 <module name="ircv3">
 <module name="ircv3_accounttag">
 <module name="ircv3_batch">
@@ -69,14 +73,18 @@ TEMPLATE_CONFIG = """
 <module name="ircv3_servertime">
 <module name="monitor">
 <module name="m_muteban">  # for testing mute extbans
+<module name="namesx"> # For multi-prefix
+<module name="noctcp">
 <module name="sasl">
-<module name="uhnames">  # For userhost-in-names
+
+# HELP/HELPOP
 <module name="alias">  # for the HELP alias
-{version_config}
+<module name="helpop">
+<include file="examples/helpop.conf.example">
 
 # Misc:
 <log method="file" type="*" level="debug" target="/tmp/ircd-{port}.log">
-<server name="My.Little.Server" description="test server" id="000" network="testnet">
+<server name="My.Little.Server" description="testnet" id="000" network="testnet">
 """
 
 TEMPLATE_SSL_CONFIG = """
@@ -84,42 +92,9 @@ TEMPLATE_SSL_CONFIG = """
 <openssl certfile="{pem_path}" keyfile="{key_path}" dhfile="{dh_path}" hash="sha1">
 """
 
-TEMPLATE_V3_CONFIG = """
-<module name="namesx"> # For multi-prefix
-<module name="services_account">
-<module name="svshold">  # Atheme raises a warning when missing
-
-# HELP/HELPOP
-<module name="helpop">
-<include file="examples/helpop.conf.example">
-"""
-
-TEMPLATE_V4_CONFIG = """
-<module name="account">
-<module name="multiprefix"> # For multi-prefix
-<module name="services">
-
-# HELP/HELPOP
-<module name="help">
-<include file="examples/help.conf.example">
-"""
-
-
-@functools.lru_cache()
-def installed_version() -> int:
-    output = subprocess.check_output(["inspircd", "--version"], universal_newlines=True)
-    if output.startswith("InspIRCd-3"):
-        return 3
-    if output.startswith("InspIRCd-4"):
-        return 4
-    if output.startswith("InspIRCd-5"):
-        return 5
-    assert False, f"unexpected version: {output}"
-
 
 class InspircdController(BaseServerController, DirectoryBasedController):
     software_name = "InspIRCd"
-    software_version = installed_version()
     supported_sasl_mechanisms = {"PLAIN"}
     supports_sts = False
     extban_mute_char = "m"
@@ -137,13 +112,19 @@ class InspircdController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str] = None,
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
         self.hostname = hostname
         self.create_config()
-        (services_hostname, services_port) = self.get_hostname_and_port()
+        (services_hostname, services_port) = find_hostname_and_port()
 
         password_field = 'password="{}"'.format(password) if password else ""
 
@@ -155,13 +136,6 @@ class InspircdController(BaseServerController, DirectoryBasedController):
         else:
             ssl_config = ""
 
-        if installed_version() == 3:
-            version_config = TEMPLATE_V3_CONFIG
-        elif installed_version() >= 4:
-            version_config = TEMPLATE_V4_CONFIG
-        else:
-            assert False, f"unexpected version: {installed_version()}"
-
         with self.open_file("server.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -171,24 +145,15 @@ class InspircdController(BaseServerController, DirectoryBasedController):
                     services_port=services_port,
                     password_field=password_field,
                     ssl_config=ssl_config,
-                    version_config=version_config,
                 )
             )
         assert self.directory
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "inspircd",
                 "--nofork",
                 "--config",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
             ],
             stdout=subprocess.DEVNULL,
         )

irctest/controllers/irc2.py

@@ -1,6 +1,6 @@
-import shutil
+import os
 import subprocess
-from typing import Optional, Type
+from typing import Optional, Set, Type
 
 from irctest.basecontrollers import (
     BaseServerController,
@@ -10,7 +10,7 @@ from irctest.basecontrollers import (
 
 TEMPLATE_CONFIG = """
 # M:<Server NAME>:<YOUR Internet IP#>:<Geographic Location>:<Port>:<SID>:
-M:My.Little.Server:{hostname}:test server:{port}:0042:
+M:My.Little.Server:{hostname}:Somewhere:{port}:0042:
 
 # A:<Your Name/Location>:<Your E-Mail Addr>:<other info>::<network name>:
 A:Organization, IRC dept.:Daemon <ircd@example.irc.org>:Client Server::IRCnet:
@@ -29,8 +29,8 @@ O:*:operpassword:operuser::::
 """
 
 
-class Irc2Controller(BaseServerController, DirectoryBasedController):
+class Ircu2Controller(BaseServerController, DirectoryBasedController):
-    software_name = "irc2"
+    binary_name: str
     services_protocol: str
 
     supports_sts = False
@@ -49,8 +49,13 @@ class Irc2Controller(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         if ssl:
             raise NotImplementedByController("TLS")
         if run_services:
@@ -61,7 +66,7 @@ class Irc2Controller(BaseServerController, DirectoryBasedController):
         self.create_config()
         password_field = password if password else ""
         assert self.directory
-        pidfile = self.directory / "ircd.pid"
+        pidfile = os.path.join(self.directory, "ircd.pid")
         with self.open_file("server.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -71,26 +76,18 @@ class Irc2Controller(BaseServerController, DirectoryBasedController):
                     pidfile=pidfile,
                 )
             )
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "ircd",
                 "-s",  # no iauth
                 "-p",
                 "on",
                 "-f",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
             ],
             # stderr=subprocess.DEVNULL,
         )
 
 
-def get_irctest_controller_class() -> Type[Irc2Controller]:
+def get_irctest_controller_class() -> Type[Ircu2Controller]:
-    return Irc2Controller
+    return Ircu2Controller

irctest/controllers/ircu2.py

@@ -1,6 +1,6 @@
-import shutil
+import os
 import subprocess
-from typing import Optional, Type
+from typing import Optional, Set, Type
 
 from irctest.basecontrollers import (
     BaseServerController,
@@ -51,7 +51,6 @@ features {{
 
 
 class Ircu2Controller(BaseServerController, DirectoryBasedController):
-    software_name = "ircu2"
     supports_sts = False
     extban_mute_char = None
 
@@ -68,8 +67,13 @@ class Ircu2Controller(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         if ssl:
             raise NotImplementedByController("TLS")
         if run_services:
@@ -80,7 +84,7 @@ class Ircu2Controller(BaseServerController, DirectoryBasedController):
         self.create_config()
         password_field = 'password = "{}";'.format(password) if password else ""
         assert self.directory
-        pidfile = self.directory / "ircd.pid"
+        pidfile = os.path.join(self.directory, "ircd.pid")
         with self.open_file("server.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -90,20 +94,12 @@ class Ircu2Controller(BaseServerController, DirectoryBasedController):
                     pidfile=pidfile,
                 )
             )
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "ircd",
                 "-n",  # don't detach
                 "-f",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
                 "-x",
                 "DEBUG",
             ],

irctest/controllers/limnoria.py

@@ -1,3 +1,4 @@
+import os
 import subprocess
 from typing import Optional, Type
 
@@ -84,7 +85,9 @@ class LimnoriaController(BaseClientController, DirectoryBasedController):
                 )
             )
         assert self.directory
-        self.proc = subprocess.Popen(["supybot", self.directory / "bot.conf"])
+        self.proc = subprocess.Popen(
+            ["supybot", os.path.join(self.directory, "bot.conf")]
+        )
 
 
 def get_irctest_controller_class() -> Type[LimnoriaController]:

irctest/controllers/mammon.py

@@ -1,4 +1,4 @@
-import shutil
+import os
 import subprocess
 from typing import Optional, Set, Type
 
@@ -33,10 +33,10 @@ extensions:
 - mammon.ext.ircv3.sasl
 - mammon.ext.misc.nopost
 metadata:
-  restricted_keys: []
+  restricted_keys:
+{restricted_keys}
   whitelist:
-  - display-name
+{authorized_keys}
-  - avatar
 monitor:
   limit: 20
 motd:
@@ -89,7 +89,9 @@ class MammonController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
         if password is not None:
             raise NotImplementedByController("PASS command")
@@ -104,25 +106,19 @@ class MammonController(BaseServerController, DirectoryBasedController):
                     directory=self.directory,
                     hostname=hostname,
                     port=port,
+                    authorized_keys=make_list(valid_metadata_keys or set()),
+                    restricted_keys=make_list(restricted_metadata_keys or set()),
                 )
             )
         # with self.open_file('server.yml', 'r') as fd:
         #    print(fd.read())
         assert self.directory
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "mammond",
                 "--nofork",  # '--debug',
                 "--config",
-                self.directory / "server.yml",
+                os.path.join(self.directory, "server.yml"),
             ]
         )
 

irctest/controllers/nefarious.py

@@ -1,11 +0,0 @@
-from typing import Type
-
-from .ircu2 import Ircu2Controller
-
-
-class NefariousController(Ircu2Controller):
-    software_name = "Nefarious"
-
-
-def get_irctest_controller_class() -> Type[NefariousController]:
-    return NefariousController

irctest/controllers/ngircd.py

@@ -1,13 +1,18 @@
-import shutil
+import os
 import subprocess
 from typing import Optional, Set, Type
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
 
 TEMPLATE_CONFIG = """
 [Global]
     Name = My.Little.Server
-    Info = test server
+    Info = ExampleNET Server
     Bind = {hostname}
     Ports = {port}
     AdminInfo1 = Bob Smith
@@ -23,7 +28,6 @@ TEMPLATE_CONFIG = """
 
 [Options]
     MorePrivacy = no  # by default, always replies to WHOWAS with ERR_WASNOSUCHNICK
-    PAM = no
 
 [Operator]
     Name = operuser
@@ -49,13 +53,19 @@ class NgircdController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
         self.hostname = hostname
         self.create_config()
-        (unused_hostname, unused_port) = self.get_hostname_and_port()
+        (unused_hostname, unused_port) = find_hostname_and_port()
 
         password_field = "Password = {}".format(password) if password else ""
 
@@ -71,7 +81,6 @@ class NgircdController(BaseServerController, DirectoryBasedController):
             fd.write("\n")
 
         assert self.directory
-
         with self.open_file("server.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -82,23 +91,15 @@ class NgircdController(BaseServerController, DirectoryBasedController):
                     password_field=password_field,
                     key_path=self.key_path,
                     pem_path=self.pem_path,
-                    empty_file=self.directory / "empty.txt",
+                    empty_file=os.path.join(self.directory, "empty.txt"),
                 )
             )
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "ngircd",
                 "--nodaemon",
                 "--config",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
             ],
             # stdout=subprocess.DEVNULL,
         )

irctest/controllers/plexus4.py

@@ -74,7 +74,7 @@ operator {{
 
 
 class Plexus4Controller(BaseHybridController):
-    software_name = "Plexus4"
+    software_name = "Hybrid"
     binary_name = "ircd"
     services_protocol = "plexus"
 

irctest/controllers/sable.py

@@ -1,497 +0,0 @@
-import os
-from pathlib import Path
-import shutil
-import signal
-import subprocess
-import tempfile
-import time
-from typing import Optional, Type
-
-from irctest.basecontrollers import (
-    BaseServerController,
-    BaseServicesController,
-    DirectoryBasedController,
-    NotImplementedByController,
-)
-from irctest.cases import BaseServerTestCase
-from irctest.exceptions import NoMessageException
-from irctest.patma import ANYSTR
-
-GEN_CERTS = """
-mkdir -p useless_openssl_data/
-
-cat > openssl.cnf <<EOF
-[ ca ]
-default_ca	= CA_default		# The default ca section
-
-[ CA_default ]
-new_certs_dir = useless_openssl_data/
-database = useless_openssl_data/db
-policy = policy_anything
-serial = useless_openssl_data/serial
-copy_extensions = copy
-email_in_dn = no
-rand_serial = no
-
-[ policy_anything ]
-countryName		       = optional
-stateOrProvinceName	   = optional
-localityName		   = optional
-organizationName	   = optional
-organizationalUnitName	= optional
-commonName		       = supplied
-emailAddress		   = optional
-
-[ usr_cert ]
-subjectAltName=subject:copy
-EOF
-
-rm -f useless_openssl_data/db
-touch useless_openssl_data/db
-echo 01 > useless_openssl_data/serial
-
-# Generate CA
-openssl req -x509 -nodes -newkey rsa:2048 -batch \
-    -subj "/CN=Test CA" \
-    -outform PEM -out ca_cert.pem \
-    -keyout ca_cert.key
-
-for server in $*; do
-    openssl genrsa -traditional \
-        -out $server.key \
-        2048
-    openssl req -nodes -batch -new \
-        -addext "subjectAltName = DNS:$server" \
-        -key $server.key \
-        -outform PEM -out server_$server.req
-    openssl ca -config openssl.cnf -days 3650 -md sha512 -batch \
-        -subj /CN=$server \
-        -keyfile ca_cert.key -cert ca_cert.pem \
-        -in server_$server.req \
-        -out $server.pem
-    openssl x509 -sha1 -in $server.pem -fingerprint -noout \
-        | sed "s/.*=//" | sed "s/://g" | tr '[:upper:]' '[:lower:]' > $server.pem.sha1
-done
-
-rm -r useless_openssl_data/
-"""
-
-_certs_dir = None
-
-
-def certs_dir() -> Path:
-    global _certs_dir
-    if _certs_dir is None:
-        certs_dir = tempfile.TemporaryDirectory()
-        (Path(certs_dir.name) / "gen_certs.sh").write_text(GEN_CERTS)
-        subprocess.run(
-            ["bash", "gen_certs.sh", "My.Little.Server", "My.Little.Services"],
-            cwd=certs_dir.name,
-            check=True,
-        )
-        _certs_dir = certs_dir
-    return Path(_certs_dir.name)
-
-
-NETWORK_CONFIG = """
-{
-    "fanout": 1,
-    "ca_file": "%(certs_dir)s/ca_cert.pem",
-
-    "peers": [
-        { "name": "My.Little.Services", "address": "%(services_hostname)s:%(services_port)s", "fingerprint": "%(services_cert_sha1)s" },
-        { "name": "My.Little.Server", "address": "%(server1_hostname)s:%(server1_port)s", "fingerprint": "%(server1_cert_sha1)s" }
-    ]
-}
-"""
-
-NETWORK_CONFIG_CONFIG = """
-{
-    "opers": [
-        {
-            "name": "operuser",
-            // echo -n "operpassword" | openssl passwd -6 -stdin
-            "hash": "$6$z5yA.OfGliDoi/R2$BgSsguS6bxAsPSCygDisgDw5JZuo5.88eU3Hyc7/4OaNpeKIxWGjOggeHzOl0xLiZg1vfwxXjOTFN14wG5vNI."
-        }
-    ],
-
-    "alias_users": [
-        %(services_alias_users)s
-    ],
-
-    "default_roles": {
-        "builtin:op": [
-            "always_send",
-            "op_self", "op_grant", "voice_self", "voice_grant",
-            "receive_op", "receive_voice", "receive_opmod",
-            "topic", "kick", "set_simple_mode", "set_key",
-            "rename",
-            "ban_view", "ban_add", "ban_remove_any",
-            "quiet_view", "quiet_add", "quiet_remove_any",
-            "exempt_view", "exempt_add", "exempt_remove_any",
-            "invite_self", "invite_other",
-            "invex_view", "invex_add", "invex_remove_any"
-        ],
-        "builtin:voice": [
-            "always_send",
-            "voice_self",
-            "receive_voice",
-            "ban_view", "quiet_view"
-        ],
-        "builtin:all": [
-            "ban_view", "quiet_view"
-        ]
-    },
-
-    "debug_mode": true
-}
-"""
-
-SERVICES_ALIAS_USERS = """
-        {
-            "nick": "ChanServ",
-            "user": "ChanServ",
-            "host": "services.",
-            "realname": "Channel services compatibility layer",
-            "command_alias": "CS"
-        },
-        {
-            "nick": "NickServ",
-            "user": "NickServ",
-            "host": "services.",
-            "realname": "Account services compatibility layer",
-            "command_alias": "NS"
-        }
-"""
-
-SERVER_CONFIG = """
-{
-    "server_id": 1,
-    "server_name": "My.Little.Server",
-
-    "management": {
-        "address": "%(server1_management_hostname)s:%(server1_management_port)s",
-        "client_ca": "%(certs_dir)s/ca_cert.pem",
-        "authorised_fingerprints": [
-            { "name": "user1", "fingerprint": "435bc6db9f22e84ba5d9652432154617c9509370" },
-        ],
-    },
-
-    "server": {
-        "listeners": [
-            { "address": "%(c2s_hostname)s:%(c2s_port)s" },
-        ],
-    },
-
-    "event_log": {
-        "event_expiry": 300, // five minutes, for local testing
-    },
-
-    "tls_config": {
-        "key_file": "%(certs_dir)s/My.Little.Server.key",
-        "cert_file": "%(certs_dir)s/My.Little.Server.pem",
-    },
-
-    "node_config": {
-        "listen_addr": "%(server1_hostname)s:%(server1_port)s",
-        "cert_file": "%(certs_dir)s/My.Little.Server.pem",
-        "key_file": "%(certs_dir)s/My.Little.Server.key",
-    },
-
-    "log": {
-        "dir": "log/server1/",
-
-        "module-levels": {
-            "": "debug",
-            "sable_ircd": "trace",
-        },
-
-        "targets": [
-            {
-                "target": "stdout",
-                "level": "trace",
-                "modules": [ "sable", "audit", "client_listener" ],
-            },
-        ],
-    },
-}
-"""
-
-SERVICES_CONFIG = """
-{
-    "server_id": 99,
-    "server_name": "My.Little.Services",
-
-    "management": {
-        "address": "%(services_management_hostname)s:%(services_management_port)s",
-        "client_ca": "%(certs_dir)s/ca_cert.pem",
-        "authorised_fingerprints": [
-            { "name": "user1", "fingerprint": "435bc6db9f22e84ba5d9652432154617c9509370" }
-        ]
-    },
-
-    "server": {
-        "database": "test_database.json",
-        "default_roles": {
-            "builtin:founder": [
-                "founder", "access_view", "access_edit", "role_view", "role_edit",
-                "op_self", "op_grant",
-                "voice_self", "voice_grant",
-                "always_send",
-                "invite_self", "invite_other",
-                "receive_op", "receive_voice", "receive_opmod",
-                "topic", "kick", "set_simple_mode", "set_key",
-                "rename",
-                "ban_view", "ban_add", "ban_remove_any",
-                "quiet_view", "quiet_add", "quiet_remove_any",
-                "exempt_view", "exempt_add", "exempt_remove_any",
-                "invex_view", "invex_add", "invex_remove_any"
-            ],
-            "builtin:op": [
-                "always_send",
-                "receive_op", "receive_voice", "receive_opmod",
-                "topic", "kick", "set_simple_mode", "set_key",
-                "rename",
-                "ban_view", "ban_add", "ban_remove_any",
-                "quiet_view", "quiet_add", "quiet_remove_any",
-                "exempt_view", "exempt_add", "exempt_remove_any",
-                "invex_view", "invex_add", "invex_remove_any"
-            ],
-            "builtin:voice": [
-                "always_send", "voice_self", "receive_voice"
-            ]
-        },
-
-        "password_hash": {
-            "algorithm": "bcrypt", // Only "bcrypt" is supported for now
-            "cost": 4,  // Exponentially faster than the default 12
-        },
-
-    },
-
-    "event_log": {
-        "event_expiry": 300, // five minutes, for local testing
-    },
-
-    "tls_config": {
-        "key_file": "%(certs_dir)s/My.Little.Services.key",
-        "cert_file": "%(certs_dir)s/My.Little.Services.pem"
-    },
-
-    "node_config": {
-        "listen_addr": "%(services_hostname)s:%(services_port)s",
-        "cert_file": "%(certs_dir)s/My.Little.Services.pem",
-        "key_file": "%(certs_dir)s/My.Little.Services.key"
-    },
-
-    "log": {
-        "dir": "log/services/",
-
-        "module-levels": {
-            "": "debug"
-        },
-
-        "targets": [
-            {
-                "target": "stdout",
-                "level": "debug",
-                "modules": [ "sable_services" ]
-            }
-        ]
-    }
-}
-"""
-
-
-class SableController(BaseServerController, DirectoryBasedController):
-    software_name = "Sable"
-    supported_sasl_mechanisms = {"PLAIN"}
-    sync_sleep_time = 0.1
-    """Sable processes commands very quickly, but responses for commands changing the
-    state may be sent after later commands for messages which don't."""
-
-    def run(
-        self,
-        hostname: str,
-        port: int,
-        *,
-        password: Optional[str],
-        ssl: bool,
-        run_services: bool,
-        faketime: Optional[str],
-    ) -> None:
-        if password is not None:
-            raise NotImplementedByController("PASS command")
-        if ssl:
-            raise NotImplementedByController("SSL")
-        if self.test_config.account_registration_before_connect:
-            raise NotImplementedByController("account-registration with before-connect")
-        if self.test_config.account_registration_requires_email:
-            raise NotImplementedByController("account-registration with email-required")
-
-        assert self.proc is None
-        self.port = port
-        self.create_config()
-
-        assert self.directory
-
-        (self.directory / "configs").mkdir()
-
-        c2s_hostname = hostname
-        c2s_port = port
-        del hostname, port
-        # base controller expects this to check for NickServ presence itself
-        self.hostname = c2s_hostname
-        self.port = c2s_port
-
-        (server1_hostname, server1_port) = self.get_hostname_and_port()
-        (services_hostname, services_port) = self.get_hostname_and_port()
-
-        # Sable requires inbound connections to match the configured hostname,
-        # so we can't configure 0.0.0.0
-        server1_hostname = services_hostname = "127.0.0.1"
-
-        (
-            server1_management_hostname,
-            server1_management_port,
-        ) = self.get_hostname_and_port()
-        (
-            services_management_hostname,
-            services_management_port,
-        ) = self.get_hostname_and_port()
-
-        self.template_vars = dict(
-            certs_dir=certs_dir(),
-            c2s_hostname=c2s_hostname,
-            c2s_port=c2s_port,
-            server1_hostname=server1_hostname,
-            server1_port=server1_port,
-            server1_cert_sha1=(certs_dir() / "My.Little.Server.pem.sha1")
-            .read_text()
-            .strip(),
-            server1_management_hostname=server1_management_hostname,
-            server1_management_port=server1_management_port,
-            services_hostname=services_hostname,
-            services_port=services_port,
-            services_cert_sha1=(certs_dir() / "My.Little.Services.pem.sha1")
-            .read_text()
-            .strip(),
-            services_management_hostname=services_management_hostname,
-            services_management_port=services_management_port,
-            services_alias_users=SERVICES_ALIAS_USERS if run_services else "",
-        )
-
-        with self.open_file("configs/network.conf") as fd:
-            fd.write(NETWORK_CONFIG % self.template_vars)
-        with self.open_file("configs/network_config.conf") as fd:
-            fd.write(NETWORK_CONFIG_CONFIG % self.template_vars)
-        with self.open_file("configs/server1.conf") as fd:
-            fd.write(SERVER_CONFIG % self.template_vars)
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
-        self.proc = subprocess.Popen(
-            [
-                *faketime_cmd,
-                "sable_ircd",
-                "--foreground",
-                "--server-conf",
-                self.directory / "configs/server1.conf",
-                "--network-conf",
-                self.directory / "configs/network.conf",
-                "--bootstrap-network",
-                self.directory / "configs/network_config.conf",
-            ],
-            cwd=self.directory,
-            preexec_fn=os.setsid,
-        )
-        self.pgroup_id = os.getpgid(self.proc.pid)
-
-        if run_services:
-            self.services_controller = SableServicesController(self.test_config, self)
-            self.services_controller.run(
-                protocol="sable",
-                server_hostname=services_hostname,
-                server_port=services_port,
-            )
-
-    def kill_proc(self) -> None:
-        os.killpg(self.pgroup_id, signal.SIGKILL)
-        super().kill_proc()
-
-    def registerUser(
-        self,
-        case: BaseServerTestCase,  # type: ignore
-        username: str,
-        password: Optional[str] = None,
-    ) -> None:
-        # XXX: Move this somewhere else when
-        # https://github.com/ircv3/ircv3-specifications/pull/152 becomes
-        # part of the specification
-        if not case.run_services:
-            raise ValueError(
-                "Attempted to register a nick, but `run_services` it not True."
-            )
-        assert password
-        client = case.addClient(show_io=True)
-        case.sendLine(client, "NICK " + username)
-        case.sendLine(client, "USER r e g :user")
-        while case.getRegistrationMessage(client).command != "001":
-            pass
-        case.getMessages(client)
-        case.sendLine(
-            client,
-            f"REGISTER * * {password}",
-        )
-        for _ in range(100):
-            time.sleep(0.1)
-            try:
-                msg = case.getMessage(client)
-            except NoMessageException:
-                continue
-            case.assertMessageMatch(
-                msg, command="REGISTER", params=["SUCCESS", username, ANYSTR]
-            )
-            break
-        else:
-            raise NoMessageException()
-        case.sendLine(client, "QUIT")
-        case.assertDisconnected(client)
-
-
-class SableServicesController(BaseServicesController):
-    server_controller: SableController
-    software_name = "Sable Services"
-
-    def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
-        assert protocol == "sable"
-        assert self.server_controller.directory is not None
-
-        with self.server_controller.open_file("configs/services.conf") as fd:
-            fd.write(SERVICES_CONFIG % self.server_controller.template_vars)
-
-        self.proc = subprocess.Popen(
-            [
-                "sable_services",
-                "--foreground",
-                "--server-conf",
-                self.server_controller.directory / "configs/services.conf",
-                "--network-conf",
-                self.server_controller.directory / "configs/network.conf",
-            ],
-            cwd=self.server_controller.directory,
-            preexec_fn=os.setsid,
-        )
-        self.pgroup_id = os.getpgid(self.proc.pid)
-
-    def kill_proc(self) -> None:
-        os.killpg(self.pgroup_id, signal.SIGKILL)
-        super().kill_proc()
-
-
-def get_irctest_controller_class() -> Type[SableController]:
-    return SableController

irctest/controllers/snircd.py

@@ -1,6 +1,6 @@
-import shutil
+import os
 import subprocess
-from typing import Optional, Type
+from typing import Optional, Set, Type
 
 from irctest.basecontrollers import (
     BaseServerController,
@@ -67,8 +67,13 @@ class SnircdController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         if ssl:
             raise NotImplementedByController("TLS")
         if run_services:
@@ -79,7 +84,7 @@ class SnircdController(BaseServerController, DirectoryBasedController):
         self.create_config()
         password_field = 'password = "{}";'.format(password) if password else ""
         assert self.directory
-        pidfile = self.directory / "ircd.pid"
+        pidfile = os.path.join(self.directory, "ircd.pid")
         with self.open_file("server.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -89,20 +94,12 @@ class SnircdController(BaseServerController, DirectoryBasedController):
                     pidfile=pidfile,
                 )
             )
-
-        if faketime and shutil.which("faketime"):
-            faketime_cmd = ["faketime", "-f", faketime]
-            self.faketime_enabled = True
-        else:
-            faketime_cmd = []
-
         self.proc = subprocess.Popen(
             [
-                *faketime_cmd,
                 "ircd",
                 "-n",  # don't detach
                 "-f",
-                self.directory / "server.conf",
+                os.path.join(self.directory, "server.conf"),
                 "-x",
                 "DEBUG",
             ],

irctest/controllers/sopel.py

@@ -1,4 +1,4 @@
-from pathlib import Path
+import os
 import subprocess
 import tempfile
 from typing import Optional, TextIO, Type, cast
@@ -38,14 +38,14 @@ class SopelController(BaseClientController):
         super().kill()
         if self.filename:
             try:
-                (Path("~/.sopel/").expanduser() / self.filename).unlink()
+                os.unlink(os.path.join(os.path.expanduser("~/.sopel/"), self.filename))
-            except OSError:  # File does not exist
+            except OSError:  #  File does not exist
                 pass
 
     def open_file(self, filename: str, mode: str = "a") -> TextIO:
-        dir_path = Path("~/.sopel/").expanduser()
+        dir_path = os.path.expanduser("~/.sopel/")
-        dir_path.mkdir(parents=True, exist_ok=True)
+        os.makedirs(dir_path, exist_ok=True)
-        return cast(TextIO, (dir_path / filename).open(mode))
+        return cast(TextIO, open(os.path.join(dir_path, filename), mode))
 
     def create_config(self) -> None:
         with self.open_file(self.filename):
@@ -73,7 +73,7 @@ class SopelController(BaseClientController):
                     auth_method="auth_method = sasl" if auth else "",
                 )
             )
-        self.proc = subprocess.Popen(["sopel", "-c", self.filename])
+        self.proc = subprocess.Popen(["sopel", "--quiet", "-c", self.filename])
 
 
 def get_irctest_controller_class() -> Type[SopelController]:

irctest/controllers/thelounge.py

@@ -1,106 +0,0 @@
-import json
-import os
-import subprocess
-from typing import Optional, Type
-
-from irctest import authentication, tls
-from irctest.basecontrollers import (
-    BaseClientController,
-    DirectoryBasedController,
-    NotImplementedByController,
-)
-
-TEMPLATE_CONFIG = """
-"use strict";
-
-module.exports = {config};
-"""
-
-
-class TheLoungeController(BaseClientController, DirectoryBasedController):
-    software_name = "TheLounge"
-    supported_sasl_mechanisms = {
-        "PLAIN",
-        "ECDSA-NIST256P-CHALLENGE",
-        "SCRAM-SHA-256",
-        "EXTERNAL",
-    }
-    supports_sts = True
-
-    def create_config(self) -> None:
-        super().create_config()
-        with self.open_file("bot.conf"):
-            pass
-        with self.open_file("conf/users.conf"):
-            pass
-
-    def run(
-        self,
-        hostname: str,
-        port: int,
-        auth: Optional[authentication.Authentication],
-        tls_config: Optional[tls.TlsConfig] = None,
-    ) -> None:
-        if tls_config is None:
-            tls_config = tls.TlsConfig(enable=False, trusted_fingerprints=[])
-        if tls_config and tls_config.trusted_fingerprints:
-            raise NotImplementedByController("Trusted fingerprints.")
-        if auth and any(
-            mech.to_string().startswith(("SCRAM-", "ECDSA-"))
-            for mech in auth.mechanisms
-        ):
-            raise NotImplementedByController("ecdsa")
-        if auth and auth.password and len(auth.password) > 300:
-            # https://github.com/thelounge/thelounge/pull/4480
-            # Note that The Lounge truncates on 300 characters, not bytes.
-            raise NotImplementedByController("Passwords longer than 300 chars")
-        # Runs a client with the config given as arguments
-        assert self.proc is None
-        self.create_config()
-        if auth:
-            mechanisms = " ".join(mech.to_string() for mech in auth.mechanisms)
-            if auth.ecdsa_key:
-                with self.open_file("ecdsa_key.pem") as fd:
-                    fd.write(auth.ecdsa_key)
-        else:
-            mechanisms = ""
-
-        assert self.directory
-        with self.open_file("config.js") as fd:
-            fd.write(
-                TEMPLATE_CONFIG.format(
-                    config=json.dumps(
-                        dict(
-                            public=False,
-                            host=f"unix:{self.directory}/sock",  # prevents binding
-                        )
-                    )
-                )
-            )
-        with self.open_file("users/testuser.json") as fd:
-            json.dump(
-                dict(
-                    networks=[
-                        dict(
-                            name="testnet",
-                            host=hostname,
-                            port=port,
-                            tls=tls_config.enable if tls_config else "False",
-                            sasl=mechanisms.lower(),
-                            saslAccount=auth.username if auth else "",
-                            saslPassword=auth.password if auth else "",
-                        )
-                    ]
-                ),
-                fd,
-            )
-        with self.open_file("users/testuser.json", "r") as fd:
-            print("config", json.load(fd)["networks"][0]["saslPassword"])
-        self.proc = subprocess.Popen(
-            [os.environ.get("THELOUNGE_BIN", "thelounge"), "start"],
-            env={**os.environ, "THELOUNGE_HOME": str(self.directory)},
-        )
-
-
-def get_irctest_controller_class() -> Type[TheLoungeController]:
-    return TheLoungeController

irctest/controllers/unrealircd.py

@@ -1,13 +1,18 @@
-import contextlib
-import fcntl
 import functools
-from pathlib import Path
+import os
+import pathlib
 import shutil
+import signal
 import subprocess
 import textwrap
-from typing import Callable, ContextManager, Iterator, Optional, Type
+from typing import Optional, Set, Type
 
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
 
 TEMPLATE_CONFIG = """
 include "modules.default.conf";
@@ -17,7 +22,7 @@ include "help/help.conf";
 
 me {{
     name "My.Little.Server";
-    info "test server";
+    info "ExampleNET Server";
     sid "001";
 }}
 admin {{
@@ -95,9 +100,6 @@ set {{
         }}
     }}
     modes-on-join "+H 100:1d";  // Enables CHATHISTORY
-
-    {set_v6only}
-
 }}
 
 tld {{
@@ -112,60 +114,13 @@ files {{
 }}
 
 oper "operuser" {{
-    password "operpassword";
+    password = "operpassword";
     mask *;
     class clients;
     operclass netadmin;
 }}
 """
 
-SET_V6ONLY = """
-// Remove RPL_WHOISSPECIAL used to advertise security groups
-whois-details {
-    security-groups { everyone none; self none; oper none; }
-}
-
-plaintext-policy {
-    server warn; // https://www.unrealircd.org/docs/FAQ#server-requires-tls
-    oper warn; // https://www.unrealircd.org/docs/FAQ#oper-requires-tls
-}
-
-anti-flood {
-    everyone {
-        connect-flood 255:10;
-    }
-}
-"""
-
-
-def _filelock(path: Path) -> Callable[[], ContextManager]:
-    """Alternative to :cls:`multiprocessing.Lock` that works with pytest-xdist"""
-
-    @contextlib.contextmanager
-    def f() -> Iterator[None]:
-        with open(path, "a") as fd:
-            fcntl.flock(fd, fcntl.LOCK_EX)
-            yield
-
-    return f
-
-
-_UNREALIRCD_BIN = shutil.which("unrealircd")
-if _UNREALIRCD_BIN:
-    _UNREALIRCD_PREFIX = Path(_UNREALIRCD_BIN).parent.parent
-
-    # Try to keep that lock file specific to this Unrealircd instance
-    _LOCK_PATH = _UNREALIRCD_PREFIX / "irctest-unrealircd-startstop.lock"
-else:
-    # unrealircd not found; we are probably going to crash later anyway...
-    _LOCK_PATH = Path("/tmp/irctest-unrealircd-startstop.lock")
-
-_STARTSTOP_LOCK = _filelock(_LOCK_PATH)
-"""
-Unreal cleans its tmp/ directory after each run, which prevents
-multiple processes from starting/stopping at the same time.
-"""
-
 
 @functools.lru_cache()
 def installed_version() -> int:
@@ -184,7 +139,6 @@ class UnrealircdController(BaseServerController, DirectoryBasedController):
     supports_sts = False
 
     extban_mute_char = "quiet" if installed_version() >= 6 else "q"
-    software_version = installed_version()
 
     def create_config(self) -> None:
         super().create_config()
@@ -199,33 +153,23 @@ class UnrealircdController(BaseServerController, DirectoryBasedController):
         password: Optional[str],
         ssl: bool,
         run_services: bool,
-        faketime: Optional[str],
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
     ) -> None:
+        if valid_metadata_keys or invalid_metadata_keys:
+            raise NotImplementedByController(
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
         self.hostname = hostname
         self.create_config()
-
+        (unused_hostname, unused_port) = find_hostname_and_port()
-        if installed_version() >= 6:
+        (services_hostname, services_port) = find_hostname_and_port()
-            extras = textwrap.dedent(
-                """
-                include "snomasks.default.conf";
-                loadmodule "cloak_md5";
-                """
-            )
-            set_v6only = SET_V6ONLY
-        else:
-            extras = ""
-            set_v6only = ""
-
-        with self.open_file("empty.txt") as fd:
-            fd.write("\n")
 
         password_field = 'password "{}";'.format(password) if password else ""
 
-        (services_hostname, services_port) = self.get_hostname_and_port()
-        (unused_hostname, unused_port) = self.get_hostname_and_port()
-
         self.gen_ssl()
         if ssl:
             (tls_hostname, tls_port) = (hostname, port)
@@ -234,8 +178,20 @@ class UnrealircdController(BaseServerController, DirectoryBasedController):
             # Unreal refuses to start without TLS enabled
             (tls_hostname, tls_port) = (unused_hostname, unused_port)
 
-        assert self.directory
+        if installed_version() >= 6:
+            extras = textwrap.dedent(
+                """
+                include "snomasks.default.conf";
+                loadmodule "cloak_md5";
+                """
+            )
+        else:
+            extras = ""
 
+        with self.open_file("empty.txt") as fd:
+            fd.write("\n")
+
+        assert self.directory
         with self.open_file("unrealircd.conf") as fd:
             fd.write(
                 TEMPLATE_CONFIG.format(
@@ -248,33 +204,41 @@ class UnrealircdController(BaseServerController, DirectoryBasedController):
                     password_field=password_field,
                     key_path=self.key_path,
                     pem_path=self.pem_path,
-                    empty_file=self.directory / "empty.txt",
+                    empty_file=os.path.join(self.directory, "empty.txt"),
-                    set_v6only=set_v6only,
                     extras=extras,
                 )
             )
 
-        if faketime and shutil.which("faketime"):
+        proot_cmd = []
-            faketime_cmd = ["faketime", "-f", faketime]
+        self.using_proot = False
-            self.faketime_enabled = True
+        if shutil.which("proot"):
-        else:
+            unrealircd_path = shutil.which("unrealircd")
-            faketime_cmd = []
+            if unrealircd_path:
+                unrealircd_prefix = pathlib.Path(unrealircd_path).parents[1]
+                tmpdir = os.path.join(self.directory, "tmp")
+                os.mkdir(tmpdir)
+                # Unreal cleans its tmp/ directory after each run, which prevents
+                # multiple processes from running at the same time.
+                # Using PRoot, we can isolate them, with a tmp/ directory for each
+                # process, so they don't interfere with each other, allowing use of
+                # the -n option (of pytest-xdist) to speed-up tests
+                proot_cmd = ["proot", "-b", f"{tmpdir}:{unrealircd_prefix}/tmp"]
+                self.using_proot = True
 
-        with _STARTSTOP_LOCK():
+        self.proc = subprocess.Popen(
-            self.proc = subprocess.Popen(
+            [
-                [
+                *proot_cmd,
-                    *faketime_cmd,
+                "unrealircd",
-                    "unrealircd",
+                "-t",
-                    "-t",
+                "-F",  # BOOT_NOFORK
-                    "-F",  # BOOT_NOFORK
+                "-f",
-                    "-f",
+                os.path.join(self.directory, "unrealircd.conf"),
-                    self.directory / "unrealircd.conf",
+            ],
-                ],
+            # stdout=subprocess.DEVNULL,
-                # stdout=subprocess.DEVNULL,
+        )
-            )
-            self.wait_for_port()
 
         if run_services:
+            self.wait_for_port()
             self.services_controller = self.services_controller_class(
                 self.test_config, self
             )
@@ -284,13 +248,17 @@ class UnrealircdController(BaseServerController, DirectoryBasedController):
                 server_port=services_port,
             )
 
-    def kill_proc(self) -> None:
+    def kill(self) -> None:
-        assert self.proc
+        if self.using_proot:
-
+            # Kill grandchild process, instead of killing proot, which takes more
-        with _STARTSTOP_LOCK():
+            # time (and does not seem to always work)
-            self.proc.kill()
+            assert self.proc is not None
-            self.proc.wait(5)  # wait for it to actually die
+            output = subprocess.check_output(
-            self.proc = None
+                ["ps", "-opid", "--no-headers", "--ppid", str(self.proc.pid)]
+            )
+            (grandchild_pid,) = [int(line) for line in output.decode().split()]
+            os.kill(grandchild_pid, signal.SIGKILL)
+        super().kill()
 
 
 def get_irctest_controller_class() -> Type[UnrealircdController]:

irctest/dashboard/format.py

@@ -1,476 +0,0 @@
-import base64
-import dataclasses
-import gzip
-import hashlib
-import importlib
-from pathlib import Path
-import re
-import sys
-from typing import (
-    IO,
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    TypeVar,
-    Union,
-)
-import xml.etree.ElementTree as ET
-
-from defusedxml.ElementTree import parse as parse_xml
-import docutils.core
-
-from .shortxml import Namespace
-
-NETLIFY_CHAR_BLACKLIST = frozenset('":<>|*?\r\n#')
-"""Characters not allowed in output filenames"""
-
-
-HTML = Namespace("http://www.w3.org/1999/xhtml")
-
-
-@dataclasses.dataclass
-class CaseResult:
-    module_name: str
-    class_name: str
-    test_name: str
-    job: str
-    success: bool
-    skipped: bool
-    system_out: Optional[str]
-    details: Optional[str] = None
-    type: Optional[str] = None
-    message: Optional[str] = None
-
-    def output_filename(self) -> str:
-        test_name = self.test_name
-        if len(test_name) > 50 or set(test_name) & NETLIFY_CHAR_BLACKLIST:
-            # File name too long or otherwise invalid. This should be good enough:
-            m = re.match(r"(?P<function_name>\w+?)\[(?P<params>.+)\]", test_name)
-            assert m, "File name is too long but has no parameter."
-            test_name = f'{m.group("function_name")}[{md5sum(m.group("params"))}]'
-        return f"{self.job}_{self.module_name}.{self.class_name}.{test_name}.txt"
-
-
-TK = TypeVar("TK")
-TV = TypeVar("TV")
-
-
-def md5sum(text: str) -> str:
-    return base64.urlsafe_b64encode(hashlib.md5(text.encode()).digest()).decode()
-
-
-def group_by(list_: Iterable[TV], key: Callable[[TV], TK]) -> Dict[TK, List[TV]]:
-    groups: Dict[TK, List[TV]] = {}
-    for value in list_:
-        groups.setdefault(key(value), []).append(value)
-
-    return groups
-
-
-def iter_job_results(job_file_name: Path, job: ET.ElementTree) -> Iterator[CaseResult]:
-    (suite,) = job.getroot()
-    for case in suite:
-        if "name" not in case.attrib:
-            continue
-
-        success = True
-        skipped = False
-        details = None
-        system_out = None
-        extra: Dict[str, str] = {}
-        for child in case:
-            if child.tag == "skipped":
-                success = True
-                skipped = True
-                details = None
-                extra = child.attrib
-            elif child.tag in ("failure", "error"):
-                success = False
-                skipped = False
-                details = child.text
-                extra = child.attrib
-            elif child.tag == "system-out":
-                assert (
-                    system_out is None
-                    # for some reason, skipped tests have two system-out;
-                    # and the second one contains test teardown
-                    or child.text.startswith(system_out.rstrip())
-                ), ("Duplicate system-out tag", repr(system_out), repr(child.text))
-                system_out = child.text
-            else:
-                assert False, child
-
-        (module_name, class_name) = case.attrib["classname"].rsplit(".", 1)
-        m = re.match(
-            r"(.*/)?pytest[ -]results[ _](?P<name>.*)"
-            r"[ _][(]?(stable|release|devel|devel_release)[)]?/pytest.xml(.gz)?",
-            str(job_file_name),
-        )
-        assert m, job_file_name
-        yield CaseResult(
-            module_name=module_name,
-            class_name=class_name,
-            test_name=case.attrib["name"],
-            job=m.group("name"),
-            success=success,
-            skipped=skipped,
-            details=details,
-            system_out=system_out,
-            **extra,
-        )
-
-
-def rst_to_element(s: str) -> ET.Element:
-    html = docutils.core.publish_parts(s, writer_name="xhtml")["html_body"]
-
-    # Force the HTML namespace on all elements produced by docutils, which are
-    # unqualified
-    tree_builder = ET.TreeBuilder(
-        element_factory=lambda tag, attrib: ET.Element(
-            "{%s}%s" % (HTML.uri, tag),
-            {"{%s}%s" % (HTML.uri, k): v for (k, v) in attrib.items()},
-        )
-    )
-    parser = ET.XMLParser(target=tree_builder)
-
-    htmltree = ET.fromstring(html, parser=parser)
-    return htmltree
-
-
-def docstring(obj: object) -> Optional[ET.Element]:
-    if obj.__doc__ is None:
-        return None
-
-    return rst_to_element(obj.__doc__)
-
-
-def build_job_html(job: str, results: List[CaseResult]) -> ET.Element:
-    jobs = sorted({result.job for result in results})
-
-    table = build_test_table(jobs, results, "job-results test-matrix")
-
-    return HTML.html(
-        HTML.head(
-            HTML.title(job),
-            HTML.link(rel="stylesheet", type="text/css", href="./style.css"),
-        ),
-        HTML.body(
-            HTML.h1(job),
-            table,
-        ),
-    )
-
-
-def build_module_html(
-    jobs: List[str], results: List[CaseResult], module_name: str
-) -> ET.Element:
-    module = importlib.import_module(module_name)
-
-    table = build_test_table(jobs, results, "module-results test-matrix")
-
-    return HTML.html(
-        HTML.head(
-            HTML.title(module_name),
-            HTML.link(rel="stylesheet", type="text/css", href="./style.css"),
-        ),
-        HTML.body(
-            HTML.h1(module_name),
-            docstring(module),
-            table,
-        ),
-    )
-
-
-def build_test_table(
-    jobs: List[str], results: List[CaseResult], class_: str
-) -> ET.Element:
-    multiple_modules = len({r.module_name for r in results}) > 1
-    results_by_module_and_class = group_by(
-        results, lambda r: (r.module_name, r.class_name)
-    )
-
-    job_row = HTML.tr(
-        HTML.th(),  # column of case name
-        [HTML.th(HTML.div(HTML.span(job)), class_="job-name") for job in jobs],
-    )
-
-    rows = []
-
-    for (module_name, class_name), class_results in sorted(
-        results_by_module_and_class.items()
-    ):
-        if multiple_modules:
-            # if the page shows classes from various modules, use the fully-qualified
-            # name in order to disambiguate and be clearer (eg. show
-            # "irctest.server_tests.extended_join.MetadataTestCase" instead of just
-            # "MetadataTestCase" which looks like it's about IRCv3's METADATA spec.
-            qualified_class_name = f"{module_name}.{class_name}"
-        else:
-            # otherwise, it's not needed, so let's not display it
-            qualified_class_name = class_name
-
-        module = importlib.import_module(module_name)
-
-        # Header row: class name
-        row_anchor = f"{qualified_class_name}"
-        rows.append(
-            HTML.tr(
-                HTML.th(
-                    HTML.h2(
-                        HTML.a(
-                            qualified_class_name,
-                            href=f"#{row_anchor}",
-                            id=row_anchor,
-                        ),
-                    ),
-                    docstring(getattr(module, class_name)),
-                    colspan=str(len(jobs) + 1),
-                )
-            )
-        )
-
-        # Header row: one column for each implementation
-        rows.append(job_row)
-
-        # One row for each test:
-        results_by_test = group_by(class_results, key=lambda r: r.test_name)
-        for test_name, test_results in sorted(results_by_test.items()):
-            row_anchor = f"{qualified_class_name}.{test_name}"
-            if len(row_anchor) >= 50:
-                # Too long; give up on generating readable URL
-                # TODO: only hash test parameter
-                row_anchor = md5sum(row_anchor)
-
-            doc = docstring(
-                getattr(getattr(module, class_name), test_name.split("[")[0])
-            )
-            row = HTML.tr(
-                HTML.th(
-                    HTML.details(
-                        HTML.summary(HTML.a(test_name, href=f"#{row_anchor}")),
-                        doc,
-                    )
-                    if doc
-                    else HTML.a(test_name, href=f"#{row_anchor}"),
-                    class_="test-name",
-                ),
-                id=row_anchor,
-            )
-            rows.append(row)
-
-            results_by_job = group_by(test_results, key=lambda r: r.job)
-            for job_name in jobs:
-                try:
-                    (result,) = results_by_job[job_name]
-                except KeyError:
-                    row.append(HTML.td("d", class_="deselected"))
-                    continue
-
-                text: Union[str, None, ET.Element]
-                attrib = {}
-
-                if result.skipped:
-                    attrib["class"] = "skipped"
-                    if result.type == "pytest.skip":
-                        text = "s"
-                    elif result.type == "pytest.xfail":
-                        text = "X"
-                        attrib["class"] = "expected-failure"
-                    else:
-                        text = result.type
-                elif result.success:
-                    attrib["class"] = "success"
-                    if result.type:
-                        # dead code?
-                        text = result.type
-                    else:
-                        text = "."
-                else:
-                    attrib["class"] = "failure"
-                    if result.type:
-                        # dead code?
-                        text = result.type
-                    else:
-                        text = "f"
-
-                if result.system_out:
-                    # There is a log file; link to it.
-                    text = HTML.a(text or "?", href=f"./{result.output_filename()}")
-                else:
-                    text = text or "?"
-                if result.message:
-                    attrib["title"] = result.message
-
-                row.append(HTML.td(text, attrib))
-
-    return HTML.table(*rows, class_=class_)
-
-
-def write_html_pages(
-    output_dir: Path, results: List[CaseResult]
-) -> List[Tuple[str, str, str]]:
-    """Returns the list of (module_name, file_name)."""
-    output_dir.mkdir(parents=True, exist_ok=True)
-    results_by_module = group_by(results, lambda r: r.module_name)
-
-    # used as columns
-    jobs = list(sorted({r.job for r in results}))
-
-    job_categories = {}
-    for job in jobs:
-        is_client = any(
-            "client_tests" in result.module_name and result.job == job
-            for result in results
-        )
-        is_server = any(
-            "server_tests" in result.module_name and result.job == job
-            for result in results
-        )
-        assert is_client != is_server, (job, is_client, is_server)
-        if job.endswith(("-atheme", "-anope", "-dlk")):
-            assert is_server
-            job_categories[job] = "server-with-services"
-        elif is_server:
-            job_categories[job] = "server"  # with or without services
-        else:
-            assert is_client
-            job_categories[job] = "client"
-
-    pages = []
-
-    for module_name, module_results in sorted(results_by_module.items()):
-        # Filter out client jobs if this is a server test module, and vice versa
-        module_categories = {
-            job_categories[result.job]
-            for result in results
-            if result.module_name == module_name and not result.skipped
-        }
-
-        module_jobs = [job for job in jobs if job_categories[job] in module_categories]
-
-        root = build_module_html(module_jobs, module_results, module_name)
-        file_name = f"{module_name}.xhtml"
-        write_xml_file(output_dir / file_name, root)
-        pages.append(("module", module_name, file_name))
-
-    for category in ("server", "client"):
-        for job in [job for job in job_categories if job_categories[job] == category]:
-            job_results = [
-                result
-                for result in results
-                if result.job == job or result.job.startswith(job + "-")
-            ]
-            root = build_job_html(job, job_results)
-            file_name = f"{job}.xhtml"
-            write_xml_file(output_dir / file_name, root)
-            pages.append(("job", job, file_name))
-
-    return pages
-
-
-def write_test_outputs(output_dir: Path, results: List[CaseResult]) -> None:
-    """Writes stdout files of each test."""
-    for result in results:
-        if result.system_out is None:
-            continue
-        output_file = output_dir / result.output_filename()
-        with output_file.open("wt") as fd:
-            fd.write(result.system_out)
-
-
-def write_html_index(output_dir: Path, pages: List[Tuple[str, str, str]]) -> None:
-    module_pages = []
-    job_pages = []
-    for page_type, title, file_name in sorted(pages):
-        if page_type == "module":
-            module_pages.append((title, file_name))
-        elif page_type == "job":
-            job_pages.append((title, file_name))
-        else:
-            assert False, page_type
-
-    page = HTML.html(
-        HTML.head(
-            HTML.title("irctest dashboard"),
-            HTML.link(rel="stylesheet", type="text/css", href="./style.css"),
-        ),
-        HTML.body(
-            HTML.h1("irctest dashboard"),
-            HTML.h2("Tests by command/specification"),
-            HTML.dl(
-                [
-                    (
-                        HTML.dt(HTML.a(module_name, href=f"./{file_name}")),
-                        HTML.dd(docstring(importlib.import_module(module_name))),
-                    )
-                    for module_name, file_name in sorted(module_pages)
-                ],
-                class_="module-index",
-            ),
-            HTML.h2("Tests by implementation"),
-            HTML.ul(
-                [
-                    HTML.li(HTML.a(job, href=f"./{file_name}"))
-                    for job, file_name in sorted(job_pages)
-                ],
-                class_="job-index",
-            ),
-        ),
-    )
-
-    write_xml_file(output_dir / "index.xhtml", page)
-
-
-def write_assets(output_dir: Path) -> None:
-    css_path = output_dir / "style.css"
-    source_css_path = Path(__file__).parent / "style.css"
-    with css_path.open("wt") as fd:
-        with source_css_path.open() as source_fd:
-            fd.write(source_fd.read())
-
-
-def write_xml_file(filename: Path, root: ET.Element) -> None:
-    # Serialize
-    if sys.version_info >= (3, 8):
-        s = ET.tostring(root, default_namespace=HTML.uri)
-    else:
-        # default_namespace not supported
-        s = ET.tostring(root)
-
-    with filename.open("wb") as fd:
-        fd.write(s)
-
-
-def parse_xml_file(filename: Path) -> ET.ElementTree:
-    fd: IO
-    if filename.suffix == ".gz":
-        with gzip.open(filename, "rb") as fd:  # type: ignore
-            return parse_xml(fd)  # type: ignore
-    else:
-        with open(filename) as fd:
-            return parse_xml(fd)  # type: ignore
-
-
-def main(output_path: Path, filenames: List[Path]) -> int:
-    results = [
-        result
-        for filename in filenames
-        for result in iter_job_results(filename, parse_xml_file(filename))
-    ]
-
-    pages = write_html_pages(output_path, results)
-
-    write_html_index(output_path, pages)
-    write_test_outputs(output_path, results)
-    write_assets(output_path)
-
-    return 0
-
-
-if __name__ == "__main__":
-    (_, output_path, *filenames) = sys.argv
-    exit(main(Path(output_path), list(map(Path, filenames))))

irctest/dashboard/github_download.py

@@ -1,87 +0,0 @@
-import dataclasses
-import gzip
-import io
-import json
-from pathlib import Path
-import sys
-from typing import Iterator
-import urllib.parse
-import urllib.request
-import zipfile
-
-
-@dataclasses.dataclass
-class Artifact:
-    repo: str
-    run_id: int
-    name: str
-    download_url: str
-
-    @property
-    def public_download_url(self) -> str:
-        # GitHub API is not available publicly for artifacts, we need to use
-        # a third-party proxy to access it...
-        name = urllib.parse.quote(self.name)
-        return f"https://nightly.link/{repo}/actions/runs/{self.run_id}/{name}.zip"
-
-
-def iter_run_artifacts(repo: str, run_id: int) -> Iterator[Artifact]:
-    request = urllib.request.Request(
-        f"https://api.github.com/repos/{repo}/actions/runs/{run_id}/artifacts"
-        "?per_page=100",
-        headers={"Accept": "application/vnd.github.v3+json"},
-    )
-
-    response = urllib.request.urlopen(request)
-
-    for artifact in json.load(response)["artifacts"]:
-        if not artifact["name"].startswith(("pytest-results_", "pytest results ")):
-            continue
-        if artifact["expired"]:
-            continue
-        yield Artifact(
-            repo=repo,
-            run_id=run_id,
-            name=artifact["name"],
-            download_url=artifact["archive_download_url"],
-        )
-
-
-def download_artifact(output_name: Path, url: str) -> None:
-    if output_name.exists():
-        return
-    response = urllib.request.urlopen(url)
-    archive_bytes = response.read()  # Can't stream it, it's a ZIP
-    with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
-        with archive.open("pytest.xml") as input_fd:
-            pytest_xml = input_fd.read()
-
-    tmp_output_path = output_name.with_suffix(".tmp")
-    with gzip.open(tmp_output_path, "wb") as output_fd:
-        output_fd.write(pytest_xml)
-
-    # Atomically write to the output path, so that we don't write partial files in case
-    # the download process is interrupted
-    tmp_output_path.rename(output_name)
-
-
-def main(output_dir: Path, repo: str, run_id: int) -> int:
-    output_dir.mkdir(parents=True, exist_ok=True)
-    run_path = output_dir / str(run_id)
-    run_path.mkdir(exist_ok=True)
-
-    for artifact in iter_run_artifacts(repo, run_id):
-        artifact_path = run_path / artifact.name / "pytest.xml.gz"
-        artifact_path.parent.mkdir(exist_ok=True)
-        try:
-            download_artifact(artifact_path, artifact.download_url)
-        except Exception:
-            download_artifact(artifact_path, artifact.public_download_url)
-        print("downloaded", artifact.name)
-
-    return 0
-
-
-if __name__ == "__main__":
-    (_, output_path, repo, run_id) = sys.argv
-    exit(main(Path(output_path), repo, int(run_id)))

irctest/dashboard/shortxml.py

@@ -1,126 +0,0 @@
-# Copyright (c) 2023 Valentin Lorentz
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-"""This module allows writing XML ASTs in a way that is more concise than the default
-:mod:`xml.etree.ElementTree` interface.
-
-For example:
-
-.. code-block:: python
-
-    from .shortxml import Namespace
-
-    HTML = Namespace("http://www.w3.org/1999/xhtml")
-
-    page = HTML.html(
-        HTML.head(
-            HTML.title("irctest dashboard"),
-            HTML.link(rel="stylesheet", type="text/css", href="./style.css"),
-        ),
-        HTML.body(
-            HTML.h1("irctest dashboard"),
-            HTML.h2("Tests by command/specification"),
-            HTML.dl(
-                [
-                    (  # elements can be arbitrarily nested in lists
-                        HTML.dt(HTML.a(title, href=f"./{title}.xhtml")),
-                        HTML.dd(defintion),
-                    )
-                    for title, definition in sorted(definitions)
-                ],
-                class_="module-index",
-            ),
-            HTML.h2("Tests by implementation"),
-            HTML.ul(
-                [
-                    HTML.li(HTML.a(job, href=f"./{file_name}"))
-                    for job, file_name in sorted(job_pages)
-                ],
-                class_="job-index",
-            ),
-        ),
-    )
-
-    print(ET.tostring(page, default_namespace=HTML.uri))
-
-
-Attributes can be passed either as dictionaries or as kwargs, and can be mixed
-with child elements.
-Trailing underscores are stripped from attributes, which allows passing reserved
-Python keywords (eg. ``class_`` instead of ``class``)
-
-Attributes are always qualified, and share the namespace of the element they are
-attached to.
-
-Mixed content (elements containing both text and child elements) is not supported.
-"""
-
-from typing import Dict, Sequence, Union
-import xml.etree.ElementTree as ET
-
-
-def _namespacify(ns: str, s: str) -> str:
-    return "{%s}%s" % (ns, s)
-
-
-_Children = Union[None, Dict[str, str], ET.Element, Sequence["_Children"]]
-
-
-class ElementFactory:
-    def __init__(self, namespace: str, tag: str):
-        self._tag = _namespacify(namespace, tag)
-        self._namespace = namespace
-
-    def __call__(self, *args: Union[str, _Children], **kwargs: str) -> ET.Element:
-        e = ET.Element(self._tag)
-
-        attributes = {k.rstrip("_"): v for (k, v) in kwargs.items()}
-        children = [*args, attributes]
-
-        if args and isinstance(children[0], str):
-            e.text = children[0]
-            children.pop(0)
-
-        for child in children:
-            self._append_child(e, child)
-
-        return e
-
-    def _append_child(self, e: ET.Element, child: _Children) -> None:
-        if isinstance(child, ET.Element):
-            e.append(child)
-        elif child is None:
-            pass
-        elif isinstance(child, dict):
-            for k, v in child.items():
-                e.set(_namespacify(self._namespace, k), str(v))
-        elif isinstance(child, str):
-            raise ValueError("Mixed content is not supported")
-        else:
-            for grandchild in child:
-                self._append_child(e, grandchild)
-
-
-class Namespace:
-    def __init__(self, uri: str):
-        self.uri = uri
-
-    def __getattr__(self, tag: str) -> ElementFactory:
-        return ElementFactory(self.uri, tag)

irctest/dashboard/style.css

@@ -1,67 +0,0 @@
-@media (prefers-color-scheme: dark) {
-    body {
-        background-color: #121212;
-        color: rgba(255, 255, 255, 0.87);
-    }
-    a {
-        filter: invert(0.85) hue-rotate(180deg);
-    }
-}
-
-dl.module-index {
-    column-width: 40em; /* Magic constant for 2 columns on average laptop/desktop */
-}
-
-/* Only 1px solid border between cells */
-table.test-matrix {
-    border-spacing: 0;
-    border-collapse: collapse;
-}
-table.test-matrix td {
-    text-align: center;
-    border: 1px solid grey;
-}
-
-/* Make link take the whole cell */
-table.test-matrix td a {
-    display: block;
-    margin: 0;
-    padding: 0;
-    width: 100%;
-    height: 100%;
-    color: black;
-    text-decoration: none;
-}
-
-/* Test matrix colors */
-table.test-matrix .deselected {
-    background-color: grey;
-}
-table.test-matrix .success {
-    background-color: green;
-}
-table.test-matrix .skipped {
-    background-color: yellow;
-}
-table.test-matrix .failure {
-    background-color: red;
-}
-table.test-matrix .expected-failure {
-    background-color: orange;
-}
-
-/* Rotate headers, thanks to https://css-tricks.com/rotated-table-column-headers/ */
-table.module-results th.job-name {
-  height: 140px;
-  white-space: nowrap;
-}
-table.module-results th.job-name > div {
-  transform:
-    translate(28px, 50px)
-    rotate(315deg);
-  width: 40px;
-}
-table.module-results th.job-name > div > span {
-  border-bottom: 1px solid grey;
-  padding-left: 0px;
-}

irctest/irc_utils/ambiguities.py

@@ -0,0 +1,23 @@
+"""
+Handles ambiguities of RFCs.
+"""
+
+from typing import List
+
+
+def normalize_namreply_params(params: List[str]) -> List[str]:
+    # So… RFC 2812 says:
+    #       "( "=" / "*" / "@" ) <channel>
+    #       :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )
+    # but spaces seem to be missing (eg. before the colon), so we
+    # don't know if there should be one before the <channel> and its
+    # prefix.
+    # So let's normalize this to “with space”, and strip spaces at the
+    # end of the nick list.
+    params = list(params)  # copy the list
+    if len(params) == 3:
+        assert params[1][0] in "=*@", params
+        params.insert(1, params[1][0])
+        params[2] = params[2][1:]
+    params[3] = params[3].rstrip()
+    return params

irctest/irc_utils/filelock.py

@@ -1,18 +0,0 @@
-"""
-Compatibility layer for filelock ( https://pypi.org/project/filelock/ );
-commonly packaged by Linux distributions but might not be available
-in some environments.
-"""
-
-import contextlib
-import os
-from typing import Any, ContextManager
-
-if os.getenv("PYTEST_XDIST_WORKER"):
-    # running under pytest-xdist; filelock is required for reliability
-    from filelock import FileLock
-else:
-    # normal test execution, no port races
-
-    def FileLock(*args: Any, **kwargs: Any) -> ContextManager[None]:
-        return contextlib.nullcontext()

irctest/irc_utils/junkdrawer.py

@@ -13,7 +13,7 @@ def ircv3_timestamp_to_unixtime(timestamp: str) -> float:
 
 
 def random_name(base: str) -> str:
-    return base + "-" + secrets.token_hex(5)
+    return base + "-" + secrets.token_hex(8)
 
 
 def find_hostname_and_port() -> Tuple[str, int]:

irctest/irc_utils/message_parser.py

@@ -15,7 +15,7 @@ TAG_ESCAPE = [
 unescape_tag_value = MultipleReplacer(dict(map(lambda x: (x[1], x[0]), TAG_ESCAPE)))
 
 # TODO: validate host
-tag_key_validator = re.compile(r"^\+?(\S+/)?[a-zA-Z0-9-]+$")
+tag_key_validator = re.compile(r"\+?(\S+/)?[a-zA-Z0-9-]+")
 
 
 def parse_tags(s: str) -> Dict[str, Optional[str]]:

irctest/numerics.py

@@ -66,7 +66,6 @@ RPL_WHOISIDLE = "317"
 RPL_ENDOFWHOIS = "318"
 RPL_WHOISCHANNELS = "319"
 RPL_WHOISSPECIAL = "320"
-RPL_LISTSTART = "321"
 RPL_LIST = "322"
 RPL_LISTEND = "323"
 RPL_CHANNELMODEIS = "324"
@@ -142,7 +141,6 @@ ERR_USERONCHANNEL = "443"
 ERR_NOLOGIN = "444"
 ERR_SUMMONDISABLED = "445"
 ERR_USERSDISABLED = "446"
-ERR_FORBIDDENCHANNEL = "448"
 ERR_NOTREGISTERED = "451"
 ERR_NEEDMOREPARAMS = "461"
 ERR_ALREADYREGISTRED = "462"

irctest/patma.py

@@ -1,7 +1,6 @@
 """Pattern-matching utilities"""
 
 import dataclasses
-import itertools
 import re
 from typing import Dict, List, Optional, Union
 
@@ -28,14 +27,6 @@ class _AnyOptStr(Operator):
         return "ANYOPTSTR"
 
 
-@dataclasses.dataclass(frozen=True)
-class OptStrRe(Operator):
-    regexp: str
-
-    def __repr__(self) -> str:
-        return f"OptStrRe(r'{self.regexp}')"
-
-
 @dataclasses.dataclass(frozen=True)
 class StrRe(Operator):
     regexp: str
@@ -106,15 +97,10 @@ def match_string(got: Optional[str], expected: Union[str, Operator, None]) -> bo
     elif isinstance(expected, _AnyStr) and got is not None:
         return True
     elif isinstance(expected, StrRe):
-        if got is None or not re.match(expected.regexp + "$", got):
+        if got is None or not re.match(expected.regexp, got):
-            return False
-    elif isinstance(expected, OptStrRe):
-        if got is None:
-            return True
-        if not re.match(expected.regexp + "$", got):
             return False
     elif isinstance(expected, NotStrRe):
-        if got is None or re.match(expected.regexp + "$", got):
+        if got is None or re.match(expected.regexp, got):
             return False
     elif isinstance(expected, InsensitiveStr):
         if got is None or got.lower() != expected.string.lower():
@@ -142,19 +128,11 @@ def match_list(
         nb_remaining_items = len(got) - len(expected)
         expected += [remainder.item] * max(nb_remaining_items, remainder.min_length)
 
-    nb_optionals = 0
+    if len(got) != len(expected):
-    for expected_value in expected:
-        if isinstance(expected_value, (_AnyOptStr, OptStrRe)):
-            nb_optionals += 1
-        else:
-            if nb_optionals > 0:
-                raise NotImplementedError("Optional values in non-final position")
-
-    if not (len(expected) - nb_optionals <= len(got) <= len(expected)):
         return False
     return all(
         match_string(got_value, expected_value)
-        for (got_value, expected_value) in itertools.zip_longest(got, expected)
+        for (got_value, expected_value) in zip(got, expected)
     )
 
 
@@ -174,23 +152,21 @@ def match_dict(
     # Set to not-None if we find a Keys() operator in the dict keys
     remaining_keys_wildcard = None
 
-    for expected_key, expected_value in expected.items():
+    for (expected_key, expected_value) in expected.items():
         if isinstance(expected_key, RemainingKeys):
             remaining_keys_wildcard = (expected_key.key, expected_value)
+        elif isinstance(expected_key, Operator):
+            raise NotImplementedError(f"Unsupported operator: {expected_key}")
         else:
-            for key in got:
+            if expected_key not in got:
-                if match_string(key, expected_key) and match_string(
+                return False
-                    got[key], expected_value
+            got_value = got.pop(expected_key)
-                ):
+            if not match_string(got_value, expected_value):
-                    got.pop(key)
-                    break
-            else:
-                # Found no (key, value) pair matching the request
                 return False
 
     if remaining_keys_wildcard:
         (expected_key, expected_value) = remaining_keys_wildcard
-        for key, value in got.items():
+        for (key, value) in got.items():
             if not match_string(key, expected_key):
                 return False
             if not match_string(value, expected_value):

irctest/self_tests/cases.py

@@ -1,5 +1,3 @@
-"""Internal checks of assertion implementations."""
-
 from typing import Dict, List, Tuple
 
 import pytest
@@ -13,7 +11,6 @@ from irctest.patma import (
     ANYSTR,
     ListRemainder,
     NotStrRe,
-    OptStrRe,
     RemainingKeys,
     StrRe,
 )
@@ -173,46 +170,13 @@ MESSAGE_SPECS: List[Tuple[Dict, List[str], List[str], List[str]]] = [
         ],
         # and they each error with:
         [
-            "expected command to match PRIVMSG, got PRIVMG",
+            "expected command to be PRIVMSG, got PRIVMG",
             "expected tags to match {'tag1': 'bar', RemainingKeys(ANYSTR): ANYOPTSTR}, got {'tag1': 'value1'}",
             "expected params to match ['#chan', 'hello'], got ['#chan', 'hello2']",
             "expected params to match ['#chan', 'hello'], got ['#chan2', 'hello']",
             "expected tags to match {'tag1': 'bar', RemainingKeys(ANYSTR): ANYOPTSTR}, got {}",
         ]
     ),
-    (
-        # the specification:
-        dict(
-            tags={StrRe("tag[12]"): "bar", **ANYDICT},
-            command="PRIVMSG",
-            params=["#chan", "hello"],
-        ),
-        # matches:
-        [
-            "@tag1=bar PRIVMSG #chan :hello",
-            "@tag1=bar;tag2= PRIVMSG #chan :hello",
-            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
-            "@tag2=bar PRIVMSG #chan :hello",
-            "@tag1=bar;tag2= PRIVMSG #chan :hello",
-            "@tag1=;tag2=bar PRIVMSG #chan :hello",
-        ],
-        # and does not match:
-        [
-            "PRIVMG #chan :hello",
-            "@tag1=value1 PRIVMSG #chan :hello",
-            "PRIVMSG #chan hello2",
-            "PRIVMSG #chan2 hello",
-            ":foo!baz@qux PRIVMSG #chan hello",
-        ],
-        # and they each error with:
-        [
-            "expected command to match PRIVMSG, got PRIVMG",
-            "expected tags to match {StrRe(r'tag[12]'): 'bar', RemainingKeys(ANYSTR): ANYOPTSTR}, got {'tag1': 'value1'}",
-            "expected params to match ['#chan', 'hello'], got ['#chan', 'hello2']",
-            "expected params to match ['#chan', 'hello'], got ['#chan2', 'hello']",
-            "expected tags to match {StrRe(r'tag[12]'): 'bar', RemainingKeys(ANYSTR): ANYOPTSTR}, got {}",
-        ]
-    ),
     (
         # the specification:
         dict(
@@ -235,34 +199,12 @@ MESSAGE_SPECS: List[Tuple[Dict, List[str], List[str], List[str]]] = [
         ],
         # and they each error with:
         [
-            "expected command to match PRIVMSG, got PRIVMG",
+            "expected command to be PRIVMSG, got PRIVMG",
             "expected tags to match {'tag1': 'bar', RemainingKeys(NotStrRe(r'tag2')): ANYOPTSTR}, got {'tag1': 'value1'}",
             "expected tags to match {'tag1': 'bar', RemainingKeys(NotStrRe(r'tag2')): ANYOPTSTR}, got {'tag1': 'bar', 'tag2': ''}",
             "expected tags to match {'tag1': 'bar', RemainingKeys(NotStrRe(r'tag2')): ANYOPTSTR}, got {'tag1': 'bar', 'tag2': 'baz'}",
         ]
     ),
-    (
-        # the specification:
-        dict(
-            command="004",
-            params=["nick", "...", OptStrRe("[a-zA-Z]+")],
-        ),
-        # matches:
-        [
-            "004 nick ... abc",
-            "004 nick ...",
-        ],
-        # and does not match:
-        [
-            "004 nick ... 123",
-            "004 nick ... :",
-        ],
-        # and they each error with:
-        [
-            "expected params to match ['nick', '...', OptStrRe(r'[a-zA-Z]+')], got ['nick', '...', '123']",
-            "expected params to match ['nick', '...', OptStrRe(r'[a-zA-Z]+')], got ['nick', '...', '']",
-        ]
-    ),
     (
         # the specification:
         dict(
@@ -345,7 +287,7 @@ MESSAGE_SPECS: List[Tuple[Dict, List[str], List[str], List[str]]] = [
         ],
         # and they each error with:
         [
-            "expected command to match PING, got PONG"
+            "expected command to be PING, got PONG"
         ]
     ),
 ]

irctest/server_tests/account_registration.py

@@ -1,203 +0,0 @@
-"""
-`Draft IRCv3 account-registration
-<https://ircv3.net/specs/extensions/account-registration>`_
-"""
-
-from irctest import cases
-from irctest.patma import ANYSTR
-
-REGISTER_CAP_NAME = "draft/account-registration"
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3")
-class RegisterTestCase(cases.BaseServerTestCase):
-    def testRegisterDefaultName(self):
-        """
-        "If <account> is *, then this value is the user’s current nickname."
-        """
-        self.connectClient(
-            "bar", name="bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertNotIn("email-required", (caps[REGISTER_CAP_NAME] or "").split(","))
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        register_response = [msg for msg in msgs if msg.command == "REGISTER"][0]
-        self.assertMessageMatch(register_response, params=["SUCCESS", ANYSTR, ANYSTR])
-
-    def testRegisterSameName(self):
-        """
-        Requested account name is the same as the nick
-        """
-        self.connectClient(
-            "bar", name="bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertNotIn("email-required", (caps[REGISTER_CAP_NAME] or "").split(","))
-        self.sendLine("bar", "REGISTER bar * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        register_response = [msg for msg in msgs if msg.command == "REGISTER"][0]
-        self.assertMessageMatch(register_response, params=["SUCCESS", ANYSTR, ANYSTR])
-
-    def testRegisterDifferentName(self):
-        """
-        Requested account name differs from the nick
-        """
-        self.connectClient(
-            "bar", name="bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertNotIn("email-required", (caps[REGISTER_CAP_NAME] or "").split(","))
-        self.sendLine("bar", "REGISTER foo * shivarampassphrase")
-        if "custom-account-name" in (caps[REGISTER_CAP_NAME] or "").split(","):
-            msgs = self.getMessages("bar")
-            register_response = [msg for msg in msgs if msg.command == "REGISTER"][0]
-            self.assertMessageMatch(
-                register_response, params=["SUCCESS", ANYSTR, ANYSTR]
-            )
-        else:
-            self.assertMessageMatch(
-                self.getMessage("bar"),
-                command="FAIL",
-                params=["REGISTER", "ACCOUNT_NAME_MUST_BE_NICK", "foo", ANYSTR],
-            )
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3")
-class RegisterBeforeConnectTestCase(cases.BaseServerTestCase):
-    @staticmethod
-    def config() -> cases.TestCaseControllerConfig:
-        return cases.TestCaseControllerConfig(
-            account_registration_requires_email=False,
-            account_registration_before_connect=True,
-        )
-
-    def testBeforeConnect(self):
-        self.addClient("bar")
-        self.requestCapabilities("bar", [REGISTER_CAP_NAME], skip_if_cap_nak=True)
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertIn("before-connect", caps[REGISTER_CAP_NAME] or "")
-        self.sendLine("bar", "NICK bar")
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        register_response = [msg for msg in msgs if msg.command == "REGISTER"][0]
-        self.assertMessageMatch(register_response, params=["SUCCESS", ANYSTR, ANYSTR])
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3")
-class RegisterBeforeConnectDisallowedTestCase(cases.BaseServerTestCase):
-    @staticmethod
-    def config() -> cases.TestCaseControllerConfig:
-        return cases.TestCaseControllerConfig(
-            account_registration_requires_email=False,
-            account_registration_before_connect=False,
-        )
-
-    def testBeforeConnect(self):
-        self.addClient("bar")
-        self.requestCapabilities("bar", [REGISTER_CAP_NAME], skip_if_cap_nak=True)
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertNotIn("before-connect", caps[REGISTER_CAP_NAME] or "")
-        self.sendLine("bar", "NICK bar")
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
-        self.assertMessageMatch(
-            fail_response,
-            params=["REGISTER", "COMPLETE_CONNECTION_REQUIRED", ANYSTR, ANYSTR],
-        )
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3")
-class RegisterEmailVerifiedBeforeConnectTestCase(cases.BaseServerTestCase):
-    @staticmethod
-    def config() -> cases.TestCaseControllerConfig:
-        return cases.TestCaseControllerConfig(
-            account_registration_requires_email=True,
-            account_registration_before_connect=True,
-        )
-
-    def testBeforeConnect(self):
-        self.addClient("bar")
-        self.requestCapabilities(
-            "bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertIn("email-required", caps[REGISTER_CAP_NAME] or "")
-        self.assertIn("before-connect", caps[REGISTER_CAP_NAME] or "")
-        self.sendLine("bar", "NICK bar")
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
-        self.assertMessageMatch(
-            fail_response, params=["REGISTER", "INVALID_EMAIL", ANYSTR, ANYSTR]
-        )
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3")
-class RegisterEmailVerifiedAfterConnectTestCase(cases.BaseServerTestCase):
-    @staticmethod
-    def config() -> cases.TestCaseControllerConfig:
-        return cases.TestCaseControllerConfig(
-            account_registration_before_connect=False,
-            account_registration_requires_email=True,
-        )
-
-    def testAfterConnect(self):
-        self.connectClient(
-            "bar", name="bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-        self.sendLine("bar", "CAP LS 302")
-        caps = self.getCapLs("bar")
-        self.assertIn(REGISTER_CAP_NAME, caps)
-        self.assertIn("email-required", caps[REGISTER_CAP_NAME] or "")
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
-        self.assertMessageMatch(
-            fail_response, params=["REGISTER", "INVALID_EMAIL", ANYSTR, ANYSTR]
-        )
-
-
-@cases.mark_services
-@cases.mark_specifications("IRCv3", "Ergo")
-class RegisterNoLandGrabsTestCase(cases.BaseServerTestCase):
-    @staticmethod
-    def config() -> cases.TestCaseControllerConfig:
-        return cases.TestCaseControllerConfig(
-            account_registration_requires_email=False,
-            account_registration_before_connect=True,
-        )
-
-    def testBeforeConnect(self):
-        # have an anonymous client take the 'root' username:
-        self.connectClient(
-            "root", name="root", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
-        )
-
-        # cannot register it out from under the anonymous nick holder:
-        self.addClient("bar")
-        self.sendLine("bar", "NICK root")
-        self.sendLine("bar", "REGISTER * * shivarampassphrase")
-        msgs = self.getMessages("bar")
-        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
-        self.assertMessageMatch(
-            fail_response, params=["REGISTER", "USERNAME_EXISTS", ANYSTR, ANYSTR]
-        )

irctest/server_tests/account_tag.py

@@ -1,12 +1,12 @@
 """
-`IRCv3 account-tag <https://ircv3.net/specs/extensions/account-tag>`_
+<http://ircv3.net/specs/extensions/account-tag-3.2.html>
 """
 
 from irctest import cases
 
 
 @cases.mark_services
-class AccountTagTestCase(cases.BaseServerTestCase):
+class AccountTagTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     def connectRegisteredClient(self, nick):
         self.addClient()
         self.sendLine(2, "CAP LS 302")
@@ -40,7 +40,7 @@ class AccountTagTestCase(cases.BaseServerTestCase):
         self.skipToWelcome(2)
 
     @cases.mark_capabilities("account-tag")
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
     def testPrivmsg(self):
         self.connectClient("foo", capabilities=["account-tag"], skip_if_cap_nak=True)
         self.getMessages(1)
@@ -54,10 +54,7 @@ class AccountTagTestCase(cases.BaseServerTestCase):
         )
 
     @cases.mark_capabilities("account-tag")
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
-    @cases.xfailIfSoftware(
-        ["Charybdis"], "https://github.com/solanum-ircd/solanum/issues/166"
-    )
     def testInvite(self):
         self.connectClient("foo", capabilities=["account-tag"], skip_if_cap_nak=True)
         self.getMessages(1)

irctest/server_tests/away.py

@@ -1,24 +1,12 @@
-"""
-AWAY command (`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-4.1>`__,
-`Modern <https://modern.ircdocs.horse/#away-message>`__)
-"""
-
 from irctest import cases
-from irctest.numerics import (
+from irctest.numerics import RPL_AWAY, RPL_NOWAWAY, RPL_UNAWAY, RPL_USERHOST
-    RPL_AWAY,
+from irctest.patma import StrRe
-    RPL_NOWAWAY,
-    RPL_UNAWAY,
-    RPL_USERHOST,
-    RPL_WHOISUSER,
-)
-from irctest.patma import ANYSTR, StrRe
 
 
 class AwayTestCase(cases.BaseServerTestCase):
     @cases.mark_specifications("RFC2812", "Modern")
     def testAway(self):
         self.connectClient("bar")
-        self.getMessages(1)
         self.sendLine(1, "AWAY :I'm not here right now")
         replies = self.getMessages(1)
         self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
@@ -30,7 +18,6 @@ class AwayTestCase(cases.BaseServerTestCase):
             command=RPL_AWAY,
             params=["qux", "bar", "I'm not here right now"],
         )
-        self.getMessages(1)
 
         self.sendLine(1, "AWAY")
         replies = self.getMessages(1)
@@ -45,27 +32,23 @@ class AwayTestCase(cases.BaseServerTestCase):
         """
         "The server acknowledges the change in away status by returning the
         `RPL_NOWAWAY` and `RPL_UNAWAY` numerics."
-        -- https://modern.ircdocs.horse/#away-message
+        -- https://github.com/ircdocs/modern-irc/pull/100
         """
         self.connectClient("bar")
         self.sendLine(1, "AWAY :I'm not here right now")
-        self.assertMessageMatch(
+        replies = self.getMessages(1)
-            self.getMessage(1), command=RPL_NOWAWAY, params=["bar", ANYSTR]
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
-        )
-        self.assertEqual(self.getMessages(1), [])
 
         self.sendLine(1, "AWAY")
-        self.assertMessageMatch(
+        replies = self.getMessages(1)
-            self.getMessage(1), command=RPL_UNAWAY, params=["bar", ANYSTR]
+        self.assertIn(RPL_UNAWAY, [msg.command for msg in replies])
-        )
-        self.assertEqual(self.getMessages(1), [])
 
     @cases.mark_specifications("Modern")
     def testAwayPrivmsg(self):
         """
         "Servers SHOULD notify clients when a user they're interacting with
         is away when relevant"
-        -- https://modern.ircdocs.horse/#away-message
+        -- https://github.com/ircdocs/modern-irc/pull/100
 
         "<client> <nick> :<message>"
         -- https://modern.ircdocs.horse/#rplaway-301
@@ -92,7 +75,7 @@ class AwayTestCase(cases.BaseServerTestCase):
         """
         "Servers SHOULD notify clients when a user they're interacting with
         is away when relevant"
-        -- https://modern.ircdocs.horse/#away-message
+        -- https://github.com/ircdocs/modern-irc/pull/100
 
         "<client> <nick> :<message>"
         -- https://modern.ircdocs.horse/#rplaway-301
@@ -130,7 +113,7 @@ class AwayTestCase(cases.BaseServerTestCase):
         """
         "Servers SHOULD notify clients when a user they're interacting with
         is away when relevant"
-        -- https://modern.ircdocs.horse/#away-message
+        -- https://github.com/ircdocs/modern-irc/pull/100
 
         "<client> <nick> :<message>"
         -- https://modern.ircdocs.horse/#rplaway-301
@@ -151,33 +134,3 @@ class AwayTestCase(cases.BaseServerTestCase):
         self.assertMessageMatch(
             self.getMessage(2), command=RPL_USERHOST, params=["qux", StrRe(r"bar=-.*")]
         )
-
-    @cases.mark_specifications("Modern")
-    def testAwayEmptyMessage(self):
-        """
-        "If [AWAY] is sent with a nonempty parameter (the 'away message')
-        then the user is set to be away. If this command is sent with no
-        parameters, or with the empty string as the parameter, the user is no
-        longer away."
-        -- https://modern.ircdocs.horse/#away-message
-        """
-        self.connectClient("bar", name="bar")
-        self.connectClient("qux", name="qux")
-
-        self.sendLine("bar", "AWAY :I'm not here right now")
-        replies = self.getMessages("bar")
-        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
-        self.sendLine("qux", "WHOIS bar")
-        replies = self.getMessages("qux")
-        self.assertIn(RPL_WHOISUSER, [msg.command for msg in replies])
-        self.assertIn(RPL_AWAY, [msg.command for msg in replies])
-
-        # empty final parameter to AWAY is treated the same as no parameter,
-        # i.e., the client is considered to be no longer away
-        self.sendLine("bar", "AWAY :")
-        replies = self.getMessages("bar")
-        self.assertIn(RPL_UNAWAY, [msg.command for msg in replies])
-        self.sendLine("qux", "WHOIS bar")
-        replies = self.getMessages("qux")
-        self.assertIn(RPL_WHOISUSER, [msg.command for msg in replies])
-        self.assertNotIn(RPL_AWAY, [msg.command for msg in replies])

irctest/server_tests/away_notify.py

@@ -1,13 +1,11 @@
 """
-`IRCv3 away-notify <https://ircv3.net/specs/extensions/away-notify>`_
+<https://ircv3.net/specs/extensions/away-notify-3.1>
 """
 
 from irctest import cases
-from irctest.numerics import RPL_NOWAWAY, RPL_UNAWAY
-from irctest.patma import ANYSTR, StrRe
 
 
-class AwayNotifyTestCase(cases.BaseServerTestCase):
+class AwayNotifyTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     @cases.mark_capabilities("away-notify")
     def testAwayNotify(self):
         """Basic away-notify test."""
@@ -22,28 +20,13 @@ class AwayNotifyTestCase(cases.BaseServerTestCase):
         self.getMessages(1)
 
         self.sendLine(2, "AWAY :i'm going away")
-        self.assertMessageMatch(
+        self.getMessages(2)
-            self.getMessage(2), command=RPL_NOWAWAY, params=["bar", ANYSTR]
-        )
-        self.assertEqual(self.getMessages(2), [])
 
         awayNotify = self.getMessage(1)
-        self.assertMessageMatch(
+        self.assertMessageMatch(awayNotify, command="AWAY", params=["i'm going away"])
-            awayNotify,
+        self.assertTrue(
-            prefix=StrRe("bar!.*"),
+            awayNotify.prefix.startswith("bar!"),
-            command="AWAY",
+            "Unexpected away-notify source: %s" % (awayNotify.prefix,),
-            params=["i'm going away"],
-        )
-
-        self.sendLine(2, "AWAY")
-        self.assertMessageMatch(
-            self.getMessage(2), command=RPL_UNAWAY, params=["bar", ANYSTR]
-        )
-        self.assertEqual(self.getMessages(2), [])
-
-        awayNotify = self.getMessage(1)
-        self.assertMessageMatch(
-            awayNotify, prefix=StrRe("bar!.*"), command="AWAY", params=[]
         )
 
     @cases.mark_capabilities("away-notify")
@@ -62,11 +45,7 @@ class AwayNotifyTestCase(cases.BaseServerTestCase):
         self.getMessages(2)
 
         self.joinChannel(2, "#chan")
-        self.assertNotIn(
+        self.getMessages(2)
-            "AWAY",
-            [m.command for m in self.getMessages(2)],
-            "joining user got their own away status when they joined",
-        )
 
         messages = [msg for msg in self.getMessages(1) if msg.command == "AWAY"]
         self.assertEqual(

irctest/server_tests/bot_mode.py

@@ -1,5 +1,6 @@
 """
-`IRCv3 bot mode <https://ircv3.net/specs/extensions/bot-mode>`_
+Draft bot mode specification, as defined in
+<https://ircv3.net/specs/extensions/bot-mode>
 """
 
 from irctest import cases, runner
@@ -67,10 +68,6 @@ class BotModeTestCase(cases.BaseServerTestCase):
             message, command=RPL_WHOISBOT, params=["usernick", "botnick", ANYSTR]
         )
 
-    @cases.xfailIfSoftware(
-        ["InspIRCd"],
-        "Uses only vendor tags for now: https://github.com/inspircd/inspircd/pull/1910",
-    )
     def testBotPrivateMessage(self):
         self._initBot()
 
@@ -85,13 +82,9 @@ class BotModeTestCase(cases.BaseServerTestCase):
             self.getMessage("user"),
             command="PRIVMSG",
             params=["usernick", "beep boop"],
-            tags={StrRe("(draft/)?bot"): None, **ANYDICT},
+            tags={"draft/bot": None, **ANYDICT},
         )
 
-    @cases.xfailIfSoftware(
-        ["InspIRCd"],
-        "Uses only vendor tags for now: https://github.com/inspircd/inspircd/pull/1910",
-    )
     def testBotChannelMessage(self):
         self._initBot()
 
@@ -111,7 +104,7 @@ class BotModeTestCase(cases.BaseServerTestCase):
             self.getMessage("user"),
             command="PRIVMSG",
             params=["#chan", "beep boop"],
-            tags={StrRe("(draft/)?bot"): None, **ANYDICT},
+            tags={"draft/bot": None, **ANYDICT},
         )
 
     def testBotWhox(self):

irctest/server_tests/bouncer.py

@@ -1,9 +1,3 @@
-"""
-`Ergo <https://ergo.chat/>`_-specific tests of
-`multiclient features
-<https://github.com/ergochat/ergo/blob/master/docs/MANUAL.md#multiclient-bouncer>`_
-"""
-
 from irctest import cases
 from irctest.irc_utils.sasl import sasl_plain_blob
 from irctest.numerics import ERR_NICKNAMEINUSE, RPL_WELCOME

irctest/server_tests/buffering.py

@@ -1,7 +1,5 @@
-"""
+"""Sends packets with various length to check the server reassembles them
-Sends packets with various length to check the server reassembles them
+correctly. Also checks truncation"""
-correctly. Also checks truncation.
-"""
 
 import socket
 import time
@@ -32,16 +30,6 @@ def _sendBytePerByte(self, line):
 
 
 class BufferingTestCase(cases.BaseServerTestCase):
-    @cases.xfailIfSoftware(
-        ["Bahamut"],
-        "cannot pass because of issues with UTF-8 handling: "
-        "https://github.com/DALnet/bahamut/issues/196",
-    )
-    @cases.xfailIfSoftware(
-        ["ircu2", "Nefarious", "snircd"],
-        "ircu2 discards the whole buffer on long lines "
-        "(TODO: refine how we exclude these tests)",
-    )
     @pytest.mark.parametrize(
         "sender_function,colon",
         [
@@ -86,10 +74,10 @@ class BufferingTestCase(cases.BaseServerTestCase):
             if messages and ERR_INPUTTOOLONG in (m.command for m in messages):
                 # https://defs.ircdocs.horse/defs/numerics.html#err-inputtoolong-417
                 self.assertGreater(
-                    len((line + payload + "\r\n").encode()),
+                    len(line + payload + "\r\n"),
                     512 - overhead,
-                    "Got ERR_INPUTTOOLONG for a message that should fit "
+                    "Got ERR_INPUTTOOLONG for a messag that should fit "
-                    "within 512 characters.",
+                    "withing 512 characters.",
                 )
                 continue
 
@@ -125,24 +113,11 @@ class BufferingTestCase(cases.BaseServerTestCase):
                     f"expected payload to be a prefix of {payload!r}, "
                     f"but got {payload!r}",
                 )
-            if self.controller.software_name == "Ergo":
-                self.assertTrue(
-                    payload_intact,
-                    f"Ergo should not truncate messages: {repr(line + payload)}, {repr(received_line)}",
-                )
 
     def get_overhead(self, client1, client2, colon):
-        """Compute the overhead added to client1's message:
+        self.sendLine(client1, f"PRIVMSG nick2 {colon}a\r\n")
-                          PRIVMSG nick2 a\r\n
-        :nick1!~user@host PRIVMSG nick2 :a\r\n
-        So typically client1's NUH length plus either 2 or 3 bytes
-        (the initial colon, the space between source and command, and possibly
-        a colon preceding the trailing).
-        """
-        outgoing = f"PRIVMSG nick2 {colon}a\r\n"
-        self.sendLine(client1, outgoing)
         line = self._getLine(client2)
-        return len(line) - len(outgoing.encode())
+        return len(line) - len(f"PRIVMSG nick2 {colon}a\r\n")
 
     def _getLine(self, client) -> bytes:
         line = b""

irctest/server_tests/cap.py

@@ -1,35 +1,9 @@
-"""
-`IRCv3 Capability negotiation
-<https://ircv3.net/specs/extensions/capability-negotiation>`_
-"""
-
 from irctest import cases
-from irctest.patma import ANYSTR, StrRe
+from irctest.patma import ANYSTR
 from irctest.runner import CapabilityNotSupported, ImplementationChoice
 
 
-class CapTestCase(cases.BaseServerTestCase):
+class CapTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
-    @cases.mark_specifications("IRCv3")
-    def testInvalidCapSubcommand(self):
-        """“If no capabilities are active, an empty parameter must be sent.”
-        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-list-subcommand>
-        """  # noqa
-        self.addClient()
-        self.sendLine(1, "CAP NOTACOMMAND")
-        self.sendLine(1, "PING test123")
-        m = self.getRegistrationMessage(1)
-        self.assertTrue(
-            self.messageDiffers(m, command="PONG", params=[ANYSTR, "test123"]),
-            "Sending “CAP NOTACOMMAND” as first message got no reply",
-        )
-        self.assertMessageMatch(
-            m,
-            command="410",
-            params=["*", "NOTACOMMAND", ANYSTR],
-            fail_msg="Sending “CAP NOTACOMMAND” as first message got a reply "
-            "that is not ERR_INVALIDCAPCMD: {msg}",
-        )
-
     @cases.mark_specifications("IRCv3")
     def testNoReq(self):
         """Test the server handles gracefully clients which do not send
@@ -44,206 +18,12 @@ class CapTestCase(cases.BaseServerTestCase):
         self.getCapLs(1)
         self.sendLine(1, "USER foo foo foo :foo")
         self.sendLine(1, "NICK foo")
-
-        # Make sure the server didn't send anything yet
-        self.sendLine(1, "CAP LS 302")
-        self.getCapLs(1)
-
         self.sendLine(1, "CAP END")
         m = self.getRegistrationMessage(1)
         self.assertMessageMatch(
             m, command="001", fail_msg="Expected 001 after sending CAP END, got {msg}."
         )
 
-    @cases.mark_specifications("IRCv3")
-    def testReqOne(self):
-        """Tests requesting a single capability"""
-        self.addClient(1)
-        self.sendLine(1, "CAP LS")
-        self.getCapLs(1)
-        self.sendLine(1, "USER foo foo foo :foo")
-        self.sendLine(1, "NICK foo")
-        self.sendLine(1, "CAP REQ :multi-prefix")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("multi-prefix ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP LIST")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "LIST", StrRe("multi-prefix ?")],
-            fail_msg="Expected CAP LIST after sending CAP LIST, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP END")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m, command="001", fail_msg="Expected 001 after sending CAP END, got {msg}."
-        )
-
-    @cases.mark_specifications("IRCv3")
-    @cases.xfailIfSoftware(
-        ["ngIRCd"],
-        "does not support userhost-in-names",
-    )
-    def testReqTwo(self):
-        """Tests requesting two capabilities at once"""
-        self.addClient(1)
-        self.sendLine(1, "CAP LS")
-        self.getCapLs(1)
-        self.sendLine(1, "USER foo foo foo :foo")
-        self.sendLine(1, "NICK foo")
-        self.sendLine(1, "CAP REQ :multi-prefix userhost-in-names")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("multi-prefix userhost-in-names ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP LIST")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[
-                ANYSTR,
-                "LIST",
-                StrRe(
-                    "(multi-prefix userhost-in-names|userhost-in-names multi-prefix) ?"
-                ),
-            ],
-            fail_msg="Expected CAP LIST after sending CAP LIST, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP END")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m, command="001", fail_msg="Expected 001 after sending CAP END, got {msg}."
-        )
-
-    @cases.mark_specifications("IRCv3")
-    @cases.xfailIfSoftware(
-        ["ngIRCd"],
-        "does not support userhost-in-names",
-    )
-    def testReqOneThenOne(self):
-        """Tests requesting two capabilities in different messages"""
-        self.addClient(1)
-        self.sendLine(1, "CAP LS")
-        self.getCapLs(1)
-        self.sendLine(1, "USER foo foo foo :foo")
-        self.sendLine(1, "NICK foo")
-
-        self.sendLine(1, "CAP REQ :multi-prefix")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("multi-prefix ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP REQ :userhost-in-names")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("userhost-in-names ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP LIST")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[
-                ANYSTR,
-                "LIST",
-                StrRe(
-                    "(multi-prefix userhost-in-names|userhost-in-names multi-prefix) ?"
-                ),
-            ],
-            fail_msg="Expected CAP LIST after sending CAP LIST, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP END")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m, command="001", fail_msg="Expected 001 after sending CAP END, got {msg}."
-        )
-
-    @cases.mark_specifications("IRCv3")
-    @cases.xfailIfSoftware(
-        ["ngIRCd"],
-        "does not support userhost-in-names",
-    )
-    def testReqPostRegistration(self):
-        """Tests requesting more capabilities after CAP END"""
-        self.addClient(1)
-        self.sendLine(1, "CAP LS")
-        self.getCapLs(1)
-        self.sendLine(1, "USER foo foo foo :foo")
-        self.sendLine(1, "NICK foo")
-
-        self.sendLine(1, "CAP REQ :multi-prefix")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("multi-prefix ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP LIST")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "LIST", StrRe("multi-prefix ?")],
-            fail_msg="Expected CAP LIST after sending CAP LIST, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP END")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m, command="001", fail_msg="Expected 001 after sending CAP END, got {msg}."
-        )
-
-        self.getMessages(1)
-
-        self.sendLine(1, "CAP REQ :userhost-in-names")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[ANYSTR, "ACK", StrRe("userhost-in-names ?")],
-            fail_msg="Expected CAP ACK after sending CAP REQ, got {msg}.",
-        )
-
-        self.sendLine(1, "CAP LIST")
-        m = self.getMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=[
-                ANYSTR,
-                "LIST",
-                StrRe(
-                    "(multi-prefix userhost-in-names|userhost-in-names multi-prefix) ?"
-                ),
-            ],
-            fail_msg="Expected CAP LIST after sending CAP LIST, got {msg}.",
-        )
-
     @cases.mark_specifications("IRCv3")
     def testReqUnavailable(self):
         """Test the server handles gracefully clients which request
@@ -260,7 +40,7 @@ class CapTestCase(cases.BaseServerTestCase):
         self.assertMessageMatch(
             m,
             command="CAP",
-            params=[ANYSTR, "NAK", StrRe("foo ?")],
+            params=[ANYSTR, "NAK", "foo"],
             fail_msg="Expected CAP NAK after requesting non-existing "
             "capability, got {msg}.",
         )
@@ -300,8 +80,7 @@ class CapTestCase(cases.BaseServerTestCase):
         """  # noqa
         self.addClient(1)
         self.sendLine(1, "CAP LS 302")
-        if "multi-prefix" not in self.getCapLs(1):
+        self.assertIn("multi-prefix", self.getCapLs(1))
-            raise CapabilityNotSupported("multi-prefix")
         self.sendLine(1, "CAP REQ :foo multi-prefix bar")
         m = self.getRegistrationMessage(1)
         self.assertMessageMatch(
@@ -335,7 +114,7 @@ class CapTestCase(cases.BaseServerTestCase):
         self.assertMessageMatch(
             m,
             command="CAP",
-            params=[ANYSTR, "ACK", StrRe("multi-prefix ?")],
+            params=[ANYSTR, "ACK", "multi-prefix"],
             fail_msg="Expected “CAP ACK :multi-prefix” after "
             "sending “CAP REQ :multi-prefix”, but got {msg}.",
         )
@@ -348,13 +127,8 @@ class CapTestCase(cases.BaseServerTestCase):
         self.addClient(1)
         self.connectClient("sender")
         self.sendLine(1, "CAP LS 302")
-        caps = set()
+        m = self.getRegistrationMessage(1)
-        while True:
+        if not ({cap1, cap2} <= set(m.params[2].split())):
-            m = self.getRegistrationMessage(1)
-            caps.update(m.params[-1].split())
-            if m.params[2] != "*":
-                break
-        if not ({cap1, cap2} <= caps):
             raise CapabilityNotSupported(f"{cap1} or {cap2}")
         self.sendLine(1, f"CAP REQ :{cap1} {cap2}")
         self.sendLine(1, "nick bar")
@@ -380,19 +154,17 @@ class CapTestCase(cases.BaseServerTestCase):
         m = self.getMessage(1)
         self.assertIn("time", m.tags, m)
 
-        # remove the multi-prefix cap
+        # remove the server-time cap
         self.sendLine(1, f"CAP REQ :-{cap2}")
         m = self.getMessage(1)
         # Must be either ACK or NAK
-        if self.messageDiffers(
+        if self.messageDiffers(m, command="CAP", params=[ANYSTR, "ACK", f"-{cap2}"]):
-            m, command="CAP", params=[ANYSTR, "ACK", StrRe(f"-{cap2} ?")]
-        ):
             self.assertMessageMatch(
-                m, command="CAP", params=[ANYSTR, "NAK", StrRe(f"-{cap2} ?")]
+                m, command="CAP", params=[ANYSTR, "NAK", f"-{cap2}"]
             )
             raise ImplementationChoice(f"Does not support CAP REQ -{cap2}")
 
-        # multi-prefix should be disabled
+        # server-time should be disabled
         self.sendLine(1, "CAP LIST")
         messages = self.getMessages(1)
         cap_list = [m for m in messages if m.command == "CAP"][0]
@@ -400,88 +172,3 @@ class CapTestCase(cases.BaseServerTestCase):
         enabled_caps.discard("cap-notify")  # implicitly added by some impls
         self.assertEqual(enabled_caps, {cap1})
         self.assertNotIn("time", cap_list.tags)
-
-    @cases.mark_specifications("IRCv3")
-    def testIrc301CapLs(self):
-        """
-        Current version:
-
-        "The LS subcommand is used to list the capabilities supported by the server.
-        The client should send an LS subcommand with no other arguments to solicit
-        a list of all capabilities."
-
-        "If a client has not indicated support for CAP LS 302 features,
-        the server MUST NOT send these new features to the client."
-        -- <https://ircv3.net/specs/core/capability-negotiation.html>
-
-        Before the v3.1 / v3.2 merge:
-
-        IRCv3.1: “The LS subcommand is used to list the capabilities
-        supported by the server. The client should send an LS subcommand with
-        no other arguments to solicit a list of all capabilities.”
-        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-ls-subcommand>
-
-        IRCv3.2: “Servers MUST NOT send messages described by this document if
-        the client only supports version 3.1.”
-        -- <http://ircv3.net/specs/core/capability-negotiation-3.2.html#version-in-cap-ls>
-        """  # noqa
-        self.addClient()
-        self.sendLine(1, "CAP LS")
-        m = self.getRegistrationMessage(1)
-        self.assertNotEqual(
-            m.params[2],
-            "*",
-            m,
-            fail_msg="Server replied with multi-line CAP LS to a "
-            "“CAP LS” (ie. IRCv3.1) request: {msg}",
-        )
-        self.assertFalse(
-            any("=" in cap for cap in m.params[2].split()),
-            "Server replied with a name-value capability in "
-            "CAP LS reply as a response to “CAP LS” (ie. IRCv3.1) "
-            "request: {}".format(m),
-        )
-
-    @cases.mark_specifications("IRCv3")
-    def testEmptyCapList(self):
-        """“If no capabilities are active, an empty parameter must be sent.”
-        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-list-subcommand>
-        """  # noqa
-        self.addClient()
-        self.sendLine(1, "CAP LIST")
-        m = self.getRegistrationMessage(1)
-        self.assertMessageMatch(
-            m,
-            command="CAP",
-            params=["*", "LIST", ""],
-            fail_msg="Sending “CAP LIST” as first message got a reply "
-            "that is not “CAP * LIST :”: {msg}",
-        )
-
-    @cases.mark_specifications("IRCv3")
-    def testNoMultiline301Response(self):
-        """
-        Current version: "If the client supports CAP version 302, the server MAY send
-        multiple lines in response to CAP LS and CAP LIST." This should be read as
-        disallowing multiline responses to pre-302 clients.
-        -- <https://ircv3.net/specs/extensions/capability-negotiation#multiline-replies-to-cap-ls-and-cap-list>
-        """  # noqa
-        self.check301ResponsePreRegistration("bar", "CAP LS")
-        self.check301ResponsePreRegistration("qux", "CAP LS 301")
-        self.check301ResponsePostRegistration("baz", "CAP LS")
-        self.check301ResponsePostRegistration("bat", "CAP LS 301")
-
-    def check301ResponsePreRegistration(self, nick, cap_ls):
-        self.addClient(nick)
-        self.sendLine(nick, cap_ls)
-        self.sendLine(nick, "NICK " + nick)
-        self.sendLine(nick, "USER u s e r")
-        self.sendLine(nick, "CAP END")
-        responses = [msg for msg in self.skipToWelcome(nick) if msg.command == "CAP"]
-        self.assertLessEqual(len(responses), 1, responses)
-
-    def check301ResponsePostRegistration(self, nick, cap_ls):
-        self.connectClient(nick, name=nick)
-        self.sendLine(nick, cap_ls)
-        responses = [msg for msg in self.getMessages(nick) if msg.command == "CAP"]
-        self.assertLessEqual(len(responses), 1, responses)

irctest/server_tests/channel.py

@@ -1,7 +1,3 @@
-"""
-Channel casemapping
-"""
-
 import pytest
 
 from irctest import cases, client_mock, runner
@@ -22,7 +18,7 @@ class ChannelCaseSensitivityTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
         self.connectClient("bar")
         if self.server_support["CASEMAPPING"] != casemapping:
-            raise runner.ImplementationChoice(
+            raise runner.NotImplementedByController(
                 "Casemapping {} not implemented".format(casemapping)
             )
         self.joinClient(1, name1)
@@ -47,7 +43,7 @@ class ChannelCaseSensitivityTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
         self.connectClient("bar")
         if self.server_support["CASEMAPPING"] != casemapping:
-            raise runner.ImplementationChoice(
+            raise runner.NotImplementedByController(
                 "Casemapping {} not implemented".format(casemapping)
             )
         self.joinClient(1, name1)

irctest/server_tests/channel_forward.py

@@ -1,9 +1,3 @@
-"""
-`Ergo <https://ergo.chat/>`_-specific tests of channel forwarding
-
-TODO: Should be extended to other servers, once a specification is written.
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_CHANOPRIVSNEEDED, ERR_INVALIDMODEPARAM, ERR_LINKCHANNEL
 

irctest/server_tests/channel_rename.py

@@ -1,22 +1,24 @@
-"""
-`Draft IRCv3 channel-rename <https://ircv3.net/specs/extensions/channel-rename>`_
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_CHANOPRIVSNEEDED
 
+MODERN_CAPS = [
+    "server-time",
+    "message-tags",
+    "batch",
+    "labeled-response",
+    "echo-message",
+    "account-tag",
+]
 RENAME_CAP = "draft/channel-rename"
 
 
-@cases.mark_specifications("IRCv3")
 class ChannelRenameTestCase(cases.BaseServerTestCase):
     """Basic tests for channel-rename."""
 
+    @cases.mark_specifications("Ergo")
     def testChannelRename(self):
-        self.connectClient(
+        self.connectClient("bar", name="bar", capabilities=MODERN_CAPS + [RENAME_CAP])
-            "bar", name="bar", capabilities=[RENAME_CAP], skip_if_cap_nak=True
+        self.connectClient("baz", name="baz", capabilities=MODERN_CAPS)
-        )
-        self.connectClient("baz", name="baz")
         self.joinChannel("bar", "#bar")
         self.joinChannel("baz", "#bar")
         self.getMessages("bar")

irctest/server_tests/chathistory.py

@@ -1,16 +1,11 @@
-"""
-`IRCv3 draft chathistory <https://ircv3.net/specs/extensions/chathistory>`_
-"""
-
-import functools
 import secrets
 import time
 
 import pytest
 
-from irctest import cases, runner
+from irctest import cases
 from irctest.irc_utils.junkdrawer import random_name
-from irctest.patma import ANYSTR, StrRe
+from irctest.patma import ANYSTR
 
 CHATHISTORY_CAP = "draft/chathistory"
 EVENT_PLAYBACK_CAP = "draft/event-playback"
@@ -21,54 +16,35 @@ SUBCOMMANDS = ["LATEST", "BEFORE", "AFTER", "BETWEEN", "AROUND"]
 MYSQL_PASSWORD = ""
 
 
-def skip_ngircd(f):
+def validate_chathistory_batch(msgs):
-    @functools.wraps(f)
+    batch_tag = None
-    def newf(self, *args, **kwargs):
+    closed_batch_tag = None
-        if self.controller.software_name == "ngIRCd":
+    result = []
-            raise runner.OptionalExtensionNotSupported("nicks longer 9 characters")
+    for msg in msgs:
-        return f(self, *args, **kwargs)
+        if msg.command == "BATCH":
-
+            batch_param = msg.params[0]
-    return newf
+            if batch_tag is None and batch_param[0] == "+":
+                batch_tag = batch_param[1:]
+            elif batch_param[0] == "-":
+                closed_batch_tag = batch_param[1:]
+        elif (
+            msg.command == "PRIVMSG"
+            and batch_tag is not None
+            and msg.tags.get("batch") == batch_tag
+        ):
+            if not msg.prefix.startswith("HistServ!"):  # FIXME: ergo-specific
+                result.append(msg.to_history_message())
+    assert batch_tag == closed_batch_tag
+    return result
 
 
 @cases.mark_specifications("IRCv3")
 @cases.mark_services
 class ChathistoryTestCase(cases.BaseServerTestCase):
-    def validate_chathistory_batch(self, msgs, target):
-        (start, *inner_msgs, end) = msgs
-
-        self.assertMessageMatch(
-            start, command="BATCH", params=[StrRe(r"\+.*"), "chathistory", target]
-        )
-        batch_tag = start.params[0][1:]
-        self.assertMessageMatch(end, command="BATCH", params=["-" + batch_tag])
-
-        result = []
-        for msg in inner_msgs:
-            if (
-                msg.command in ("PRIVMSG", "TOPIC")
-                and batch_tag is not None
-                and msg.tags.get("batch") == batch_tag
-            ):
-                if not msg.prefix.startswith("HistServ!"):  # FIXME: ergo-specific
-                    result.append(msg.to_history_message())
-        return result
-
     @staticmethod
     def config() -> cases.TestCaseControllerConfig:
         return cases.TestCaseControllerConfig(chathistory=True)
 
-    def _supports_msgid(self):
-        return "msgid" in self.server_support.get(
-            "MSGREFTYPES", "msgid,timestamp"
-        ).split(",")
-
-    def _supports_timestamp(self):
-        return "timestamp" in self.server_support.get(
-            "MSGREFTYPES", "msgid,timestamp"
-        ).split(",")
-
-    @skip_ngircd
     def testInvalidTargets(self):
         bar, pw = random_name("bar"), random_name("pw")
         self.controller.registerUser(self, bar, pw)
@@ -114,7 +90,6 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
         )
 
     @pytest.mark.private_chathistory
-    @skip_ngircd
     def testMessagesToSelf(self):
         bar, pw = random_name("bar"), random_name("pw")
         self.controller.registerUser(self, bar, pw)
@@ -187,19 +162,7 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
         self.assertEqual(len(set(msg.time for msg in echo_messages)), num_messages)
 
     @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
-    @skip_ngircd
     def testChathistory(self, subcommand):
-        if subcommand == "BETWEEN" and self.controller.software_name == "UnrealIRCd":
-            pytest.xfail(
-                "CHATHISTORY BETWEEN does not apply bounds correct "
-                "https://bugs.unrealircd.org/view.php?id=5952"
-            )
-        if subcommand == "AROUND" and self.controller.software_name == "UnrealIRCd":
-            pytest.xfail(
-                "CHATHISTORY AROUND excludes 'central' messages "
-                "https://bugs.unrealircd.org/view.php?id=5953"
-            )
-
         self.connectClient(
             "bar",
             capabilities=[
@@ -230,49 +193,7 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
         self.validate_echo_messages(NUM_MESSAGES, echo_messages)
         self.validate_chathistory(subcommand, echo_messages, 1, chname)
 
-    @skip_ngircd
-    def testChathistoryNoEventPlayback(self):
-        """Tests that non-messages don't appear in the chat history when event-playback
-        is not enabled."""
-
-        self.connectClient(
-            "bar",
-            capabilities=[
-                "message-tags",
-                "server-time",
-                "echo-message",
-                "batch",
-                "labeled-response",
-                "sasl",
-                CHATHISTORY_CAP,
-            ],
-            skip_if_cap_nak=True,
-        )
-        chname = "#chan" + secrets.token_hex(12)
-        self.joinChannel(1, chname)
-        self.getMessages(1)
-        self.getMessages(1)
-
-        NUM_MESSAGES = 10
-        echo_messages = []
-        for i in range(NUM_MESSAGES):
-            self.sendLine(1, "TOPIC %s :this is topic %d" % (chname, i))
-            self.getMessages(1)
-            self.sendLine(1, "PRIVMSG %s :this is message %d" % (chname, i))
-            echo_messages.extend(
-                msg.to_history_message() for msg in self.getMessages(1)
-            )
-            time.sleep(0.002)
-
-        self.validate_echo_messages(NUM_MESSAGES, echo_messages)
-        self.sendLine(1, "CHATHISTORY LATEST %s * 100" % chname)
-        (batch_open, *messages, batch_close) = self.getMessages(1)
-        self.assertMessageMatch(batch_open, command="BATCH")
-        self.assertMessageMatch(batch_close, command="BATCH")
-        self.assertEqual([msg for msg in messages if msg.command != "PRIVMSG"], [])
-
     @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
-    @skip_ngircd
     def testChathistoryEventPlayback(self, subcommand):
         self.connectClient(
             "bar",
@@ -295,27 +216,20 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
         NUM_MESSAGES = 10
         echo_messages = []
         for i in range(NUM_MESSAGES):
-            self.sendLine(1, "TOPIC %s :this is topic %d" % (chname, i))
-            echo_messages.extend(
-                msg.to_history_message() for msg in self.getMessages(1)
-            )
-            time.sleep(0.002)
-
             self.sendLine(1, "PRIVMSG %s :this is message %d" % (chname, i))
             echo_messages.extend(
                 msg.to_history_message() for msg in self.getMessages(1)
             )
             time.sleep(0.002)
 
-        self.validate_echo_messages(NUM_MESSAGES * 2, echo_messages)
+        self.validate_echo_messages(NUM_MESSAGES, echo_messages)
         self.validate_chathistory(subcommand, echo_messages, 1, chname)
 
     @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
     @pytest.mark.private_chathistory
-    @skip_ngircd
     def testChathistoryDMs(self, subcommand):
-        c1 = random_name("foo")
+        c1 = "foo" + secrets.token_hex(12)
-        c2 = random_name("bar")
+        c2 = "bar" + secrets.token_hex(12)
         self.controller.registerUser(self, c1, "sesame1")
         self.controller.registerUser(self, c2, "sesame2")
         self.connectClient(
@@ -363,14 +277,11 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
             )
             time.sleep(0.002)
 
-        self.getMessages(1)
-        self.getMessages(2)
-
         self.validate_echo_messages(NUM_MESSAGES, echo_messages)
         self.validate_chathistory(subcommand, echo_messages, 1, c2)
         self.validate_chathistory(subcommand, echo_messages, 2, c1)
 
-        c3 = random_name("baz")
+        c3 = "baz" + secrets.token_hex(12)
         self.connectClient(
             c3,
             capabilities=[
@@ -459,212 +370,188 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
     def _validate_chathistory_LATEST(self, echo_messages, user, chname):
         INCLUSIVE_LIMIT = len(echo_messages) * 2
         self.sendLine(user, "CHATHISTORY LATEST %s * %d" % (chname, INCLUSIVE_LIMIT))
-        result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
         self.assertEqual(echo_messages, result)
 
         self.sendLine(user, "CHATHISTORY LATEST %s * %d" % (chname, 5))
-        result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
         self.assertEqual(echo_messages[-5:], result)
 
         self.sendLine(user, "CHATHISTORY LATEST %s * %d" % (chname, 1))
-        result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
         self.assertEqual(echo_messages[-1:], result)
 
-        if self._supports_msgid():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY LATEST %s msgid=%s %d"
-                "CHATHISTORY LATEST %s msgid=%s %d"
+            % (chname, echo_messages[4].msgid, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[4].msgid, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[5:], result)
-            self.assertEqual(echo_messages[5:], result)
 
-        if self._supports_timestamp():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY LATEST %s timestamp=%s %d"
-                "CHATHISTORY LATEST %s timestamp=%s %d"
+            % (chname, echo_messages[4].time, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[4].time, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[5:], result)
-            self.assertEqual(echo_messages[5:], result)
 
     def _validate_chathistory_BEFORE(self, echo_messages, user, chname):
         INCLUSIVE_LIMIT = len(echo_messages) * 2
-        if self._supports_msgid():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY BEFORE %s msgid=%s %d"
-                "CHATHISTORY BEFORE %s msgid=%s %d"
+            % (chname, echo_messages[6].msgid, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[6].msgid, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[:6], result)
-            self.assertEqual(echo_messages[:6], result)
 
-        if self._supports_timestamp():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY BEFORE %s timestamp=%s %d"
-                "CHATHISTORY BEFORE %s timestamp=%s %d"
+            % (chname, echo_messages[6].time, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[6].time, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[:6], result)
-            self.assertEqual(echo_messages[:6], result)
 
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY BEFORE %s timestamp=%s %d"
+            "CHATHISTORY BEFORE %s timestamp=%s %d"
-                % (chname, echo_messages[6].time, 2),
+            % (chname, echo_messages[6].time, 2),
-            )
+        )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
-            self.assertEqual(echo_messages[4:6], result)
+        self.assertEqual(echo_messages[4:6], result)
 
     def _validate_chathistory_AFTER(self, echo_messages, user, chname):
         INCLUSIVE_LIMIT = len(echo_messages) * 2
-        if self._supports_msgid():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY AFTER %s msgid=%s %d"
-                "CHATHISTORY AFTER %s msgid=%s %d"
+            % (chname, echo_messages[3].msgid, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[3].msgid, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[4:], result)
-            self.assertEqual(echo_messages[4:], result)
 
-        if self._supports_timestamp():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY AFTER %s timestamp=%s %d"
-                "CHATHISTORY AFTER %s timestamp=%s %d"
+            % (chname, echo_messages[3].time, INCLUSIVE_LIMIT),
-                % (chname, echo_messages[3].time, INCLUSIVE_LIMIT),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[4:], result)
-            self.assertEqual(echo_messages[4:], result)
 
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY AFTER %s timestamp=%s %d"
+            "CHATHISTORY AFTER %s timestamp=%s %d" % (chname, echo_messages[3].time, 3),
-                % (chname, echo_messages[3].time, 3),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[4:7], result)
-            self.assertEqual(echo_messages[4:7], result)
 
     def _validate_chathistory_BETWEEN(self, echo_messages, user, chname):
         INCLUSIVE_LIMIT = len(echo_messages) * 2
-        if self._supports_msgid():
+        # BETWEEN forwards and backwards
-            # BETWEEN forwards and backwards
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
-                "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            % (
-                % (
+                chname,
-                    chname,
+                echo_messages[0].msgid,
-                    echo_messages[0].msgid,
+                echo_messages[-1].msgid,
-                    echo_messages[-1].msgid,
+                INCLUSIVE_LIMIT,
-                    INCLUSIVE_LIMIT,
+            ),
-                ),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[1:-1], result)
-            self.assertEqual(echo_messages[1:-1], result)
 
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
-                % (
+            % (
-                    chname,
+                chname,
-                    echo_messages[-1].msgid,
+                echo_messages[-1].msgid,
-                    echo_messages[0].msgid,
+                echo_messages[0].msgid,
-                    INCLUSIVE_LIMIT,
+                INCLUSIVE_LIMIT,
-                ),
+            ),
-            )
+        )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
-            self.assertEqual(echo_messages[1:-1], result)
+        self.assertEqual(echo_messages[1:-1], result)
 
-            # BETWEEN forwards and backwards with a limit, should get
+        # BETWEEN forwards and backwards with a limit, should get
-            # different results this time
+        # different results this time
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
-                % (chname, echo_messages[0].msgid, echo_messages[-1].msgid, 3),
+            % (chname, echo_messages[0].msgid, echo_messages[-1].msgid, 3),
-            )
+        )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
-            self.assertEqual(echo_messages[1:4], result)
+        self.assertEqual(echo_messages[1:4], result)
 
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
-                % (chname, echo_messages[-1].msgid, echo_messages[0].msgid, 3),
+            % (chname, echo_messages[-1].msgid, echo_messages[0].msgid, 3),
-            )
+        )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        result = validate_chathistory_batch(self.getMessages(user))
-            self.assertEqual(echo_messages[-4:-1], result)
+        self.assertEqual(echo_messages[-4:-1], result)
 
-        if self._supports_timestamp():
+        # same stuff again but with timestamps
-            # same stuff again but with timestamps
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
-                "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+            % (chname, echo_messages[0].time, echo_messages[-1].time, INCLUSIVE_LIMIT),
-                % (
+        )
-                    chname,
+        result = validate_chathistory_batch(self.getMessages(user))
-                    echo_messages[0].time,
+        self.assertEqual(echo_messages[1:-1], result)
-                    echo_messages[-1].time,
+        self.sendLine(
-                    INCLUSIVE_LIMIT,
+            user,
-                ),
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
-            )
+            % (chname, echo_messages[-1].time, echo_messages[0].time, INCLUSIVE_LIMIT),
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        )
-            self.assertEqual(echo_messages[1:-1], result)
+        result = validate_chathistory_batch(self.getMessages(user))
-            self.sendLine(
+        self.assertEqual(echo_messages[1:-1], result)
-                user,
+        self.sendLine(
-                "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+            user,
-                % (
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
-                    chname,
+            % (chname, echo_messages[0].time, echo_messages[-1].time, 3),
-                    echo_messages[-1].time,
+        )
-                    echo_messages[0].time,
+        result = validate_chathistory_batch(self.getMessages(user))
-                    INCLUSIVE_LIMIT,
+        self.assertEqual(echo_messages[1:4], result)
-                ),
+        self.sendLine(
-            )
+            user,
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
-            self.assertEqual(echo_messages[1:-1], result)
+            % (chname, echo_messages[-1].time, echo_messages[0].time, 3),
-            self.sendLine(
+        )
-                user,
+        result = validate_chathistory_batch(self.getMessages(user))
-                "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+        self.assertEqual(echo_messages[-4:-1], result)
-                % (chname, echo_messages[0].time, echo_messages[-1].time, 3),
-            )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
-            self.assertEqual(echo_messages[1:4], result)
-            self.sendLine(
-                user,
-                "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
-                % (chname, echo_messages[-1].time, echo_messages[0].time, 3),
-            )
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
-            self.assertEqual(echo_messages[-4:-1], result)
 
     def _validate_chathistory_AROUND(self, echo_messages, user, chname):
-        if self._supports_msgid():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY AROUND %s msgid=%s %d" % (chname, echo_messages[7].msgid, 1),
-                "CHATHISTORY AROUND %s msgid=%s %d"
+        )
-                % (chname, echo_messages[7].msgid, 1),
+        result = validate_chathistory_batch(self.getMessages(user))
-            )
+        self.assertEqual([echo_messages[7]], result)
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
-            self.assertEqual([echo_messages[7]], result)
 
-            self.sendLine(
+        self.sendLine(
-                user,
+            user,
-                "CHATHISTORY AROUND %s msgid=%s %d"
+            "CHATHISTORY AROUND %s msgid=%s %d" % (chname, echo_messages[7].msgid, 3),
-                % (chname, echo_messages[7].msgid, 3),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertEqual(echo_messages[6:9], result)
-            self.assertEqual(echo_messages[6:9], result)
 
-        if self._supports_timestamp():
+        self.sendLine(
-            self.sendLine(
+            user,
-                user,
+            "CHATHISTORY AROUND %s timestamp=%s %d"
-                "CHATHISTORY AROUND %s timestamp=%s %d"
+            % (chname, echo_messages[7].time, 3),
-                % (chname, echo_messages[7].time, 3),
+        )
-            )
+        result = validate_chathistory_batch(self.getMessages(user))
-            result = self.validate_chathistory_batch(self.getMessages(user), chname)
+        self.assertIn(echo_messages[7], result)
-            self.assertIn(echo_messages[7], result)
 
     @pytest.mark.arbitrary_client_tags
-    @skip_ngircd
     def testChathistoryTagmsg(self):
-        c1 = random_name("foo")
+        c1 = "foo" + secrets.token_hex(12)
-        c2 = random_name("bar")
+        c2 = "bar" + secrets.token_hex(12)
         chname = "#chan" + secrets.token_hex(12)
         self.controller.registerUser(self, c1, "sesame1")
         self.controller.registerUser(self, c2, "sesame2")
@@ -760,11 +647,10 @@ class ChathistoryTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.arbitrary_client_tags
     @pytest.mark.private_chathistory
-    @skip_ngircd
     def testChathistoryDMClientOnlyTags(self):
         # regression test for Ergo #1411
-        c1 = random_name("foo")
+        c1 = "foo" + secrets.token_hex(12)
-        c2 = random_name("bar")
+        c2 = "bar" + secrets.token_hex(12)
         self.controller.registerUser(self, c1, "sesame1")
         self.controller.registerUser(self, c2, "sesame2")
         self.connectClient(

irctest/server_tests/chmodes/auditorium.py

@@ -1,9 +1,3 @@
-"""
-`Ergo <https://ergo.chat/>`_-specific tests of auditorium mode
-
-TODO: Should be extended to other servers, once a specification is written.
-"""
-
 import math
 import time
 

irctest/server_tests/chmodes/ban.py

@@ -1,24 +1,12 @@
-"""
+from irctest import cases
-Channel ban (`RFC 1459
+from irctest.numerics import ERR_BANNEDFROMCHAN, RPL_BANLIST, RPL_ENDOFBANLIST
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.3.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.3>`__,
-`Modern <https://modern.ircdocs.horse/#ban-channel-mode>`__)
-and ban exception (`Modern <https://modern.ircdocs.horse/#exception-channel-mode>`__)
-"""
-
-from irctest import cases, runner
-from irctest.numerics import (
-    ERR_BANNEDFROMCHAN,
-    ERR_CANNOTSENDTOCHAN,
-    RPL_BANLIST,
-    RPL_ENDOFBANLIST,
-)
 from irctest.patma import ANYSTR, StrRe
 
 
 class BanModeTestCase(cases.BaseServerTestCase):
     @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testBanJoin(self):
+    def testBan(self):
+        """Basic ban operation"""
         self.connectClient("chanop", name="chanop")
         self.joinChannel("chanop", "#chan")
         self.getMessages("chanop")
@@ -36,58 +24,9 @@ class BanModeTestCase(cases.BaseServerTestCase):
         self.sendLine("bar", "JOIN #chan")
         self.assertMessageMatch(self.getMessage("bar"), command="JOIN")
 
-    @cases.mark_specifications("Modern")
-    def testBanPrivmsg(self):
-        """
-        TODO: this checks the following quote is false:
-
-        "If `<target>` is a channel name and the client is [banned](#ban-channel-mode)
-        and not covered by a [ban exception](#ban-exception-channel-mode), the
-        message will not be delivered and the command will silently fail."
-        -- https://modern.ircdocs.horse/#privmsg-message
-
-        to check https://github.com/ircdocs/modern-irc/pull/201
-        """
-        self.connectClient("chanop", name="chanop")
-        self.joinChannel("chanop", "#chan")
-        self.getMessages("chanop")
-
-        self.connectClient("Bar", name="bar")
-        self.getMessages("bar")
-        self.sendLine("bar", "JOIN #chan")
-        self.getMessages("bar")
-        self.getMessages("chanop")
-
-        self.sendLine("chanop", "MODE #chan +b bar!*@*")
-        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
-        self.getMessages("chanop")
-        self.getMessages("bar")
-
-        self.sendLine("bar", "PRIVMSG #chan :hello world")
-        self.assertMessageMatch(
-            self.getMessage("bar"),
-            command=ERR_CANNOTSENDTOCHAN,
-            params=["Bar", "#chan", ANYSTR],
-        )
-        self.assertEqual(self.getMessages("bar"), [])
-        self.assertEqual(self.getMessages("chanop"), [])
-
-        self.sendLine("chanop", "MODE #chan -b bar!*@*")
-        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
-        self.getMessages("chanop")
-        self.getMessages("bar")
-
-        self.sendLine("bar", "PRIVMSG #chan :hello again")
-        self.assertEqual(self.getMessages("bar"), [])
-        self.assertMessageMatch(
-            self.getMessage("chanop"),
-            command="PRIVMSG",
-            params=["#chan", "hello again"],
-        )
-
     @cases.mark_specifications("Modern")
     def testBanList(self):
-        """`RPL_BANLIST <https://modern.ircdocs.horse/#rplbanlist-367>`_"""
+        """https://github.com/ircdocs/modern-irc/pull/125"""
         self.connectClient("chanop")
         self.joinChannel(1, "#chan")
         self.getMessages(1)
@@ -131,65 +70,6 @@ class BanModeTestCase(cases.BaseServerTestCase):
             ],
         )
 
-    @cases.mark_specifications("Modern")
-    def testBanException(self):
-        """`Exception mode <https://modern.ircdocs.horse/#exception-channel-mode`_,
-        detected using `ISUPPORT EXCEPTS
-        <https://modern.ircdocs.horse/#excepts-parameter>`_ and checked against
-        `ISUPPORT CHANMODES <https://modern.ircdocs.horse/#chanmodes-parameter>`_"""
-        self.connectClient("chanop", name="chanop")
-
-        if "EXCEPTS" in self.server_support:
-            mode = self.server_support["EXCEPTS"] or "e"
-            if "CHANMODES" in self.server_support:
-                self.assertIn(
-                    mode,
-                    self.server_support["CHANMODES"],
-                    fail_msg="ISUPPORT EXCEPTS is present, but '{item}' is missing "
-                    "from 'CHANMODES={list}'",
-                )
-                self.assertIn(
-                    mode,
-                    self.server_support["CHANMODES"].split(",")[0],
-                    fail_msg="ISUPPORT EXCEPTS is present, but '{item}' is not "
-                    "in group A",
-                )
-        else:
-            mode = "e"
-            if "CHANMODES" in self.server_support:
-                if "e" not in self.server_support["CHANMODES"]:
-                    raise runner.OptionalExtensionNotSupported(
-                        "Ban exception (or mode letter is not +e)"
-                    )
-                self.assertIn(
-                    mode,
-                    self.server_support["CHANMODES"].split(",")[0],
-                    fail_msg="Mode +e (assumed to be ban exception) is present, "
-                    "but 'e' is not in group A",
-                )
-            else:
-                raise runner.OptionalExtensionNotSupported("ISUPPORT CHANMODES")
-
-        self.sendLine("chanop", "JOIN #chan")
-        self.getMessages("chanop")
-        self.sendLine("chanop", "MODE #chan +b ba*!*@*")
-        self.getMessages("chanop")
-
-        # banned client cannot join
-        self.connectClient("Bar", name="bar")
-        self.sendLine("bar", "JOIN #chan")
-        self.assertMessageMatch(self.getMessage("bar"), command=ERR_BANNEDFROMCHAN)
-
-        # chanop sets exception
-        self.sendLine("chanop", "MODE #chan +e *ar!*@*")
-        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
-
-        # client can now join
-        self.sendLine("bar", "JOIN #chan")
-        self.assertMessageMatch(self.getMessage("bar"), command="JOIN")
-
-    # TODO: Add testBanExceptionList, once the numerics are specified in Modern
-
     @cases.mark_specifications("Ergo")
     def testCaseInsensitive(self):
         """Some clients allow unsetting modes if their argument matches

irctest/server_tests/chmodes/ergo.py

@@ -1,7 +1,3 @@
-"""
-Various Ergo-specific channel modes
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_CANNOTSENDTOCHAN, ERR_CHANOPRIVSNEEDED
 

irctest/server_tests/chmodes/key.py

@@ -1,10 +1,3 @@
-"""
-Channel key (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.3.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.3>`__,
-`Modern <https://modern.ircdocs.horse/#key-channel-mode>`__)
-"""
-
 import pytest
 
 from irctest import cases
@@ -27,16 +20,10 @@ class KeyTestCase(cases.BaseServerTestCase):
 
         self.connectClient("qux")
         self.getMessages(2)
-        # JOIN with a missing key MUST receive ERR_BADCHANNELKEY:
         self.sendLine(2, "JOIN #chan")
-        reply_cmds = {msg.command for msg in self.getMessages(2)}
+        reply = self.getMessages(2)
-        self.assertNotIn("JOIN", reply_cmds)
+        self.assertNotIn("JOIN", {msg.command for msg in reply})
-        self.assertIn(ERR_BADCHANNELKEY, reply_cmds)
+        self.assertIn(ERR_BADCHANNELKEY, {msg.command for msg in reply})
-        # similarly for JOIN with an incorrect key:
-        self.sendLine(2, "JOIN #chan bees")
-        reply_cmds = {msg.command for msg in self.getMessages(2)}
-        self.assertNotIn("JOIN", reply_cmds)
-        self.assertIn(ERR_BADCHANNELKEY, reply_cmds)
 
         self.sendLine(2, "JOIN #chan beer")
         reply = self.getMessages(2)
@@ -44,8 +31,8 @@ class KeyTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.parametrize(
         "key",
-        ["passphrase with spaces", "long" * 100, "", " "],
+        ["passphrase with spaces", "long" * 100, ""],
-        ids=["spaces", "long", "empty", "only-space"],
+        ids=["spaces", "long", "empty"],
     )
     @cases.mark_specifications("RFC2812", "Modern")
     def testKeyValidation(self, key):
@@ -70,23 +57,6 @@ class KeyTestCase(cases.BaseServerTestCase):
         -- https://modern.ircdocs.horse/#key-channel-mode
         -- https://github.com/ircdocs/modern-irc/pull/111
         """
-        if key == "" and self.controller.software_name in (
-            "ircu2",
-            "Nefarious",
-            "snircd",
-        ):
-            pytest.xfail(
-                "ircu2 returns ERR_NEEDMOREPARAMS on empty keys: "
-                "https://github.com/UndernetIRC/ircu2/issues/13"
-            )
-        if (key == "" or " " in key) and self.controller.software_name == "ngIRCd":
-            pytest.xfail(
-                "ngIRCd does not validate channel keys: "
-                "https://github.com/ngircd/ngircd/issues/290"
-            )
-        if key == " " and self.controller.software_name == "irc2":
-            pytest.xfail("irc2 rewrites non-empty keys that contain only spaces")
-
         self.connectClient("bar")
         self.joinChannel(1, "#chan")
         self.sendLine(1, f"MODE #chan +k :{key}")

irctest/server_tests/chmodes/moderated.py

@@ -1,9 +1,3 @@
-"""
-Channel moderation mode (`RFC 2812
-<https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.3>`__,
-`Modern <https://modern.ircdocs.horse/#ban-channel-mode>`__)
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_CANNOTSENDTOCHAN
 

irctest/server_tests/chmodes/mute_extban.py

@@ -1,7 +1,3 @@
-"""
-Mute extban, currently no specifications or ways to discover it.
-"""
-
 from irctest import cases, runner
 from irctest.numerics import ERR_CANNOTSENDTOCHAN, ERR_CHANOPRIVSNEEDED
 from irctest.patma import ANYLIST, StrRe
@@ -198,7 +194,7 @@ class MuteExtbanTestCase(cases.BaseServerTestCase):
             self.getMessages(client)
 
         # +e grants an exemption to +b
-        self.sendLine("chanop", f"MODE #chan +e {prefix}{self.char()}:*!*evan@*")
+        self.sendLine("chanop", f"MODE #chan +e {prefix}{self.char()}:*!~evan@*")
         replies = {msg.command for msg in self.getMessages("chanop")}
         self.assertIn("MODE", replies)
         self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)

irctest/server_tests/chmodes/no_ctcp.py

@@ -1,31 +0,0 @@
-from irctest import cases
-from irctest.numerics import ERR_CANNOTSENDTOCHAN
-
-
-class NoCTCPChannelModeTestCase(cases.BaseServerTestCase):
-    @cases.mark_specifications("Ergo")
-    def testNoCTCPChannelMode(self):
-        """Test Ergo's +C channel mode that blocks CTCPs."""
-        self.connectClient("bar")
-        self.joinChannel(1, "#chan")
-        self.sendLine(1, "MODE #chan +C")
-        self.getMessages(1)
-
-        self.connectClient("qux")
-        self.joinChannel(2, "#chan")
-        self.getMessages(2)
-
-        self.sendLine(1, "PRIVMSG #chan :\x01ACTION hi\x01")
-        self.getMessages(1)
-        ms = self.getMessages(2)
-        self.assertEqual(len(ms), 1)
-        self.assertMessageMatch(
-            ms[0], command="PRIVMSG", params=["#chan", "\x01ACTION hi\x01"]
-        )
-
-        self.sendLine(1, "PRIVMSG #chan :\x01PING 1473523796 918320\x01")
-        ms = self.getMessages(1)
-        self.assertEqual(len(ms), 1)
-        self.assertMessageMatch(ms[0], command=ERR_CANNOTSENDTOCHAN)
-        ms = self.getMessages(2)
-        self.assertEqual(ms, [])

irctest/server_tests/chmodes/no_external.py

@@ -1,38 +0,0 @@
-"""
-Channel "no external messages" mode (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.3.1>`__,
-`Modern <https://modern.ircdocs.horse/#no-external-messages-mode>`__)
-"""
-
-from irctest import cases
-from irctest.numerics import ERR_CANNOTSENDTOCHAN
-
-
-class NoExternalMessagesTestCase(cases.BaseServerTestCase):
-    @cases.mark_specifications("RFC1459", "Modern")
-    def testNoExternalMessagesMode(self):
-        # test the +n channel mode
-        self.connectClient("chanop", name="chanop")
-        self.joinChannel("chanop", "#chan")
-        self.sendLine("chanop", "MODE #chan +n")
-        self.getMessages("chanop")
-
-        self.connectClient("baz", name="baz")
-        # this message should be suppressed completely by +n
-        self.sendLine("baz", "PRIVMSG #chan :hi from baz")
-        replies = self.getMessages("baz")
-        reply_cmds = {reply.command for reply in replies}
-        self.assertIn(ERR_CANNOTSENDTOCHAN, reply_cmds)
-        self.assertEqual(self.getMessages("chanop"), [])
-
-        # set the channel to -n: baz should be able to send now
-        self.sendLine("chanop", "MODE #chan -n")
-        replies = self.getMessages("chanop")
-        modeLines = [line for line in replies if line.command == "MODE"]
-        self.assertMessageMatch(modeLines[0], command="MODE", params=["#chan", "-n"])
-        self.sendLine("baz", "PRIVMSG #chan :hi again from baz")
-        self.getMessages("baz")
-        relays = self.getMessages("chanop")
-        self.assertMessageMatch(
-            relays[0], command="PRIVMSG", params=["#chan", "hi again from baz"]
-        )

irctest/server_tests/chmodes/noctcp.py

@@ -0,0 +1,69 @@
+from irctest import cases, runner
+from irctest.numerics import ERR_CANNOTSENDTOCHAN
+from irctest.patma import ANYSTR
+
+
+class NoctcpModeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Modern")
+    def testNoctcpMode(self):
+        """
+        "This mode is used in almost all IRC software today. The standard mode letter
+        used for it is `"+C"`.
+        When this mode is set, should not send [CTCP](/ctcp.html) messages, except
+        CTCP Action (also known as `/me`) to the channel.
+        When blocking a message because of this mode, servers SHOULD use
+        ERR_CANNOTSENDTOCHAN"
+        -- TODO add link
+        """
+        self.connectClient("chanop")
+
+        if "C" not in self.server_support.get("CHANMODES", ""):
+            raise runner.NotImplementedByController("+C (noctcp) channel mode")
+
+        # Both users join:
+
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)  # synchronize
+
+        self.connectClient("user")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(2)
+        self.getMessages(1)
+
+        # Send ACTION and PING, both should go through:
+
+        self.sendLine(2, "PRIVMSG #chan :\x01ACTION is testing\x01")
+        self.sendLine(2, "PRIVMSG #chan :\x01PING 12345\x01")
+        self.assertEqual(self.getMessages(2), [])
+
+        self.assertEqual(
+            [(m.command, m.params[1]) for m in self.getMessages(1)],
+            [
+                ("PRIVMSG", "\x01ACTION is testing\x01"),
+                ("PRIVMSG", "\x01PING 12345\x01"),
+            ],
+        )
+
+        # Set mode +C:
+
+        self.sendLine(1, "MODE #chan +C")
+        self.getMessages(1)
+        self.getMessages(2)
+
+        # Send ACTION and PING, only ACTION should go through:
+
+        self.sendLine(2, "PRIVMSG #chan :\x01ACTION is testing\x01")
+        self.assertEqual(self.getMessages(2), [])
+        self.sendLine(2, "PRIVMSG #chan :\x01PING 12345\x01")
+        self.assertMessageMatch(
+            self.getMessage(2),
+            command=ERR_CANNOTSENDTOCHAN,
+            params=["user", "#chan", ANYSTR],
+        )
+
+        self.assertEqual(
+            [(m.command, m.params[1]) for m in self.getMessages(1)],
+            [
+                ("PRIVMSG", "\x01ACTION is testing\x01"),
+            ],
+        )

irctest/server_tests/chmodes/secret.py

@@ -1,10 +1,3 @@
-"""
-Channel secrecy mode (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.3.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.3>`__,
-`Modern <https://modern.ircdocs.horse/#secret-channel-mode>`__)
-"""
-
 from irctest import cases
 from irctest.numerics import RPL_LIST
 

irctest/server_tests/confusables.py

@@ -1,8 +1,3 @@
-"""
-`Ergo <https://ergo.chat/>`_-specific tests for nick collisions based on Unicode
-confusable characters
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_NICKNAMEINUSE, RPL_WELCOME
 
@@ -12,8 +7,8 @@ class ConfusablesTestCase(cases.BaseServerTestCase):
     @staticmethod
     def config() -> cases.TestCaseControllerConfig:
         return cases.TestCaseControllerConfig(
-            ergo_config=lambda config: config["server"].update(
+            ergo_config=lambda config: config["accounts"].update(
-                {"casemapping": "precis"},
+                {"nick-reservation": {"enabled": True, "method": "strict"}}
             )
         )
 

irctest/server_tests/connection_registration.py

@@ -1,16 +1,12 @@
 """
 Tests section 4.1 of RFC 1459.
 <https://tools.ietf.org/html/rfc1459#section-4.1>
-
-TODO: cross-reference Modern and RFC 2812 too
 """
 
-import time
-
 from irctest import cases
 from irctest.client_mock import ConnectionClosed
-from irctest.numerics import ERR_NEEDMOREPARAMS, ERR_PASSWDMISMATCH
+from irctest.numerics import ERR_NEEDMOREPARAMS
-from irctest.patma import ANYLIST, ANYSTR, OptStrRe, StrRe
+from irctest.patma import ANYSTR, StrRe
 
 
 class PasswordedConnectionRegistrationTestCase(cases.BaseServerTestCase):
@@ -40,14 +36,8 @@ class PasswordedConnectionRegistrationTestCase(cases.BaseServerTestCase):
             m.command, "001", msg="Got 001 after NICK+USER but missing PASS"
         )
 
-    @cases.mark_specifications("Modern")
+    @cases.mark_specifications("RFC1459", "RFC2812")
     def testWrongPassword(self):
-        """
-        "If the password supplied does not match the password expected by the server,
-        then the server SHOULD send ERR_PASSWDMISMATCH and MUST close the connection
-        with ERROR."
-        -- https://github.com/ircdocs/modern-irc/pull/172
-        """
         self.addClient()
         self.sendLine(1, "PASS {}".format(self.password + "garbage"))
         self.sendLine(1, "NICK foo")
@@ -56,13 +46,6 @@ class PasswordedConnectionRegistrationTestCase(cases.BaseServerTestCase):
         self.assertNotEqual(
             m.command, "001", msg="Got 001 after NICK+USER but incorrect PASS"
         )
-        self.assertIn(m.command, {ERR_PASSWDMISMATCH, "ERROR"})
-
-        if m.command == "ERR_PASSWDMISMATCH":
-            m = self.getRegistrationMessage(1)
-            self.assertEqual(
-                m.command, "ERROR", msg="ERR_PASSWDMISMATCH not followed by ERROR."
-            )
 
     @cases.mark_specifications("RFC1459", "RFC2812", strict=True)
     def testPassAfterNickuser(self):
@@ -85,92 +68,6 @@ class PasswordedConnectionRegistrationTestCase(cases.BaseServerTestCase):
 
 
 class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
-    def testConnectionRegistration(self):
-        self.addClient()
-        self.sendLine(1, "NICK foo")
-        self.sendLine(1, "USER foo * * :foo")
-
-        for numeric in ("001", "002", "003"):
-            self.assertMessageMatch(
-                self.getRegistrationMessage(1),
-                command=numeric,
-                params=["foo", ANYSTR],
-            )
-
-        self.assertMessageMatch(
-            self.getRegistrationMessage(1),
-            command="004",  # RPL_MYINFO
-            params=[
-                "foo",
-                "My.Little.Server",
-                ANYSTR,  # version
-                StrRe("[a-zA-Z]+"),  # user modes
-                StrRe("[a-zA-Z]+"),  # channel modes
-                OptStrRe("[a-zA-Z]+"),  # channel modes with parameter
-            ],
-        )
-
-        # ISUPPORT
-        m = self.getRegistrationMessage(1)
-        while True:
-            self.assertMessageMatch(
-                m,
-                command="005",
-                params=["foo", *ANYLIST],
-            )
-            m = self.getRegistrationMessage(1)
-            if m.command != "005":
-                break
-
-        if m.command in ("042", "396"):  # RPL_YOURID / RPL_VISIBLEHOST, non-standard
-            m = self.getRegistrationMessage(1)
-
-        # LUSERS
-        while m.command in ("250", "251", "252", "253", "254", "255", "265", "266"):
-            m = self.getRegistrationMessage(1)
-
-        if m.command == "375":  # RPL_MOTDSTART
-            self.assertMessageMatch(
-                m,
-                command="375",
-                params=["foo", ANYSTR],
-            )
-            while (m := self.getRegistrationMessage(1)).command == "372":
-                self.assertMessageMatch(
-                    m,
-                    command="372",  # RPL_MOTD
-                    params=["foo", ANYSTR],
-                )
-            self.assertMessageMatch(
-                m,
-                command="376",  # RPL_ENDOFMOTD
-                params=["foo", ANYSTR],
-            )
-        else:
-            self.assertMessageMatch(
-                m,
-                command="422",  # ERR_NOMOTD
-                params=["foo", ANYSTR],
-            )
-
-        # User mode
-        if m.command == "MODE":
-            self.assertMessageMatch(
-                m,
-                command="MODE",
-                params=["foo", ANYSTR, *ANYLIST],
-            )
-            m = self.getRegistrationMessage(1)
-        elif m.command == "221":  # RPL_UMODEIS
-            self.assertMessageMatch(
-                m,
-                command="221",
-                params=["foo", ANYSTR, *ANYLIST],
-            )
-            m = self.getRegistrationMessage(1)
-        else:
-            print("Warning: missing MODE")
-
     @cases.mark_specifications("RFC1459")
     def testQuitDisconnects(self):
         """“The server must close the connection to a client which sends a
@@ -185,10 +82,6 @@ class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
             self.getMessages(1)
 
     @cases.mark_specifications("RFC2812")
-    @cases.xfailIfSoftware(["Charybdis", "Solanum"], "very flaky")
-    @cases.xfailIfSoftware(
-        ["ircu2", "Nefarious", "snircd"], "ircu2 does not send ERROR"
-    )
     def testQuitErrors(self):
         """“A client session is terminated with a quit message.  The server
         acknowledges this by sending an ERROR message to the client.”
@@ -221,7 +114,7 @@ class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
         self.assertNotEqual(
             m.command,
             "001",
-            "Received 001 after registering with the nick of a registered user.",
+            "Received 001 after registering with the nick of a " "registered user.",
         )
 
     def testEarlyNickCollision(self):
@@ -269,10 +162,6 @@ class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
             "neither got 001.",
         )
 
-    @cases.xfailIfSoftware(
-        ["ircu2", "Nefarious", "ngIRCd"],
-        "uses a default value instead of ERR_NEEDMOREPARAMS",
-    )
     def testEmptyRealname(self):
         """
         Syntax:
@@ -295,57 +184,59 @@ class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
             params=[StrRe(r"(\*|foo)"), "USER", ANYSTR],
         )
 
-    def testNonutf8Realname(self):
+    @cases.mark_specifications("IRCv3")
-        self.addClient()
+    def testIrc301CapLs(self):
-        self.sendLine(1, "NICK foo")
+        """
-        line = b"USER username * * :i\xe8rc\xe9\r\n"
+        Current version:
-        print("1 -> S (repr): " + repr(line))
-        self.clients[1].conn.sendall(line)
-        for _ in range(10):
-            time.sleep(1)
-            d = self.clients[1].conn.recv(10000)
-            self.assertTrue(d, "Server closed connection")
-            print("S -> 1 (repr): " + repr(d))
-            if b" 001 " in d:
-                break
-            if b"ERROR " in d or b" FAIL " in d:
-                # Rejected; nothing more to test.
-                return
-            for line in d.split(b"\r\n"):
-                if line.startswith(b"PING "):
-                    line = line.replace(b"PING", b"PONG") + b"\r\n"
-                    print("1 -> S (repr): " + repr(line))
-                    self.clients[1].conn.sendall(line)
-        else:
-            self.assertTrue(False, "stuck waiting")
-        self.sendLine(1, "WHOIS foo")
-        time.sleep(3)  # for ngIRCd
-        d = self.clients[1].conn.recv(10000)
-        print("S -> 1 (repr): " + repr(d))
-        self.assertIn(b"username", d)
 
-    def testNonutf8Username(self):
+        "The LS subcommand is used to list the capabilities supported by the server.
+        The client should send an LS subcommand with no other arguments to solicit
+        a list of all capabilities."
+
+        "If a client has not indicated support for CAP LS 302 features,
+        the server MUST NOT send these new features to the client."
+        -- <https://ircv3.net/specs/core/capability-negotiation.html>
+
+        Before the v3.1 / v3.2 merge:
+
+        IRCv3.1: “The LS subcommand is used to list the capabilities
+        supported by the server. The client should send an LS subcommand with
+        no other arguments to solicit a list of all capabilities.”
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-ls-subcommand>
+
+        IRCv3.2: “Servers MUST NOT send messages described by this document if
+        the client only supports version 3.1.”
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.2.html#version-in-cap-ls>
+        """  # noqa
         self.addClient()
-        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "CAP LS")
-        self.sendLine(1, "USER 😊😊😊😊😊😊😊😊😊😊 * * :realname")
+        m = self.getRegistrationMessage(1)
-        for _ in range(10):
+        self.assertNotEqual(
-            time.sleep(1)
+            m.params[2],
-            d = self.clients[1].conn.recv(10000)
+            "*",
-            self.assertTrue(d, "Server closed connection")
+            m,
-            print("S -> 1 (repr): " + repr(d))
+            fail_msg="Server replied with multi-line CAP LS to a "
-            if b" 001 " in d:
+            "“CAP LS” (ie. IRCv3.1) request: {msg}",
-                break
+        )
-            if b" 468" in d or b"ERROR " in d:
+        self.assertFalse(
-                # Rejected; nothing more to test.
+            any("=" in cap for cap in m.params[2].split()),
-                return
+            "Server replied with a name-value capability in "
-            for line in d.split(b"\r\n"):
+            "CAP LS reply as a response to “CAP LS” (ie. IRCv3.1) "
-                if line.startswith(b"PING "):
+            "request: {}".format(m),
-                    line = line.replace(b"PING", b"PONG") + b"\r\n"
+        )
-                    print("1 -> S (repr): " + repr(line))
+
-                    self.clients[1].conn.sendall(line)
+    @cases.mark_specifications("IRCv3")
-        else:
+    def testEmptyCapList(self):
-            self.assertTrue(False, "stuck waiting")
+        """“If no capabilities are active, an empty parameter must be sent.”
-        self.sendLine(1, "WHOIS foo")
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-list-subcommand>
-        d = self.clients[1].conn.recv(10000)
+        """  # noqa
-        print("S -> 1 (repr): " + repr(d))
+        self.addClient()
-        self.assertIn(b"realname", d)
+        self.sendLine(1, "CAP LIST")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=["*", "LIST", ""],
+            fail_msg="Sending “CAP LIST” as first message got a reply "
+            "that is not “CAP * LIST :”: {msg}",
+        )

irctest/server_tests/echo_message.py

@@ -1,10 +1,11 @@
 """
-`IRCv3 echo-message <https://ircv3.net/specs/extensions/echo-message>`_
+<http://ircv3.net/specs/extensions/echo-message-3.2.html>
 """
 
 import pytest
 
 from irctest import cases
+from irctest.basecontrollers import NotImplementedByController
 from irctest.irc_utils.junkdrawer import random_name
 from irctest.patma import ANYDICT
 
@@ -22,20 +23,36 @@ class EchoMessageTestCase(cases.BaseServerTestCase):
     @cases.mark_capabilities("echo-message")
     def testEchoMessage(self, command, solo, server_time):
         """<http://ircv3.net/specs/extensions/echo-message-3.2.html>"""
-        capabilities = ["server-time"] if server_time else []
+        self.addClient()
+        self.sendLine(1, "CAP LS 302")
+        capabilities = self.getCapLs(1)
+        if "echo-message" not in capabilities:
+            raise NotImplementedByController("echo-message")
+        if server_time and "server-time" not in capabilities:
+            raise NotImplementedByController("server-time")
 
-        self.connectClient(
+        # TODO: check also without this
-            "baz",
+        self.sendLine(
-            capabilities=["echo-message", *capabilities],
+            1,
-            skip_if_cap_nak=True,
+            "CAP REQ :echo-message{}".format(" server-time" if server_time else ""),
         )
+        self.getRegistrationMessage(1)
+        # TODO: Remove this one the trailing space issue is fixed in Charybdis
+        # and Mammon:
+        # self.assertMessageMatch(m, command='CAP',
+        #        params=['*', 'ACK', 'echo-message'] +
+        #        (['server-time'] if server_time else []),
+        #        fail_msg='Did not ACK advertised capabilities: {msg}')
+        self.sendLine(1, "USER f * * :foo")
+        self.sendLine(1, "NICK baz")
+        self.sendLine(1, "CAP END")
+        self.skipToWelcome(1)
+        self.getMessages(1)
 
         self.sendLine(1, "JOIN #chan")
 
-        # Synchronize
-        self.getMessages(1)
-
         if not solo:
+            capabilities = ["server-time"] if server_time else None
             self.connectClient("qux", capabilities=capabilities)
             self.sendLine(2, "JOIN #chan")
 

irctest/server_tests/ergo/services.py

@@ -1,7 +1,3 @@
-"""
-`Ergo <https://ergo.chat/>`-specific tests of NickServ.
-"""
-
 from irctest import cases
 from irctest.numerics import RPL_YOUREOPER
 

irctest/server_tests/extended_join.py

@@ -1,12 +1,12 @@
 """
-`IRCv3 extended-join <https://ircv3.net/specs/extensions/extended-join>`_
+<http://ircv3.net/specs/extensions/extended-join-3.1.html>
 """
 
 from irctest import cases
 
 
 @cases.mark_services
-class MetadataTestCase(cases.BaseServerTestCase):
+class MetadataTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     def connectRegisteredClient(self, nick):
         self.addClient()
         self.sendLine(2, "CAP LS 302")
@@ -50,7 +50,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         )
 
     @cases.mark_capabilities("extended-join")
-    @cases.skipUnlessHasMechanism("PLAIN")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
     def testLoggedIn(self):
         self.connectClient("foo", capabilities=["extended-join"], skip_if_cap_nak=True)
         self.joinChannel(1, "#chan")

irctest/server_tests/help.py

@@ -1,8 +1,7 @@
 """
-The HELP and HELPOP command (`Modern <https://modern.ircdocs.horse/#help-message>`__)
+The HELP and HELPOP command.
 """
 
-import functools
 import re
 
 import pytest
@@ -18,30 +17,6 @@ from irctest.numerics import (
 from irctest.patma import ANYSTR, StrRe
 
 
-def with_xfails(f):
-    @functools.wraps(f)
-    def newf(self, command, *args, **kwargs):
-        if command == "HELP" and self.controller.software_name == "Bahamut":
-            raise runner.ImplementationChoice(
-                "fail because Bahamut forwards /HELP to HelpServ (but not /HELPOP)"
-            )
-
-        if self.controller.software_name in ("irc2", "ircu2", "ngIRCd"):
-            raise runner.ImplementationChoice(
-                "numerics in reply to /HELP and /HELPOP (uses NOTICE instead)"
-            )
-
-        if self.controller.software_name == "UnrealIRCd":
-            raise runner.ImplementationChoice(
-                "fails because Unreal uses custom numerics "
-                "https://github.com/unrealircd/unrealircd/pull/184"
-            )
-
-        return f(self, command, *args, **kwargs)
-
-    return newf
-
-
 class HelpTestCase(cases.BaseServerTestCase):
     def _assertValidHelp(self, messages, subject):
         if subject != ANYSTR:
@@ -71,7 +46,6 @@ class HelpTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.parametrize("command", ["HELP", "HELPOP"])
     @cases.mark_specifications("Modern")
-    @with_xfails
     def testHelpNoArg(self, command):
         self.connectClient("nick")
         self.sendLine(1, f"{command}")
@@ -85,7 +59,6 @@ class HelpTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.parametrize("command", ["HELP", "HELPOP"])
     @cases.mark_specifications("Modern")
-    @with_xfails
     def testHelpPrivmsg(self, command):
         self.connectClient("nick")
         self.sendLine(1, f"{command} PRIVMSG")
@@ -98,7 +71,6 @@ class HelpTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.parametrize("command", ["HELP", "HELPOP"])
     @cases.mark_specifications("Modern")
-    @with_xfails
     def testHelpUnknownSubject(self, command):
         self.connectClient("nick")
         self.sendLine(1, f"{command} THISISNOTACOMMAND")

irctest/server_tests/info.py

@@ -1,8 +1,5 @@
 """
-The INFO command  (`RFC 1459
+The INFO command.
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.3.8>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.4.10>`__,
-`Modern <https://modern.ircdocs.horse/#info-message>`__)
 """
 
 import pytest
@@ -87,9 +84,6 @@ class InfoTestCase(cases.BaseServerTestCase):
 
     @pytest.mark.parametrize("target", ["invalid.server.example", "invalidserver"])
     @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True)
-    @cases.xfailIfSoftware(
-        ["Ergo"], "does not apply to Ergo, which ignores the optional <target> argument"
-    )
     def testInfoNosuchserver(self, target):
         """
         <https://datatracker.ietf.org/doc/html/rfc1459#section-4.3.8>

irctest/server_tests/invite.py

@@ -1,18 +1,10 @@
-"""
-The INVITE command  (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.7>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.7>`__,
-`Modern <https://modern.ircdocs.horse/#invite-message>`__)
-"""
-
 import pytest
 
-from irctest import cases, runner
+from irctest import cases
 from irctest.numerics import (
     ERR_BANNEDFROMCHAN,
     ERR_CHANOPRIVSNEEDED,
     ERR_INVITEONLYCHAN,
-    ERR_NEEDMOREPARAMS,
     ERR_NOSUCHNICK,
     ERR_NOTONCHANNEL,
     ERR_USERONCHANNEL,
@@ -201,9 +193,6 @@ class InviteTestCase(cases.BaseServerTestCase):
         self._testInvite(opped=True, invite_only=invite_only)
 
     @cases.mark_specifications("RFC1459", "RFC2812", "Modern", strict=True)
-    @cases.xfailIfSoftware(
-        ["Hybrid", "Plexus4"], "the only strict test that Hybrid fails"
-    )
     def testInviteUnopped(self):
         """Tests invites from unopped users on not-invite-only chans."""
         self._testInvite(opped=False, invite_only=False)
@@ -241,11 +230,6 @@ class InviteTestCase(cases.BaseServerTestCase):
         )
 
     @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    @cases.xfailIfSoftware(
-        ["Plexus4"],
-        "Plexus4 allows non-op to invite if (and only if) the channel is not "
-        "invite-only",
-    )
     def testInviteInviteOnly(self):
         """
         "To invite a user to a channel which is invite only (MODE
@@ -360,8 +344,8 @@ class InviteTestCase(cases.BaseServerTestCase):
         self.getMessages(2)
 
         self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)
         self.sendLine(2, "JOIN #chan")
+        self.getMessages(1)
         self.getMessages(2)
         self.getMessages(1)
 
@@ -373,87 +357,6 @@ class InviteTestCase(cases.BaseServerTestCase):
             params=["foo", "bar", "#chan", ANYSTR],
         )
 
-    @cases.mark_specifications("RFC2812", "Modern")
-    @cases.xfailIfSoftware(
-        ["ircu2"],
-        "Uses 346/347 instead of 336/337 to reply to INVITE "
-        "https://github.com/UndernetIRC/ircu2/pull/20",
-    )
-    def testInviteList(self):
-        self.connectClient("foo")
-        self.connectClient("bar")
-        self.getMessages(1)
-        self.getMessages(2)
-
-        self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)
-
-        self.sendLine(1, "INVITE bar #chan")
-        self.getMessages(1)
-        self.getMessages(2)
-
-        self.sendLine(2, "INVITE")
-        m = self.getMessage(2)
-        if m.command == ERR_NEEDMOREPARAMS:
-            raise runner.OptionalExtensionNotSupported("INVITE with no parameter")
-        if m.command != "337":
-            # Hybrid always sends an empty list; so skip this.
-            self.assertMessageMatch(
-                m,
-                command="336",
-                params=["bar", "#chan"],
-            )
-            m = self.getMessage(2)
-        self.assertMessageMatch(
-            m,
-            command="337",
-            params=["bar", ANYSTR],
-        )
-
-    @cases.mark_isupport("INVEX")
-    @cases.mark_specifications("Modern")
-    def testInvexList(self):
-        self.connectClient("foo")
-        self.getMessages(1)
-
-        if "INVEX" in self.server_support:
-            invex = self.server_support.get("INVEX") or "I"
-        else:
-            raise runner.IsupportTokenNotSupported("INVEX")
-
-        self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)
-
-        self.sendLine(1, f"MODE #chan +{invex} bar!*@*")
-        self.getMessages(1)
-
-        self.sendLine(1, f"MODE #chan +{invex}")
-        m = self.getMessage(1)
-        if len(m.params) == 3:
-            # Old format
-            self.assertMessageMatch(
-                m,
-                command="346",
-                params=["foo", "#chan", "bar!*@*"],
-            )
-        else:
-            self.assertMessageMatch(
-                m,
-                command="346",
-                params=[
-                    "foo",
-                    "#chan",
-                    "bar!*@*",
-                    StrRe("foo(!.*@.*)?"),
-                    StrRe("[0-9]+"),
-                ],
-            )
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="347",
-            params=["foo", "#chan", ANYSTR],
-        )
-
     @cases.mark_specifications("Ergo")
     def testInviteExemptsFromBan(self):
         # regression test for ergochat/ergo#1876;

irctest/server_tests/isupport.py

@@ -1,46 +1,9 @@
-"""
-RPL_ISUPPORT: `format <https://modern.ircdocs.horse/#rplisupport-005>`__
-and various `tokens <https://modern.ircdocs.horse/#rplisupport-parameters>`__
-"""
-
 import re
 
 from irctest import cases, runner
 
 
 class IsupportTestCase(cases.BaseServerTestCase):
-    @cases.mark_specifications("Modern")
-    @cases.mark_isupport("PREFIX")
-    def testParameters(self):
-        """https://modern.ircdocs.horse/#rplisupport-005"""
-
-        # <https://modern.ircdocs.horse/#connection-registration>
-        # "Upon successful completion of the registration process,
-        #  the server MUST send, in this order:
-        #  [...]
-        #  5. at least one RPL_ISUPPORT (005) numeric to the client."
-        welcome_005s = [
-            msg for msg in self.connectClient("foo") if msg.command == "005"
-        ]
-        self.assertGreaterEqual(len(welcome_005s), 1)
-        for msg in welcome_005s:
-            # first parameter is the client's nickname;
-            # last parameter is a human-readable trailing, typically
-            # "are supported by this server"
-            self.assertGreaterEqual(len(msg.params), 3)
-            self.assertEqual(msg.params[0], "foo")
-            # "As the maximum number of message parameters to any reply is 15,
-            # the maximum number of RPL_ISUPPORT tokens that can be advertised
-            # is 13."
-            self.assertLessEqual(len(msg.params), 15)
-            for param in msg.params[1:-1]:
-                self.validateIsupportParam(param)
-
-    def validateIsupportParam(self, param):
-        if not param.isascii():
-            raise ValueError("Invalid non-ASCII 005 parameter", param)
-        # TODO add more validation
-
     @cases.mark_specifications("Modern")
     @cases.mark_isupport("PREFIX")
     def testPrefix(self):
@@ -48,7 +11,7 @@ class IsupportTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
 
         if "PREFIX" not in self.server_support:
-            raise runner.IsupportTokenNotSupported("PREFIX")
+            raise runner.NotImplementedByController("PREFIX")
 
         if self.server_support["PREFIX"] == "":
             # "The value is OPTIONAL and when it is not specified indicates that no
@@ -56,8 +19,7 @@ class IsupportTestCase(cases.BaseServerTestCase):
             return
 
         m = re.match(
-            r"^\((?P<modes>[a-zA-Z]+)\)(?P<prefixes>\S+)$",
+            r"\((?P<modes>[a-zA-Z]+)\)(?P<prefixes>\S+)", self.server_support["PREFIX"]
-            self.server_support["PREFIX"],
         )
         self.assertTrue(
             m,
@@ -113,10 +75,10 @@ class IsupportTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
 
         if "TARGMAX" not in self.server_support:
-            raise runner.IsupportTokenNotSupported("TARGMAX")
+            raise runner.NotImplementedByController("TARGMAX")
 
         parts = self.server_support["TARGMAX"].split(",")
         for part in parts:
             self.assertTrue(
-                re.match("^[A-Z]+:[0-9]*$", part), "Invalid TARGMAX key:value: %r", part
+                re.match("[A-Z]+:[0-9]*", part), "Invalid TARGMAX key:value: %r", part
             )

irctest/server_tests/join.py

@@ -1,29 +1,5 @@
-"""
+from irctest import cases
-The JOIN command  (`RFC 1459
+from irctest.irc_utils import ambiguities
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.1>`__,
-`Modern <https://modern.ircdocs.horse/#join-message>`__)
-"""
-
-from irctest import cases, runner
-from irctest.numerics import (
-    ERR_BADCHANMASK,
-    ERR_FORBIDDENCHANNEL,
-    ERR_NOSUCHCHANNEL,
-    RPL_ENDOFNAMES,
-    RPL_NAMREPLY,
-)
-from irctest.patma import ANYSTR, StrRe
-
-ERR_BADCHANNAME = "479"  # Hybrid only, and conflicts with others
-
-
-JOIN_ERROR_NUMERICS = {
-    ERR_BADCHANMASK,
-    ERR_NOSUCHCHANNEL,
-    ERR_FORBIDDENCHANNEL,
-    ERR_BADCHANNAME,
-}
 
 
 class JoinTestCase(cases.BaseServerTestCase):
@@ -43,24 +19,14 @@ class JoinTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
         self.sendLine(1, "JOIN #chan")
         received_commands = {m.command for m in self.getMessages(1)}
-        expected_commands = {RPL_NAMREPLY, RPL_ENDOFNAMES, "JOIN"}
+        expected_commands = {"353", "366"}  # RPL_NAMREPLY  # RPL_ENDOFNAMES
-        acceptable_commands = expected_commands | {"MODE"}
+        self.assertTrue(
-        self.assertLessEqual(  # set inclusion
+            expected_commands.issubset(received_commands),
-            expected_commands,
-            received_commands,
             "Server sent {} commands, but at least {} were expected.".format(
                 received_commands, expected_commands
             ),
         )
-        self.assertLessEqual(  # ditto
-            received_commands,
-            acceptable_commands,
-            "Server sent {} commands, but only {} were expected.".format(
-                received_commands, acceptable_commands
-            ),
-        )
 
-    @cases.xfailIfSoftware(["Bahamut", "irc2"], "trailing space on RPL_NAMREPLY")
     @cases.mark_specifications("RFC2812")
     def testJoinNamreply(self):
         """“353    RPL_NAMREPLY
@@ -75,23 +41,33 @@ class JoinTestCase(cases.BaseServerTestCase):
 
         for m in self.getMessages(1):
             if m.command == "353":
-                self.assertMessageMatch(
+                self.assertIn(
-                    m, params=["foo", StrRe(r"[=\*@]"), "#chan", StrRe("[@+]?foo")]
+                    len(m.params),
-                )
+                    (3, 4),
-
-        self.connectClient("bar")
-        self.sendLine(2, "JOIN #chan")
-
-        for m in self.getMessages(2):
-            if m.command == "353":
-                self.assertMessageMatch(
                     m,
-                    params=[
+                    fail_msg="RPL_NAM_REPLY with number of arguments "
-                        "bar",
+                    "<3 or >4: {msg}",
-                        StrRe(r"[=\*@]"),
+                )
-                        "#chan",
+                params = ambiguities.normalize_namreply_params(m.params)
-                        StrRe("([@+]?foo bar|bar [@+]?foo)"),
+                self.assertIn(
-                    ],
+                    params[1],
+                    "=*@",
+                    m,
+                    fail_msg="Bad channel prefix: {item} not in {list}: {msg}",
+                )
+                self.assertEqual(
+                    params[2],
+                    "#chan",
+                    m,
+                    fail_msg="Bad channel name: {got} instead of " "{expects}: {msg}",
+                )
+                self.assertIn(
+                    params[3],
+                    {"foo", "@foo", "+foo"},
+                    m,
+                    fail_msg="Bad user list: should contain only user "
+                    '"foo" with an optional "+" or "@" prefix, but got: '
+                    "{msg}",
                 )
 
     def testJoinTwice(self):
@@ -105,173 +81,32 @@ class JoinTestCase(cases.BaseServerTestCase):
         # if the join is successful, or has an error among the given set.
         for m in self.getMessages(1):
             if m.command == "353":
-                self.assertMessageMatch(
+                self.assertIn(
-                    m, params=["foo", StrRe(r"[=\*@]"), "#chan", StrRe("[@+]?foo")]
+                    len(m.params),
+                    (3, 4),
+                    m,
+                    fail_msg="RPL_NAM_REPLY with number of arguments "
+                    "<3 or >4: {msg}",
+                )
+                params = ambiguities.normalize_namreply_params(m.params)
+                self.assertIn(
+                    params[1],
+                    "=*@",
+                    m,
+                    fail_msg="Bad channel prefix: {item} not in {list}: {msg}",
+                )
+                self.assertEqual(
+                    params[2],
+                    "#chan",
+                    m,
+                    fail_msg="Bad channel name: {got} instead of " "{expects}: {msg}",
+                )
+                self.assertIn(
+                    params[3],
+                    {"foo", "@foo", "+foo"},
+                    m,
+                    fail_msg='Bad user list after user "foo" joined twice '
+                    "the same channel: should contain only user "
+                    '"foo" with an optional "+" or "@" prefix, but got: '
+                    "{msg}",
                 )
-
-    def testJoinPartiallyInvalid(self):
-        """TODO: specify this in Modern"""
-        self.connectClient("foo")
-        if int(self.targmax.get("JOIN") or "4") < 2:
-            raise runner.OptionalExtensionNotSupported("multi-channel JOIN")
-
-        self.sendLine(1, "JOIN #valid,inv@lid")
-        messages = self.getMessages(1)
-        received_commands = {m.command for m in messages}
-        expected_commands = {RPL_NAMREPLY, RPL_ENDOFNAMES, "JOIN"}
-        acceptable_commands = expected_commands | JOIN_ERROR_NUMERICS | {"MODE"}
-        self.assertLessEqual(
-            expected_commands,
-            received_commands,
-            "Server sent {} commands, but at least {} were expected.".format(
-                received_commands, expected_commands
-            ),
-        )
-        self.assertLessEqual(
-            received_commands,
-            acceptable_commands,
-            "Server sent {} commands, but only {} were expected.".format(
-                received_commands, acceptable_commands
-            ),
-        )
-
-        nb_errors = 0
-        for m in messages:
-            if m.command in JOIN_ERROR_NUMERICS:
-                nb_errors += 1
-                self.assertMessageMatch(m, params=["foo", "inv@lid", ANYSTR])
-
-        self.assertEqual(
-            nb_errors,
-            1,
-            fail_msg="Expected 1 error when joining channels '#valid' and 'inv@lid', "
-            "got {got}",
-        )
-
-    @cases.mark_capabilities("batch", "labeled-response")
-    def testJoinPartiallyInvalidLabeledResponse(self):
-        """TODO: specify this in Modern"""
-        self.connectClient(
-            "foo", capabilities=["batch", "labeled-response"], skip_if_cap_nak=True
-        )
-        if int(self.targmax.get("JOIN") or "4") < 2:
-            raise runner.OptionalExtensionNotSupported("multi-channel JOIN")
-
-        self.sendLine(1, "@label=label1 JOIN #valid,inv@lid")
-        messages = self.getMessages(1)
-
-        first_msg = messages.pop(0)
-        last_msg = messages.pop(-1)
-        self.assertMessageMatch(
-            first_msg, command="BATCH", params=[StrRe(r"\+.*"), "labeled-response"]
-        )
-        batch_id = first_msg.params[0][1:]
-        self.assertMessageMatch(last_msg, command="BATCH", params=["-" + batch_id])
-
-        received_commands = {m.command for m in messages}
-        expected_commands = {RPL_NAMREPLY, RPL_ENDOFNAMES, "JOIN"}
-        acceptable_commands = expected_commands | JOIN_ERROR_NUMERICS | {"MODE"}
-        self.assertLessEqual(
-            expected_commands,
-            received_commands,
-            "Server sent {} commands, but at least {} were expected.".format(
-                received_commands, expected_commands
-            ),
-        )
-        self.assertLessEqual(
-            received_commands,
-            acceptable_commands,
-            "Server sent {} commands, but only {} were expected.".format(
-                received_commands, acceptable_commands
-            ),
-        )
-
-        nb_errors = 0
-        for m in messages:
-            self.assertIn("batch", m.tags)
-            self.assertEqual(m.tags["batch"], batch_id)
-            if m.command in JOIN_ERROR_NUMERICS:
-                nb_errors += 1
-                self.assertMessageMatch(m, params=["foo", "inv@lid", ANYSTR])
-
-        self.assertEqual(
-            nb_errors,
-            1,
-            fail_msg="Expected 1 error when joining channels '#valid' and 'inv@lid', "
-            "got {got}",
-        )
-
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testJoinKey(self):
-        """Joins a single channel with a key"""
-        self.connectClient("chanop")
-        self.joinChannel(1, "#chan")
-        self.sendLine(1, "MODE #chan +k key")
-        self.getMessages(1)
-
-        self.connectClient("joiner")
-        self.sendLine(2, "JOIN #chan key")
-        self.assertMessageMatch(
-            self.getMessage(2),
-            command="JOIN",
-            params=["#chan"],
-        )
-
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testJoinKeys(self):
-        """Joins two channels, both with keys"""
-        self.connectClient("chanop")
-        if self.targmax.get("JOIN", "1000") == "1":
-            raise runner.OptionalExtensionNotSupported("Multi-target JOIN")
-        self.joinChannel(1, "#chan1")
-        self.sendLine(1, "MODE #chan1 +k key1")
-        self.getMessages(1)
-        self.joinChannel(1, "#chan2")
-        self.sendLine(1, "MODE #chan2 +k key2")
-        self.getMessages(1)
-
-        self.connectClient("joiner")
-        self.sendLine(2, "JOIN #chan1,#chan2 key1,key2")
-        self.assertMessageMatch(
-            self.getMessage(2),
-            command="JOIN",
-            params=["#chan1"],
-        )
-        self.assertMessageMatch(
-            [
-                msg
-                for msg in self.getMessages(2)
-                if msg.command not in {RPL_NAMREPLY, RPL_ENDOFNAMES}
-            ][0],
-            command="JOIN",
-            params=["#chan2"],
-        )
-
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testJoinManySingleKey(self):
-        """Joins two channels, the first one has a key."""
-        self.connectClient("chanop")
-        if self.targmax.get("JOIN", "1000") == "1":
-            raise runner.OptionalExtensionNotSupported("Multi-target JOIN")
-        self.joinChannel(1, "#chan1")
-        self.sendLine(1, "MODE #chan1 +k key1")
-        self.getMessages(1)
-        self.joinChannel(1, "#chan2")
-        self.getMessages(1)
-
-        self.connectClient("joiner")
-        self.sendLine(2, "JOIN #chan1,#chan2 key1")
-        self.assertMessageMatch(
-            self.getMessage(2),
-            command="JOIN",
-            params=["#chan1"],
-        )
-        self.assertMessageMatch(
-            [
-                msg
-                for msg in self.getMessages(2)
-                if msg.command not in {RPL_NAMREPLY, RPL_ENDOFNAMES}
-            ][0],
-            command="JOIN",
-            params=["#chan2"],
-        )

irctest/server_tests/kick.py

@@ -1,10 +1,3 @@
-"""
-The KICK command  (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.>`__,
-`Modern <https://modern.ircdocs.horse/#kick-message>`__)
-"""
-
 import pytest
 
 from irctest import cases, client_mock, runner
@@ -96,10 +89,6 @@ class KickTestCase(cases.BaseServerTestCase):
             self.assertMessageMatch(m3, command="KICK", params=["#chan", "bar", ANYSTR])
 
     @cases.mark_specifications("RFC2812")
-    @cases.xfailIfSoftware(
-        ["Charybdis", "ircu2", "irc2", "Solanum"],
-        "uses the nick of the kickee rather than the kicker.",
-    )
     def testKickDefaultComment(self):
         """
         "If a "comment" is
@@ -230,8 +219,13 @@ class KickTestCase(cases.BaseServerTestCase):
         self.connectClient("qux")
         self.joinChannel(4, "#chan")
 
-        if self.targmax.get("KICK", "1") == "1":
+        targmax = dict(
-            raise runner.OptionalExtensionNotSupported("Multi-target KICK")
+            item.split(":", 1)
+            for item in self.server_support.get("TARGMAX", "").split(",")
+            if item
+        )
+        if targmax.get("KICK", "1") == "1":
+            raise runner.NotImplementedByController("Multi-target KICK")
 
         # TODO: check foo is an operator
 

irctest/server_tests/labeled_responses.py

@@ -1,8 +1,8 @@
 """
-`IRCv3 labeled-response <https://ircv3.net/specs/extensions/labeled-response>`_
-
 This specification is a little hard to test because all labels are optional;
 so there may be many false positives.
+
+<https://ircv3.net/specs/extensions/labeled-response.html>
 """
 
 import re
@@ -12,10 +12,9 @@ import pytest
 from irctest import cases
 from irctest.numerics import ERR_UNKNOWNCOMMAND
 from irctest.patma import ANYDICT, ANYOPTSTR, NotStrRe, RemainingKeys, StrRe
-from irctest.runner import OptionalExtensionNotSupported
 
 
-class LabeledResponsesTestCase(cases.BaseServerTestCase):
+class LabeledResponsesTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     @cases.mark_capabilities("echo-message", "batch", "labeled-response")
     def testLabeledPrivmsgResponsesToMultipleClients(self):
         self.connectClient(
@@ -23,10 +22,7 @@ class LabeledResponsesTestCase(cases.BaseServerTestCase):
             capabilities=["echo-message", "batch", "labeled-response"],
             skip_if_cap_nak=True,
         )
-        if int(self.targmax.get("PRIVMSG", "1") or "4") < 3:
-            raise OptionalExtensionNotSupported("PRIVMSG to multiple targets")
         self.getMessages(1)
-
         self.connectClient(
             "bar",
             capabilities=["echo-message", "batch", "labeled-response"],

irctest/server_tests/links.py

@@ -1,136 +0,0 @@
-from irctest import cases, runner
-from irctest.numerics import ERR_UNKNOWNCOMMAND, RPL_ENDOFLINKS, RPL_LINKS
-from irctest.patma import ANYSTR, StrRe
-
-
-class LinksTestCase(cases.BaseServerTestCase):
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testLinksSingleServer(self):
-        """
-        Only testing the parameter-less case.
-
-        https://datatracker.ietf.org/doc/html/rfc1459#section-4.3.3
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.4.5
-        https://github.com/ircdocs/modern-irc/pull/175
-
-        "
-        364     RPL_LINKS
-                        "<mask> <server> :<hopcount> <server info>"
-        365     RPL_ENDOFLINKS
-                        "<mask> :End of /LINKS list"
-
-                - In replying to the LINKS message, a server must send
-                  replies back using the RPL_LINKS numeric and mark the
-                  end of the list using an RPL_ENDOFLINKS reply.
-        "
-        -- https://datatracker.ietf.org/doc/html/rfc1459#page-51
-        -- https://datatracker.ietf.org/doc/html/rfc2812#page-48
-
-        RPL_LINKS: "<client> * <server> :<hopcount> <server info>"
-        RPL_ENDOFLINKS: "<client> * :End of /LINKS list"
-        -- https://github.com/ircdocs/modern-irc/pull/175/files
-        """
-        self.connectClient("nick")
-        self.sendLine(1, "LINKS")
-        messages = self.getMessages(1)
-        if messages[0].command == ERR_UNKNOWNCOMMAND:
-            raise runner.OptionalCommandNotSupported("LINKS")
-
-        # Ignore '/LINKS has been disabled' from ircu2
-        messages = [m for m in messages if m.command != "NOTICE"]
-
-        self.assertMessageMatch(
-            messages.pop(-1),
-            command=RPL_ENDOFLINKS,
-            params=["nick", "*", ANYSTR],
-        )
-
-        if not messages:
-            # This server probably redacts links
-            return
-
-        self.assertMessageMatch(
-            messages[0],
-            command=RPL_LINKS,
-            params=[
-                "nick",
-                "My.Little.Server",
-                "My.Little.Server",
-                StrRe("0 (0042 )?test server"),
-            ],
-        )
-
-
-@cases.mark_services
-class ServicesLinksTestCase(cases.BaseServerTestCase):
-    # On every IRCd but Ergo, services are linked.
-    # Ergo does not implement LINKS at all, so this test is skipped.
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testLinksWithServices(self):
-        """
-        Only testing the parameter-less case.
-
-        https://datatracker.ietf.org/doc/html/rfc1459#section-4.3.3
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.4.5
-
-        "
-        364     RPL_LINKS
-                        "<mask> <server> :<hopcount> <server info>"
-        365     RPL_ENDOFLINKS
-                        "<mask> :End of /LINKS list"
-
-                - In replying to the LINKS message, a server must send
-                  replies back using the RPL_LINKS numeric and mark the
-                  end of the list using an RPL_ENDOFLINKS reply.
-        "
-        -- https://datatracker.ietf.org/doc/html/rfc1459#page-51
-        -- https://datatracker.ietf.org/doc/html/rfc2812#page-48
-
-        RPL_LINKS: "<client> * <server> :<hopcount> <server info>"
-        RPL_ENDOFLINKS: "<client> * :End of /LINKS list"
-        -- https://github.com/ircdocs/modern-irc/pull/175/files
-        """
-        self.connectClient("nick")
-        self.sendLine(1, "LINKS")
-        messages = self.getMessages(1)
-
-        if messages[0].command == ERR_UNKNOWNCOMMAND:
-            raise runner.OptionalCommandNotSupported("LINKS")
-
-        # Ignore '/LINKS has been disabled' from ircu2
-        messages = [m for m in messages if m.command != "NOTICE"]
-
-        self.assertMessageMatch(
-            messages.pop(-1),
-            command=RPL_ENDOFLINKS,
-            params=["nick", "*", ANYSTR],
-        )
-
-        if not messages:
-            # This server redacts links
-            return
-
-        messages.sort(key=lambda m: m.params[-1])
-
-        self.assertMessageMatch(
-            messages.pop(0),
-            command=RPL_LINKS,
-            params=[
-                "nick",
-                "My.Little.Server",
-                "My.Little.Server",
-                StrRe("0 (0042 )?test server"),
-            ],
-        )
-        self.assertMessageMatch(
-            messages.pop(0),
-            command=RPL_LINKS,
-            params=[
-                "nick",
-                "services.example.org",
-                "My.Little.Server",
-                StrRe("1 .+"),  # SID instead of description for Anope...
-            ],
-        )
-
-        self.assertEqual(messages, [])

irctest/server_tests/list.py

@@ -1,71 +1,40 @@
-"""
+from irctest import cases
-The LIST command  (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.6>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.6>`__,
-`Modern <https://modern.ircdocs.horse/#list-message>`__)
-"""
-
-import time
-
-from irctest import cases, runner
-from irctest.numerics import RPL_LIST, RPL_LISTEND, RPL_LISTSTART
 
 
-class _BasedListTestCase(cases.BaseServerTestCase):
+class ListTestCase(cases.BaseServerTestCase):
-    def _parseChanList(self, client):
-        channels = set()
-        while True:
-            m = self.getMessage(client)
-            if m.command == RPL_LISTEND:
-                break
-            if m.command == RPL_LIST:
-                if m.params[1].startswith("&"):
-                    # skip local pseudo-channels listed by ngircd and ircu
-                    continue
-                channels.add(m.params[1])
-
-        return channels
-
-
-class ListTestCase(_BasedListTestCase):
     @cases.mark_specifications("RFC1459", "RFC2812")
-    @cases.xfailIfSoftware(["irc2"], "irc2 deprecated LIST")
     def testListEmpty(self):
         """<https://tools.ietf.org/html/rfc1459#section-4.2.6>
         <https://tools.ietf.org/html/rfc2812#section-3.2.6>
-        <https://modern.ircdocs.horse/#list-message>
         """
         self.connectClient("foo")
         self.connectClient("bar")
         self.getMessages(1)
         self.sendLine(2, "LIST")
         m = self.getMessage(2)
-        if m.command == RPL_LISTSTART:
+        if m.command == "321":
-            # skip
+            # skip RPL_LISTSTART
             m = self.getMessage(2)
         # skip local pseudo-channels listed by ngircd and ircu
-        while m.command == RPL_LIST and m.params[1].startswith("&"):
+        while m.command == "322" and m.params[1].startswith("&"):
             m = self.getMessage(2)
         self.assertNotEqual(
             m.command,
-            RPL_LIST,
+            "322",  # RPL_LIST
             "LIST response gives (at least) one channel, whereas there " "is none.",
         )
         self.assertMessageMatch(
             m,
-            command=RPL_LISTEND,
+            command="323",  # RPL_LISTEND
             fail_msg="Second reply to LIST is not 322 (RPL_LIST) "
             "or 323 (RPL_LISTEND), or but: {msg}",
         )
 
     @cases.mark_specifications("RFC1459", "RFC2812")
-    @cases.xfailIfSoftware(["irc2"], "irc2 deprecated LIST")
     def testListOne(self):
         """When a channel exists, LIST should get it in a reply.
         <https://tools.ietf.org/html/rfc1459#section-4.2.6>
         <https://tools.ietf.org/html/rfc2812#section-3.2.6>
-
-        <https://modern.ircdocs.horse/#list-message>
         """
         self.connectClient("foo")
         self.connectClient("bar")
@@ -73,331 +42,34 @@ class ListTestCase(_BasedListTestCase):
         self.getMessages(1)
         self.sendLine(2, "LIST")
         m = self.getMessage(2)
-        if m.command == RPL_LISTSTART:
+        if m.command == "321":
-            # skip
+            # skip RPL_LISTSTART
             m = self.getMessage(2)
         self.assertNotEqual(
             m.command,
-            RPL_LISTEND,
+            "323",  # RPL_LISTEND
             fail_msg="LIST response ended (ie. 323, aka RPL_LISTEND) "
             "without listing any channel, whereas there is one.",
         )
         self.assertMessageMatch(
             m,
-            command=RPL_LIST,
+            command="322",  # RPL_LIST
             fail_msg="Second reply to LIST is not 322 (RPL_LIST), "
             "nor 323 (RPL_LISTEND) but: {msg}",
         )
         m = self.getMessage(2)
         # skip local pseudo-channels listed by ngircd and ircu
-        while m.command == RPL_LIST and m.params[1].startswith("&"):
+        while m.command == "322" and m.params[1].startswith("&"):
             m = self.getMessage(2)
         self.assertNotEqual(
             m.command,
-            RPL_LIST,
+            "322",  # RPL_LIST
             fail_msg="LIST response gives (at least) two channels, "
             "whereas there is only one.",
         )
         self.assertMessageMatch(
             m,
-            command=RPL_LISTEND,
+            command="323",  # RPL_LISTEND
             fail_msg="Third reply to LIST is not 322 (RPL_LIST) "
             "or 323 (RPL_LISTEND), or but: {msg}",
         )
-
-    @cases.mark_specifications("RFC1459", "RFC2812")
-    @cases.xfailIfSoftware(
-        ["Charybdis", "Solanum"],
-        "Charybdis and Solanum insert ERR_NOSUCHNICK reply in LIST",
-    )
-    def testListNonexistent(self):
-        """LIST on a nonexistent channel does not send an error
-        response.
-        <https://tools.ietf.org/html/rfc1459#section-4.2.6>
-        <https://tools.ietf.org/html/rfc2812#section-3.2.6>
-        """
-        self.connectClient("bar")
-        self.sendLine(1, "LIST #nonexistent")
-        responses = {msg.command for msg in self.getMessages(1)}
-        # successful response MUST include RPL_LISTEND:
-        self.assertIn(RPL_LISTEND, responses)
-        # and MUST NOT include RPL_LIST (since there is no matching channel)
-        # or any error numerics:
-        self.assertLessEqual(responses, {RPL_LISTSTART, RPL_LISTEND})
-
-    @cases.mark_isupport("ELIST")
-    @cases.mark_specifications("Modern")
-    def testListMask(self):
-        """
-        "M: Searching based on mask."
-        -- <https://modern.ircdocs.horse/#elist-parameter>
-        -- https://datatracker.ietf.org/doc/html/draft-hardy-irc-isupport-00#section-4.8
-        """
-        self.connectClient("foo")
-
-        if "M" not in self.server_support.get("ELIST", ""):
-            raise runner.OptionalExtensionNotSupported("ELIST=M")
-
-        self.connectClient("bar")
-        self.sendLine(1, "JOIN #chan1")
-        self.getMessages(1)
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self.sendLine(2, "LIST *an1")
-        self.assertEqual(self._parseChanList(2), {"#chan1"})
-
-        self.sendLine(2, "LIST *an2")
-        self.assertEqual(self._parseChanList(2), {"#chan2"})
-
-        self.sendLine(2, "LIST #c*n2")
-        self.assertEqual(self._parseChanList(2), {"#chan2"})
-
-        self.sendLine(2, "LIST *an3")
-        self.assertEqual(self._parseChanList(2), set())
-
-        self.sendLine(2, "LIST #ch*")
-        self.assertEqual(self._parseChanList(2), {"#chan1", "#chan2"})
-
-    @cases.mark_isupport("ELIST")
-    @cases.mark_specifications("Modern")
-    def testListNotMask(self):
-        """
-        " N: Searching based on a non-matching mask. i.e., the opposite of M."
-        -- <https://modern.ircdocs.horse/#elist-parameter>
-        -- https://datatracker.ietf.org/doc/html/draft-hardy-irc-isupport-00#section-4.8
-        """
-        self.connectClient("foo")
-
-        if "N" not in self.server_support.get("ELIST", ""):
-            raise runner.OptionalExtensionNotSupported("ELIST=N")
-
-        self.sendLine(1, "JOIN #chan1")
-        self.getMessages(1)
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self.connectClient("bar")
-
-        self.sendLine(2, "LIST !*an1")
-        self.assertEqual(self._parseChanList(2), {"#chan2"})
-
-        self.sendLine(2, "LIST !*an2")
-        self.assertEqual(self._parseChanList(2), {"#chan1"})
-
-        self.sendLine(2, "LIST !#c*n2")
-        self.assertEqual(self._parseChanList(2), {"#chan1"})
-
-        self.sendLine(2, "LIST !*an3")
-        self.assertEqual(self._parseChanList(2), {"#chan1", "#chan2"})
-
-        self.sendLine(2, "LIST !#ch*")
-        self.assertEqual(self._parseChanList(2), set())
-
-    @cases.mark_isupport("ELIST")
-    @cases.mark_specifications("Modern")
-    def testListUsers(self):
-        """
-        "U: Searching based on user count within the channel, via the "<val" and
-        ">val" modifiers to search for a channel that has less or more than val users,
-        respectively."
-        -- <https://modern.ircdocs.horse/#elist-parameter>
-        -- https://datatracker.ietf.org/doc/html/draft-hardy-irc-isupport-00#section-4.8
-        """
-        self.connectClient("foo")
-
-        if "U" not in self.server_support.get("ELIST", ""):
-            raise runner.OptionalExtensionNotSupported("ELIST=U")
-
-        self.sendLine(1, "JOIN #chan1")
-        self.getMessages(1)
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self.connectClient("bar")
-        self.sendLine(2, "JOIN #chan2")
-        self.getMessages(2)
-
-        self.connectClient("baz")
-
-        self.sendLine(3, "LIST >0")
-        self.assertEqual(self._parseChanList(3), {"#chan1", "#chan2"})
-
-        self.sendLine(3, "LIST <1")
-        self.assertEqual(self._parseChanList(3), set())
-
-        self.sendLine(3, "LIST <100")
-        self.assertEqual(self._parseChanList(3), {"#chan1", "#chan2"})
-
-        self.sendLine(3, "LIST >1")
-        self.assertEqual(self._parseChanList(3), {"#chan2"})
-
-        self.sendLine(3, "LIST <2")
-        self.assertEqual(self._parseChanList(3), {"#chan1"})
-
-        self.sendLine(3, "LIST <100")
-        self.assertEqual(self._parseChanList(3), {"#chan1", "#chan2"})
-
-
-class FaketimeListTestCase(_BasedListTestCase):
-    faketime = "+1y x30"  # for every wall clock second, 1 minute passed for the server
-
-    def _sleep_minutes(self, n):
-        for _ in range(n):
-            if self.controller.faketime_enabled:
-                # From the server's point of view, 1 min will pass
-                time.sleep(2)
-            else:
-                time.sleep(60)
-
-            # reply to pings
-            self.getMessages(1)
-            self.getMessages(2)
-
-    @cases.mark_isupport("ELIST")
-    @cases.mark_specifications("Modern")
-    @cases.xfailIfSoftware(
-        ["Plexus4", "Hybrid"],
-        "Hybrid and Plexus4 filter on ELIST=C with the opposite meaning",
-    )
-    @cases.xfailIf(
-        lambda self: bool(
-            self.controller.software_name == "UnrealIRCd"
-            and self.controller.software_version == 5
-        ),
-        "UnrealIRCd <6.0.3 filters on ELIST=C with the opposite meaning",
-    )
-    def testListCreationTime(self):
-        """
-        " C: Searching based on channel creation time, via the "C<val" and "C>val"
-        modifiers to search for a channel creation time that is higher or lower
-        than val."
-        -- <https://modern.ircdocs.horse/#elist-parameter>
-        -- https://datatracker.ietf.org/doc/html/draft-hardy-irc-isupport-00#section-4.8
-
-        Unfortunately, this is ambiguous, because "val" is a time delta (in minutes),
-        not a timestamp.
-
-        On InspIRCd and Charybdis/Solanum, "C<val" is interpreted as "the channel was
-        created less than <val> minutes ago
-
-        On UnrealIRCd, Plexus, and Hybrid, it is interpreted as "the channel's creation
-        time is a timestamp lower than <val> minutes ago" (ie. the exact opposite)
-
-        "C: Searching based on channel creation time, via the "C<val" and "C>val"
-        modifiers to search for a channel that was created either less than `val`
-        minutes ago, or more than `val` minutes ago, respectively"
-        -- https://github.com/ircdocs/modern-irc/pull/171
-        """
-        self.connectClient("foo")
-
-        if "C" not in self.server_support.get("ELIST", ""):
-            raise runner.OptionalExtensionNotSupported("ELIST=C")
-
-        self.connectClient("bar")
-        self.sendLine(1, "JOIN #chan1")
-        self.getMessages(1)
-
-        # Helps debugging
-        self.sendLine(1, "TIME")
-        self.getMessages(1)
-
-        self._sleep_minutes(2)
-
-        # Helps debugging
-        self.sendLine(1, "TIME")
-        self.getMessages(1)
-
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self._sleep_minutes(1)
-
-        self.sendLine(2, "LIST C>2")
-        self.assertEqual(self._parseChanList(2), {"#chan1"})
-
-        self.sendLine(2, "LIST C<2")
-        self.assertEqual(self._parseChanList(2), {"#chan2"})
-
-        self.sendLine(2, "LIST C<0")
-        if self.controller.software_name == "InspIRCd":
-            self.assertEqual(self._parseChanList(2), {"#chan1", "#chan2"})
-        else:
-            self.assertEqual(self._parseChanList(2), set())
-
-        self.sendLine(2, "LIST C>0")
-        self.assertEqual(self._parseChanList(2), {"#chan1", "#chan2"})
-
-        self.sendLine(2, "LIST C<10")
-        self.assertEqual(self._parseChanList(2), {"#chan1", "#chan2"})
-
-    @cases.mark_isupport("ELIST")
-    @cases.mark_specifications("Modern")
-    @cases.xfailIf(
-        lambda self: bool(
-            self.controller.software_name == "UnrealIRCd"
-            and self.controller.software_version == 5
-        ),
-        "UnrealIRCd <6.0.3 advertises ELIST=T but does not implement it",
-    )
-    def testListTopicTime(self):
-        """
-        "T: Searching based on topic time, via the "T<val" and "T>val"
-        modifiers to search for a topic time that is lower or higher than
-        val respectively."
-        -- <https://modern.ircdocs.horse/#elist-parameter>
-        -- https://datatracker.ietf.org/doc/html/draft-hardy-irc-isupport-00#section-4.8
-
-        See testListCreationTime's docstring for comments on this.
-
-        "T: Searching based on topic set time, via the "T<val" and "T>val" modifiers
-        to search for a topic time that was set less than `val` minutes ago, or more
-        than `val` minutes ago, respectively."
-        -- https://github.com/ircdocs/modern-irc/pull/171
-        """
-        self.connectClient("foo")
-
-        if "T" not in self.server_support.get("ELIST", ""):
-            raise runner.OptionalExtensionNotSupported("ELIST=T")
-
-        self.connectClient("bar")
-        self.sendLine(1, "JOIN #chan1")
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self.sendLine(1, "TOPIC #chan1 :First channel")
-        self.getMessages(1)
-
-        # Helps debugging
-        self.sendLine(1, "TIME")
-        self.getMessages(1)
-
-        self._sleep_minutes(2)
-
-        # Helps debugging
-        self.sendLine(1, "TIME")
-        self.getMessages(1)
-
-        self.sendLine(1, "TOPIC #chan2 :Second channel")
-        self.getMessages(1)
-
-        self._sleep_minutes(1)
-
-        self.sendLine(1, "LIST T>2")
-        self.assertEqual(self._parseChanList(1), {"#chan1"})
-
-        self.sendLine(1, "LIST T<2")
-        self.assertEqual(self._parseChanList(1), {"#chan2"})
-
-        self.sendLine(1, "LIST T<0")
-        if self.controller.software_name == "InspIRCd":
-            # Insp internally represents "LIST T>0" like "LIST"
-            self.assertEqual(self._parseChanList(1), {"#chan1", "#chan2"})
-        else:
-            self.assertEqual(self._parseChanList(1), set())
-
-        self.sendLine(1, "LIST T>0")
-        self.assertEqual(self._parseChanList(1), {"#chan1", "#chan2"})
-
-        self.sendLine(1, "LIST T<10")
-        self.assertEqual(self._parseChanList(1), {"#chan1", "#chan2"})

irctest/server_tests/lusers.py

@@ -1,11 +1,3 @@
-"""
-The LUSERS command  (`RFC 2812
-<https://datatracker.ietf.org/doc/html/rfc2812#section-3.4.2>`__,
-`Modern <https://modern.ircdocs.horse/#lusers-message>`__),
-which provides statistics on user counts.
-"""
-
-
 from dataclasses import dataclass
 import re
 from typing import Optional
@@ -153,10 +145,6 @@ class BasicLusersTestCase(LusersTestCase):
         self.getLusers("bar", True)
 
     @cases.mark_specifications("Modern")
-    @cases.xfailIfSoftware(
-        ["ircu2", "Nefarious", "snircd"],
-        "test depends on Modern behavior, not just RFC2812",
-    )
     def testLusersFull(self):
         self.connectClient("bar", name="bar")
         lusers = self.getLusers("bar", False)
@@ -174,22 +162,10 @@ class BasicLusersTestCase(LusersTestCase):
 
 class LusersUnregisteredTestCase(LusersTestCase):
     @cases.mark_specifications("RFC2812")
-    @cases.xfailIfSoftware(
-        ["Nefarious"],
-        "Nefarious doesn't seem to distinguish unregistered users from normal ones",
-    )
     def testLusersRfc2812(self):
         self.doLusersTest(True)
 
     @cases.mark_specifications("Modern")
-    @cases.xfailIfSoftware(
-        ["Nefarious"],
-        "Nefarious doesn't seem to distinguish unregistered users from normal ones",
-    )
-    @cases.xfailIfSoftware(
-        ["ircu2", "Nefarious", "snircd"],
-        "test depends on Modern behavior, not just RFC2812",
-    )
     def testLusersFull(self):
         self.doLusersTest(False)
 
@@ -253,10 +229,6 @@ class LusersUnregisteredDefaultInvisibleTestCase(LusersUnregisteredTestCase):
         )
 
     @cases.mark_specifications("Ergo")
-    @cases.xfailIfSoftware(
-        ["Nefarious"],
-        "Nefarious doesn't seem to distinguish unregistered users from normal ones",
-    )
     def testLusers(self):
         self.doLusersTest(False)
         lusers = self.getLusers("bar", False)

irctest/server_tests/message_tags.py

@@ -1,5 +1,5 @@
 """
-`IRCv3 message-tags <https://ircv3.net/specs/extensions/message-tags>`_
+https://ircv3.net/specs/extensions/message-tags.html
 """
 
 import pytest
@@ -10,7 +10,7 @@ from irctest.numerics import ERR_INPUTTOOLONG
 from irctest.patma import ANYDICT, ANYSTR, StrRe
 
 
-class MessageTagsTestCase(cases.BaseServerTestCase):
+class MessageTagsTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     @pytest.mark.arbitrary_client_tags
     @cases.mark_capabilities("message-tags")
     def testBasic(self):

irctest/server_tests/messages.py

@@ -1,10 +1,10 @@
 """
-The PRIVMSG and NOTICE commands.
+Section 3.2 of RFC 2812
+<https://tools.ietf.org/html/rfc2812#section-3.3>
 """
 
 from irctest import cases
 from irctest.numerics import ERR_INPUTTOOLONG
-from irctest.patma import ANYSTR
 
 
 class PrivmsgTestCase(cases.BaseServerTestCase):
@@ -13,7 +13,6 @@ class PrivmsgTestCase(cases.BaseServerTestCase):
         """<https://tools.ietf.org/html/rfc2812#section-3.3.1>"""
         self.connectClient("foo")
         self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)  # synchronize
         self.connectClient("bar")
         self.sendLine(2, "JOIN #chan")
         self.getMessages(2)  # synchronize
@@ -34,48 +33,6 @@ class PrivmsgTestCase(cases.BaseServerTestCase):
         # ERR_NOSUCHNICK, ERR_NOSUCHCHANNEL, or ERR_CANNOTSENDTOCHAN
         self.assertIn(msg.command, ("401", "403", "404"))
 
-    @cases.mark_specifications("RFC1459", "RFC2812")
-    def testPrivmsgToUser(self):
-        """<https://tools.ietf.org/html/rfc2812#section-3.3.1>"""
-        self.connectClient("foo")
-        self.connectClient("bar")
-        self.sendLine(1, "PRIVMSG bar :hey there!")
-        self.getMessages(1)
-        pms = [msg for msg in self.getMessages(2) if msg.command == "PRIVMSG"]
-        self.assertEqual(len(pms), 1)
-        self.assertMessageMatch(pms[0], command="PRIVMSG", params=["bar", "hey there!"])
-
-    @cases.mark_specifications("RFC1459", "RFC2812")
-    def testPrivmsgNonexistentUser(self):
-        """<https://tools.ietf.org/html/rfc2812#section-3.3.1>"""
-        self.connectClient("foo")
-        self.sendLine(1, "PRIVMSG bar :hey there!")
-        msg = self.getMessage(1)
-        # ERR_NOSUCHNICK: 401 <sender> <recipient> :No such nick
-        self.assertMessageMatch(msg, command="401", params=["foo", "bar", ANYSTR])
-
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    @cases.xfailIfSoftware(
-        ["irc2"],
-        "replies with ERR_NEEDMOREPARAMS instead of ERR_NOTEXTTOSEND",
-    )
-    def testEmptyPrivmsg(self):
-        self.connectClient("foo")
-        self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)  # synchronize
-        self.connectClient("bar")
-        self.sendLine(2, "JOIN #chan")
-        self.getMessages(2)  # synchronize
-        self.getMessages(1)  # synchronize
-        self.sendLine(1, "PRIVMSG #chan :")
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="412",  # ERR_NOTEXTTOSEND
-            params=["foo", ANYSTR],
-        )
-        self.assertEqual(self.getMessages(2), [])
-
 
 class NoticeTestCase(cases.BaseServerTestCase):
     @cases.mark_specifications("RFC1459", "RFC2812")
@@ -95,15 +52,6 @@ class NoticeTestCase(cases.BaseServerTestCase):
         )
 
     @cases.mark_specifications("RFC1459", "RFC2812")
-    @cases.xfailIfSoftware(
-        ["InspIRCd"],
-        "replies with ERR_NOSUCHCHANNEL to NOTICE to non-existent channels",
-    )
-    @cases.xfailIfSoftware(
-        ["UnrealIRCd"],
-        "replies with ERR_NOSUCHCHANNEL to NOTICE to non-existent channels: "
-        "https://bugs.unrealircd.org/view.php?id=5949",
-    )
     def testNoticeNonexistentChannel(self):
         """
         "automatic replies must never be
@@ -124,14 +72,6 @@ class NoticeTestCase(cases.BaseServerTestCase):
 
 class TagsTestCase(cases.BaseServerTestCase):
     @cases.mark_capabilities("message-tags")
-    @cases.xfailIf(
-        lambda self: bool(
-            self.controller.software_name == "UnrealIRCd"
-            and self.controller.software_version == 5
-        ),
-        "UnrealIRCd <6.0.7 dropped messages with excessively large tags: "
-        "https://bugs.unrealircd.org/view.php?id=5947",
-    )
     def testLineTooLong(self):
         self.connectClient("bar", capabilities=["message-tags"], skip_if_cap_nak=True)
         self.connectClient(

irctest/server_tests/metadata.py

@@ -1,13 +1,14 @@
 """
-`Deprecated IRCv3 Metadata <https://ircv3.net/specs/core/metadata-3.2>`_
+Tests METADATA features.
+<http://ircv3.net/specs/core/metadata-3.2.html>
 """
 
 from irctest import cases
 
 
 class MetadataTestCase(cases.BaseServerTestCase):
-    valid_metadata_keys = {"display-name", "avatar"}
+    valid_metadata_keys = {"valid_key1", "valid_key2"}
-    invalid_metadata_keys = {"indisplay-name", "inavatar"}
+    invalid_metadata_keys = {"invalid_key1", "invalid_key2"}
 
     @cases.mark_specifications("IRCv3", deprecated=True)
     def testInIsupport(self):
@@ -36,7 +37,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
     def testGetOneUnsetValid(self):
         """<http://ircv3.net/specs/core/metadata-3.2.html#metadata-get>"""
         self.connectClient("foo")
-        self.sendLine(1, "METADATA * GET display-name")
+        self.sendLine(1, "METADATA * GET valid_key1")
         m = self.getMessage(1)
         self.assertMessageMatch(
             m,
@@ -52,7 +53,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-get>
         """
         self.connectClient("foo")
-        self.sendLine(1, "METADATA * GET display-name avatar")
+        self.sendLine(1, "METADATA * GET valid_key1 valid_key2")
         m = self.getMessage(1)
         self.assertMessageMatch(
             m,
@@ -62,10 +63,10 @@ class MetadataTestCase(cases.BaseServerTestCase):
         )
         self.assertEqual(
             m.params[1],
-            "display-name",
+            "valid_key1",
             m,
-            fail_msg="Response to “METADATA * GET display-name avatar” "
+            fail_msg="Response to “METADATA * GET valid_key1 valid_key2” "
-            "did not respond to display-name first: {msg}",
+            "did not respond to valid_key1 first: {msg}",
         )
         m = self.getMessage(1)
         self.assertMessageMatch(
@@ -76,10 +77,10 @@ class MetadataTestCase(cases.BaseServerTestCase):
         )
         self.assertEqual(
             m.params[1],
-            "avatar",
+            "valid_key2",
             m,
-            fail_msg="Response to “METADATA * GET display-name avatar” "
+            fail_msg="Response to “METADATA * GET valid_key1 valid_key2” "
-            "did not respond to avatar as second response: {msg}",
+            "did not respond to valid_key2 as second response: {msg}",
         )
 
     @cases.mark_specifications("IRCv3", deprecated=True)
@@ -135,7 +136,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         )
         self.assertEqual(
             m.params[1],
-            "display-name",
+            "valid_key1",
             m,
             fail_msg="Second param of 761 after setting “{expects}” to "
             "“{}” is not “{expects}”: {msg}.",
@@ -190,7 +191,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
     def testSetGetValid(self):
         """<http://ircv3.net/specs/core/metadata-3.2.html>"""
         self.connectClient("foo")
-        self.assertSetGetValue("*", "display-name", "myvalue")
+        self.assertSetGetValue("*", "valid_key1", "myvalue")
 
     @cases.mark_specifications("IRCv3", deprecated=True)
     def testSetGetZeroCharInValue(self):
@@ -198,7 +199,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-restrictions>
         """
         self.connectClient("foo")
-        self.assertSetGetValue("*", "display-name", "zero->\0<-zero", "zero->\\0<-zero")
+        self.assertSetGetValue("*", "valid_key1", "zero->\0<-zero", "zero->\\0<-zero")
 
     @cases.mark_specifications("IRCv3", deprecated=True)
     def testSetGetHeartInValue(self):
@@ -209,7 +210,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         self.connectClient("foo")
         self.assertSetGetValue(
             "*",
-            "display-name",
+            "valid_key1",
             "->{}<-".format(heart),
             "zero->{}<-zero".format(heart.encode()),
         )
@@ -223,7 +224,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
         # Sending directly because it is not valid UTF-8 so Python would
         # not like it
         self.clients[1].conn.sendall(
-            b"METADATA * SET display-name " b":invalid UTF-8 ->\xc3<-\r\n"
+            b"METADATA * SET valid_key1 " b":invalid UTF-8 ->\xc3<-\r\n"
         )
         commands = {m.command for m in self.getMessages(1)}
         self.assertNotIn(
@@ -233,7 +234,7 @@ class MetadataTestCase(cases.BaseServerTestCase):
             "UTF-8 was answered with 761 (RPL_KEYVALUE)",
         )
         self.clients[1].conn.sendall(
-            b"METADATA * SET display-name " b":invalid UTF-8: \xc3\r\n"
+            b"METADATA * SET valid_key1 " b":invalid UTF-8: \xc3\r\n"
         )
         commands = {m.command for m in self.getMessages(1)}
         self.assertNotIn(

irctest/server_tests/monitor.py

@@ -1,14 +1,11 @@
 """
-`IRCv3 MONITOR <https://ircv3.net/specs/extensions/monitor>`_
+<http://ircv3.net/specs/core/monitor-3.2.html>
-and `IRCv3 extended-monitor` <https://ircv3.net/specs/extensions/extended-monitor>`_
 """
 
-import pytest
+from irctest import cases
-
+from irctest.basecontrollers import NotImplementedByController
-from irctest import cases, runner
 from irctest.client_mock import NoMessageException
 from irctest.numerics import (
-    ERR_ERRONEUSNICKNAME,
     RPL_ENDOFMONLIST,
     RPL_MONLIST,
     RPL_MONOFFLINE,
@@ -17,10 +14,10 @@ from irctest.numerics import (
 from irctest.patma import ANYSTR, StrRe
 
 
-class _BaseMonitorTestCase(cases.BaseServerTestCase):
+class MonitorTestCase(cases.BaseServerTestCase):
     def check_server_support(self):
         if "MONITOR" not in self.server_support:
-            raise runner.IsupportTokenNotSupported("MONITOR")
+            raise NotImplementedByController("MONITOR")
 
     def assertMononline(self, client, nick, m=None):
         if not m:
@@ -46,8 +43,6 @@ class _BaseMonitorTestCase(cases.BaseServerTestCase):
             extra_format=(nick,),
         )
 
-
-class MonitorTestCase(_BaseMonitorTestCase):
     @cases.mark_specifications("IRCv3")
     @cases.mark_isupport("MONITOR")
     def testMonitorOneDisconnected(self):
@@ -191,15 +186,14 @@ class MonitorTestCase(_BaseMonitorTestCase):
         self.check_server_support()
         self.sendLine(1, "MONITOR + *!username@localhost")
         self.sendLine(1, "MONITOR + *!username@127.0.0.1")
-        expected_command = StrRe(f"({RPL_MONOFFLINE}|{ERR_ERRONEUSNICKNAME})")
         try:
             m = self.getMessage(1)
-            self.assertMessageMatch(m, command=expected_command)
+            self.assertMessageMatch(m, command="731")
         except NoMessageException:
             pass
         else:
             m = self.getMessage(1)
-            self.assertMessageMatch(m, command=expected_command)
+            self.assertMessageMatch(m, command="731")
         self.connectClient("bar")
         try:
             m = self.getMessage(1)
@@ -251,23 +245,6 @@ class MonitorTestCase(_BaseMonitorTestCase):
             extra_format=(messages,),
         )
 
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_isupport("MONITOR")
-    def testMonitorClear(self):
-        """“Clears the list of targets being monitored. No output will be returned
-        for use of this command.“
-        -- <https://ircv3.net/specs/extensions/monitor#monitor-c>
-        """
-        self.connectClient("foo")
-        self.check_server_support()
-        self.sendLine(1, "MONITOR + bar")
-        self.getMessages(1)
-
-        self.sendLine(1, "MONITOR C")
-        self.sendLine(1, "MONITOR L")
-        m = self.getMessage(1)
-        self.assertEqual(m.command, RPL_ENDOFMONLIST)
-
     @cases.mark_specifications("IRCv3")
     @cases.mark_isupport("MONITOR")
     def testMonitorList(self):
@@ -303,35 +280,6 @@ class MonitorTestCase(_BaseMonitorTestCase):
         self.sendLine(1, "MONITOR L")
         checkMonitorSubjects(self.getMessages(1), "bar", {"bazbat"})
 
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_isupport("MONITOR")
-    def testMonitorStatus(self):
-        """“Outputs for each target in the list being monitored, whether
-        the client is online or offline. All targets that are online will
-        be sent using RPL_MONONLINE, all targets that are offline will be
-        sent using RPL_MONOFFLINE.“
-        -- <https://ircv3.net/specs/extensions/monitor#monitor-s>
-        """
-        self.connectClient("foo")
-        self.check_server_support()
-        self.connectClient("bar")
-        self.sendLine(1, "MONITOR + bar,baz")
-        self.getMessages(1)
-
-        self.sendLine(1, "MONITOR S")
-        msgs = self.getMessages(1)
-        self.assertEqual(
-            len(msgs),
-            2,
-            fail_msg="Expected one RPL_MONONLINE (730) and one RPL_MONOFFLINE (731), got: {}",
-            extra_format=(msgs,),
-        )
-
-        msgs.sort(key=lambda m: m.command)
-
-        self.assertMononline(1, "bar", m=msgs[0])
-        self.assertMonoffline(1, "baz", m=msgs[1])
-
     @cases.mark_specifications("IRCv3")
     @cases.mark_isupport("MONITOR")
     def testNickChange(self):
@@ -348,11 +296,10 @@ class MonitorTestCase(_BaseMonitorTestCase):
         self.sendLine(2, "NICK qux")
         self.getMessages(2)
         mononline = self.getMessages(1)[0]
-        self.assertMessageMatch(
+        self.assertEqual(mononline.command, RPL_MONONLINE)
-            mononline,
+        self.assertEqual(len(mononline.params), 2, mononline.params)
-            command=RPL_MONONLINE,
+        self.assertIn(mononline.params[0], ("bar", "*"))
-            params=[StrRe(r"(bar|\*)"), StrRe("qux(!.*)?")],
+        self.assertEqual(mononline.params[1].split("!")[0], "qux")
-        )
 
         # no numerics for a case change
         self.sendLine(2, "NICK QUX")
@@ -363,246 +310,7 @@ class MonitorTestCase(_BaseMonitorTestCase):
         self.getMessages(2)
         monoffline = self.getMessages(1)[0]
         # should get RPL_MONOFFLINE with the current unfolded nick
-        self.assertMessageMatch(
+        self.assertEqual(monoffline.command, RPL_MONOFFLINE)
-            monoffline,
+        self.assertEqual(len(monoffline.params), 2, monoffline.params)
-            command=RPL_MONOFFLINE,
+        self.assertIn(monoffline.params[0], ("bar", "*"))
-            params=[StrRe(r"(bar|\*)"), "QUX"],
+        self.assertEqual(monoffline.params[1].split("!")[0], "QUX")
-        )
-
-
-class _BaseExtendedMonitorTestCase(_BaseMonitorTestCase):
-    def _setupExtendedMonitor(self, monitor_before_connect, watcher_caps, watched_caps):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html"""
-        self.connectClient(
-            "foo",
-            capabilities=["extended-monitor", *watcher_caps],
-            skip_if_cap_nak=True,
-        )
-
-        if monitor_before_connect:
-            self.sendLine(1, "MONITOR + bar")
-            self.getMessages(1)
-            self.connectClient("bar", capabilities=watched_caps, skip_if_cap_nak=True)
-            self.getMessages(2)
-        else:
-            self.connectClient("bar", capabilities=watched_caps, skip_if_cap_nak=True)
-            self.getMessages(2)
-            self.sendLine(1, "MONITOR + bar")
-
-        self.assertMononline(1, "bar")
-        self.assertEqual(self.getMessages(1), [])
-
-
-class ExtendedMonitorTestCase(_BaseExtendedMonitorTestCase):
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "away-notify")
-    @pytest.mark.parametrize(
-        "monitor_before_connect,cap",
-        [
-            pytest.param(
-                monitor_before_connect,
-                cap,
-                id=("monitor_before_connect" if monitor_before_connect else "")
-                + "-"
-                + ("with-cap" if cap else ""),
-            )
-            for monitor_before_connect in [True, False]
-            for cap in [True, False]
-        ],
-    )
-    def testExtendedMonitorAway(self, monitor_before_connect, cap):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        with https://ircv3.net/specs/extensions/away-notify
-        """
-        if cap:
-            self._setupExtendedMonitor(
-                monitor_before_connect, ["away-notify"], ["away-notify"]
-            )
-        else:
-            self._setupExtendedMonitor(monitor_before_connect, ["away-notify"], [])
-
-        self.sendLine(2, "AWAY :afk")
-        self.getMessages(2)
-        self.assertMessageMatch(
-            self.getMessage(1), nick="bar", command="AWAY", params=["afk"]
-        )
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-        self.sendLine(2, "AWAY")
-        self.getMessages(2)
-        self.assertMessageMatch(
-            self.getMessage(1), nick="bar", command="AWAY", params=[]
-        )
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "away-notify")
-    @pytest.mark.parametrize(
-        "monitor_before_connect,cap",
-        [
-            pytest.param(
-                monitor_before_connect,
-                cap,
-                id=("monitor_before_connect" if monitor_before_connect else "")
-                + "-"
-                + ("with-cap" if cap else ""),
-            )
-            for monitor_before_connect in [True, False]
-            for cap in [True, False]
-        ],
-    )
-    def testExtendedMonitorAwayNoCap(self, monitor_before_connect, cap):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        does nothing when ``away-notify`` is not enabled by the watcher
-        """
-        if cap:
-            self._setupExtendedMonitor(monitor_before_connect, [], ["away-notify"])
-        else:
-            self._setupExtendedMonitor(monitor_before_connect, [], [])
-
-        self.sendLine(2, "AWAY :afk")
-        self.getMessages(2)
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-        self.sendLine(2, "AWAY")
-        self.getMessages(2)
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "setname")
-    @pytest.mark.parametrize("monitor_before_connect", [True, False])
-    def testExtendedMonitorSetName(self, monitor_before_connect):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        with https://ircv3.net/specs/extensions/setname
-        """
-        self._setupExtendedMonitor(monitor_before_connect, ["setname"], ["setname"])
-
-        self.sendLine(2, "SETNAME :new name")
-        self.getMessages(2)
-        self.assertMessageMatch(
-            self.getMessage(1), nick="bar", command="SETNAME", params=["new name"]
-        )
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "setname")
-    @pytest.mark.parametrize("monitor_before_connect", [True, False])
-    def testExtendedMonitorSetNameNoCap(self, monitor_before_connect):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        does nothing when ``setname`` is not enabled by the watcher
-        """
-        self._setupExtendedMonitor(monitor_before_connect, [], ["setname"])
-
-        self.sendLine(2, "SETNAME :new name")
-        self.getMessages(2)
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-
-@cases.mark_services
-class AuthenticatedExtendedMonitorTestCase(_BaseExtendedMonitorTestCase):
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "account-notify")
-    @pytest.mark.parametrize(
-        "monitor_before_connect,cap",
-        [
-            pytest.param(
-                monitor_before_connect,
-                cap,
-                id=("monitor_before_connect" if monitor_before_connect else "")
-                + "-"
-                + ("with-cap" if cap else ""),
-            )
-            for monitor_before_connect in [True, False]
-            for cap in [True, False]
-        ],
-    )
-    def testExtendedMonitorAccountNotify(self, monitor_before_connect, cap):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        does nothing when ``account-notify`` is not enabled by the watcher
-        """
-        self.controller.registerUser(self, "jilles", "sesame")
-
-        if cap:
-            self._setupExtendedMonitor(
-                monitor_before_connect,
-                ["account-notify"],
-                ["account-notify", "sasl", "cap-notify"],
-            )
-        else:
-            self._setupExtendedMonitor(
-                monitor_before_connect, ["account-notify"], ["sasl", "cap-notify"]
-            )
-
-        self.sendLine(2, "AUTHENTICATE PLAIN")
-        m = self.getRegistrationMessage(2)
-        self.assertMessageMatch(
-            m,
-            command="AUTHENTICATE",
-            params=["+"],
-            fail_msg="Sent “AUTHENTICATE PLAIN”, server should have "
-            "replied with “AUTHENTICATE +”, but instead sent: {msg}",
-        )
-        self.sendLine(2, "AUTHENTICATE amlsbGVzAGppbGxlcwBzZXNhbWU=")
-        m = self.getRegistrationMessage(2)
-        self.assertMessageMatch(
-            m,
-            command="900",
-            fail_msg="Did not send 900 after correct SASL authentication.",
-        )
-        self.getMessages(2)
-
-        self.assertMessageMatch(
-            self.getMessage(1), nick="bar", command="ACCOUNT", params=["jilles"]
-        )
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")
-
-    @cases.mark_specifications("IRCv3")
-    @cases.mark_capabilities("extended-monitor", "account-notify")
-    @pytest.mark.parametrize(
-        "monitor_before_connect,cap",
-        [
-            pytest.param(
-                monitor_before_connect,
-                cap,
-                id=("monitor_before_connect" if monitor_before_connect else "")
-                + "-"
-                + ("with-cap" if cap else ""),
-            )
-            for monitor_before_connect in [True, False]
-            for cap in [True, False]
-        ],
-    )
-    def testExtendedMonitorAccountNotifyNoCap(self, monitor_before_connect, cap):
-        """Tests https://ircv3.net/specs/extensions/extended-monitor.html
-        does nothing when ``account-notify`` is not enabled by the watcher
-        """
-        self.controller.registerUser(self, "jilles", "sesame")
-
-        if cap:
-            self._setupExtendedMonitor(
-                monitor_before_connect, [], ["account-notify", "sasl", "cap-notify"]
-            )
-        else:
-            self._setupExtendedMonitor(
-                monitor_before_connect, [], ["sasl", "cap-notify"]
-            )
-
-        self.sendLine(2, "AUTHENTICATE PLAIN")
-        m = self.getRegistrationMessage(2)
-        self.assertMessageMatch(
-            m,
-            command="AUTHENTICATE",
-            params=["+"],
-            fail_msg="Sent “AUTHENTICATE PLAIN”, server should have "
-            "replied with “AUTHENTICATE +”, but instead sent: {msg}",
-        )
-        self.sendLine(2, "AUTHENTICATE amlsbGVzAGppbGxlcwBzZXNhbWU=")
-        m = self.getRegistrationMessage(2)
-        self.assertMessageMatch(
-            m,
-            command="900",
-            fail_msg="Did not send 900 after correct SASL authentication.",
-        )
-        self.getMessages(2)
-
-        self.assertEqual(self.getMessages(1), [], "watcher got unexpected messages")

irctest/server_tests/multi_prefix.py

@@ -1,5 +1,6 @@
 """
-`IRCv3 multi-prefix <https://ircv3.net/specs/extensions/multi-prefix>`_
+Tests multi-prefix.
+<http://ircv3.net/specs/extensions/multi-prefix-3.1.html>
 """
 
 from irctest import cases
@@ -15,7 +16,7 @@ class MultiPrefixTestCase(cases.BaseServerTestCase):
 
         These prefixes MUST be in order of ‘rank’, from highest to lowest.
         """
-        self.connectClient("foo", capabilities=["multi-prefix"], skip_if_cap_nak=True)
+        self.connectClient("foo", capabilities=["multi-prefix"])
         self.joinChannel(1, "#chan")
         self.sendLine(1, "MODE #chan +v foo")
         self.getMessages(1)
@@ -24,6 +25,11 @@ class MultiPrefixTestCase(cases.BaseServerTestCase):
 
         self.sendLine(1, "NAMES #chan")
         reply = self.getMessage(1)
+        self.assertMessageMatch(
+            reply,
+            command="353",
+            fail_msg="Expected NAMES response (353) with @+foo, got: {msg}",
+        )
         self.assertMessageMatch(
             reply,
             command="353",
@@ -42,57 +48,9 @@ class MultiPrefixTestCase(cases.BaseServerTestCase):
             8,
             "Expected WHO response (352) with 8 params, got: {msg}".format(msg=msg),
         )
-        self.assertIn(
+        self.assertTrue(
-            "@+",
+            "@+" in msg.params[6],
-            msg.params[6],
             'Expected WHO response (352) with "@+" in param 7, got: {msg}'.format(
                 msg=msg
             ),
         )
-
-    @cases.xfailIfSoftware(
-        ["irc2", "Bahamut"], "irc2 and Bahamut send a trailing space"
-    )
-    def testNoMultiPrefix(self):
-        """When not requested, only the highest prefix should be sent"""
-        self.connectClient("foo")
-        self.joinChannel(1, "#chan")
-        self.sendLine(1, "MODE #chan +v foo")
-        self.getMessages(1)
-
-        # TODO(dan): Make sure +v is voice
-
-        self.sendLine(1, "NAMES #chan")
-        reply = self.getMessage(1)
-        self.assertMessageMatch(
-            reply,
-            command="353",
-            params=["foo", ANYSTR, "#chan", "@foo"],
-            fail_msg="Expected NAMES response (353) with @foo, got: {msg}",
-        )
-        self.getMessages(1)
-
-        self.sendLine(1, "WHO #chan")
-        msg = self.getMessage(1)
-        self.assertEqual(
-            msg.command, "352", msg, fail_msg="Expected WHO response (352), got: {msg}"
-        )
-        self.assertGreaterEqual(
-            len(msg.params),
-            8,
-            "Expected WHO response (352) with 8 params, got: {msg}".format(msg=msg),
-        )
-        self.assertIn(
-            "@",
-            msg.params[6],
-            'Expected WHO response (352) with "@" in param 7, got: {msg}'.format(
-                msg=msg
-            ),
-        )
-        self.assertNotIn(
-            "+",
-            msg.params[6],
-            'Expected WHO response (352) with no "+" in param 7, got: {msg}'.format(
-                msg=msg
-            ),
-        )

irctest/server_tests/multiline.py

@@ -1,9 +1,9 @@
 """
-`Draft IRCv3 multiline <https://ircv3.net/specs/extensions/multiline>`_
+draft/multiline
 """
 
 from irctest import cases
-from irctest.patma import ANYDICT, ANYSTR, StrRe
+from irctest.patma import ANYDICT, StrRe
 
 CAP_NAME = "draft/multiline"
 BATCH_TYPE = "draft/multiline"
@@ -12,7 +12,7 @@ CONCAT_TAG = "draft/multiline-concat"
 base_caps = ["message-tags", "batch", "echo-message", "server-time", "labeled-response"]
 
 
-class MultilineTestCase(cases.BaseServerTestCase):
+class MultilineTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
     @cases.mark_capabilities("draft/multiline")
     def testBasic(self):
         self.connectClient(
@@ -135,86 +135,3 @@ class MultilineTestCase(cases.BaseServerTestCase):
         self.assertIn("+client-only-tag", fallback_relay[0].tags)
         self.assertIn("+client-only-tag", fallback_relay[1].tags)
         self.assertEqual(fallback_relay[0].tags["msgid"], msgid)
-
-    @cases.mark_capabilities("draft/multiline")
-    def testInvalidBatchTag(self):
-        """Test that an unexpected change of batch tag results in
-        FAIL BATCH MULTILINE_INVALID."""
-
-        self.connectClient(
-            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=True
-        )
-        self.joinChannel(1, "#test")
-
-        # invalid batch tag:
-        self.sendLine(1, "BATCH +123 %s #test" % (BATCH_TYPE,))
-        self.sendLine(1, "@batch=231 PRIVMSG #test :hi")
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="FAIL",
-            params=["BATCH", "MULTILINE_INVALID", ANYSTR],
-        )
-
-    @cases.mark_capabilities("draft/multiline")
-    def testInvalidBlankConcatTag(self):
-        """Test that the concat tag on a blank message results in
-        FAIL BATCH MULTILINE_INVALID."""
-
-        self.connectClient(
-            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=True
-        )
-        self.joinChannel(1, "#test")
-
-        # cannot send the concat tag with a blank message:
-        self.sendLine(1, "BATCH +123 %s #test" % (BATCH_TYPE,))
-        self.sendLine(1, "@batch=123 PRIVMSG #test :hi")
-        self.sendLine(1, "@batch=123;%s PRIVMSG #test :" % (CONCAT_TAG,))
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="FAIL",
-            params=["BATCH", "MULTILINE_INVALID", ANYSTR],
-        )
-
-    @cases.mark_specifications("Ergo")
-    def testLineLimit(self):
-        """This is an Ergo-specific test for line limit enforcement
-        in multiline messages. Right now it hardcodes the same limits as in
-        the Ergo controller; we can generalize it in future for other multiline
-        implementations.
-        """
-
-        self.connectClient(
-            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=False
-        )
-        self.joinChannel(1, "#test")
-
-        # line limit exceeded
-        self.sendLine(1, "BATCH +123 %s #test" % (BATCH_TYPE,))
-        for i in range(33):
-            self.sendLine(1, "@batch=123 PRIVMSG #test hi")
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="FAIL",
-            params=["BATCH", "MULTILINE_MAX_LINES", "32", ANYSTR],
-        )
-
-    @cases.mark_specifications("Ergo")
-    def testByteLimit(self):
-        """This is an Ergo-specific test for line limit enforcement
-        in multiline messages (see testLineLimit).
-        """
-
-        self.connectClient(
-            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=False
-        )
-        self.joinChannel(1, "#test")
-
-        # byte limit exceeded
-        self.sendLine(1, "BATCH +234 %s #test" % (BATCH_TYPE,))
-        for i in range(11):
-            self.sendLine(1, "@batch=234 PRIVMSG #test " + ("x" * 400))
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command="FAIL",
-            params=["BATCH", "MULTILINE_MAX_BYTES", "4096", ANYSTR],
-        )

irctest/server_tests/names.py

@@ -1,156 +1,9 @@
-"""
+from irctest import cases
-The NAMES command  (`RFC 1459
+from irctest.numerics import RPL_ENDOFNAMES
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5>`__,
+from irctest.patma import ANYSTR
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5>`__,
-`Modern <https://modern.ircdocs.horse/#names-message>`__)
-"""
-
-from irctest import cases, runner
-from irctest.numerics import RPL_ENDOFNAMES, RPL_NAMREPLY
-from irctest.patma import ANYSTR, StrRe
 
 
 class NamesTestCase(cases.BaseServerTestCase):
-    def _testNames(self, symbol: bool, allow_trailing_space: bool):
-        self.connectClient("nick1")
-        self.sendLine(1, "JOIN #chan")
-        self.getMessages(1)
-        self.connectClient("nick2")
-        self.sendLine(2, "JOIN #chan")
-        self.getMessages(2)
-        self.getMessages(1)
-
-        self.sendLine(1, "NAMES #chan")
-
-        # TODO: It is technically allowed to have one line for each;
-        # but noone does that.
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=[
-                "nick1",
-                *(["="] if symbol else []),
-                "#chan",
-                StrRe(
-                    "(nick2 @nick1|@nick1 nick2)"
-                    + (" ?" if allow_trailing_space else "")
-                ),
-            ],
-        )
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_ENDOFNAMES,
-            params=["nick1", "#chan", ANYSTR],
-        )
-
-    @cases.mark_specifications("RFC1459", deprecated=True)
-    def testNames1459(self):
-        """
-        https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        """
-        self._testNames(symbol=False, allow_trailing_space=True)
-
-    @cases.mark_specifications("RFC2812", "Modern")
-    def testNames2812(self):
-        """
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNames(symbol=True, allow_trailing_space=True)
-
-    @cases.mark_specifications("Modern")
-    @cases.xfailIfSoftware(
-        ["Bahamut", "irc2"], "Bahamut and irc2 send a trailing space in RPL_NAMREPLY"
-    )
-    def testNamesModern(self):
-        """
-        https://modern.ircdocs.horse/#names-message
-        """
-        self._testNames(symbol=True, allow_trailing_space=False)
-
-    @cases.mark_specifications("RFC2812", "Modern")
-    def testNames2812Secret(self):
-        """The symbol sent for a secret channel is `@` instead of `=`:
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        https://modern.ircdocs.horse/#rplnamreply-353
-        """
-        self.connectClient("nick1")
-        self.sendLine(1, "JOIN #chan")
-        # enable secret channel mode
-        self.sendLine(1, "MODE #chan +s")
-        self.getMessages(1)
-        self.sendLine(1, "NAMES #chan")
-        messages = self.getMessages(1)
-        self.assertMessageMatch(
-            messages[0],
-            command=RPL_NAMREPLY,
-            params=["nick1", "@", "#chan", StrRe("@nick1 ?")],
-        )
-        self.assertMessageMatch(
-            messages[1],
-            command=RPL_ENDOFNAMES,
-            params=["nick1", "#chan", ANYSTR],
-        )
-
-        self.connectClient("nick2")
-        self.sendLine(2, "JOIN #chan")
-        namreplies = [msg for msg in self.getMessages(2) if msg.command == RPL_NAMREPLY]
-        self.assertNotEqual(len(namreplies), 0)
-        for msg in namreplies:
-            self.assertMessageMatch(
-                msg, command=RPL_NAMREPLY, params=["nick2", "@", "#chan", ANYSTR]
-            )
-
-    def _testNamesMultipleChannels(self, symbol):
-        self.connectClient("nick1")
-
-        if self.targmax.get("NAMES", "1") == "1":
-            raise runner.OptionalExtensionNotSupported("Multi-target NAMES")
-
-        self.sendLine(1, "JOIN #chan1")
-        self.sendLine(1, "JOIN #chan2")
-        self.getMessages(1)
-
-        self.sendLine(1, "NAMES #chan1,#chan2")
-
-        # TODO: order is unspecified
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=["nick1", *(["="] if symbol else []), "#chan1", "@nick1"],
-        )
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=["nick1", *(["="] if symbol else []), "#chan2", "@nick1"],
-        )
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_ENDOFNAMES,
-            params=["nick1", "#chan1,#chan2", ANYSTR],
-        )
-
-    @cases.mark_isupport("TARGMAX")
-    @cases.mark_specifications("RFC1459", deprecated=True)
-    def testNamesMultipleChannels1459(self):
-        """
-        https://modern.ircdocs.horse/#names-message
-        https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesMultipleChannels(symbol=False)
-
-    @cases.mark_isupport("TARGMAX")
-    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
-    def testNamesMultipleChannels2812(self):
-        """
-        https://modern.ircdocs.horse/#names-message
-        https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesMultipleChannels(symbol=True)
-
     @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
     def testNamesInvalidChannel(self):
         """
@@ -194,101 +47,3 @@ class NamesTestCase(cases.BaseServerTestCase):
             command=RPL_ENDOFNAMES,
             params=["foo", "#nonexisting", ANYSTR],
         )
-
-    def _testNamesNoArgumentPublic(self, symbol):
-        self.connectClient("nick1")
-        self.getMessages(1)
-        self.sendLine(1, "JOIN #chan1")
-        self.connectClient("nick2")
-        self.sendLine(2, "JOIN #chan2")
-        self.sendLine(2, "MODE #chan2 -sp")
-        self.getMessages(1)
-        self.getMessages(2)
-
-        self.sendLine(1, "NAMES")
-
-        # TODO: order is unspecified
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=["nick1", *(["="] if symbol else []), "#chan1", "@nick1"],
-        )
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=["nick1", *(["="] if symbol else []), "#chan2", "@nick2"],
-        )
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_ENDOFNAMES,
-            params=["nick1", ANYSTR, ANYSTR],
-        )
-
-    @cases.mark_specifications("RFC1459", deprecated=True)
-    def testNamesNoArgumentPublic1459(self):
-        """
-        "If no <channel> parameter is given, a list of all channels and their
-        occupants is returned."
-        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesNoArgumentPublic(symbol=False)
-
-    @cases.mark_specifications("RFC2812", deprecated=True)
-    def testNamesNoArgumentPublic2812(self):
-        """
-        "If no <channel> parameter is given, a list of all channels and their
-        occupants is returned."
-        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesNoArgumentPublic(symbol=True)
-
-    def _testNamesNoArgumentPrivate(self, symbol):
-        self.connectClient("nick1")
-        self.getMessages(1)
-        self.sendLine(1, "JOIN #chan1")
-        self.connectClient("nick2")
-        self.sendLine(2, "JOIN #chan2")
-        self.sendLine(2, "MODE #chan2 +sp")
-        self.getMessages(1)
-        self.getMessages(2)
-
-        self.sendLine(1, "NAMES")
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_NAMREPLY,
-            params=["nick1", *(["="] if symbol else []), "#chan1", "@nick1"],
-        )
-
-        self.assertMessageMatch(
-            self.getMessage(1),
-            command=RPL_ENDOFNAMES,
-            params=["nick1", ANYSTR, ANYSTR],
-        )
-
-    @cases.mark_specifications("RFC1459", deprecated=True)
-    def testNamesNoArgumentPrivate1459(self):
-        """
-        "If no <channel> parameter is given, a list of all channels and their
-        occupants is returned.  At the end of this list, a list of users who
-        are visible but either not on any channel or not on a visible channel
-        are listed as being on `channel' "*"."
-        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesNoArgumentPrivate(symbol=False)
-
-    @cases.mark_specifications("RFC2812", deprecated=True)
-    def testNamesNoArgumentPrivate2812(self):
-        """
-        "If no <channel> parameter is given, a list of all channels and their
-        occupants is returned.  At the end of this list, a list of users who
-        are visible but either not on any channel or not on a visible channel
-        are listed as being on `channel' "*"."
-        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
-        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
-        """
-        self._testNamesNoArgumentPrivate(symbol=True)

irctest/server_tests/part.py

@@ -1,16 +1,6 @@
-"""
-The PART command  (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-6.1>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-5.2>`__,
-`Modern <https://modern.ircdocs.horse/#part-message>`__)
-
-TODO: cross-reference Modern
-"""
-
 import time
 
 from irctest import cases
-from irctest.numerics import RPL_NAMREPLY
 
 
 class PartTestCase(cases.BaseServerTestCase):
@@ -85,12 +75,6 @@ class PartTestCase(cases.BaseServerTestCase):
         self.getMessages(1)
         self.getMessages(2)
 
-        self.sendLine(2, "PRIVMSG #chan :hi everyone")
-        self.getMessages(2)
-        self.assertMessageMatch(
-            self.getMessage(1), command="PRIVMSG", params=["#chan", "hi everyone"]
-        )
-
         self.sendLine(1, "PART #chan")
         # both the PART'ing client and the other channel member should receive
         # a PART line:
@@ -99,21 +83,6 @@ class PartTestCase(cases.BaseServerTestCase):
         m = self.getMessage(2)
         self.assertMessageMatch(m, command="PART")
 
-        self.sendLine(2, "PRIVMSG #chan :hi again everyone")
-        self.getMessages(2)
-        # client 1 has PART'ed and should not receive channel messages:
-        self.assertEqual(self.getMessages(1), [])
-
-        # client 1 should no longer appear in NAMES responses:
-        names = set()
-        self.sendLine(2, "NAMES #chan")
-        for reply in self.getMessages(2):
-            if reply.command != RPL_NAMREPLY:
-                continue
-            names.update(reply.params[-1].replace("@", "").split())
-        self.assertNotIn("bar", names)
-        self.assertIn("baz", names)
-
     @cases.mark_specifications("RFC2812")
     def testBasicPartRfc2812(self):
         """

irctest/server_tests/pingpong.py

@@ -1,7 +1,3 @@
-"""
-The PING and PONG commands
-"""
-
 from irctest import cases
 from irctest.numerics import ERR_NEEDMOREPARAMS, ERR_NOORIGIN
 from irctest.patma import ANYSTR

irctest/server_tests/quit.py

@@ -1,21 +1,12 @@
-"""
-The QUITcommand  (`RFC 1459
-<https://datatracker.ietf.org/doc/html/rfc1459#section-4.1.6>`__,
-`RFC 2812 <https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.1>`__,
-`Modern <https://modern.ircdocs.horse/#quit-message>`__)
-
-TODO: cross-reference RFC 1459 and Modern
-"""
-
 import time
 
 from irctest import cases
+from irctest.numerics import ERR_CANNOTSENDTOCHAN
 from irctest.patma import StrRe
 
 
 class ChannelQuitTestCase(cases.BaseServerTestCase):
     @cases.mark_specifications("RFC2812")
-    @cases.xfailIfSoftware(["ircu2", "Nefarious", "snircd"], "ircu2 does not echo QUIT")
     def testQuit(self):
         """“Once a user has joined a channel, he receives information about
         all commands his server receives affecting the channel.  This
@@ -39,3 +30,31 @@ class ChannelQuitTestCase(cases.BaseServerTestCase):
         m = self.getMessage(1)
         self.assertMessageMatch(m, command="QUIT", params=[StrRe(".*qux out.*")])
         self.assertTrue(m.prefix.startswith("qux"))  # nickmask of quitter
+
+
+class NoCTCPTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testQuit(self):
+        self.connectClient("bar")
+        self.joinChannel(1, "#chan")
+        self.sendLine(1, "MODE #chan +C")
+        self.getMessages(1)
+
+        self.connectClient("qux")
+        self.joinChannel(2, "#chan")
+        self.getMessages(2)
+
+        self.sendLine(1, "PRIVMSG #chan :\x01ACTION hi\x01")
+        self.getMessages(1)
+        ms = self.getMessages(2)
+        self.assertEqual(len(ms), 1)
+        self.assertMessageMatch(
+            ms[0], command="PRIVMSG", params=["#chan", "\x01ACTION hi\x01"]
+        )
+
+        self.sendLine(1, "PRIVMSG #chan :\x01PING 1473523796 918320\x01")
+        ms = self.getMessages(1)
+        self.assertEqual(len(ms), 1)
+        self.assertMessageMatch(ms[0], command=ERR_CANNOTSENDTOCHAN)
+        ms = self.getMessages(2)
+        self.assertEqual(ms, [])

irctest/server_tests/readq.py

@@ -1,12 +1,9 @@
-"""
-`Ergo <https://ergo.chat/>`_-specific tests of responses to DoS attacks
-using long lines.
-"""
-
 from irctest import cases
 
 
 class ReadqTestCase(cases.BaseServerTestCase):
+    """Test responses to DoS attacks using long lines."""
+
     @cases.mark_specifications("Ergo")
     @cases.mark_capabilities("message-tags")
     def testReadqTags(self):

irctest/server_tests/register_verify.py

@@ -0,0 +1,132 @@
+from irctest import cases
+from irctest.patma import ANYSTR
+
+REGISTER_CAP_NAME = "draft/account-registration"
+
+
+@cases.mark_specifications("IRCv3")
+class RegisterBeforeConnectTestCase(cases.BaseServerTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"]["registration"].update(
+                {"allow-before-connect": True}
+            )
+        )
+
+    def testBeforeConnect(self):
+        self.addClient("bar")
+        self.requestCapabilities("bar", [REGISTER_CAP_NAME], skip_if_cap_nak=True)
+        self.sendLine("bar", "CAP LS 302")
+        caps = self.getCapLs("bar")
+        self.assertIn(REGISTER_CAP_NAME, caps)
+        self.assertIn("before-connect", caps[REGISTER_CAP_NAME])
+        self.sendLine("bar", "NICK bar")
+        self.sendLine("bar", "REGISTER * * shivarampassphrase")
+        msgs = self.getMessages("bar")
+        register_response = [msg for msg in msgs if msg.command == "REGISTER"][0]
+        self.assertMessageMatch(register_response, params=["SUCCESS", ANYSTR, ANYSTR])
+
+
+@cases.mark_specifications("IRCv3")
+class RegisterBeforeConnectDisallowedTestCase(cases.BaseServerTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"]["registration"].update(
+                {"allow-before-connect": False}
+            )
+        )
+
+    def testBeforeConnect(self):
+        self.addClient("bar")
+        self.requestCapabilities("bar", [REGISTER_CAP_NAME], skip_if_cap_nak=True)
+        self.sendLine("bar", "CAP LS 302")
+        caps = self.getCapLs("bar")
+        self.assertIn(REGISTER_CAP_NAME, caps)
+        self.assertEqual(caps[REGISTER_CAP_NAME], None)
+        self.sendLine("bar", "NICK bar")
+        self.sendLine("bar", "REGISTER * * shivarampassphrase")
+        msgs = self.getMessages("bar")
+        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
+        self.assertMessageMatch(
+            fail_response,
+            params=["REGISTER", "COMPLETE_CONNECTION_REQUIRED", ANYSTR, ANYSTR],
+        )
+
+
+@cases.mark_specifications("IRCv3")
+class RegisterEmailVerifiedTestCase(cases.BaseServerTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"]["registration"].update(
+                {
+                    "email-verification": {
+                        "enabled": True,
+                        "sender": "test@example.com",
+                        "require-tls": True,
+                        "helo-domain": "example.com",
+                    },
+                    "allow-before-connect": True,
+                }
+            )
+        )
+
+    def testBeforeConnect(self):
+        self.addClient("bar")
+        self.requestCapabilities(
+            "bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
+        )
+        self.sendLine("bar", "CAP LS 302")
+        caps = self.getCapLs("bar")
+        self.assertIn(REGISTER_CAP_NAME, caps)
+        self.assertEqual(
+            set(caps[REGISTER_CAP_NAME].split(",")),
+            {"before-connect", "email-required"},
+        )
+        self.sendLine("bar", "NICK bar")
+        self.sendLine("bar", "REGISTER * * shivarampassphrase")
+        msgs = self.getMessages("bar")
+        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
+        self.assertMessageMatch(
+            fail_response, params=["REGISTER", "INVALID_EMAIL", ANYSTR, ANYSTR]
+        )
+
+    def testAfterConnect(self):
+        self.connectClient(
+            "bar", name="bar", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
+        )
+        self.sendLine("bar", "REGISTER * * shivarampassphrase")
+        msgs = self.getMessages("bar")
+        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
+        self.assertMessageMatch(
+            fail_response, params=["REGISTER", "INVALID_EMAIL", ANYSTR, ANYSTR]
+        )
+
+
+@cases.mark_specifications("IRCv3", "Ergo")
+class RegisterNoLandGrabsTestCase(cases.BaseServerTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"]["registration"].update(
+                {"allow-before-connect": True}
+            )
+        )
+
+    def testBeforeConnect(self):
+        # have an anonymous client take the 'root' username:
+        self.connectClient(
+            "root", name="root", capabilities=[REGISTER_CAP_NAME], skip_if_cap_nak=True
+        )
+
+        # cannot register it out from under the anonymous nick holder:
+        self.addClient("bar")
+        self.sendLine("bar", "NICK root")
+        self.sendLine("bar", "REGISTER * * shivarampassphrase")
+        msgs = self.getMessages("bar")
+        fail_response = [msg for msg in msgs if msg.command == "FAIL"][0]
+        self.assertMessageMatch(
+            fail_response, params=["REGISTER", "USERNAME_EXISTS", ANYSTR, ANYSTR]
+        )

irctest/server_tests/regressions.py

@@ -1,14 +1,11 @@
 """
-Regression tests for bugs in `Ergo <https://ergo.chat/>`_.
+Regression tests for bugs in oragono.
 """
 
-from irctest import cases, runner
+import time
-from irctest.numerics import (
+
-    ERR_ERRONEUSNICKNAME,
+from irctest import cases
-    ERR_NICKNAMEINUSE,
+from irctest.numerics import ERR_ERRONEUSNICKNAME, ERR_NICKNAMEINUSE, RPL_WELCOME
-    RPL_HELLO,
-    RPL_WELCOME,
-)
 from irctest.patma import ANYDICT
 
 
@@ -42,21 +39,14 @@ class RegressionsTestCase(cases.BaseServerTestCase):
         self.getMessages(1)
         self.getMessages(2)
 
-        # 'alice' is claimed, so 'Alice' is reserved and Bob cannot take it:
+        # case change: both alice and bob should get a successful nick line
-        self.sendLine(2, "NICK Alice")
-        ms = self.getMessages(2)
-        self.assertEqual(len(ms), 1)
-        self.assertMessageMatch(ms[0], command=ERR_NICKNAMEINUSE)
-
-        # but alice can change case to 'Alice'; both alice and bob should get
-        # a successful NICK line
         self.sendLine(1, "NICK Alice")
         ms = self.getMessages(1)
         self.assertEqual(len(ms), 1)
-        self.assertMessageMatch(ms[0], nick="alice", command="NICK", params=["Alice"])
+        self.assertMessageMatch(ms[0], command="NICK", params=["Alice"])
         ms = self.getMessages(2)
         self.assertEqual(len(ms), 1)
-        self.assertMessageMatch(ms[0], nick="alice", command="NICK", params=["Alice"])
+        self.assertMessageMatch(ms[0], command="NICK", params=["Alice"])
 
         # no responses, either to the user or to friends, from a no-op nick change
         self.sendLine(1, "NICK Alice")
@@ -67,12 +57,6 @@ class RegressionsTestCase(cases.BaseServerTestCase):
 
     @cases.mark_capabilities("message-tags", "batch", "echo-message", "server-time")
     def testTagCap(self):
-        if self.controller.software_name == "UnrealIRCd":
-            raise runner.ImplementationChoice(
-                "Arbitrary +draft/reply values (TODO: adapt this test to use real "
-                "values so their pass Unreal's validation) "
-                "https://bugs.unrealircd.org/view.php?id=5948"
-            )
         # regression test for oragono #754
         self.connectClient(
             "alice",
@@ -115,13 +99,13 @@ class RegressionsTestCase(cases.BaseServerTestCase):
         )
 
     @cases.mark_specifications("RFC1459")
-    @cases.xfailIfSoftware(["ngIRCd"], "wat")
     def testStarNick(self):
         self.addClient(1)
         self.sendLine(1, "NICK *")
         self.sendLine(1, "USER u s e r")
         replies = {"NOTICE"}
-        while replies <= {"NOTICE", RPL_HELLO}:
+        time.sleep(2)  # give time to slow servers, like irc2 to reply
+        while replies == {"NOTICE"}:
             replies = set(msg.command for msg in self.getMessages(1, synchronize=False))
         self.assertIn(ERR_ERRONEUSNICKNAME, replies)
         self.assertNotIn(RPL_WELCOME, replies)
@@ -197,27 +181,3 @@ class RegressionsTestCase(cases.BaseServerTestCase):
         self.sendLine(2, "USER u s e r")
         reply = self.getRegistrationMessage(2)
         self.assertMessageMatch(reply, command=RPL_WELCOME)
-
-    @cases.mark_specifications("IRCv3")
-    def testLabeledNick(self):
-        """
-        InspIRCd up to 3.16.1 used the new nick as source of NICK changes
-
-        https://github.com/inspircd/inspircd/issues/2067
-
-        https://github.com/inspircd/inspircd/commit/83f01b36a11734fd91a4e7aad99c15463858fe4a
-        """
-        self.connectClient(
-            "alice",
-            capabilities=["batch", "labeled-response"],
-            skip_if_cap_nak=True,
-        )
-
-        self.sendLine(1, "@label=abc NICK alice2")
-        self.assertMessageMatch(
-            self.getMessage(1),
-            nick="alice",
-            command="NICK",
-            params=["alice2"],
-            tags={"label": "abc", **ANYDICT},
-        )

irctest/server_tests/relaymsg.py

@@ -1,7 +1,3 @@
-"""
-RELAYMSG command of `Ergo <https://ergo.chat/>`_
-"""
-
 from irctest import cases
 from irctest.irc_utils.junkdrawer import random_name
 from irctest.patma import ANYSTR

irctest/server_tests/roleplay.py

@@ -1,7 +1,3 @@
-"""
-Roleplay features of `Ergo <https://ergo.chat/>`_
-"""
-
 from irctest import cases
 from irctest.irc_utils.junkdrawer import random_name
 from irctest.numerics import ERR_CANNOTSENDRP