Add tests for PRIVMSG to a server mask

https://github.com/ircdocs/modern-irc/pull/134

A bunch of tests are failing, we need to work this out in the Modern PR

Note: it needs the following patch to plexus4 to be relevant:

```diff
diff --git a/modules/core/m_message.c b/modules/core/m_message.c
index adf0821..7568f20 100644
--- a/modules/core/m_message.c
+++ b/modules/core/m_message.c
@@ -575,7 +575,7 @@ handle_special(int p_or_n, const char *command, struct Client *client_p,
       return;
     }

-    if (MyClient(source_p) && !HasUMode(source_p, UMODE_NETADMIN) && !HasFlag(source_p, FLAGS_SERVICE) && strcmp(nick + 1, me.name))
+    if (false)
     {
       sendto_one(source_p, form_str(ERR_NOPRIVILEGES), me.name, source_p->name);
       return;
```

(I'm too lazy to figure out how to become a netadmin)

.github/workflows/lint.yml

@@ -0,0 +1,41 @@
+name: Lint
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        path: |
+          ~/.cache
+        key: ${{ runner.os }}-lint
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install pre-commit pytest
+        pip install -r requirements.txt
+
+    - name: Lint
+      run: |
+        pre-commit run -a
+
+    - name: Check generated workflows are in sync
+      run: |
+        python make_workflows.py
+        git diff --exit-code

.github/workflows/test-devel.yml

@@ -0,0 +1,989 @@
+# This file was auto-generated by make_workflows.py.
+# Do not edit it manually, modifications will be lost.
+
+jobs:
+  build-anope:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache Anope
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-anope-2.0.9
+        path: '~/.cache
+
+          ${{ github.workspace }}/anope
+
+          '
+    - name: Checkout Anope
+      uses: actions/checkout@v2
+      with:
+        path: anope
+        ref: 2.0.9
+        repository: anope/anope
+    - name: Build Anope
+      run: |-
+        cd $GITHUB_WORKSPACE/anope/
+        cp $GITHUB_WORKSPACE/data/anope/* .
+        CFLAGS=-O0 ./Config -quick
+        make -C build -j 4
+        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@v2
+      with:
+        name: installed-anope
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-bahamut:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-bahamut-devel
+        path: '~/.cache
+
+          ${ github.workspace }/Bahamut
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout Bahamut
+      uses: actions/checkout@v2
+      with:
+        path: Bahamut
+        ref: master
+        repository: DALnet/Bahamut
+    - name: Build Bahamut
+      run: |
+        cd $GITHUB_WORKSPACE/Bahamut/
+        patch src/s_user.c < $GITHUB_WORKSPACE/bahamut_localhost.patch
+        echo "#undef THROTTLE_ENABLE" >> include/config.h
+        libtoolize --force
+        aclocal
+        autoheader
+        automake --force-missing --add-missing || true
+        autoreconf
+        ./configure --prefix=$HOME/.local/
+        make -j 4
+        make install
+        mkdir -p $HOME/.local/bin/
+        cp $HOME/.local/ircd $HOME/.local/bin/ircd
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-bahamut.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-bahamut
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-hybrid:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-hybrid-devel
+        path: '~/.cache
+
+          ${ github.workspace }/ircd-hybrid
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout Hybrid
+      uses: actions/checkout@v2
+      with:
+        path: ircd-hybrid
+        ref: 8.2.x
+        repository: ircd-hybrid/ircd-hybrid
+    - name: Build Hybrid
+      run: |
+        cd $GITHUB_WORKSPACE/ircd-hybrid/
+        ./configure --prefix=$HOME/.local/
+        make -j 4
+        make install
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-hybrid.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-hybrid
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-inspircd:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout InspIRCd
+      uses: actions/checkout@v2
+      with:
+        path: inspircd
+        ref: master
+        repository: inspircd/inspircd
+    - name: Build InspIRCd
+      run: |
+        cd $GITHUB_WORKSPACE/inspircd/
+        patch src/inspircd.cpp < $GITHUB_WORKSPACE/inspircd_mainloop.patch
+        ./configure --prefix=$HOME/.local/inspircd --development
+        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@v2
+      with:
+        name: installed-inspircd
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-ngircd:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-ngircd-devel
+        path: '~/.cache
+
+          ${ github.workspace }/ngircd
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout ngircd
+      uses: actions/checkout@v2
+      with:
+        path: ngircd
+        ref: master
+        repository: ngircd/ngircd
+    - name: Build ngircd
+      run: |
+        cd $GITHUB_WORKSPACE/ngircd
+        ./autogen.sh
+        ./configure --prefix=$HOME/.local/
+        make -j 4
+        make install
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-ngircd.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-ngircd
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-plexus4:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-plexus4-devel
+        path: '~/.cache
+
+          ${ github.workspace }/placeholder
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: clone
+      run: 'curl https://gitlab.com/rizon/plexus4/-/archive/master/plexus4-master.tar.gz
+        | tar -zx
+
+        mv plexus4* plexus4'
+    - name: build
+      run: 'cd $GITHUB_WORKSPACE/plexus4
+
+        ./autogen.sh
+
+        ./configure --prefix=$HOME/.local/
+
+        make -j 4
+
+        make install'
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-plexus4.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-plexus4
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-solanum:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-solanum-devel
+        path: '~/.cache
+
+          ${ github.workspace }/solanum
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout Solanum
+      uses: actions/checkout@v2
+      with:
+        path: solanum
+        ref: main
+        repository: solanum-ircd/solanum
+    - name: Build Solanum
+      run: |
+        cd $GITHUB_WORKSPACE/solanum/
+        ./autogen.sh
+        ./configure --prefix=$HOME/.local/
+        make -j 4
+        make install
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-solanum.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-solanum
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-unrealircd:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-unrealircd-devel
+        path: '~/.cache
+
+          ${ github.workspace }/unrealircd
+
+          '
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout UnrealIRCd
+      uses: actions/checkout@v2
+      with:
+        path: unrealircd
+        ref: unreal52
+        repository: unrealircd/unrealircd
+    - name: Build UnrealIRCd
+      run: |
+        cd $GITHUB_WORKSPACE/unrealircd/
+        cp $GITHUB_WORKSPACE/data/unreal/* .
+        # Need to use a specific -march, because GitHub has inconsistent
+        # architectures across workers, which result in random SIGILL with some
+        # worker combinations
+        sudo apt install libsodium-dev libargon2-dev
+        CFLAGS="-O0 -march=x86-64" CXXFLAGS="$CFLAGS" ./Config -quick
+        make -j 4
+        make install
+    - name: Make artefact tarball
+      run: cd ~; tar -czf artefacts-unrealircd.tar.gz .local/ go/
+    - name: Upload build artefacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: installed-unrealircd
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  publish-test-results:
+    if: success() || failure()
+    name: Publish Unit Tests Results
+    needs:
+    - test-bahamut
+    - test-bahamut-anope
+    - test-bahamut-atheme
+    - test-ergo
+    - test-hybrid
+    - test-inspircd
+    - test-inspircd-anope
+    - test-ircu2
+    - test-limnoria
+    - test-ngircd
+    - test-ngircd-anope
+    - test-ngircd-atheme
+    - test-plexus4
+    - test-solanum
+    - test-sopel
+    - test-unrealircd
+    - test-unrealircd-anope
+    - test-unrealircd-atheme
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Download Artifacts
+      uses: actions/download-artifact@v2
+      with:
+        path: artifacts
+    - if: github.event_name == 'pull_request'
+      name: Publish Unit Test Results
+      uses: actions/github-script@v4
+      with:
+        result-encoding: string
+        script: |
+          let body = '';
+          const options = {};
+          options.listeners = {
+              stdout: (data) => {
+                  body += data.toString();
+              }
+          };
+          await exec.exec('bash', ['-c', 'shopt -s globstar; python3 report.py artifacts/**/*.xml'], options);
+          github.issues.createComment({
+            issue_number: context.issue.number,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body,
+          });
+          return body;
+  test-bahamut:
+    needs:
+    - build-bahamut
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-bahamut
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        bahamut
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results bahamut (devel)
+        path: pytest.xml
+  test-bahamut-anope:
+    needs:
+    - build-bahamut
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-bahamut
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH   make
+        bahamut-anope
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results bahamut-anope (devel)
+        path: pytest.xml
+  test-bahamut-atheme:
+    needs:
+    - build-bahamut
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-bahamut
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        bahamut-atheme
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results bahamut-atheme (devel)
+        path: pytest.xml
+  test-ergo:
+    needs: []
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout Ergo
+      uses: actions/checkout@v2
+      with:
+        path: ergo
+        ref: master
+        repository: ergochat/ergo
+    - uses: actions/setup-go@v2
+      with:
+        go-version: ~1.16
+    - run: go version
+    - name: Build Ergo
+      run: |
+        cd $GITHUB_WORKSPACE/ergo/
+        make build
+        make install
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/go/sbin:~/go/bin:$PATH
+        make ergo
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results ergo (devel)
+        path: pytest.xml
+  test-hybrid:
+    needs:
+    - build-hybrid
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-hybrid
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        hybrid
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results hybrid (devel)
+        path: pytest.xml
+  test-inspircd:
+    needs:
+    - build-inspircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH
+        make inspircd
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results inspircd (devel)
+        path: pytest.xml
+  test-inspircd-anope:
+    needs:
+    - build-inspircd
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-inspircd
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH  make
+        inspircd-anope
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results inspircd-anope (devel)
+        path: pytest.xml
+  test-ircu2:
+    needs: []
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout ircu2
+      uses: actions/checkout@v2
+      with:
+        path: ircu2
+        ref: u2_10_12_branch
+        repository: undernetirc/ircu2
+    - name: Build ircu2
+      run: |
+        cd $GITHUB_WORKSPACE/ircu2
+        # We need --with-maxcon, to set MAXCONNECTIONS so that it's much lower than
+        # NN_MAX_CLIENT, or ircu2 crashes with a somewhat cryptic error on startup.
+        ./configure --prefix=$HOME/.local/ --with-maxcon=1024 --enable-debug
+        make -j 4
+        make install
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        ircu2
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results ircu2 (devel)
+        path: pytest.xml
+  test-limnoria:
+    needs: []
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Install dependencies
+      run: pip install git+https://github.com/ProgVal/Limnoria.git@testing cryptography
+        pyxmpp2-scram
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        limnoria
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results limnoria (devel)
+        path: pytest.xml
+  test-ngircd:
+    needs:
+    - build-ngircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-ngircd
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local//sbin:~/.local//bin:$PATH
+        make ngircd
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results ngircd (devel)
+        path: pytest.xml
+  test-ngircd-anope:
+    needs:
+    - build-ngircd
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-ngircd
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local//sbin:~/.local//bin:$PATH  make
+        ngircd-anope
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results ngircd-anope (devel)
+        path: pytest.xml
+  test-ngircd-atheme:
+    needs:
+    - build-ngircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-ngircd
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local//sbin:~/.local//bin:$PATH
+        make ngircd-atheme
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results ngircd-atheme (devel)
+        path: pytest.xml
+  test-plexus4:
+    needs:
+    - build-plexus4
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-plexus4
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH   make
+        plexus4
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results plexus4 (devel)
+        path: pytest.xml
+  test-solanum:
+    needs:
+    - build-solanum
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-solanum
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        solanum
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results solanum (devel)
+        path: pytest.xml
+  test-sopel:
+    needs: []
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Install dependencies
+      run: pip install git+https://github.com/sopel-irc/sopel.git
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  make
+        sopel
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results sopel (devel)
+        path: pytest.xml
+  test-unrealircd:
+    needs:
+    - build-unrealircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-unrealircd
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/unrealircd/sbin:~/.local/unrealircd/bin:$PATH
+        make unrealircd
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results unrealircd (devel)
+        path: pytest.xml
+  test-unrealircd-anope:
+    needs:
+    - build-unrealircd
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-unrealircd
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/unrealircd/sbin:~/.local/unrealircd/bin:$PATH  make
+        unrealircd-anope
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results unrealircd-anope (devel)
+        path: pytest.xml
+  test-unrealircd-atheme:
+    needs:
+    - build-unrealircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-unrealircd
+        path: '~'
+    - name: Unpack artefacts
+      run: cd ~; find -name 'artefacts-*.tar.gz' -exec tar -xzf '{}' \;
+    - name: Install Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/unrealircd/sbin:~/.local/unrealircd/bin:$PATH
+        make unrealircd-atheme
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results unrealircd-atheme (devel)
+        path: pytest.xml
+name: irctest with devel versions
+'on':
+  schedule:
+  - cron: 51 8 * * 6
+  - cron: 51 8 * * 0
+  - cron: 51 17 * * *
+  workflow_dispatch: null

.github/workflows/test-devel_release.yml

@@ -0,0 +1,215 @@
+# This file was auto-generated by make_workflows.py.
+# Do not edit it manually, modifications will be lost.
+
+jobs:
+  build-anope:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - name: Cache Anope
+      uses: actions/cache@v2
+      with:
+        key: 3-${{ runner.os }}-anope-2.0.9
+        path: '~/.cache
+
+          ${{ github.workspace }}/anope
+
+          '
+    - name: Checkout Anope
+      uses: actions/checkout@v2
+      with:
+        path: anope
+        ref: 2.0.9
+        repository: anope/anope
+    - name: Build Anope
+      run: |-
+        cd $GITHUB_WORKSPACE/anope/
+        cp $GITHUB_WORKSPACE/data/anope/* .
+        CFLAGS=-O0 ./Config -quick
+        make -C build -j 4
+        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@v2
+      with:
+        name: installed-anope
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  build-inspircd:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Create directories
+      run: cd ~/; mkdir -p .local/ go/
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Checkout InspIRCd
+      uses: actions/checkout@v2
+      with:
+        path: inspircd
+        ref: insp3
+        repository: inspircd/inspircd
+    - name: Build InspIRCd
+      run: |
+        cd $GITHUB_WORKSPACE/inspircd/
+        patch src/inspircd.cpp < $GITHUB_WORKSPACE/inspircd_mainloop.patch
+        ./configure --prefix=$HOME/.local/inspircd --development
+        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@v2
+      with:
+        name: installed-inspircd
+        path: ~/artefacts-*.tar.gz
+        retention-days: 1
+  publish-test-results:
+    if: success() || failure()
+    name: Publish Unit Tests Results
+    needs:
+    - test-inspircd
+    - test-inspircd-anope
+    - test-inspircd-atheme
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Download Artifacts
+      uses: actions/download-artifact@v2
+      with:
+        path: artifacts
+    - if: github.event_name == 'pull_request'
+      name: Publish Unit Test Results
+      uses: actions/github-script@v4
+      with:
+        result-encoding: string
+        script: |
+          let body = '';
+          const options = {};
+          options.listeners = {
+              stdout: (data) => {
+                  body += data.toString();
+              }
+          };
+          await exec.exec('bash', ['-c', 'shopt -s globstar; python3 report.py artifacts/**/*.xml'], options);
+          github.issues.createComment({
+            issue_number: context.issue.number,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body,
+          });
+          return body;
+  test-inspircd:
+    needs:
+    - build-inspircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH
+        make inspircd
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results inspircd (devel_release)
+        path: pytest.xml
+  test-inspircd-anope:
+    needs:
+    - build-inspircd
+    - build-anope
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      uses: actions/download-artifact@v2
+      with:
+        name: installed-inspircd
+        path: '~'
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH  make
+        inspircd-anope
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results inspircd-anope (devel_release)
+        path: pytest.xml
+  test-inspircd-atheme:
+    needs:
+    - build-inspircd
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.7
+    - name: Download build artefacts
+      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 Atheme
+      run: sudo apt-get install atheme-services
+    - name: Install irctest dependencies
+      run: |-
+        python -m pip install --upgrade pip
+        pip install pytest pytest-xdist -r requirements.txt
+    - name: Test with pytest
+      run: PYTEST_ARGS='--junit-xml pytest.xml' PATH=$HOME/.local/bin:$PATH  PATH=~/.local/inspircd/sbin:~/.local/inspircd/bin:$PATH
+        make inspircd-atheme
+    - if: always()
+      name: Publish results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest results inspircd-atheme (devel_release)
+        path: pytest.xml
+name: irctest with devel_release versions
+'on':
+  schedule:
+  - cron: 51 8 * * 6
+  - cron: 51 8 * * 0
+  - cron: 51 17 * * *
+  workflow_dispatch: null

.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+exclude: ^irctest/scram
+
+repos:
+  - repo: https://github.com/psf/black
+    rev: 20.8b1
+    hooks:
+      - id: black
+        language_version: python3
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.5.2
+    hooks:
+      - id: isort
+
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.3
+    hooks:
+      - id: flake8
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.812
+    hooks:
+      - id: mypy

CONTRIBUTING.md

@@ -0,0 +1,92 @@
+# Contributing
+
+## Code style
+
+### Syntax
+
+Any color you like as long as it's [Black](https://github.com/psf/black).
+In short:
+
+* 88 columns
+* double quotes
+* avoid backslashes at line breaks (use parentheses)
+* closing brackets/parentheses/... go on the same indent level as the line
+  that opened them
+
+We also use `isort` to order imports (in short: just
+[follow PEP 8](https://www.python.org/dev/peps/pep-0008/#imports))
+
+You can use [pre-commit](https://pre-commit.com/) to automatically run them
+when you create a git commit.
+Alternatively, run `pre-commit run -a`
+
+
+### Naming
+
+[Follow PEP 8](https://www.python.org/dev/peps/pep-0008/#naming-conventions),
+with these exceptions:
+
+* assertion methods (eg. `assertMessageMatch` are mixedCase to be consistent
+  with the unittest module)
+* other methods defined in `cases.py` are also mixedCase for consistency with
+  the former, for now
+* test names are also mixedCase for the same reason
+
+Additionally:
+
+* test module names should be snake\_case and match the name of the
+  specification they are testing (if IRCv3), or the feature they are
+  testing (if RFC or just common usage)
+
+
+## What to test
+
+**All tests should have a docstring** pointing to a reference document
+(eg. RFC, IRCv3 specification, or modern.ircdocs.horse).
+If there is no reference, documentation can do.
+
+If the behavior being tested is not documented, then **please document it
+outside** this repository (eg. at modern.ircdocs.horse),
+and/or get it specified through IRCv3.
+
+"That's just how everyone does it" is not good justification.
+Linking to an external document saying "Here is how everyone does it" is.
+
+If reference documents / documentations are long or not trivial,
+**try to quote the specific part being tested**.
+See `irctest/server_tests/kick.py` for example.
+
+Tests for **pending/draft specifications are welcome**.
+
+Note that irctest also welcomes implementation-specific tests for
+functional testing; for now only Ergo.
+This does not relax the requirement on documentating tests.
+
+
+## Writing tests
+
+**Use unittest-style assertions** (`self.assertEqual(x, y)` instead of
+pytest-style (`assert x == y`). This allows consistency with the assertion
+methods we define, such as `assertMessageMatch`.
+
+Always **add an error message in assertions**.
+`irctest` should show readable errors to people unfamiliar with the
+codebase.
+Ideally, explain what happened and what should have happened instead.
+
+All tests should be tagged with
+`@cases.mark_specifications`.
+
+
+## Continuous integration
+
+We run automated tests on all commits and pull requests, to check that tests
+accept existing implementations.
+Scripts to run the tests are defined in `workflows.yml`, and the
+`make_workflows.py` script reads this configuration to generate files
+in `.github/workflows/` that are used by the CI.
+
+If an implementation cannot pass a test, that test should be excluded via
+a definition in the Makefile.
+If it is a bug, please open a bug report to the affected software if possible,
+and link to the bug report in a comment.

Makefile

@@ -1,5 +1,331 @@
-.PHONY: oragono
+PYTEST ?= python3 -m pytest
 
-oragono:
-	pyflakes3 ./irctest/cases.py ./irctest/client_mock.py ./irctest/controllers/oragono.py irctest/server_tests/*.py
-	./test.py irctest.controllers.oragono
+# Extra arguments to pass to pytest (eg. `-n 4` to run in parallel if
+# pytest-xdist is installed)
+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
+BAHAMUT_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not IRCv3 \
+	and not buffering \
+	$(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
+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) \
+	$(EXTRA_SELECTORS)
+
+ERGO_SELECTORS := \
+	not deprecated \
+	$(EXTRA_SELECTORS)
+
+# testInviteUnoppedModern is the only strict test that Hybrid fails
+HYBRID_SELECTORS := \
+	not Ergo \
+	and not testInviteUnoppedModern \
+	and not deprecated \
+	$(EXTRA_SELECTORS)
+
+# testNoticeNonexistentChannel fails because of https://github.com/inspircd/inspircd/issues/1849
+# testBotPrivateMessage and testBotChannelMessage fail because https://github.com/inspircd/inspircd/pull/1910 is not released yet
+# testNamesInvalidChannel and testNamesNonexistingChannel fail because https://github.com/inspircd/inspircd/pull/1922 is not released yet.
+INSPIRCD_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not testNoticeNonexistentChannel \
+	and not testBotPrivateMessage and not testBotChannelMessage \
+	and not testNamesInvalidChannel and not testNamesNonexistingChannel \
+	$(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 tests fail because they depend on Modern behavior, not just RFC2812 (TODO: update lusers tests to accept RFC2812-compliant implementations)
+# 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.
+IRCU2_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not buffering \
+	and not testQuit \
+	and not lusers \
+	and not statusmsg \
+	and not (testKeyValidation and empty) \
+	and not testKickDefaultComment \
+	and not testEmptyRealname \
+	$(EXTRA_SELECTORS)
+
+# same justification as ircu2
+SNIRCD_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not buffering \
+	and not testQuit \
+	and not lusers \
+	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
+IRC2_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not testListEmpty and not testListOne \
+	and not testKickDefaultComment \
+	and not testWallopsPrivileges \
+	$(EXTRA_SELECTORS)
+
+MAMMON_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	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
+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 \
+	$(EXTRA_SELECTORS)
+
+# testInviteUnoppedModern is the only strict test that Plexus4 fails
+# testInviteInviteOnlyModern fails because Plexus4 allows non-op to invite if (and only if) the channel is not invite-only
+PLEXUS4_SELECTORS := \
+	not Ergo \
+	and not testInviteUnoppedModern \
+	and not testInviteInviteOnlyModern \
+	and not deprecated \
+	$(EXTRA_SELECTORS)
+
+# Limnoria 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
+LIMNORIA_SELECTORS := \
+	(foo or not foo) \
+	$(EXTRA_SELECTORS)
+
+# testQuitErrors is too flaky for CI
+# testKickDefaultComment fails because solanum uses the nick of the kickee rather than the kicker.
+SOLANUM_SELECTORS := \
+	not Ergo \
+	and not deprecated \
+	and not strict \
+	and not testQuitErrors \
+	and not testKickDefaultComment \
+	$(EXTRA_SELECTORS)
+
+SOPEL_SELECTORS := \
+	not testPlainNotAvailable \
+	$(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
+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)) \
+	$(EXTRA_SELECTORS)
+
+.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 limnoria sopel solanum unrealircd
+
+flakes:
+	find irctest/ -name "*.py" -not -path "irctest/scram/*" -print0 | xargs -0 pyflakes3
+
+bahamut:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.bahamut \
+		-m 'not services' \
+		-n 10 \
+		-k '$(BAHAMUT_SELECTORS)'
+
+bahamut-atheme:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.bahamut \
+		--services-controller=irctest.controllers.atheme_services \
+		-m 'services' \
+		-n 10 \
+		-k '$(BAHAMUT_SELECTORS)'
+
+bahamut-anope:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.bahamut \
+		--services-controller=irctest.controllers.anope_services \
+		-m 'services' \
+		-n 10 \
+		-k '$(BAHAMUT_SELECTORS) $(ANOPE_SELECTORS)'
+
+charybdis:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.charybdis \
+		--services-controller=irctest.controllers.atheme_services \
+		-k '$(CHARYBDIS_SELECTORS)'
+
+ergo:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.ergo \
+		-k "$(ERGO_SELECTORS)"
+
+hybrid:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.hybrid \
+		-m 'not services' \
+		-k "$(HYBRID_SELECTORS)"
+
+inspircd:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.inspircd \
+		-m 'not services' \
+		-k '$(INSPIRCD_SELECTORS)'
+
+inspircd-atheme:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.inspircd \
+		--services-controller=irctest.controllers.atheme_services \
+		-m 'services' \
+		-k '$(INSPIRCD_SELECTORS)'
+
+inspircd-anope:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.inspircd \
+		--services-controller=irctest.controllers.anope_services \
+		-m 'services' \
+		-k '$(INSPIRCD_SELECTORS) $(ANOPE_SELECTORS)'
+
+ircu2:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.ircu2 \
+		-m 'not services and not IRCv3' \
+		-n 10 \
+		-k '$(IRCU2_SELECTORS)'
+
+snircd:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.snircd \
+		-m 'not services and not IRCv3' \
+		-n 10 \
+		-k '$(SNIRCD_SELECTORS)'
+
+irc2:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.irc2 \
+		-m 'not services and not IRCv3' \
+		-n 10 \
+		-k '$(IRC2_SELECTORS)'
+
+limnoria:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.limnoria \
+		-k '$(LIMNORIA_SELECTORS)'
+
+mammon:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.mammon \
+		-k '$(MAMMON_SELECTORS)'
+
+plexus4:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.plexus4 \
+		-m 'not services' \
+		-k "$(PLEXUS4_SELECTORS)"
+
+ngircd:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.ngircd \
+		-m 'not services' \
+		-n 10 \
+		-k "$(NGIRCD_SELECTORS)"
+
+ngircd-anope:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.ngircd \
+		--services-controller=irctest.controllers.anope_services \
+		-m 'services' \
+		-k "$(NGIRCD_SELECTORS)"
+
+ngircd-atheme:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller irctest.controllers.ngircd \
+		--services-controller=irctest.controllers.atheme_services \
+		-m 'services' \
+		-k "$(NGIRCD_SELECTORS)"
+
+solanum:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.solanum \
+		--services-controller=irctest.controllers.atheme_services \
+		-k '$(SOLANUM_SELECTORS)'
+
+sopel:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.sopel \
+		-k '$(SOPEL_SELECTORS)'
+
+unrealircd:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.unrealircd \
+		-m 'not services' \
+		-k '$(UNREALIRCD_SELECTORS)'
+
+unrealircd-atheme:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.unrealircd \
+		--services-controller=irctest.controllers.atheme_services \
+		-m 'services' \
+		-k '$(UNREALIRCD_SELECTORS)'
+
+unrealircd-anope:
+	$(PYTEST) $(PYTEST_ARGS) \
+		--controller=irctest.controllers.unrealircd \
+		--services-controller=irctest.controllers.anope_services \
+		-m 'services' \
+		-k '$(UNREALIRCD_SELECTORS) $(ANOPE_SELECTORS)'

README.md

@@ -1,10 +1,7 @@
 # irctest
 
 This project aims at testing interoperability of software using the
-IRC protocol, by running them against test suites and making different
-software communicate with each other.
-
-It is very young and does not contain a lot of test cases yet.
+IRC protocol, by running them against common test suites.
 
 ## The big picture
 
@@ -14,95 +11,193 @@ This project contains:
 * small wrappers around existing software to run tests on them
 
 Wrappers run software in temporary directories, so running `irctest` should
-have no side effect, with [the exception of Sopel](https://github.com/sopel-irc/sopel/issues/946).
+have no side effect.
 
 ## Prerequisites
 
 Install irctest and dependencies:
 
 ```
+cd ~
 git clone https://github.com/ProgVal/irctest.git
 cd irctest
 pip3 install --user -r requirements.txt
 python3 setup.py install --user
 ```
 
-Add `~/.local/bin/` to your `PATH` if it is not.
+Add `~/.local/bin/` (and/or `~/go/bin/` for Ergo)
+to your `PATH` if it is not.
 
 ```
-export PATH=$HOME/.local/bin/:$PATH
+export PATH=$HOME/.local/bin/:$HOME/go/bin/:$PATH
 ```
 
-## Run tests
+## Using pytest
 
-To run (client) tests on Limnoria:
+irctest is invoked using the pytest test runner / CLI.
 
-```
-pip3 install --user limnoria
-python3 -m irctest irctest.controllers.limnoria
-```
+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).
 
-To run (client) tests on Sopel:
+The rest of this README assumes `pytest` works.
 
-```
-pip3 install --user sopel
-mkdir ~/.sopel/
-python3 -m irctest irctest.controllers.sopel
-```
+## Test selection
 
-To run (server) tests on InspIRCd:
+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`.
+
+By default, all tests run; even niche ones. So you probably always want to
+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
+  integration test suite)
+* tests for deprecated specifications, such as the IRCv3 METADATA
+  specification
+* tests that check for a strict interpretation of a specification, when
+  the specification is ambiguous.
+
+## Running tests
+
+### Servers
+
+#### Ergo:
 
 ```
 cd /tmp/
-git clone https://github.com/inspircd/inspircd.git
-cd inspircd
-./configure --prefix=$HOME/.local/ --development
+git clone https://github.com/ergochat/ergo.git
+cd ergo/
+make install
+cd ~/irctest
+pytest --controller irctest.controllers.ergo -k 'not deprecated'
+```
+
+#### Solanum:
+
+```
+cd /tmp/
+git clone https://github.com/solanum-ircd/solanum.git
+cd solanum
+./autogen.sh
+./configure --prefix=$HOME/.local/
 make -j 4
 make install
-python3 -m irctest irctest.controllers.inspircd
+pytest --controller irctest.controllers.solanum -k 'not Ergo and not deprecated and not strict'
 ```
 
-To run (server) tests on Mammon:
-
-```
-pip3 install --user git+https://github.com/mammon-ircd/mammon.git
-python3 -m irctest irctest.controllers.mammon
-```
-
-To run (server) tests on Charybdis::
+#### Charybdis:
 
 ```
 cd /tmp/
 git clone https://github.com/atheme/charybdis.git
 cd charybdis
+./autogen.sh
 ./configure --prefix=$HOME/.local/
 make -j 4
 make install
-python3 -m irctest irctest.controllers.charybdis
+cd ~/irctest
+pytest --controller irctest.controllers.charybdis -k 'not Ergo and not deprecated and not strict'
 ```
 
-## Full help
+#### InspIRCd:
 
 ```
-usage: python3 -m irctest [-h] [--show-io] [-v] [-s SPECIFICATION] [-l] module
+cd /tmp/
+git clone https://github.com/inspircd/inspircd.git
+cd inspircd
 
-positional arguments:
-  module                The module used to run the tested program.
+# optional, makes tests run considerably faster
+patch src/inspircd.cpp < ~/irctest/inspircd_mainloop.patch
 
-optional arguments:
-  -h, --help            show this help message and exit
-  --show-io             Show input/outputs with the tested program.
-  -v, --verbose         Verbosity. Give this option multiple times to make it
-                        even more verbose.
-  -s SPECIFICATION, --specification SPECIFICATION
-                        The set of specifications to test the program with.
-                        Valid values: RFC1459, RFC2812, IRCv3.1, IRCv3.2. Use
-                        this option multiple times to test with multiple
-                        specifications. If it is not given, defaults to all.
-  -l, --loose           Disables strict checks of conformity to the
-                        specification. Strict means the specification is
-                        unclear, and the most restrictive interpretation is
-                        choosen.
+./configure --prefix=$HOME/.local/ --development
+make -j 4
+make install
+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:
+
+```
+cd /tmp/
+git clone https://github.com/unrealircd/unrealircd.git
+cd unrealircd
+./Config  # This will ask a few questions, answer them.
+make -j 4
+make install
+cd ~/irctest
+pytest --controller irctest.controllers.unreal -k 'not Ergo and not deprecated and not strict'
+```
+
+
+### Servers with services
+
+Besides Ergo (that has built-in services), most server controllers can optionally run
+service packages.
+
+#### Atheme:
+
+You can install it with
+
+```
+sudo apt install atheme-services
+```
+
+and add this to the `pytest` call:
+
+```
+--services-controller irctest.controllers.atheme_services
+```
+
+#### Anope:
+
+Build with:
+
+```
+cd /tmp/
+git clone https://github.com/anope/anope.git
+cd anope
+./Config  # This will ask a few questions, answer them.
+make -C build -j 4
+make -C build install
+```
+
+and add this to the `pytest` call:
+
+```
+--services-controller irctest.controllers.anope_services
+```
+
+
+### Clients
+
+#### Limnoria:
+
+```
+pip3 install --user limnoria pyxmpp2-scram
+cd ~/irctest
+pytest --controller  irctest.controllers.limnoria
+```
+
+#### Sopel:
+
+```
+pip3 install --user sopel
+mkdir ~/.sopel/
+cd ~/irctest
+pytest --controller irctest.controllers.sopel
 ```
 
 ## What `irctest` is not
@@ -114,3 +209,4 @@ At best, `irctest` can help you find issues in your software, but it may
 still have false positives (because it does not implement itself a
 full-featured client/server, so it supports only “usual” behavior).
 Bug reports for false positives are welcome.
+

bahamut_localhost.patch

@@ -0,0 +1,20 @@
+Allows connections from localhost
+
+diff --git a/src/s_user.c b/src/s_user.c
+index 317b00e..adfcfcf 100644
+--- a/src/s_user.c
++++ b/src/s_user.c
+@@ -594,13 +594,6 @@ register_user(aClient *cptr, aClient *sptr, char *nick, char *username,
+ 	    dots = 1;
+ 	}
+ 
+-	if (!dots) 
+-        {
+-            sendto_realops("Invalid hostname for %s, dumping user %s",
+-                           sptr->hostip, sptr->name);
+-            return exit_client(cptr, sptr, &me, "Invalid hostname");
+-        }
+-        
+         if (bad_dns) 
+         {
+             sendto_one(sptr, ":%s NOTICE %s :*** Notice -- You have a bad "

conftest.py

@@ -0,0 +1,126 @@
+import importlib
+
+import _pytest.unittest
+import pytest
+
+# Must be called before importing irctest.cases.
+pytest.register_assert_rewrite("irctest.cases")
+
+from irctest.basecontrollers import (  # noqa: E402
+    BaseClientController,
+    BaseServerController,
+)
+from irctest.cases import (  # noqa: E402
+    BaseClientTestCase,
+    BaseServerTestCase,
+    _IrcTestCase,
+)
+
+
+def pytest_addoption(parser):
+    """Called by pytest, registers CLI options passed to the pytest command."""
+    parser.addoption(
+        "--controller", help="Which module to use to run the tested software."
+    )
+    parser.addoption(
+        "--services-controller", help="Which module to use to run a services package."
+    )
+    parser.addoption(
+        "--openssl-bin", type=str, default="openssl", help="The openssl binary to use"
+    )
+
+
+def pytest_configure(config):
+    """Called by pytest, after it parsed the command-line."""
+    module_name = config.getoption("controller")
+    services_module_name = config.getoption("services_controller")
+
+    if module_name is None:
+        print("Missing --controller option, errors may occur.")
+        _IrcTestCase.controllerClass = None
+        _IrcTestCase.show_io = True  # TODO
+        return
+
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError:
+        pytest.exit("Cannot import module {}".format(module_name), 1)
+
+    controller_class = module.get_irctest_controller_class()
+    if issubclass(controller_class, BaseClientController):
+        from irctest import client_tests as module
+
+        if services_module_name is not None:
+            pytest.exit("You may not use --services-controller for client tests.")
+    elif issubclass(controller_class, BaseServerController):
+        from irctest import server_tests as module
+    else:
+        pytest.exit(
+            r"{}.Controller should be a subclass of "
+            r"irctest.basecontroller.Base{{Client,Server}}Controller".format(
+                module_name
+            ),
+            1,
+        )
+
+    if services_module_name is not None:
+        try:
+            services_module = importlib.import_module(services_module_name)
+        except ImportError:
+            pytest.exit("Cannot import module {}".format(services_module_name), 1)
+        controller_class.services_controller_class = (
+            services_module.get_irctest_controller_class()
+        )
+
+    _IrcTestCase.controllerClass = controller_class
+    _IrcTestCase.controllerClass.openssl_bin = config.getoption("openssl_bin")
+    _IrcTestCase.show_io = True  # TODO
+
+
+def pytest_collection_modifyitems(session, config, items):
+    """Called by pytest after finishing the test collection,
+    and before actually running the tests.
+
+    This function filters out client tests if running with a server controller,
+    and vice versa.
+    """
+
+    # First, check if we should run server tests or client tests
+    server_tests = client_tests = False
+    if _IrcTestCase.controllerClass is None:
+        pass
+    elif issubclass(_IrcTestCase.controllerClass, BaseServerController):
+        server_tests = True
+    elif issubclass(_IrcTestCase.controllerClass, BaseClientController):
+        client_tests = True
+    else:
+        assert False, (
+            f"{_IrcTestCase.controllerClass} inherits neither "
+            f"BaseClientController or BaseServerController"
+        )
+
+    filtered_items = []
+
+    # Iterate over each of the test functions (they are pytest "Nodes")
+    for item in items:
+        assert isinstance(item, _pytest.python.Function)
+
+        # unittest-style test functions have the node of UnitTest class as parent
+        assert isinstance(item.parent, _pytest.python.Instance)
+
+        # and that node references the UnitTest class
+        assert issubclass(item.parent.cls, _IrcTestCase)
+
+        # and in this project, TestCase classes all inherit either from
+        # BaseClientController or BaseServerController.
+        if issubclass(item.parent.cls, BaseServerTestCase):
+            if server_tests:
+                filtered_items.append(item)
+        elif issubclass(item.parent.cls, BaseClientTestCase):
+            if client_tests:
+                filtered_items.append(item)
+        else:
+            filtered_items.append(item)
+
+    # Finally, rewrite in-place the list of tests pytest will run
+    items[:] = filtered_items

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/unreal/README

@@ -0,0 +1,3 @@
+Boilerplate files so Unreal can be built non-interactively.
+
+Obviously, you shouldn't use the .pem in a production environment!

data/unreal/config.settings

@@ -0,0 +1,24 @@
+BASEPATH="$HOME/.local/unrealircd"
+BINDIR="$HOME/.local/unrealircd/bin"
+DATADIR="$HOME/.local/unrealircd/data"
+CONFDIR="$HOME/.local/unrealircd/conf"
+MODULESDIR="$HOME/.local/unrealircd/modules"
+LOGDIR="$HOME/.local/unrealircd/logs"
+CACHEDIR="$HOME/.local/unrealircd/cache"
+DOCDIR="$HOME/.local/unrealircd/doc"
+TMPDIR="$HOME/.local/unrealircd/tmp"
+PRIVATELIBDIR="$HOME/.local/unrealircd/lib"
+PREFIXAQ="1"
+MAXCONNECTIONS_REQUEST="auto"
+NICKNAMEHISTORYLENGTH="2000"
+DEFPERM="0600"
+SSLDIR=""
+REMOTEINC=""
+CURLDIR=""
+SHOWLISTMODES="1"
+NOOPEROVERRIDE=""
+OPEROVERRIDEVERIFY=""
+GENCERTIFICATE="1"
+EXTRAPARA=""
+ADVANCED=""
+

data/unreal/server.cert.pem

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICGDCCAZ6gAwIBAgIUeHAOQnvT7N9kCmUuIklelkzz8SUwCgYIKoZIzj0EAwIw
+QzELMAkGA1UEBhMCVVMxETAPBgNVBAgMCE5ldyBZb3JrMRIwEAYDVQQKDAlJUkMg
+Z2Vla3MxDTALBgNVBAsMBElSQ2QwHhcNMjEwNzAyMTk1MTM5WhcNMzEwNjMwMTk1
+MTM5WjBDMQswCQYDVQQGEwJVUzERMA8GA1UECAwITmV3IFlvcmsxEjAQBgNVBAoM
+CUlSQyBnZWVrczENMAsGA1UECwwESVJDZDB2MBAGByqGSM49AgEGBSuBBAAiA2IA
+BHA6iqLQgkS42xHg/dEPq9dKjlLi0HWvCM7nOCXAyFy1DjrmbFoSCQBCUbISsk/C
+Txru3YIfXe6jSCS8UTb15m70mrmmiUr/umxiqjAOiso051hCrzxVmjTpEAqMSnrc
+zKNTMFEwHQYDVR0OBBYEFFNHqsBNxDNhVxfAgdv6/y4Xd6/ZMB8GA1UdIwQYMBaA
+FFNHqsBNxDNhVxfAgdv6/y4Xd6/ZMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0E
+AwIDaAAwZQIwAo29xUEAzqOMgPAWtMifHFLuPQPuWcNGbaI5S4W81NO8uIcNv/kM
+mFocuITr76p0AjEApzGjc5wM+KydwoVTP+fg1aGQA13Ba2nCzN3R5XwR/USCigjv
+na1QtWAKjpvR/rsp
+-----END CERTIFICATE-----

data/unreal/server.key.pem

@@ -0,0 +1,9 @@
+-----BEGIN EC PARAMETERS-----
+BgUrgQQAIg==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MIGkAgEBBDCWkDHktJiTqC7im+Ni37fbXxtMBqIKPwkAItpKMeuh28QrXWwNE1a5
+wSa38C1nd8igBwYFK4EEACKhZANiAARwOoqi0IJEuNsR4P3RD6vXSo5S4tB1rwjO
+5zglwMhctQ465mxaEgkAQlGyErJPwk8a7t2CH13uo0gkvFE29eZu9Jq5polK/7ps
+YqowDorKNOdYQq88VZo06RAKjEp63Mw=
+-----END EC PRIVATE KEY-----

data/unreal/server.req.pem

@@ -0,0 +1,9 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIBOjCBwgIBADBDMQswCQYDVQQGEwJVUzERMA8GA1UECAwITmV3IFlvcmsxEjAQ
+BgNVBAoMCUlSQyBnZWVrczENMAsGA1UECwwESVJDZDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABHA6iqLQgkS42xHg/dEPq9dKjlLi0HWvCM7nOCXAyFy1DjrmbFoSCQBC
+UbISsk/CTxru3YIfXe6jSCS8UTb15m70mrmmiUr/umxiqjAOiso051hCrzxVmjTp
+EAqMSnrczKAAMAoGCCqGSM49BAMCA2cAMGQCMEL5ezlauGUaxh+pXt897ffmzqci
+fqYm3FgVW5x6EdtCxtcwwAwnR84LKcd/YRKOygIwNmZiRVKeSeC7Ess1PxuzT1Mu
+Cw3bBqkE5LmO1hu/+0lK+QoFPEeLDrygIh+SDdGH
+-----END CERTIFICATE REQUEST-----

inspircd_mainloop.patch

@@ -0,0 +1,25 @@
+When a client registers (ie. sends USER+NICK), InspIRCd does not
+immediately answers with 001. Instead it waits for the next iteration
+of the main loop to call `DoBackgroundUserStuff`.
+
+However, this main loop executes only once a second. This is usually
+fine, but makes irctest considerably slower, as irctest uses hundreds
+of very short-lived connections.
+
+This patch removes the frequency limitation of the main loop to make
+InspIRCd more responsive.
+
+diff --git a/src/inspircd.cpp b/src/inspircd.cpp
+index 5760e631b..1da0285fb 100644
+--- a/src/inspircd.cpp
++++ b/src/inspircd.cpp
+@@ -680,7 +680,7 @@ void InspIRCd::Run()
+		 * timing using this event, so we dont have to
+		 * time this exactly).
+		 */
+-		if (TIME.tv_sec != OLDTIME)
++		if (true)
+		{
+			CollectStats();
+			CheckTimeSkip(OLDTIME, TIME.tv_sec);
+

irctest/__main__.py

@@ -1,87 +0,0 @@
-import sys
-import unittest
-import argparse
-import unittest
-import functools
-import importlib
-from .cases import _IrcTestCase
-from .runner import TextTestRunner
-from .specifications import Specifications
-from .basecontrollers import BaseClientController, BaseServerController
-
-def main(args):
-    try:
-        module = importlib.import_module(args.module)
-    except ImportError:
-        print('Cannot import module {}'.format(args.module), file=sys.stderr)
-        exit(1)
-
-    controller_class = module.get_irctest_controller_class()
-    if issubclass(controller_class, BaseClientController):
-        import irctest.client_tests as module
-    elif issubclass(controller_class, BaseServerController):
-        import irctest.server_tests as module
-    else:
-        print(r'{}.Controller should be a subclass of '
-                r'irctest.basecontroller.Base{{Client,Server}}Controller'
-                .format(args.module),
-                file=sys.stderr)
-        exit(1)
-    _IrcTestCase.controllerClass = controller_class
-    _IrcTestCase.controllerClass.openssl_bin = args.openssl_bin
-    _IrcTestCase.show_io = args.show_io
-    _IrcTestCase.strictTests = not args.loose
-    if args.specification:
-        try:
-            _IrcTestCase.testedSpecifications = frozenset(
-                Specifications.of_name(x) for x in args.specification
-                )
-        except ValueError:
-            print('Invalid set of specifications: {}'
-                    .format(', '.join(args.specification)))
-            exit(1)
-    else:
-        _IrcTestCase.testedSpecifications = frozenset(
-                Specifications)
-    print('Testing {} on specification(s): {}'.format(
-        controller_class.software_name,
-        ', '.join(sorted(map(lambda x:x.value,
-            _IrcTestCase.testedSpecifications)))))
-    ts = module.discover()
-    testRunner = TextTestRunner(
-            verbosity=args.verbose,
-            descriptions=True,
-            )
-    testLoader = unittest.loader.defaultTestLoader
-    result = testRunner.run(ts)
-    if result.failures or result.errors:
-        exit(1)
-    else:
-        exit(0)
-
-
-parser = argparse.ArgumentParser(
-        description='A script to test interoperability of IRC software.')
-parser.add_argument('module', type=str,
-        help='The module used to run the tested program.')
-parser.add_argument('--openssl-bin', type=str, default='openssl',
-        help='The openssl binary to use')
-parser.add_argument('--show-io', action='store_true',
-        help='Show input/outputs with the tested program.')
-parser.add_argument('-v', '--verbose', action='count', default=1,
-        help='Verbosity. Give this option multiple times to make '
-        'it even more verbose.')
-parser.add_argument('-s', '--specification', type=str, action='append',
-        help=('The set of specifications to test the program with. '
-        'Valid values: {}. '
-        'Use this option multiple times to test with multiple '
-        'specifications. If it is not given, defaults to all.')
-        .format(', '.join(x.value for x in Specifications)))
-parser.add_argument('-l', '--loose', action='store_true',
-        help='Disables strict checks of conformity to the specification. '
-        'Strict means the specification is unclear, and the most restrictive '
-        'interpretation is choosen.')
-
-
-args = parser.parse_args()
-main(args)

irctest/authentication.py

@@ -1,19 +1,23 @@
+import dataclasses
 import enum
-import collections
+from typing import Optional, Tuple
+
 
 @enum.unique
 class Mechanisms(enum.Enum):
     """Enumeration for representing possible mechanisms."""
-    @classmethod
-    def as_string(cls, mech):
-        return {cls.plain: 'PLAIN',
-                cls.ecdsa_nist256p_challenge: 'ECDSA-NIST256P-CHALLENGE',
-                cls.scram_sha_256: 'SCRAM-SHA-256',
-                }[mech]
+
+    def to_string(self) -> str:
+        return self.name.upper().replace("_", "-")
+
     plain = 1
     ecdsa_nist256p_challenge = 2
     scram_sha_256 = 3
 
-Authentication = collections.namedtuple('Authentication',
-        'mechanisms username password ecdsa_key')
-Authentication.__new__.__defaults__ = ([Mechanisms.plain], None, None, None)
+
+@dataclasses.dataclass
+class Authentication:
+    mechanisms: Tuple[Mechanisms] = (Mechanisms.plain,)
+    username: Optional[str] = None
+    password: Optional[str] = None
+    ecdsa_key: Optional[str] = None

irctest/basecontrollers.py

@@ -1,49 +1,112 @@
+from __future__ import annotations
+
+import dataclasses
 import os
 import shutil
 import socket
+import subprocess
 import tempfile
 import time
-import subprocess
+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.junkdrawer import find_hostname_and_port
+from .irc_utils.message_parser import Message
 from .runner import NotImplementedByController
 
+
+class ProcessStopped(Exception):
+    """Raised when the controlled process stopped unexpectedly"""
+
+    pass
+
+
+@dataclasses.dataclass
+class TestCaseControllerConfig:
+    """Test-case-specific configuration passed to the controller.
+    This is usually used to ask controllers to enable a feature;
+    but should not be an issue if controllers enable it all the time."""
+
+    chathistory: bool = False
+    """Whether to enable chathistory features."""
+
+    ergo_roleplay: bool = False
+    """Whether to enable the Ergo role-play commands."""
+
+    ergo_config: Optional[Callable[[Dict], Any]] = None
+    """Oragono-specific configuration function that alters the dict in-place
+    This should be used as little as possible, using the other attributes instead;
+    as they are work with any controller."""
+
+
 class _BaseController:
     """Base class for software controllers.
 
     A software controller is an object that handles configuring and running
     a process (eg. a server or a client), as well as sending it instructions
     that are not part of the IRC specification."""
-    pass
 
-class DirectoryBasedController(_BaseController):
-    """Helper for controllers whose software configuration is based on an
-    arbitrary directory."""
-    def __init__(self):
-        super().__init__()
-        self.directory = None
+    # set by conftest.py
+    openssl_bin: str
+
+    supports_sts: bool
+    supported_sasl_mechanisms: Set[str]
+    proc: Optional[subprocess.Popen]
+
+    def __init__(self, test_config: TestCaseControllerConfig):
+        self.test_config = test_config
         self.proc = None
 
-    def kill_proc(self):
+    def check_is_alive(self) -> None:
+        assert self.proc
+        self.proc.poll()
+        if self.proc.returncode is not None:
+            raise ProcessStopped()
+
+    def kill_proc(self) -> None:
         """Terminates the controlled process, waits for it to exit, and
         eventually kills it."""
+        assert self.proc
         self.proc.terminate()
         try:
             self.proc.wait(5)
         except subprocess.TimeoutExpired:
             self.proc.kill()
         self.proc = None
-    def kill(self):
+
+    def kill(self) -> None:
         """Calls `kill_proc` and cleans the configuration."""
         if self.proc:
             self.kill_proc()
+
+
+class DirectoryBasedController(_BaseController):
+    """Helper for controllers whose software configuration is based on an
+    arbitrary directory."""
+
+    directory: Optional[str]
+
+    def __init__(self, test_config: TestCaseControllerConfig):
+        super().__init__(test_config)
+        self.directory = None
+
+    def kill(self) -> None:
+        """Calls `kill_proc` and cleans the configuration."""
+        super().kill()
         if self.directory:
             shutil.rmtree(self.directory)
-    def terminate(self):
+
+    def terminate(self) -> None:
         """Stops the process gracefully, and does not clean its config."""
+        assert self.proc
         self.proc.terminate()
         self.proc.wait()
         self.proc = None
-    def open_file(self, name, mode='a'):
+
+    def open_file(self, name: str, mode: str = "a") -> IO:
         """Open a file in the configuration directory."""
         assert self.directory
         if os.sep in name:
@@ -52,51 +115,244 @@ class DirectoryBasedController(_BaseController):
                 os.makedirs(dir_)
             assert os.path.isdir(dir_)
         return open(os.path.join(self.directory, name), mode)
-    def create_config(self):
-        """If there is no config dir, creates it and returns True.
-        Else returns False."""
-        if self.directory:
-            return False
-        else:
-            self.directory = tempfile.mkdtemp()
-            return True
 
-    def gen_ssl(self):
-        self.csr_path = os.path.join(self.directory, 'ssl.csr')
-        self.key_path = os.path.join(self.directory, 'ssl.key')
-        self.pem_path = os.path.join(self.directory, 'ssl.pem')
-        self.dh_path = os.path.join(self.directory, 'dh.pem')
-        subprocess.check_output([self.openssl_bin, 'req', '-new', '-newkey', 'rsa',
-            '-nodes', '-out', self.csr_path, '-keyout', self.key_path,
-            '-batch'],
-            stderr=subprocess.DEVNULL)
-        subprocess.check_output([self.openssl_bin, 'x509', '-req',
-            '-in', self.csr_path, '-signkey', self.key_path,
-            '-out', self.pem_path],
-            stderr=subprocess.DEVNULL)
-        subprocess.check_output([self.openssl_bin, 'dhparam',
-            '-out', self.dh_path, '128'],
-            stderr=subprocess.DEVNULL)
+    def create_config(self) -> None:
+        if not self.directory:
+            self.directory = tempfile.mkdtemp()
+
+    def gen_ssl(self) -> None:
+        assert self.directory
+        self.csr_path = os.path.join(self.directory, "ssl.csr")
+        self.key_path = os.path.join(self.directory, "ssl.key")
+        self.pem_path = os.path.join(self.directory, "ssl.pem")
+        self.dh_path = os.path.join(self.directory, "dh.pem")
+        subprocess.check_output(
+            [
+                self.openssl_bin,
+                "req",
+                "-new",
+                "-newkey",
+                "rsa",
+                "-nodes",
+                "-out",
+                self.csr_path,
+                "-keyout",
+                self.key_path,
+                "-batch",
+            ],
+            stderr=subprocess.DEVNULL,
+        )
+        subprocess.check_output(
+            [
+                self.openssl_bin,
+                "x509",
+                "-req",
+                "-in",
+                self.csr_path,
+                "-signkey",
+                self.key_path,
+                "-out",
+                self.pem_path,
+            ],
+            stderr=subprocess.DEVNULL,
+        )
+        subprocess.check_output(
+            [self.openssl_bin, "dhparam", "-out", self.dh_path, "128"],
+            stderr=subprocess.DEVNULL,
+        )
+
 
 class BaseClientController(_BaseController):
     """Base controller for IRC clients."""
-    def run(self, hostname, port, auth):
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        auth: Optional[authentication.Authentication],
+        tls_config: Optional[tls.TlsConfig] = None,
+    ) -> None:
         raise NotImplementedError()
 
+
 class BaseServerController(_BaseController):
     """Base controller for IRC server."""
+
+    software_name: str  # Class property
+    _port_wait_interval = 0.1
     port_open = False
-    def run(self, hostname, port, password,
-            valid_metadata_keys, invalid_metadata_keys):
+    port: int
+    hostname: str
+    services_controller: Optional[BaseServicesController] = None
+    services_controller_class: Type[BaseServicesController]
+    extban_mute_char: Optional[str] = None
+    """Character used for the 'mute' extban"""
+    nickserv = "NickServ"
+
+    def get_hostname_and_port(self) -> Tuple[str, int]:
+        return find_hostname_and_port()
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        valid_metadata_keys: Optional[Set[str]],
+        invalid_metadata_keys: Optional[Set[str]],
+    ) -> None:
         raise NotImplementedError()
-    def registerUser(self, case, username, password=None):
-        raise NotImplementedByController('account registration')
-    def wait_for_port(self):
+
+    def registerUser(
+        self,
+        case: irctest.cases.BaseServerTestCase,  # type: ignore
+        username: str,
+        password: Optional[str] = None,
+    ) -> None:
+        if self.services_controller is not None:
+            self.services_controller.registerUser(case, username, password)
+        else:
+            raise NotImplementedByController("account registration")
+
+    def wait_for_port(self) -> None:
         while not self.port_open:
-            time.sleep(0.1)
+            self.check_is_alive()
+            time.sleep(self._port_wait_interval)
             try:
-                c = socket.create_connection(('localhost', self.port), timeout=1.0)
+                c = socket.create_connection(("localhost", self.port), timeout=1.0)
+                c.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
+
+                # Make sure the server properly processes the disconnect.
+                # Otherwise, it may still count it in LUSER and fail tests in
+                # test_lusers.py (eg. this happens with Charybdis 3.5.0)
+                c.sendall(b"QUIT :chkport\r\n")
+                data = b""
+                try:
+                    while b"chkport" not in data and b"ERROR" not in data:
+                        data += c.recv(4096)
+                        time.sleep(0.01)
+
+                        c.send(b" ")  # Triggers BrokenPipeError
+                except BrokenPipeError:
+                    # ircu2 cuts the connection without a message if registration
+                    # is not complete.
+                    pass
+
                 c.close()
                 self.port_open = True
-            except Exception as e:
+            except Exception:
                 continue
+
+    def wait_for_services(self) -> None:
+        assert self.services_controller
+        self.services_controller.wait_for_services()
+
+    def terminate(self) -> None:
+        if self.services_controller is not None:
+            self.services_controller.terminate()  # type: ignore
+        super().terminate()  # type: ignore
+
+    def kill(self) -> None:
+        if self.services_controller is not None:
+            self.services_controller.kill()  # type: ignore
+        super().kill()
+
+
+class BaseServicesController(_BaseController):
+    def __init__(
+        self,
+        test_config: TestCaseControllerConfig,
+        server_controller: BaseServerController,
+    ):
+        super().__init__(test_config)
+        self.test_config = test_config
+        self.server_controller = server_controller
+        self.services_up = False
+
+    def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
+        raise NotImplementedError("BaseServerController.run()")
+
+    def wait_for_services(self) -> None:
+        if self.services_up:
+            # Don't check again if they are already available
+            return
+        self.server_controller.wait_for_port()
+
+        c = ClientMock(name="chkNS", show_io=True)
+        c.connect(self.server_controller.hostname, self.server_controller.port)
+        c.sendLine("NICK chkNS")
+        c.sendLine("USER chk chk chk chk")
+        for msg in c.getMessages(synchronize=False):
+            if msg.command == "PING":
+                # Hi Unreal
+                c.sendLine("PONG :" + msg.params[0])
+        c.getMessages()
+
+        timeout = time.time() + 5
+        while True:
+            c.sendLine(f"PRIVMSG {self.server_controller.nickserv} :HELP")
+            msgs = self.getNickServResponse(c)
+            for msg in msgs:
+                if msg.command == "401":
+                    # NickServ not available yet
+                    pass
+                elif msg.command == "NOTICE":
+                    # NickServ is available
+                    assert "nickserv" in (msg.prefix or "").lower(), msg
+                    print("breaking")
+                    break
+                else:
+                    assert False, f"unexpected reply from NickServ: {msg}"
+            else:
+                if time.time() > timeout:
+                    raise Exception("Timeout while waiting for NickServ")
+                continue
+
+            # If we're here, it means we broke from the for loop, so NickServ
+            # is available and we can break again
+            break
+
+        c.sendLine("QUIT")
+        c.getMessages()
+        c.disconnect()
+        self.services_up = True
+
+    def getNickServResponse(self, client: Any) -> List[Message]:
+        """Wrapper aroung getMessages() that waits longer, because NickServ
+        is queried asynchronously."""
+        msgs: List[Message] = []
+        while not msgs:
+            time.sleep(0.05)
+            msgs = client.getMessages()
+        return msgs
+
+    def registerUser(
+        self,
+        case: irctest.cases.BaseServerTestCase,  # type: ignore
+        username: str,
+        password: Optional[str] = None,
+    ) -> None:
+        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"PRIVMSG {self.server_controller.nickserv} "
+            f":REGISTER {password} foo@example.org",
+        )
+        msgs = self.getNickServResponse(case.clients[client])
+        if self.server_controller.software_name == "inspircd":
+            assert "900" in {msg.command for msg in msgs}, msgs
+        assert "NOTICE" in {msg.command for msg in msgs}, msgs
+        case.sendLine(client, "QUIT")
+        case.assertDisconnected(client)

irctest/client_mock.py

@@ -1,36 +1,55 @@
+import socket
 import ssl
 import sys
 import time
-import socket
+from typing import Any, Callable, List, Optional, Union
+
+from .exceptions import ConnectionClosed, NoMessageException
 from .irc_utils import message_parser
-from .exceptions import NoMessageException, ConnectionClosed
+
 
 class ClientMock:
-    def __init__(self, name, show_io):
+    def __init__(self, name: Any, show_io: bool):
         self.name = name
         self.show_io = show_io
-        self.inbuffer = []
+        self.inbuffer: List[message_parser.Message] = []
         self.ssl = False
-    def connect(self, hostname, port):
+
+    def connect(self, hostname: str, port: int) -> None:
         self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.conn.settimeout(1) # TODO: configurable
+
+        # probably useful for test_buffering, as it relies on chunking
+        # the packets to be useful
+        self.conn.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
+
+        self.conn.settimeout(1)  # TODO: configurable
         self.conn.connect((hostname, port))
         if self.show_io:
-            print('{:.3f} {}: connects to server.'.format(time.time(), self.name))
-    def disconnect(self):
+            print("{:.3f} {}: connects to server.".format(time.time(), self.name))
+
+    def disconnect(self) -> None:
         if self.show_io:
-            print('{:.3f} {}: disconnects from server.'.format(time.time(), self.name))
+            print("{:.3f} {}: disconnects from server.".format(time.time(), self.name))
         self.conn.close()
-    def starttls(self):
-        assert not self.ssl, 'SSL already active.'
+
+    def starttls(self) -> None:
+        assert not self.ssl, "SSL already active."
         self.conn = ssl.wrap_socket(self.conn)
         self.ssl = True
-    def getMessages(self, synchronize=True, assert_get_one=False):
+
+    def getMessages(
+        self, synchronize: bool = True, assert_get_one: bool = False, raw: bool = False
+    ) -> List[message_parser.Message]:
+        """actually returns List[str] in the rare case where raw=True."""
+        __tracebackhide__ = True  # Hide from pytest tracebacks on test failure.
+        token: Optional[str]
         if synchronize:
-            token = 'synchronize{}'.format(time.monotonic())
-            self.sendLine('PING {}'.format(token))
+            token = "synchronize{}".format(time.monotonic())
+            self.sendLine("PING {}".format(token))
+        else:
+            token = None
         got_pong = False
-        data = b''
+        data = b""
         (self.inbuffer, messages) = ([], self.inbuffer)
         conn = self.conn
         try:
@@ -38,12 +57,11 @@ class ClientMock:
                 try:
                     new_data = conn.recv(4096)
                 except socket.timeout:
-                    if not assert_get_one and not synchronize and data == b'':
+                    if not assert_get_one and not synchronize and data == b"":
                         # Received nothing
                         return []
                     if self.show_io:
-                        print('{:.3f} waiting…'.format(time.time()))
-                    time.sleep(0.1)
+                        print("{:.3f} {}: waiting…".format(time.time(), self.name))
                     continue
                 except ConnectionResetError:
                     raise ConnectionClosed()
@@ -52,26 +70,38 @@ class ClientMock:
                         # Connection closed
                         raise ConnectionClosed()
                 data += new_data
-                if not new_data.endswith(b'\r\n'):
-                    time.sleep(0.1)
+                if not new_data.endswith(b"\r\n"):
                     continue
                 if not synchronize:
                     got_pong = True
-                for line in data.decode().split('\r\n'):
+                for line in data.decode().split("\r\n"):
                     if line:
                         if self.show_io:
-                            print('{time:.3f}{ssl} S -> {client}: {line}'.format(
-                                time=time.time(),
-                                ssl=' (ssl)' if self.ssl else '',
-                                client=self.name,
-                                line=line))
-                        message = message_parser.parse_message(line + '\r\n')
-                        if message.command == 'PONG' and \
-                                token in message.params:
+                            print(
+                                "{time:.3f}{ssl} S -> {client}: {line}".format(
+                                    time=time.time(),
+                                    ssl=" (ssl)" if self.ssl else "",
+                                    client=self.name,
+                                    line=line,
+                                )
+                            )
+                        message = message_parser.parse_message(line)
+                        if message.command == "PONG" and token in message.params:
                             got_pong = True
+                        elif (
+                            synchronize
+                            and message.command == "451"
+                            and message.params[1] == "PING"
+                        ):
+                            raise ValueError(
+                                "Got '451 * PONG'. Did you forget synchronize=False?"
+                            )
                         else:
-                            messages.append(message)
-                data = b''
+                            if raw:
+                                messages.append(line)  # type: ignore
+                            else:
+                                messages.append(message)
+                data = b""
         except ConnectionClosed:
             if messages:
                 return messages
@@ -79,31 +109,58 @@ class ClientMock:
                 raise
         else:
             return messages
-    def getMessage(self, filter_pred=None, synchronize=True):
+
+    def getMessage(
+        self,
+        filter_pred: Optional[Callable[[message_parser.Message], bool]] = None,
+        synchronize: bool = True,
+        raw: bool = False,
+    ) -> message_parser.Message:
+        """Returns str in the rare case where raw=True"""
+        __tracebackhide__ = True  # Hide from pytest tracebacks on test failure.
         while True:
             if not self.inbuffer:
                 self.inbuffer = self.getMessages(
-                        synchronize=synchronize, assert_get_one=True)
+                    synchronize=synchronize, assert_get_one=True, raw=raw
+                )
             if not self.inbuffer:
                 raise NoMessageException()
-            message = self.inbuffer.pop(0) # TODO: use dequeue
+            message = self.inbuffer.pop(0)  # TODO: use dequeue
             if not filter_pred or filter_pred(message):
                 return message
-    def sendLine(self, line):
-        if not line.endswith('\r\n'):
-            line += '\r\n'
-        encoded_line = line.encode()
+
+    def sendLine(self, line: Union[str, bytes]) -> None:
+        if isinstance(line, str):
+            encoded_line = line.encode()
+        elif isinstance(line, bytes):
+            encoded_line = line
+        else:
+            raise ValueError(line)
+        if not encoded_line.endswith(b"\r\n"):
+            encoded_line += b"\r\n"
         try:
-            ret = self.conn.sendall(encoded_line)
+            ret = self.conn.sendall(encoded_line)  # type: ignore
         except BrokenPipeError:
             raise ConnectionClosed()
-        if sys.version_info <= (3, 6) and self.ssl: # https://bugs.python.org/issue25951
+        if (
+            sys.version_info <= (3, 6) and self.ssl
+        ):  # https://bugs.python.org/issue25951
             assert ret == len(encoded_line), (ret, repr(encoded_line))
         else:
             assert ret is None, ret
         if self.show_io:
-            print('{time:.3f}{ssl} {client} -> S: {line}'.format(
-                time=time.time(),
-                ssl=' (ssl)' if self.ssl else '',
-                client=self.name,
-                line=line.strip('\r\n')))
+            if isinstance(line, str):
+                escaped_line = line
+                escaped = ""
+            else:
+                escaped_line = repr(line)
+                escaped = " (escaped)"
+            print(
+                "{time:.3f}{escaped}{ssl} {client} -> S: {line}".format(
+                    time=time.time(),
+                    escaped=escaped,
+                    ssl=" (ssl)" if self.ssl else "",
+                    client=self.name,
+                    line=escaped_line.strip("\r\n"),
+                )
+            )

irctest/client_tests/cap.py

@@ -1,14 +1,15 @@
 from irctest import cases
 from irctest.irc_utils.message_parser import Message
 
-class CapTestCase(cases.BaseClientTestCase, cases.ClientNegociationHelper):
-    @cases.SpecificationSelector.requiredBySpecification('IRCv3.1', 'IRCv3.2')
+
+class CapTestCase(cases.BaseClientTestCase):
+    @cases.mark_specifications("IRCv3")
     def testSendCap(self):
         """Send CAP LS 302 and read the result."""
         self.readCapLs()
 
-    @cases.SpecificationSelector.requiredBySpecification('IRCv3.1', 'IRCv3.2')
+    @cases.mark_specifications("IRCv3")
     def testEmptyCapLs(self):
         """Empty result to CAP LS. Client should send CAP END."""
         m = self.negotiateCapabilities([])
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))
+        self.assertEqual(m, Message({}, None, "CAP", ["END"]))

irctest/client_tests/sasl.py

@@ -0,0 +1,276 @@
+import base64
+
+import pytest
+
+try:
+    import ecdsa
+    from ecdsa.util import sigdecode_der
+except ImportError:
+    ecdsa = None
+
+from irctest import authentication, cases, scram
+from irctest.irc_utils.message_parser import Message
+
+ECDSA_KEY = """
+-----BEGIN EC PARAMETERS-----
+BggqhkjOPQMBBw==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIIJueQ3W2IrGbe9wKdOI75yGS7PYZSj6W4tg854hlsvmoAoGCCqGSM49
+AwEHoUQDQgAEAZmaVhNSMmV5r8FXPvKuMnqDKyIA9pDHN5TNMfiF3mMeikGgK10W
+IRX9cyi2wdYg9mUUYyh9GKdBCYHGUJAiCA==
+-----END EC PRIVATE KEY-----
+"""
+
+CHALLENGE = bytes(range(32))
+assert len(CHALLENGE) == 32
+
+
+class IdentityHash:
+    def __init__(self, data):
+        self._data = data
+
+    def digest(self):
+        return self._data
+
+
+class SaslTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPlain(self):
+        """Test PLAIN authentication with correct username/password."""
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.plain],
+            username="jilles",
+            password="sesame",
+        )
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["PLAIN"]))
+        self.sendLine("AUTHENTICATE +")
+        m = self.getMessage()
+        self.assertEqual(
+            m, Message({}, None, "AUTHENTICATE", ["amlsbGVzAGppbGxlcwBzZXNhbWU="])
+        )
+        self.sendLine("900 * * jilles :You are now logged in.")
+        self.sendLine("903 * :SASL authentication successful")
+        m = self.negotiateCapabilities(["sasl"], False)
+        self.assertEqual(m, Message({}, None, "CAP", ["END"]))
+
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPlainNotAvailable(self):
+        """`sasl=EXTERNAL` is advertized, whereas the client is configured
+        to use PLAIN.
+
+        A client implementing sasl-3.2 can give up authentication immediately.
+        A client not implementing it will try authenticating, and will get
+        a 904.
+        """
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.plain],
+            username="jilles",
+            password="sesame",
+        )
+        m = self.negotiateCapabilities(["sasl=EXTERNAL"], auth=auth)
+        self.assertEqual(self.acked_capabilities, {"sasl"})
+        if m == Message({}, None, "CAP", ["END"]):
+            # IRCv3.2-style, for clients that skip authentication
+            # when unavailable (eg. Limnoria)
+            return
+        elif m.command == "QUIT":
+            # IRCv3.2-style, for clients that quit when unavailable
+            # (eg. Sopel)
+            return
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["PLAIN"]))
+        self.sendLine("904 {} :SASL auth failed".format(self.nick))
+        m = self.getMessage()
+        self.assertMessageMatch(m, command="CAP")
+
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPlainLarge(self):
+        """Test the client splits large AUTHENTICATE messages whose payload
+        is not a multiple of 400.
+        <http://ircv3.net/specs/extensions/sasl-3.1.html#the-authenticate-command>
+        """
+        # TODO: authzid is optional
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.plain],
+            username="foo",
+            password="bar" * 200,
+        )
+        authstring = base64.b64encode(
+            b"\x00".join([b"foo", b"foo", b"bar" * 200])
+        ).decode()
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["PLAIN"]))
+        self.sendLine("AUTHENTICATE +")
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", [authstring[0:400]]), m)
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", [authstring[400:800]]))
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", [authstring[800:]]))
+        self.sendLine("900 * * {} :You are now logged in.".format("foo"))
+        self.sendLine("903 * :SASL authentication successful")
+        m = self.negotiateCapabilities(["sasl"], False)
+        self.assertEqual(m, Message({}, None, "CAP", ["END"]))
+
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPlainLargeMultiple(self):
+        """Test the client splits large AUTHENTICATE messages whose payload
+        is a multiple of 400.
+        <http://ircv3.net/specs/extensions/sasl-3.1.html#the-authenticate-command>
+        """
+        # TODO: authzid is optional
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.plain],
+            username="foo",
+            password="quux" * 148,
+        )
+        authstring = base64.b64encode(
+            b"\x00".join([b"foo", b"foo", b"quux" * 148])
+        ).decode()
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["PLAIN"]))
+        self.sendLine("AUTHENTICATE +")
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", [authstring[0:400]]), m)
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", [authstring[400:800]]))
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["+"]))
+        self.sendLine("900 * * {} :You are now logged in.".format("foo"))
+        self.sendLine("903 * :SASL authentication successful")
+        m = self.negotiateCapabilities(["sasl"], False)
+        self.assertEqual(m, Message({}, None, "CAP", ["END"]))
+
+    @pytest.mark.skipif(ecdsa is None, reason="python3-ecdsa is not available")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("ECDSA-NIST256P-CHALLENGE")
+    def testEcdsa(self):
+        """Test ECDSA authentication."""
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.ecdsa_nist256p_challenge],
+            username="jilles",
+            ecdsa_key=ECDSA_KEY,
+        )
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(
+            m, Message({}, None, "AUTHENTICATE", ["ECDSA-NIST256P-CHALLENGE"])
+        )
+        self.sendLine("AUTHENTICATE +")
+        m = self.getMessage()
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["amlsbGVz"]))  # jilles
+        self.sendLine(
+            "AUTHENTICATE {}".format(base64.b64encode(CHALLENGE).decode("ascii"))
+        )
+        m = self.getMessage()
+        self.assertMessageMatch(m, command="AUTHENTICATE")
+        sk = ecdsa.SigningKey.from_pem(ECDSA_KEY)
+        vk = sk.get_verifying_key()
+        signature = base64.b64decode(m.params[0])
+        try:
+            vk.verify(
+                signature, CHALLENGE, hashfunc=IdentityHash, sigdecode=sigdecode_der
+            )
+        except ecdsa.BadSignatureError:
+            raise AssertionError("Bad signature")
+        self.sendLine("900 * * foo :You are now logged in.")
+        self.sendLine("903 * :SASL authentication successful")
+        m = self.negotiateCapabilities(["sasl"], False)
+        self.assertEqual(m, Message({}, None, "CAP", ["END"]))
+
+    @cases.OptionalityHelper.skipUnlessHasMechanism("SCRAM-SHA-256")
+    def testScram(self):
+        """Test SCRAM-SHA-256 authentication."""
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.scram_sha_256],
+            username="jilles",
+            password="sesame",
+        )
+
+        class PasswdDb:
+            def get_password(self, *args):
+                return ("sesame", "plain")
+
+        authenticator = scram.SCRAMServerAuthenticator(
+            "SHA-256", channel_binding=False, password_database=PasswdDb()
+        )
+
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["SCRAM-SHA-256"]))
+        self.sendLine("AUTHENTICATE +")
+
+        m = self.getMessage()
+        self.assertEqual(m.command, "AUTHENTICATE", m)
+        client_first = base64.b64decode(m.params[0])
+        response = authenticator.start(properties={}, initial_response=client_first)
+        assert isinstance(response, bytes), response
+        self.sendLine("AUTHENTICATE :" + base64.b64encode(response).decode())
+
+        m = self.getMessage()
+        self.assertEqual(m.command, "AUTHENTICATE", m)
+        msg = base64.b64decode(m.params[0])
+        r = authenticator.response(msg)
+        assert isinstance(r, tuple), r
+        assert len(r) == 2, r
+        (properties, response) = r
+        self.sendLine("AUTHENTICATE :" + base64.b64encode(response).decode())
+        self.assertEqual(properties, {"authzid": None, "username": "jilles"})
+
+        m = self.getMessage()
+        self.assertEqual(m.command, "AUTHENTICATE", m)
+        self.assertEqual(m.params, ["+"], m)
+
+    @cases.OptionalityHelper.skipUnlessHasMechanism("SCRAM-SHA-256")
+    def testScramBadPassword(self):
+        """Test SCRAM-SHA-256 authentication with a bad password."""
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.scram_sha_256],
+            username="jilles",
+            password="sesame",
+        )
+
+        class PasswdDb:
+            def get_password(self, *args):
+                return ("notsesame", "plain")
+
+        authenticator = scram.SCRAMServerAuthenticator(
+            "SHA-256", channel_binding=False, password_database=PasswdDb()
+        )
+
+        m = self.negotiateCapabilities(["sasl"], auth=auth)
+        self.assertEqual(m, Message({}, None, "AUTHENTICATE", ["SCRAM-SHA-256"]))
+        self.sendLine("AUTHENTICATE +")
+
+        m = self.getMessage()
+        self.assertEqual(m.command, "AUTHENTICATE", m)
+        client_first = base64.b64decode(m.params[0])
+        response = authenticator.start(properties={}, initial_response=client_first)
+        assert isinstance(response, bytes), response
+        self.sendLine("AUTHENTICATE :" + base64.b64encode(response).decode())
+
+        m = self.getMessage()
+        self.assertEqual(m.command, "AUTHENTICATE", m)
+        msg = base64.b64decode(m.params[0])
+        with self.assertRaises(scram.NotAuthorizedException):
+            authenticator.response(msg)
+
+
+class Irc302SaslTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPlainNotAvailable(self):
+        """Test the client does not try to authenticate using a mechanism the
+        server does not advertise.
+        Actually, this is optional."""
+        auth = authentication.Authentication(
+            mechanisms=[authentication.Mechanisms.plain],
+            username="jilles",
+            password="sesame",
+        )
+        m = self.negotiateCapabilities(["sasl=EXTERNAL"], auth=auth)
+        self.assertEqual(self.acked_capabilities, {"sasl"})
+
+        if m.command == "QUIT":
+            # Some clients quit when it can't authenticate (eg. Sopel)
+            pass
+        else:
+            # Others will just skip authentication (eg. Limnoria)
+            self.assertEqual(m, Message({}, None, "CAP", ["END"]))

irctest/client_tests/test_sasl.py

@@ -1,257 +0,0 @@
-import hashlib
-
-import ecdsa
-from ecdsa.util import sigencode_der, sigdecode_der
-import base64
-import pyxmpp2_scram as scram
-
-from irctest import cases
-from irctest import authentication
-from irctest.irc_utils.message_parser import Message
-
-ECDSA_KEY = """
------BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIIJueQ3W2IrGbe9wKdOI75yGS7PYZSj6W4tg854hlsvmoAoGCCqGSM49
-AwEHoUQDQgAEAZmaVhNSMmV5r8FXPvKuMnqDKyIA9pDHN5TNMfiF3mMeikGgK10W
-IRX9cyi2wdYg9mUUYyh9GKdBCYHGUJAiCA==
------END EC PRIVATE KEY-----
-"""
-
-CHALLENGE = bytes(range(32))
-assert len(CHALLENGE) == 32
-
-class IdentityHash:
-    def __init__(self, data):
-        self._data = data
-
-    def digest(self):
-        return self._data
-
-class SaslTestCase(cases.BaseClientTestCase, cases.ClientNegociationHelper,
-                   cases.OptionalityHelper):
-    @cases.OptionalityHelper.skipUnlessHasMechanism('PLAIN')
-    def testPlain(self):
-        """Test PLAIN authentication with correct username/password."""
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.plain],
-                username='jilles',
-                password='sesame',
-                )
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['PLAIN']))
-        self.sendLine('AUTHENTICATE +')
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            ['amlsbGVzAGppbGxlcwBzZXNhbWU=']))
-        self.sendLine('900 * * jilles :You are now logged in.')
-        self.sendLine('903 * :SASL authentication successful')
-        m = self.negotiateCapabilities(['sasl'], False)
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('PLAIN')
-    def testPlainNotAvailable(self):
-        """`sasl=EXTERNAL` is advertized, whereas the client is configured
-        to use PLAIN.
-
-        A client implementing sasl-3.2 can give up authentication immediately.
-        A client not implementing it will try authenticating, and will get
-        a 904.
-        """
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.plain],
-                username='jilles',
-                password='sesame',
-                )
-        m = self.negotiateCapabilities(['sasl=EXTERNAL'], auth=auth)
-        self.assertEqual(self.acked_capabilities, {'sasl'})
-        if m == Message([], None, 'CAP', ['END']):
-            # IRCv3.2-style
-            return
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['PLAIN']))
-        self.sendLine('904 {} :SASL auth failed'.format(self.nick))
-        m = self.getMessage()
-        self.assertMessageEqual(m, command='CAP')
-
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('PLAIN')
-    def testPlainLarge(self):
-        """Test the client splits large AUTHENTICATE messages whose payload
-        is not a multiple of 400.
-        <http://ircv3.net/specs/extensions/sasl-3.1.html#the-authenticate-command>
-        """
-        # TODO: authzid is optional
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.plain],
-                username='foo',
-                password='bar'*200,
-                )
-        authstring = base64.b64encode(b'\x00'.join(
-            [b'foo', b'foo', b'bar'*200])).decode()
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['PLAIN']))
-        self.sendLine('AUTHENTICATE +')
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            [authstring[0:400]]), m)
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            [authstring[400:800]]))
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            [authstring[800:]]))
-        self.sendLine('900 * * {} :You are now logged in.'.format('foo'))
-        self.sendLine('903 * :SASL authentication successful')
-        m = self.negotiateCapabilities(['sasl'], False)
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('PLAIN')
-    def testPlainLargeMultiple(self):
-        """Test the client splits large AUTHENTICATE messages whose payload
-        is a multiple of 400.
-        <http://ircv3.net/specs/extensions/sasl-3.1.html#the-authenticate-command>
-        """
-        # TODO: authzid is optional
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.plain],
-                username='foo',
-                password='quux'*148,
-                )
-        authstring = base64.b64encode(b'\x00'.join(
-            [b'foo', b'foo', b'quux'*148])).decode()
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['PLAIN']))
-        self.sendLine('AUTHENTICATE +')
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            [authstring[0:400]]), m)
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            [authstring[400:800]]))
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            ['+']))
-        self.sendLine('900 * * {} :You are now logged in.'.format('foo'))
-        self.sendLine('903 * :SASL authentication successful')
-        m = self.negotiateCapabilities(['sasl'], False)
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('ECDSA-NIST256P-CHALLENGE')
-    def testEcdsa(self):
-        """Test ECDSA authentication.
-        """
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.ecdsa_nist256p_challenge],
-                username='jilles',
-                ecdsa_key=ECDSA_KEY,
-                )
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['ECDSA-NIST256P-CHALLENGE']))
-        self.sendLine('AUTHENTICATE +')
-        m = self.getMessage()
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE',
-            ['amlsbGVz'])) # jilles
-        self.sendLine('AUTHENTICATE {}'.format(base64.b64encode(CHALLENGE).decode('ascii')))
-        m = self.getMessage()
-        self.assertMessageEqual(m, command='AUTHENTICATE')
-        sk = ecdsa.SigningKey.from_pem(ECDSA_KEY)
-        vk = sk.get_verifying_key()
-        signature = base64.b64decode(m.params[0])
-        try:
-            vk.verify(signature, CHALLENGE, hashfunc=IdentityHash, sigdecode=sigdecode_der)
-        except ecdsa.BadSignatureError:
-            raise AssertionError('Bad signature')
-        self.sendLine('900 * * foo :You are now logged in.')
-        self.sendLine('903 * :SASL authentication successful')
-        m = self.negotiateCapabilities(['sasl'], False)
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('SCRAM-SHA-256')
-    def testScram(self):
-        """Test SCRAM-SHA-256 authentication.
-        """
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.scram_sha_256],
-                username='jilles',
-                password='sesame',
-                )
-        class PasswdDb:
-            def get_password(self, *args):
-                return ('sesame', 'plain')
-        authenticator = scram.SCRAMServerAuthenticator('SHA-256',
-                channel_binding=False, password_database=PasswdDb())
-
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['SCRAM-SHA-256']))
-        self.sendLine('AUTHENTICATE +')
-
-        m = self.getMessage()
-        self.assertEqual(m.command, 'AUTHENTICATE', m)
-        client_first = base64.b64decode(m.params[0])
-        response = authenticator.start(properties={}, initial_response=client_first)
-        assert isinstance(response, bytes), response
-        self.sendLine('AUTHENTICATE :' + base64.b64encode(response).decode())
-
-        m = self.getMessage()
-        self.assertEqual(m.command, 'AUTHENTICATE', m)
-        msg = base64.b64decode(m.params[0])
-        r = authenticator.response(msg)
-        assert isinstance(r, tuple), r
-        assert len(r) == 2, r
-        (properties, response) = r
-        self.sendLine('AUTHENTICATE :' + base64.b64encode(response).decode())
-        self.assertEqual(properties, {'authzid': None, 'username': 'jilles'})
-
-        m = self.getMessage()
-        self.assertEqual(m.command, 'AUTHENTICATE', m)
-        self.assertEqual(m.params, ['+'], m)
-
-    @cases.OptionalityHelper.skipUnlessHasMechanism('SCRAM-SHA-256')
-    def testScramBadPassword(self):
-        """Test SCRAM-SHA-256 authentication with a bad password.
-        """
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.scram_sha_256],
-                username='jilles',
-                password='sesame',
-                )
-        class PasswdDb:
-            def get_password(self, *args):
-                return ('notsesame', 'plain')
-        authenticator = scram.SCRAMServerAuthenticator('SHA-256',
-                channel_binding=False, password_database=PasswdDb())
-
-        m = self.negotiateCapabilities(['sasl'], auth=auth)
-        self.assertEqual(m, Message([], None, 'AUTHENTICATE', ['SCRAM-SHA-256']))
-        self.sendLine('AUTHENTICATE +')
-
-        m = self.getMessage()
-        self.assertEqual(m.command, 'AUTHENTICATE', m)
-        client_first = base64.b64decode(m.params[0])
-        response = authenticator.start(properties={}, initial_response=client_first)
-        assert isinstance(response, bytes), response
-        self.sendLine('AUTHENTICATE :' + base64.b64encode(response).decode())
-
-        m = self.getMessage()
-        self.assertEqual(m.command, 'AUTHENTICATE', m)
-        msg = base64.b64decode(m.params[0])
-        with self.assertRaises(scram.NotAuthorizedException):
-            authenticator.response(msg)
-
-class Irc302SaslTestCase(cases.BaseClientTestCase, cases.ClientNegociationHelper,
-                         cases.OptionalityHelper):
-    @cases.OptionalityHelper.skipUnlessHasMechanism('PLAIN')
-    def testPlainNotAvailable(self):
-        """Test the client does not try to authenticate using a mechanism the
-        server does not advertise.
-        Actually, this is optional."""
-        auth = authentication.Authentication(
-                mechanisms=[authentication.Mechanisms.plain],
-                username='jilles',
-                password='sesame',
-                )
-        m = self.negotiateCapabilities(['sasl=EXTERNAL'], auth=auth)
-        self.assertEqual(self.acked_capabilities, {'sasl'})
-        self.assertEqual(m, Message([], None, 'CAP', ['END']))

irctest/client_tests/tls.py

@@ -1,10 +1,9 @@
 import socket
 import ssl
 
-from irctest import tls
-from irctest import cases
+from irctest import cases, runner, tls
 from irctest.exceptions import ConnectionClosed
-from irctest.irc_utils.message_parser import Message
+from irctest.patma import ANYSTR
 
 BAD_CERT = """
 -----BEGIN CERTIFICATE-----
@@ -60,7 +59,7 @@ h4WuPDAI4yh24GjaCZYGR5xcqPCy5CNjMLxdA7HsP+Gcr3eY5XS7noBrbC6IaA0j
 -----END PRIVATE KEY-----
 """
 
-GOOD_FINGERPRINT = 'E1EE6DE2DBC0D43E3B60407B5EE389AEC9D2C53178E0FB14CD51C3DFD544AA2B'
+GOOD_FINGERPRINT = "E1EE6DE2DBC0D43E3B60407B5EE389AEC9D2C53178E0FB14CD51C3DFD544AA2B"
 GOOD_CERT = """
 -----BEGIN CERTIFICATE-----
 MIIDXTCCAkWgAwIBAgIJAKtD9XMC1R0vMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
@@ -115,71 +114,62 @@ El9iqRlAhgqaXc4Iz/Zxxhs=
 -----END PRIVATE KEY-----
 """
 
-class TlsTestCase(cases.BaseClientTestCase):
-    def testTrustedCertificate(self): 
-        tls_config = tls.TlsConfig(
-                enable=True,
-                trusted_fingerprints=[GOOD_FINGERPRINT])
-        (hostname, port) = self.server.getsockname()
-        self.controller.run(
-                hostname=hostname,
-                port=port,
-                auth=None,
-                tls_config=tls_config,
-                )
-        self.acceptClient(tls_cert=GOOD_CERT, tls_key=GOOD_KEY)
-        m = self.getMessage()
 
-    def testUntrustedCertificate(self): 
-        tls_config = tls.TlsConfig(
-                enable=True,
-                trusted_fingerprints=[GOOD_FINGERPRINT])
+class TlsTestCase(cases.BaseClientTestCase):
+    def testTrustedCertificate(self):
+        tls_config = tls.TlsConfig(enable=True, trusted_fingerprints=[GOOD_FINGERPRINT])
         (hostname, port) = self.server.getsockname()
         self.controller.run(
-                hostname=hostname,
-                port=port,
-                auth=None,
-                tls_config=tls_config,
-                )
+            hostname=hostname, port=port, auth=None, tls_config=tls_config
+        )
+        self.acceptClient(tls_cert=GOOD_CERT, tls_key=GOOD_KEY)
+        self.getMessage()
+
+    def testUntrustedCertificate(self):
+        tls_config = tls.TlsConfig(enable=True, trusted_fingerprints=[GOOD_FINGERPRINT])
+        (hostname, port) = self.server.getsockname()
+        self.controller.run(
+            hostname=hostname, port=port, auth=None, tls_config=tls_config
+        )
         self.acceptClient(tls_cert=BAD_CERT, tls_key=BAD_KEY)
         with self.assertRaises((ConnectionClosed, ConnectionResetError)):
-            m = self.getMessage()
+            self.getMessage()
 
 
 class StsTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
     def setUp(self):
         super().setUp()
         self.insecure_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.insecure_server.bind(('', 0)) # Bind any free port
+        self.insecure_server.bind(("", 0))  # Bind any free port
         self.insecure_server.listen(1)
 
     def tearDown(self):
         self.insecure_server.close()
         super().tearDown()
 
-    @cases.OptionalityHelper.skipUnlessSupportsCapability('sts')
+    @cases.mark_capabilities("sts")
     def testSts(self):
+        if not self.controller.supports_sts:
+            raise runner.CapabilityNotSupported("sts")
         tls_config = tls.TlsConfig(
-                enable=False,
-                trusted_fingerprints=[GOOD_FINGERPRINT])
+            enable=False, trusted_fingerprints=[GOOD_FINGERPRINT]
+        )
 
         # Connect client to insecure server
         (hostname, port) = self.insecure_server.getsockname()
         self.controller.run(
-                hostname=hostname,
-                port=port,
-                auth=None,
-                tls_config=tls_config,
-                )
+            hostname=hostname, port=port, auth=None, tls_config=tls_config
+        )
         self.acceptClient(server=self.insecure_server)
 
         # Send STS policy to client
-        m = self.getMessage()
-        self.assertEqual(m.command, 'CAP',
-                'First message is not CAP LS.')
-        self.assertEqual(m.params[0], 'LS',
-                'First message is not CAP LS.')
-        self.sendLine('CAP * LS :sts=port={}'.format(self.server.getsockname()[1]))
+        self.assertMessageMatch(
+            self.getMessage(),
+            command="CAP",
+            params=["LS", ANYSTR],
+            fail_msg="First message is not CAP LS: {got}",
+        )
+        self.sendLine("CAP * LS :sts=port={}".format(self.server.getsockname()[1]))
 
         # "If the client is not already connected securely to the server
         # at the requested hostname, it MUST close the insecure connection
@@ -187,11 +177,12 @@ class StsTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
         self.acceptClient(tls_cert=GOOD_CERT, tls_key=GOOD_KEY)
 
         # Send the STS policy, over secure connection this time
-        self.sendLine('CAP * LS :sts=duration=10,port={}'.format(
-            self.server.getsockname()[1]))
+        self.sendLine(
+            "CAP * LS :sts=duration=10,port={}".format(self.server.getsockname()[1])
+        )
 
         # Make the client reconnect. It should reconnect to the secure server.
-        self.sendLine('ERROR :closing link')
+        self.sendLine("ERROR :closing link")
         self.acceptClient()
 
         # Kill the client
@@ -199,34 +190,31 @@ class StsTestCase(cases.BaseClientTestCase, cases.OptionalityHelper):
 
         # Run the client, still configured to connect to the insecure server
         self.controller.run(
-                hostname=hostname,
-                port=port,
-                auth=None,
-                tls_config=tls_config,
-                )
+            hostname=hostname, port=port, auth=None, tls_config=tls_config
+        )
 
         # The client should remember the STS policy and connect to the secure
         # server
         self.acceptClient()
 
-    @cases.OptionalityHelper.skipUnlessSupportsCapability('sts')
+    @cases.mark_capabilities("sts")
     def testStsInvalidCertificate(self):
+        if not self.controller.supports_sts:
+            raise runner.CapabilityNotSupported("sts")
+
         # Connect client to insecure server
         (hostname, port) = self.insecure_server.getsockname()
-        self.controller.run(
-                hostname=hostname,
-                port=port,
-                auth=None,
-                )
+        self.controller.run(hostname=hostname, port=port, auth=None)
         self.acceptClient(server=self.insecure_server)
 
         # Send STS policy to client
-        m = self.getMessage()
-        self.assertEqual(m.command, 'CAP',
-                'First message is not CAP LS.')
-        self.assertEqual(m.params[0], 'LS',
-                'First message is not CAP LS.')
-        self.sendLine('CAP * LS :sts=port={}'.format(self.server.getsockname()[1]))
+        self.assertMessageMatch(
+            self.getMessage(),
+            command="CAP",
+            params=["LS", ANYSTR],
+            fail_msg="First message is not CAP LS: {got}",
+        )
+        self.sendLine("CAP * LS :sts=port={}".format(self.server.getsockname()[1]))
 
         # The client will reconnect to the TLS port. Unfortunately, it does
         # not trust its fingerprint.

irctest/controllers/anope_services.py

@@ -0,0 +1,126 @@
+import os
+import shutil
+import subprocess
+from typing import Type
+
+from irctest.basecontrollers import BaseServicesController, DirectoryBasedController
+
+TEMPLATE_CONFIG = """
+serverinfo {{
+    name = "services.example.org"
+    description = "Anope IRC Services"
+    numeric = "00A"
+    pid = "services.pid"
+    motd = "conf/empty_file"
+}}
+
+uplink  {{
+    host = "{server_hostname}"
+    port = {server_port}
+    password = "password"
+}}
+
+module {{
+    name = "{protocol}"
+}}
+
+networkinfo {{
+    networkname = "testnet"
+    nicklen = 31
+    userlen = 10
+    hostlen = 64
+    chanlen = 32
+}}
+
+mail {{
+    usemail = no
+}}
+
+service {{
+    nick = "NickServ"
+    user = "services"
+    host = "services.host"
+    gecos = "Nickname Registration Service"
+}}
+
+module {{
+    name = "nickserv"
+    client = "NickServ"
+    forceemail = no
+    passlen = 1000  # Some tests need long passwords
+}}
+command {{ service = "NickServ"; name = "HELP"; command = "generic/help"; }}
+
+module {{
+    name = "ns_register"
+    registration = "none"
+}}
+command {{ service = "NickServ"; name = "REGISTER"; command = "nickserv/register"; }}
+
+options {{
+    casemap = "ascii"
+    readtimeout = 5s
+    warningtimeout = 4h
+}}
+
+module {{ name = "m_sasl" }}
+module {{ name = "enc_sha256" }}
+module {{ name = "ns_cert" }}
+
+"""
+
+
+class AnopeController(BaseServicesController, DirectoryBasedController):
+    """Collaborator for server controllers that rely on Anope"""
+
+    def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
+        self.create_config()
+
+        assert protocol in (
+            "bahamut",
+            "inspircd3",
+            "charybdis",
+            "hybrid",
+            "plexus",
+            "unreal4",
+            "ngircd",
+        )
+
+        with self.open_file("conf/services.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    protocol=protocol,
+                    server_hostname=server_hostname,
+                    server_port=server_port,
+                )
+            )
+
+        with self.open_file("conf/empty_file") as fd:
+            pass
+
+        assert self.directory
+
+        # Config and code need to be in the same directory, *obviously*
+        os.symlink(
+            os.path.join(
+                os.path.dirname(shutil.which("services")), "..", "lib"  # type: ignore
+            ),
+            os.path.join(self.directory, "lib"),
+        )
+
+        self.proc = subprocess.Popen(
+            [
+                "services",
+                "-n",  # don't fork
+                "--config=services.conf",  # can't be an absolute path
+                # "--logdir",
+                # f"/tmp/services-{server_port}.log",
+            ],
+            cwd=self.directory,
+            # stdout=subprocess.DEVNULL,
+            # stderr=subprocess.DEVNULL,
+        )
+
+
+def get_irctest_controller_class() -> Type[AnopeController]:
+    return AnopeController

irctest/controllers/atheme_services.py

@@ -0,0 +1,110 @@
+import os
+import subprocess
+from typing import Optional, Type
+
+import irctest
+from irctest.basecontrollers import BaseServicesController, DirectoryBasedController
+import irctest.cases
+import irctest.runner
+
+TEMPLATE_CONFIG = """
+loadmodule "modules/protocol/{protocol}";
+loadmodule "modules/backend/opensex";
+loadmodule "modules/crypto/pbkdf2";
+
+loadmodule "modules/nickserv/main";
+loadmodule "modules/nickserv/cert";
+loadmodule "modules/nickserv/register";
+loadmodule "modules/nickserv/verify";
+
+loadmodule "modules/saslserv/main";
+loadmodule "modules/saslserv/authcookie";
+#loadmodule "modules/saslserv/ecdh-x25519-challenge";
+loadmodule "modules/saslserv/ecdsa-nist256p-challenge";
+loadmodule "modules/saslserv/external";
+loadmodule "modules/saslserv/plain";
+#loadmodule "modules/saslserv/scram";
+
+serverinfo {{
+    name = "services.example.org";
+    desc = "Atheme IRC Services";
+    numeric = "00A";
+    netname = "testnet";
+    adminname = "no admin";
+    adminemail = "no-admin@example.org";
+    registeremail = "registration@example.org";
+    auth = none;  // Disable email check
+}};
+
+general {{
+    commit_interval = 5;
+}};
+
+uplink "My.Little.Server" {{
+    host = "{server_hostname}";
+    port = {server_port};
+    send_password = "password";
+    receive_password = "password";
+}};
+
+saslserv {{
+    nick = "SaslServ";
+}};
+"""
+
+
+class AthemeController(BaseServicesController, DirectoryBasedController):
+    """Mixin for server controllers that rely on Atheme"""
+
+    def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
+        self.create_config()
+
+        if protocol == "inspircd3":
+            # That's the name used by Anope
+            protocol = "inspircd"
+        assert protocol in ("bahamut", "inspircd", "charybdis", "unreal4", "ngircd")
+
+        with self.open_file("services.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    protocol=protocol,
+                    server_hostname=server_hostname,
+                    server_port=server_port,
+                )
+            )
+
+        assert self.directory
+        self.proc = subprocess.Popen(
+            [
+                "atheme-services",
+                "-n",  # don't fork
+                "-c",
+                os.path.join(self.directory, "services.conf"),
+                "-l",
+                f"/tmp/services-{server_port}.log",
+                "-p",
+                os.path.join(self.directory, "services.pid"),
+                "-D",
+                self.directory,
+            ],
+            # stdout=subprocess.DEVNULL,
+            # stderr=subprocess.DEVNULL,
+        )
+
+    def registerUser(
+        self,
+        case: irctest.cases.BaseServerTestCase,
+        username: str,
+        password: Optional[str] = None,
+    ) -> None:
+        assert password
+        if len(password.encode()) > 288:
+            # It's hardcoded at compile-time :(
+            # https://github.com/atheme/atheme/blob/4fa0e03bd3ce2cb6041a339f308616580c5aac29/include/atheme/constants.h#L51
+            raise irctest.runner.NotImplementedByController("Passwords over 288 bytes")
+
+        super().registerUser(case, username, password)
+
+
+def get_irctest_controller_class() -> Type[AthemeController]:
+    return AthemeController

irctest/controllers/bahamut.py

@@ -0,0 +1,163 @@
+import os
+import shutil
+import subprocess
+from typing import Optional, Set, Type
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
+
+TEMPLATE_CONFIG = """
+global {{
+    name    My.Little.Server;         # IRC name of the server
+    info    "located on earth";     # A short info line
+}};
+
+options {{
+    network_name    unconfigured;
+    allow_split_ops;                # Give ops in empty channels
+
+    services_name   services.example.org;
+
+    // if you need to link more than 1 server, uncomment the following line
+    servtype        hub;
+}};
+
+/* where to listen for connections */
+port {{
+    port    {port};
+    bind    {hostname};
+}};
+
+/* allow clients to connect */
+allow {{
+    host    *@*;    # Allow anyone
+    class   users;  # Place them in the users class
+    flags   T;      # No throttling
+    {password_field}
+}};
+
+/* connection class for users */
+class {{
+    name        users;      # Class name
+    maxusers    100;        # Maximum connections
+    pingfreq    1000;       # Check idle connections every N seconds
+    maxsendq    100000;     # 100KB send buffer limit
+}};
+
+/* for services */
+super {{
+    "services.example.org";
+}};
+
+
+/* class for services */
+class {{
+    name        services;
+    pingfreq    60;         # Idle check every minute
+    maxsendq    5000000;    # 5MB backlog buffer
+}};
+
+/* our services */
+connect {{
+    name        services.example.org;
+    host        *@127.0.0.1;  # unfortunately, masks aren't allowed here
+    apasswd     password;
+    cpasswd     password;
+    class       services;
+}};
+
+oper {{
+    name operuser;
+    host *@*;
+    passwd operpassword;
+    access  *Aa;
+    class users;
+}};
+"""
+
+
+class BahamutController(BaseServerController, DirectoryBasedController):
+    software_name = "Bahamut"
+    supported_sasl_mechanisms: Set[str] = set()
+    supports_sts = False
+    nickserv = "NickServ@services.example.org"
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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()
+        (services_hostname, services_port) = find_hostname_and_port()
+
+        password_field = "passwd {};".format(password) if password else ""
+
+        self.gen_ssl()
+
+        assert self.directory
+
+        # they are hardcoded... thankfully Bahamut reads them from the CWD.
+        shutil.copy(self.pem_path, os.path.join(self.directory, "ircd.crt"))
+        shutil.copy(self.key_path, os.path.join(self.directory, "ircd.key"))
+
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    services_hostname=services_hostname,
+                    services_port=services_port,
+                    password_field=password_field,
+                    # key_path=self.key_path,
+                    # pem_path=self.pem_path,
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                # "strace", "-f", "-e", "file",
+                "ircd",
+                "-t",  # don't fork
+                "-f",
+                os.path.join(self.directory, "server.conf"),
+            ],
+            # stdout=subprocess.DEVNULL,
+        )
+
+        if run_services:
+            self.wait_for_port()
+            self.services_controller = self.services_controller_class(
+                self.test_config, self
+            )
+            self.services_controller.run(
+                protocol="bahamut",
+                server_hostname=hostname,
+                server_port=port,
+            )
+
+
+def get_irctest_controller_class() -> Type[BahamutController]:
+    return BahamutController

irctest/controllers/base_hybrid.py

@@ -0,0 +1,97 @@
+import os
+import subprocess
+from typing import Optional, Set
+
+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}";
+    ssl_cert = "{pem_path}";
+    ssl_dh_params = "{dh_path}";
+"""
+
+
+class BaseHybridController(BaseServerController, DirectoryBasedController):
+    """A base class for all controllers derived from ircd-hybrid (Hybrid itself,
+    Charybdis, Solanum, ...)"""
+
+    binary_name: str
+    services_protocol: str
+
+    supports_sts = False
+    extban_mute_char = None
+
+    template_config: str
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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) = find_hostname_and_port()
+        password_field = 'password = "{}";'.format(password) if password else ""
+        if ssl:
+            self.gen_ssl()
+            ssl_config = TEMPLATE_SSL_CONFIG.format(
+                key_path=self.key_path, pem_path=self.pem_path, dh_path=self.dh_path
+            )
+        else:
+            ssl_config = ""
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                (self.template_config).format(
+                    hostname=hostname,
+                    port=port,
+                    services_hostname=services_hostname,
+                    services_port=services_port,
+                    password_field=password_field,
+                    ssl_config=ssl_config,
+                )
+            )
+        assert self.directory
+        self.proc = subprocess.Popen(
+            [
+                self.binary_name,
+                "-foreground",
+                "-configfile",
+                os.path.join(self.directory, "server.conf"),
+                "-pidfile",
+                os.path.join(self.directory, "server.pid"),
+            ],
+            # stderr=subprocess.DEVNULL,
+        )
+
+        if run_services:
+            self.wait_for_port()
+            self.services_controller = self.services_controller_class(
+                self.test_config, self
+            )
+            self.services_controller.run(
+                protocol=self.services_protocol,
+                server_hostname=hostname,
+                server_port=services_port,
+            )

irctest/controllers/charybdis.py

@@ -1,13 +1,6 @@
-import os
-import time
-import shutil
-import tempfile
-import subprocess
+from typing import Type
 
-from irctest import client_mock
-from irctest import authentication
-from irctest.basecontrollers import NotImplementedByController
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from .base_hybrid import BaseHybridController
 
 TEMPLATE_CONFIG = """
 serverinfo {{
@@ -16,73 +9,76 @@ serverinfo {{
     description = "test server";
 {ssl_config}
 }};
+
+general {{
+    throttle_count = 100;  # We need to connect lots of clients quickly
+    sasl_service = "SaslServ";
+}};
+
+class "server" {{
+    ping_time = 5 minutes;
+    connectfreq = 5 minutes;
+}};
+
 listen {{
     defer_accept = yes;
 
     host = "{hostname}";
     port = {port};
+    port = {services_port};
 }};
+
 auth {{
     user = "*";
     flags = exceed_limit;
     {password_field}
 }};
+
 channel {{
     disable_local_channels = no;
     no_create_on_split = no;
     no_join_on_split = no;
     displayed_usercount = 0;
 }};
-"""
 
-TEMPLATE_SSL_CONFIG = """
-    ssl_private_key = "{key_path}";
-    ssl_cert = "{pem_path}";
-    ssl_dh_params = "{dh_path}";
+connect "services.example.org" {{
+    host = "localhost";  # Used to validate incoming connection
+    port = 0;  # We don't need servers to connect to services
+    send_password = "password";
+    accept_password = "password";
+    class = "server";
+    flags = topicburst;
+}};
+service {{
+    name = "services.example.org";
+}};
+
+privset "omnioper" {{
+    privs = oper:general, oper:privs, oper:testline, oper:kill, oper:operwall, oper:message,
+            oper:routing, oper:kline, oper:unkline, oper:xline,
+            oper:resv, oper:cmodes, oper:mass_notice, oper:wallops,
+            oper:remoteban,
+            usermode:servnotice, auspex:oper, auspex:hostname, auspex:umodes, auspex:cmodes,
+            oper:admin, oper:die, oper:rehash, oper:spy, oper:grant;
+}};
+operator "operuser" {{
+    user = "*@*";
+    password = "operpassword";
+    privset = "omnioper";
+    flags = ~encrypted;
+}};
 """
 
 
-class CharybdisController(BaseServerController, DirectoryBasedController):
-    software_name = 'Charybdis'
-    supported_sasl_mechanisms = set()
-    supported_capabilities = set()  # Not exhaustive
-    def create_config(self):
-        super().create_config()
-        with self.open_file('server.conf'):
-            pass
+class CharybdisController(BaseHybridController):
+    software_name = "Charybdis"
+    binary_name = "charybdis"
+    services_protocol = "charybdis"
 
-    def run(self, hostname, port, password=None, ssl=False,
-            valid_metadata_keys=None, invalid_metadata_keys=None):
-        if valid_metadata_keys or invalid_metadata_keys:
-            raise NotImplementedByController(
-                    'Defining valid and invalid METADATA keys.')
-        assert self.proc is None
-        self.create_config()
-        self.port = port
-        password_field = 'password = "{}";'.format(password) if password else ''
-        if ssl:
-            self.gen_ssl()
-            ssl_config = TEMPLATE_SSL_CONFIG.format(
-                    key_path=self.key_path,
-                    pem_path=self.pem_path,
-                    dh_path=self.dh_path,
-                    )
-        else:
-            ssl_config = ''
-        with self.open_file('server.conf') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                hostname=hostname,
-                port=port,
-                password_field=password_field,
-                ssl_config=ssl_config,
-                ))
-        self.proc = subprocess.Popen(['charybdis', '-foreground',
-            '-configfile', os.path.join(self.directory, 'server.conf'),
-            '-pidfile', os.path.join(self.directory, 'server.pid'),
-            ],
-            stderr=subprocess.DEVNULL
-            )
+    supported_sasl_mechanisms = {"PLAIN"}
+
+    template_config = TEMPLATE_CONFIG
 
 
-def get_irctest_controller_class():
+def get_irctest_controller_class() -> Type[CharybdisController]:
     return CharybdisController

irctest/controllers/ergo.py

@@ -0,0 +1,305 @@
+import copy
+import json
+import os
+import subprocess
+from typing import Any, Dict, Optional, Set, Type, Union
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.cases import BaseServerTestCase
+
+BASE_CONFIG = {
+    "network": {"name": "ErgoTest"},
+    "server": {
+        "name": "My.Little.Server",
+        "listeners": {},
+        "max-sendq": "16k",
+        "connection-limits": {
+            "enabled": True,
+            "cidr-len-ipv4": 32,
+            "cidr-len-ipv6": 64,
+            "ips-per-subnet": 1,
+            "exempted": ["localhost"],
+        },
+        "connection-throttling": {
+            "enabled": True,
+            "cidr-len-ipv4": 32,
+            "cidr-len-ipv6": 64,
+            "ips-per-subnet": 16,
+            "duration": "10m",
+            "max-connections": 1,
+            "ban-duration": "10m",
+            "ban-message": "Try again later",
+            "exempted": ["localhost"],
+        },
+        "lookup-hostnames": False,
+        "enforce-utf8": True,
+        "relaymsg": {"enabled": True, "separators": "/", "available-to-chanops": True},
+        "compatibility": {
+            "allow-truncation": False,
+        },
+    },
+    "accounts": {
+        "authentication-enabled": True,
+        "advertise-scram": True,
+        "multiclient": {
+            "allowed-by-default": True,
+            "enabled": True,
+            "always-on": "disabled",
+        },
+        "registration": {
+            "bcrypt-cost": 4,
+            "enabled": True,
+            "enabled-callbacks": ["none"],
+            "verify-timeout": "120h",
+        },
+        "nick-reservation": {
+            "enabled": True,
+            "method": "strict",
+        },
+    },
+    "channels": {"registration": {"enabled": True}},
+    "datastore": {"path": None},
+    "limits": {
+        "awaylen": 200,
+        "chan-list-modes": 60,
+        "channellen": 64,
+        "kicklen": 390,
+        "linelen": {"rest": 2048},
+        "monitor-entries": 100,
+        "nicklen": 32,
+        "topiclen": 390,
+        "whowas-entries": 100,
+        "multiline": {"max-bytes": 4096, "max-lines": 32},
+    },
+    "history": {
+        "enabled": True,
+        "channel-length": 128,
+        "client-length": 128,
+        "chathistory-maxmessages": 100,
+        "tagmsg-storage": {
+            "default": False,
+            "whitelist": ["+draft/persist", "+persist"],
+        },
+    },
+    "oper-classes": {
+        "server-admin": {
+            "title": "Server Admin",
+            "capabilities": [
+                "oper:local_kill",
+                "oper:local_ban",
+                "oper:local_unban",
+                "nofakelag",
+                "oper:remote_kill",
+                "oper:remote_ban",
+                "oper:remote_unban",
+                "oper:rehash",
+                "oper:die",
+                "accreg",
+                "sajoin",
+                "samode",
+                "vhosts",
+                "chanreg",
+                "relaymsg",
+            ],
+        }
+    },
+    "opers": {
+        "operuser": {
+            "class": "server-admin",
+            "whois-line": "is a server admin",
+            # "operpassword"
+            "password": "$2a$04$bKb6k5A6yuFA2wx.iJtxcuT2dojHQAjHd5ZPK/I2sjJml7p4spxjG",
+        }
+    },
+}
+
+LOGGING_CONFIG = {"logging": [{"method": "stderr", "level": "debug", "type": "*"}]}
+
+
+def hash_password(password: Union[str, bytes]) -> str:
+    if isinstance(password, str):
+        password = password.encode("utf-8")
+    # simulate entry of password and confirmation:
+    input_ = password + b"\n" + password + b"\n"
+    p = subprocess.Popen(
+        ["ergo", "genpasswd"], stdin=subprocess.PIPE, stdout=subprocess.PIPE
+    )
+    out, _ = p.communicate(input_)
+    return out.decode("utf-8")
+
+
+class ErgoController(BaseServerController, DirectoryBasedController):
+    software_name = "Ergo"
+    _port_wait_interval = 0.01
+    supported_sasl_mechanisms = {"PLAIN", "SCRAM-SHA-256"}
+    supports_sts = True
+    extban_mute_char = "m"
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("ircd.yaml"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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)
+
+        assert self.directory
+
+        enable_chathistory = self.test_config.chathistory
+        enable_roleplay = self.test_config.ergo_roleplay
+        if enable_chathistory or enable_roleplay:
+            config = self.addMysqlToConfig(config)
+
+        if enable_roleplay:
+            config["roleplay"] = {"enabled": True}
+
+        if self.test_config.ergo_config:
+            self.test_config.ergo_config(config)
+
+        self.port = port
+        bind_address = "127.0.0.1:%s" % (port,)
+        listener_conf = None  # plaintext
+        if ssl:
+            self.key_path = os.path.join(self.directory, "ssl.key")
+            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"] = 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 = 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"])
+        self.proc = subprocess.Popen(
+            ["ergo", "run", "--conf", self._config_path, "--quiet"]
+        )
+
+    def wait_for_services(self) -> None:
+        # Nothing to wait for, they start at the same time as Ergo.
+        pass
+
+    def registerUser(
+        self,
+        case: BaseServerTestCase,
+        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
+            # controllers.
+            raise ValueError(
+                "Attempted to register a nick, but `run_services` it not True."
+            )
+        client = case.addClient(show_io=False)
+        case.sendLine(client, "CAP LS 302")
+        case.sendLine(client, "NICK " + username)
+        case.sendLine(client, "USER r e g :user")
+        case.sendLine(client, "CAP END")
+        while case.getRegistrationMessage(client).command != "001":
+            pass
+        case.getMessages(client)
+        assert password
+        case.sendLine(client, "NS REGISTER " + password)
+        msg = case.getMessage(client)
+        assert msg.params == [username, "Account created"]
+        case.sendLine(client, "QUIT")
+        case.assertDisconnected(client)
+
+    def _write_config(self) -> None:
+        with open(self._config_path, "w") as fd:
+            json.dump(self._config, fd)
+
+    def baseConfig(self) -> Dict:
+        return copy.deepcopy(BASE_CONFIG)
+
+    def getConfig(self) -> Dict:
+        return copy.deepcopy(self._config)
+
+    def addLoggingToConfig(self, config: Optional[Dict] = None) -> Dict:
+        if config is None:
+            config = self.baseConfig()
+        config.update(LOGGING_CONFIG)
+        return config
+
+    def addMysqlToConfig(self, config: Optional[Dict] = None) -> Dict:
+        mysql_password = os.getenv("MYSQL_PASSWORD")
+        if config is None:
+            config = self.baseConfig()
+        if not mysql_password:
+            return config
+        config["datastore"]["mysql"] = {
+            "enabled": True,
+            "host": "localhost",
+            "user": "ergo",
+            "password": mysql_password,
+            "history-database": "ergo_history",
+            "timeout": "3s",
+        }
+        config["accounts"]["multiclient"] = {
+            "enabled": True,
+            "allowed-by-default": True,
+            "always-on": "disabled",
+        }
+        config["history"]["persistent"] = {
+            "enabled": True,
+            "unregistered-channels": True,
+            "registered-channels": "opt-out",
+            "direct-messages": "opt-out",
+        }
+        return config
+
+    def rehash(self, case: BaseServerTestCase, config: Dict) -> None:
+        self._config = config
+        self._write_config()
+        client = "operator_for_rehash"
+        case.connectClient(nick=client, name=client)
+        case.sendLine(client, "OPER operuser operpassword")
+        case.sendLine(client, "REHASH")
+        case.getMessages(client)
+        case.sendLine(client, "QUIT")
+        case.assertDisconnected(client)
+
+    def enable_debug_logging(self, case: BaseServerTestCase) -> None:
+        config = self.getConfig()
+        config.update(LOGGING_CONFIG)
+        self.rehash(case, config)
+
+
+def get_irctest_controller_class() -> Type[ErgoController]:
+    return ErgoController

irctest/controllers/external_server.py

@@ -0,0 +1,50 @@
+import os
+from typing import Optional, Set, Tuple, Type
+
+from irctest.basecontrollers import BaseServerController
+
+
+class ExternalServerController(BaseServerController):
+    """Dummy controller that doesn't run a server.
+    Instead, it allows connecting to servers ran outside irctest."""
+
+    software_name = "unknown external server"
+    supported_sasl_mechanisms = set(
+        os.environ.get("IRCTEST_SERVER_SASL_MECHS", "").split()
+    )
+
+    def check_is_alive(self) -> None:
+        pass
+
+    def kill_proc(self) -> None:
+        pass
+
+    def wait_for_port(self) -> None:
+        pass
+
+    def get_hostname_and_port(self) -> Tuple[str, int]:
+        hostname = os.environ.get("IRCTEST_SERVER_HOSTNAME")
+        port = os.environ.get("IRCTEST_SERVER_PORT")
+        if not hostname or not port:
+            raise RuntimeError(
+                "Please set IRCTEST_SERVER_HOSTNAME and IRCTEST_SERVER_PORT."
+            )
+        return (hostname, int(port))
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        valid_metadata_keys: Optional[Set[str]] = None,
+        invalid_metadata_keys: Optional[Set[str]] = None,
+        restricted_metadata_keys: Optional[Set[str]] = None,
+    ) -> None:
+        pass
+
+
+def get_irctest_controller_class() -> Type[ExternalServerController]:
+    return ExternalServerController

irctest/controllers/girc.py

@@ -1,45 +1,38 @@
 import subprocess
+from typing import Optional, Type
 
-from irctest.basecontrollers import BaseClientController, NotImplementedByController
+from irctest import authentication, tls
+from irctest.basecontrollers import (
+    BaseClientController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
 
-class GircController(BaseClientController):
-    software_name = 'gIRC'
-    supported_sasl_mechanisms = ['PLAIN']
-    supported_capabilities = set()  # Not exhaustive
 
-    def __init__(self):
-        super().__init__()
-        self.directory = None
-        self.proc = None
+class GircController(BaseClientController, DirectoryBasedController):
+    software_name = "gIRC"
+    supported_sasl_mechanisms = {"PLAIN"}
 
-    def kill(self):
-        if self.proc:
-            self.proc.terminate()
-            try:
-                self.proc.wait(5)
-            except subprocess.TimeoutExpired:
-                self.proc.kill()
-            self.proc = None
-
-    def __del__(self):
-        if self.proc:
-            self.proc.kill()
-        if self.directory:
-            self.directory.cleanup()
-
-    def run(self, hostname, port, auth, tls_config):
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        auth: Optional[authentication.Authentication],
+        tls_config: Optional[tls.TlsConfig] = None,
+    ) -> None:
         if tls_config:
             print(tls_config)
-            raise NotImplementedByController('TLS options')
-        args = ['--host', hostname, '--port', str(port), '--quiet']
+            raise NotImplementedByController("TLS options")
+        args = ["--host", hostname, "--port", str(port), "--quiet"]
 
         if auth and auth.username and auth.password:
-            args += ['--sasl-name', auth.username]
-            args += ['--sasl-pass', auth.password]
-            args += ['--sasl-fail-is-ok']
+            args += ["--sasl-name", auth.username]
+            args += ["--sasl-pass", auth.password]
+            args += ["--sasl-fail-is-ok"]
 
         # Runs a client with the config given as arguments
-        self.proc = subprocess.Popen(['girc_test', 'connect'] + args)
+        self.proc = subprocess.Popen(["girc_test", "connect"] + args)
 
-def get_irctest_controller_class():
+
+def get_irctest_controller_class() -> Type[GircController]:
     return GircController

irctest/controllers/hybrid.py

@@ -1,88 +1,82 @@
-import os
-import time
-import shutil
-import tempfile
-import subprocess
+from typing import Set, Type
 
-from irctest import client_mock
-from irctest import authentication
-from irctest.basecontrollers import NotImplementedByController
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from .base_hybrid import BaseHybridController
 
 TEMPLATE_CONFIG = """
 serverinfo {{
     name = "My.Little.Server";
     sid = "42X";
     description = "test server";
+
+    # Hybrid defaults to 9
+    max_nick_length = 20;
 {ssl_config}
 }};
+
+general {{
+    throttle_count = 100;  # We need to connect lots of clients quickly
+    sasl_service = "SaslServ";
+
+    # Allow PART/QUIT reasons quickly
+    anti_spam_exit_message_time = 0;
+
+    # Allow all commands quickly
+    pace_wait_simple = 0;
+    pace_wait = 0;
+}};
+
 listen {{
+    defer_accept = yes;
+
     host = "{hostname}";
     port = {port};
+    port = {services_port};
 }};
-general {{
-    disable_auth = yes;
-    anti_nick_flood = no;
-    max_nick_changes = 256;
-    throttle_count = 512;
+
+class {{
+    name = "server";
+    ping_time = 5 minutes;
+    connectfreq = 5 minutes;
 }};
+connect {{
+    name = "services.example.org";
+    host = "localhost";  # Used to validate incoming connection
+    port = 0;  # We don't need servers to connect to services
+    send_password = "password";
+    accept_password = "password";
+    class = "server";
+}};
+service {{
+    name = "services.example.org";
+}};
+
 auth {{
     user = "*";
     flags = exceed_limit;
     {password_field}
 }};
-"""
 
-TEMPLATE_SSL_CONFIG = """
-    rsa_private_key_file = "{key_path}";
-    ssl_certificate_file = "{pem_path}";
-    ssl_dh_param_file = "{dh_path}";
+operator {{
+    name = "operuser";
+    user = "*@*";
+    password = "operpassword";
+    encrypted = no;
+    umodes = locops, servnotice, wallop;
+    flags = admin, connect, connect:remote, die, globops, kill, kill:remote,
+            kline, module, rehash, restart, set, unkline, unxline, wallops, xline;
+}};
 """
 
 
-class HybridController(BaseServerController, DirectoryBasedController):
-    software_name = 'Hybrid'
-    supported_sasl_mechanisms = set()
-    supported_capabilities = set()  # Not exhaustive
+class HybridController(BaseHybridController):
+    software_name = "Hybrid"
+    binary_name = "ircd"
+    services_protocol = "hybrid"
 
-    def create_config(self):
-        super().create_config()
-        with self.open_file('server.conf'):
-            pass
+    supported_sasl_mechanisms: Set[str] = set()
 
-    def run(self, hostname, port, password=None, ssl=False,
-            valid_metadata_keys=None, invalid_metadata_keys=None):
-        if valid_metadata_keys or invalid_metadata_keys:
-            raise NotImplementedByController(
-                    'Defining valid and invalid METADATA keys.')
-        assert self.proc is None
-        self.create_config()
-        self.port = port
-        password_field = 'password = "{}";'.format(password) if password else ''
-        if ssl:
-            self.gen_ssl()
-            ssl_config = TEMPLATE_SSL_CONFIG.format(
-                    key_path=self.key_path,
-                    pem_path=self.pem_path,
-                    dh_path=self.dh_path,
-                    )
-        else:
-            ssl_config = ''
-        with self.open_file('server.conf') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                hostname=hostname,
-                port=port,
-                password_field=password_field,
-                ssl_config=ssl_config,
-                ))
-        self.proc = subprocess.Popen(['ircd', '-foreground',
-            '-configfile', os.path.join(self.directory, 'server.conf'),
-            '-pidfile', os.path.join(self.directory, 'server.pid'),
-            ],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
-            )
+    template_config = TEMPLATE_CONFIG
 
 
-def get_irctest_controller_class():
+def get_irctest_controller_class() -> Type[HybridController]:
     return HybridController

irctest/controllers/inspircd.py

@@ -1,25 +1,82 @@
 import os
-import time
-import shutil
-import tempfile
 import subprocess
+from typing import Optional, Set, Type
 
-from irctest import authentication
-from irctest.basecontrollers import NotImplementedByController
-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:
 <bind address="{hostname}" port="{port}" type="clients">
 {ssl_config}
-<module name="cap">
-<module name="ircv3">
-<module name="ircv3_capnotify">
-<module name="ircv3_echomessage">
-<module name="namesx"> # For multi-prefix
 <connect allow="*"
     resolvehostnames="no" # Faster
+    recvq="40960" # Needs to be larger than a valid message with tags
+    timeout="10"  # So tests don't hang too long
     {password_field}>
+
+<class
+    name="ServerOperators"
+    commands="WALLOPS GLOBOPS"
+    privs="channels/auspex users/auspex channels/auspex servers/auspex users/mass-message"
+    >
+<type
+    name="NetAdmin"
+    classes="ServerOperators"
+    >
+<oper name="operuser"
+      password="operpassword"
+      host="*@*"
+      type="NetAdmin"
+      class="ServerOperators"
+      >
+
+<options casemapping="ascii">
+
+# Disable 'NOTICE #chan :*** foo invited bar into the channel-
+<security announceinvites="none">
+
+# Services:
+<bind address="{services_hostname}" port="{services_port}" type="servers">
+<link name="services.example.org"
+    ipaddr="{services_hostname}"
+    port="{services_port}"
+    allowmask="*"
+    recvpass="password"
+    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="botmode">
+<module name="cap">
+<module name="ircv3">
+<module name="ircv3_accounttag">
+<module name="ircv3_batch">
+<module name="ircv3_capnotify">
+<module name="ircv3_ctctags">
+<module name="ircv3_echomessage">
+<module name="ircv3_invitenotify">
+<module name="ircv3_labeledresponse">
+<module name="ircv3_msgid">
+<module name="ircv3_servertime">
+<module name="monitor">
+<module name="m_muteban">  # for testing mute extbans
+<module name="namesx"> # For multi-prefix
+<module name="sasl">
+
+# Misc:
 <log method="file" type="*" level="debug" target="/tmp/ircd-{port}.log">
+<server name="My.Little.Server" description="testnet" id="000" network="testnet">
 """
 
 TEMPLATE_SSL_CONFIG = """
@@ -27,47 +84,83 @@ TEMPLATE_SSL_CONFIG = """
 <openssl certfile="{pem_path}" keyfile="{key_path}" dhfile="{dh_path}" hash="sha1">
 """
 
-class InspircdController(BaseServerController, DirectoryBasedController):
-    software_name = 'InspIRCd'
-    supported_sasl_mechanisms = set()
-    supported_capabilities = set()  # Not exhaustive
 
-    def create_config(self):
+class InspircdController(BaseServerController, DirectoryBasedController):
+    software_name = "InspIRCd"
+    supported_sasl_mechanisms = {"PLAIN"}
+    supports_sts = False
+    extban_mute_char = "m"
+
+    def create_config(self) -> None:
         super().create_config()
-        with self.open_file('server.conf'):
+        with self.open_file("server.conf"):
             pass
 
-    def run(self, hostname, port, password=None, ssl=False,
-            restricted_metadata_keys=None,
-            valid_metadata_keys=None, invalid_metadata_keys=None):
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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.')
+                "Defining valid and invalid METADATA keys."
+            )
         assert self.proc is None
         self.port = port
+        self.hostname = hostname
         self.create_config()
-        password_field = 'password="{}"'.format(password) if password else ''
+        (services_hostname, services_port) = find_hostname_and_port()
+
+        password_field = 'password="{}"'.format(password) if password else ""
+
         if ssl:
             self.gen_ssl()
             ssl_config = TEMPLATE_SSL_CONFIG.format(
-                    key_path=self.key_path,
-                    pem_path=self.pem_path,
-                    dh_path=self.dh_path,
-                    )
+                key_path=self.key_path, pem_path=self.pem_path, dh_path=self.dh_path
+            )
         else:
-            ssl_config = ''
-        with self.open_file('server.conf') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                hostname=hostname,
-                port=port,
-                password_field=password_field,
-                ssl_config=ssl_config
-                ))
-        self.proc = subprocess.Popen(['inspircd', '--nofork', '--config',
-            os.path.join(self.directory, 'server.conf')],
-            stdout=subprocess.DEVNULL
+            ssl_config = ""
+
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    services_hostname=services_hostname,
+                    services_port=services_port,
+                    password_field=password_field,
+                    ssl_config=ssl_config,
+                )
+            )
+        assert self.directory
+        self.proc = subprocess.Popen(
+            [
+                "inspircd",
+                "--nofork",
+                "--config",
+                os.path.join(self.directory, "server.conf"),
+            ],
+            stdout=subprocess.DEVNULL,
+        )
+
+        if run_services:
+            self.wait_for_port()
+            self.services_controller = self.services_controller_class(
+                self.test_config, self
+            )
+            self.services_controller.run(
+                protocol="inspircd3",
+                server_hostname=services_hostname,
+                server_port=services_port,
             )
 
-def get_irctest_controller_class():
-    return InspircdController
 
+def get_irctest_controller_class() -> Type[InspircdController]:
+    return InspircdController

irctest/controllers/irc2.py

@@ -0,0 +1,93 @@
+import os
+import subprocess
+from typing import Optional, Set, Type
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+
+TEMPLATE_CONFIG = """
+# M:<Server NAME>:<YOUR Internet IP#>:<Geographic Location>:<Port>:<SID>:
+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:
+
+# P:<YOUR Internet IP#>:<*>::<Port>:<Flags>
+P::::{port}::
+
+# Y:<Class>:<Ping Frequency>::<Max Links>:<SendQ>:<Local Limit>:<Global Limit>:
+Y:10:90::100:512000:100.100:100.100:
+
+# I:<TARGET Host Addr>:<Password>:<TARGET Hosts NAME>:<Port>:<Class>:<Flags>:
+I::{password_field}:::10::
+
+# O:<TARGET Host NAME>:<Password>:<Nickname>:<Port>:<Class>:<Flags>:
+O:*:operpassword:operuser::::
+"""
+
+
+class Ircu2Controller(BaseServerController, DirectoryBasedController):
+    binary_name: str
+    services_protocol: str
+
+    supports_sts = False
+    extban_mute_char = None
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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:
+            raise NotImplementedByController("Services")
+        assert self.proc is None
+        self.port = port
+        self.hostname = hostname
+        self.create_config()
+        password_field = password if password else ""
+        assert self.directory
+        pidfile = os.path.join(self.directory, "ircd.pid")
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    password_field=password_field,
+                    pidfile=pidfile,
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                "ircd",
+                "-s",  # no iauth
+                "-p",
+                "on",
+                "-f",
+                os.path.join(self.directory, "server.conf"),
+            ],
+            # stderr=subprocess.DEVNULL,
+        )
+
+
+def get_irctest_controller_class() -> Type[Ircu2Controller]:
+    return Ircu2Controller

irctest/controllers/ircu2.py

@@ -0,0 +1,111 @@
+import os
+import subprocess
+from typing import Optional, Set, Type
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+
+TEMPLATE_CONFIG = """
+General {{
+    name = "My.Little.Server";
+    numeric = 42;
+    description = "test server";
+}};
+
+Port {{
+    vhost = "{hostname}";
+    port = {port};
+}};
+
+Class {{
+    name = "Client";
+    pingfreq = 5 minutes;
+    sendq = 160000;
+    maxlinks = 1024;
+}};
+
+Client {{
+    username = "*";
+    class = "Client";
+    {password_field}
+}};
+
+Operator {{
+    local = no;
+    host = "*@*";
+    password = "$PLAIN$operpassword";
+    name = "operuser";
+    class = "Client";
+}};
+
+features {{
+    "PPATH" = "{pidfile}";
+
+    # workaround for whois tests, checking the server name
+    "HIS_SERVERNAME" = "My.Little.Server";
+}};
+"""
+
+
+class Ircu2Controller(BaseServerController, DirectoryBasedController):
+    supports_sts = False
+    extban_mute_char = None
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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:
+            raise NotImplementedByController("Services")
+        assert self.proc is None
+        self.port = port
+        self.hostname = hostname
+        self.create_config()
+        password_field = 'password = "{}";'.format(password) if password else ""
+        assert self.directory
+        pidfile = os.path.join(self.directory, "ircd.pid")
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    password_field=password_field,
+                    pidfile=pidfile,
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                "ircd",
+                "-n",  # don't detach
+                "-f",
+                os.path.join(self.directory, "server.conf"),
+                "-x",
+                "DEBUG",
+            ],
+            # stderr=subprocess.DEVNULL,
+        )
+
+
+def get_irctest_controller_class() -> Type[Ircu2Controller]:
+    return Ircu2Controller

irctest/controllers/limnoria.py

@@ -1,9 +1,8 @@
 import os
 import subprocess
+from typing import Optional, Type
 
-from irctest import authentication
-from irctest import tls
-from irctest.basecontrollers import NotImplementedByController
+from irctest import authentication, tls
 from irctest.basecontrollers import BaseClientController, DirectoryBasedController
 
 TEMPLATE_CONFIG = """
@@ -26,50 +25,64 @@ supybot.networks.testnet.sasl.ecdsa_key: {directory}/ecdsa_key.pem
 supybot.networks.testnet.sasl.mechanisms: {mechanisms}
 """
 
+
 class LimnoriaController(BaseClientController, DirectoryBasedController):
-    software_name = 'Limnoria'
+    software_name = "Limnoria"
     supported_sasl_mechanisms = {
-            'PLAIN', 'ECDSA-NIST256P-CHALLENGE', 'SCRAM-SHA-256', 'EXTERNAL',
-            }
-    supported_capabilities = set(['sts'])  # Not exhaustive
+        "PLAIN",
+        "ECDSA-NIST256P-CHALLENGE",
+        "SCRAM-SHA-256",
+        "EXTERNAL",
+    }
+    supports_sts = True
 
-    def create_config(self):
-        create_config = super().create_config()
-        if create_config:
-            with self.open_file('bot.conf'):
-                pass
-            with self.open_file('conf/users.conf'):
-                pass
+    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, port, auth, tls_config=None):
+    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=[])
         # Runs a client with the config given as arguments
         assert self.proc is None
         self.create_config()
         if auth:
-            mechanisms = ' '.join(map(authentication.Mechanisms.as_string,
-                auth.mechanisms))
+            mechanisms = " ".join(mech.to_string() for mech in auth.mechanisms)
             if auth.ecdsa_key:
-                with self.open_file('ecdsa_key.pem') as fd:
+                with self.open_file("ecdsa_key.pem") as fd:
                     fd.write(auth.ecdsa_key)
         else:
-            mechanisms = ''
-        with self.open_file('bot.conf') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                directory=self.directory,
-                loglevel='CRITICAL',
-                hostname=hostname,
-                port=port,
-                username=auth.username if auth else '',
-                password=auth.password if auth else '',
-                mechanisms=mechanisms.lower(),
-                enable_tls=tls_config.enable if tls_config else 'False',
-                trusted_fingerprints=' '.join(tls_config.trusted_fingerprints) if tls_config else '',
-                ))
-        self.proc = subprocess.Popen(['supybot',
-            os.path.join(self.directory, 'bot.conf')],
-            stderr=subprocess.STDOUT)
+            mechanisms = ""
+        with self.open_file("bot.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    directory=self.directory,
+                    loglevel="CRITICAL",
+                    hostname=hostname,
+                    port=port,
+                    username=auth.username if auth else "",
+                    password=auth.password if auth else "",
+                    mechanisms=mechanisms.lower(),
+                    enable_tls=tls_config.enable if tls_config else "False",
+                    trusted_fingerprints=" ".join(tls_config.trusted_fingerprints)
+                    if tls_config
+                    else "",
+                )
+            )
+        assert self.directory
+        self.proc = subprocess.Popen(
+            ["supybot", os.path.join(self.directory, "bot.conf")]
+        )
 
-def get_irctest_controller_class():
+
+def get_irctest_controller_class() -> Type[LimnoriaController]:
     return LimnoriaController

irctest/controllers/mammon.py

@@ -1,9 +1,13 @@
 import os
-import time
 import subprocess
+from typing import Optional, Set, Type
 
-from irctest.basecontrollers import NotImplementedByController
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.cases import BaseServerTestCase
 
 TEMPLATE_CONFIG = """
 clients:
@@ -58,66 +62,89 @@ server:
   recvq_len: 20
 """
 
-def make_list(l):
-    return '\n'.join(map('  - {}'.format, l))
+
+def make_list(list_: Set[str]) -> str:
+    return "\n".join(map("  - {}".format, list_))
+
 
 class MammonController(BaseServerController, DirectoryBasedController):
-    software_name = 'Mammon'
-    supported_sasl_mechanisms = {
-            'PLAIN', 'ECDSA-NIST256P-CHALLENGE',
-            }
-    supported_capabilities = set()  # Not exhaustive
+    software_name = "Mammon"
+    supported_sasl_mechanisms = {"PLAIN", "ECDSA-NIST256P-CHALLENGE"}
 
-    def create_config(self):
+    def create_config(self) -> None:
         super().create_config()
-        with self.open_file('server.conf'):
+        with self.open_file("server.conf"):
             pass
 
-    def kill_proc(self):
+    def kill_proc(self) -> None:
         # Mammon does not seem to handle SIGTERM very well
+        assert self.proc
         self.proc.kill()
 
-    def run(self, hostname, port, password=None, ssl=False,
-            restricted_metadata_keys=(),
-            valid_metadata_keys=(), invalid_metadata_keys=()):
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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')
+            raise NotImplementedByController("PASS command")
         if ssl:
-            raise NotImplementedByController('SSL')
+            raise NotImplementedByController("SSL")
         assert self.proc is None
         self.port = port
         self.create_config()
-        with self.open_file('server.yml') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                directory=self.directory,
-                hostname=hostname,
-                port=port,
-                authorized_keys=make_list(valid_metadata_keys),
-                restricted_keys=make_list(restricted_metadata_keys),
-                ))
-        #with self.open_file('server.yml', 'r') as fd:
+        with self.open_file("server.yml") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    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())
-        self.proc = subprocess.Popen(['mammond', '--nofork', #'--debug',
-            '--config', os.path.join(self.directory, 'server.yml')])
+        assert self.directory
+        self.proc = subprocess.Popen(
+            [
+                "mammond",
+                "--nofork",  # '--debug',
+                "--config",
+                os.path.join(self.directory, "server.yml"),
+            ]
+        )
 
-    def registerUser(self, case, username, password=None):
+    def registerUser(
+        self,
+        case: BaseServerTestCase,
+        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
         client = case.addClient(show_io=False)
-        case.sendLine(client, 'CAP LS 302')
-        case.sendLine(client, 'NICK registration_user')
-        case.sendLine(client, 'USER r e g :user')
-        case.sendLine(client, 'CAP END')
-        while case.getRegistrationMessage(client).command != '001':
+        case.sendLine(client, "CAP LS 302")
+        case.sendLine(client, "NICK registration_user")
+        case.sendLine(client, "USER r e g :user")
+        case.sendLine(client, "CAP END")
+        while case.getRegistrationMessage(client).command != "001":
             pass
         list(case.getMessages(client))
-        case.sendLine(client, 'REG CREATE {} passphrase {}'.format(
-            username, password))
+        case.sendLine(client, "REG CREATE {} passphrase {}".format(username, password))
         msg = case.getMessage(client)
-        assert msg.command == '920', msg
+        assert msg.command == "920", msg
         list(case.getMessages(client))
         case.removeClient(client)
 
-def get_irctest_controller_class():
+
+def get_irctest_controller_class() -> Type[MammonController]:
     return MammonController

irctest/controllers/ngircd.py

@@ -0,0 +1,117 @@
+import os
+import subprocess
+from typing import Optional, Set, Type
+
+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 = ExampleNET Server
+    Bind = {hostname}
+    Ports = {port}
+    AdminInfo1 = Bob Smith
+    AdminEMail = email@example.org
+    {password_field}
+
+[Server]
+    Name = services.example.org
+    MyPassword = password
+    PeerPassword = password
+    Passive = yes  # don't connect to it
+    ServiceMask = *Serv
+
+[Operator]
+    Name = operuser
+    Password = operpassword
+"""
+
+
+class NgircdController(BaseServerController, DirectoryBasedController):
+    software_name = "ngIRCd"
+    supported_sasl_mechanisms: Set[str] = set()
+    supports_sts = False
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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()
+
+        password_field = "Password = {}".format(password) if password else ""
+
+        self.gen_ssl()
+        if ssl:
+            (tls_hostname, tls_port) = (hostname, port)
+            (hostname, port) = (unused_hostname, unused_port)
+        else:
+            # Unreal refuses to start without TLS enabled
+            (tls_hostname, tls_port) = (unused_hostname, unused_port)
+
+        with self.open_file("empty.txt") as fd:
+            fd.write("\n")
+
+        assert self.directory
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    tls_hostname=tls_hostname,
+                    tls_port=tls_port,
+                    password_field=password_field,
+                    key_path=self.key_path,
+                    pem_path=self.pem_path,
+                    empty_file=os.path.join(self.directory, "empty.txt"),
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                "ngircd",
+                "--nodaemon",
+                "--config",
+                os.path.join(self.directory, "server.conf"),
+            ],
+            # stdout=subprocess.DEVNULL,
+        )
+
+        if run_services:
+            self.wait_for_port()
+            self.services_controller = self.services_controller_class(
+                self.test_config, self
+            )
+            self.services_controller.run(
+                protocol="ngircd",
+                server_hostname=hostname,
+                server_port=port,
+            )
+
+
+def get_irctest_controller_class() -> Type[NgircdController]:
+    return NgircdController

irctest/controllers/oragono.py

@@ -1,144 +0,0 @@
-import os
-import subprocess
-
-from irctest.basecontrollers import NotImplementedByController
-from irctest.basecontrollers import BaseServerController, DirectoryBasedController
-
-TEMPLATE_CONFIG = """
-network:
-    name: OragonoTest
-
-server:
-    name: oragono.test
-    listen:
-        - "{hostname}:{port}"
-    {tls}
-
-    check-ident: false
-
-    max-sendq: 16k
-
-    connection-limits:
-        cidr-len-ipv4: 24
-        cidr-len-ipv6: 120
-        ips-per-subnet: 16
-
-        exempted:
-            - "127.0.0.1/8"
-            - "::1/128"
-
-    connection-throttling:
-        enabled: true
-        cidr-len-ipv4: 32
-        cidr-len-ipv6: 128
-        duration: 10m
-        max-connections: 12
-        ban-duration: 10m
-        ban-message: You have attempted to connect too many times within a short duration. Wait a while, and you will be able to connect.
-
-        exempted:
-            - "127.0.0.1/8"
-            - "::1/128"
-
-accounts:
-    registration:
-        enabled: true
-        verify-timeout: "120h"
-        enabled-callbacks:
-            - none # no verification needed, will instantly register successfully
-        allow-multiple-per-connection: true
-
-    authentication-enabled: true
-
-channels:
-    registration:
-        enabled: true
-
-datastore:
-    path: {directory}/ircd.db
-
-limits:
-    nicklen: 32
-    channellen: 64
-    awaylen: 200
-    kicklen: 390
-    topiclen: 390
-    monitor-entries: 100
-    whowas-entries: 100
-    chan-list-modes: 60
-    linelen:
-        tags: 2048
-        rest: 2048
-"""
-
-class OragonoController(BaseServerController, DirectoryBasedController):
-    software_name = 'Oragono'
-    supported_sasl_mechanisms = {
-            'PLAIN',
-    }
-    supported_capabilities = set()  # Not exhaustive
-
-    def create_config(self):
-        super().create_config()
-        with self.open_file('ircd.yaml'):
-            pass
-
-    def kill_proc(self):
-        self.proc.kill()
-
-    def run(self, hostname, port, password=None, ssl=False,
-            restricted_metadata_keys=None,
-            valid_metadata_keys=None, invalid_metadata_keys=None):
-        if valid_metadata_keys or invalid_metadata_keys:
-            raise NotImplementedByController(
-                    'Defining valid and invalid METADATA keys.')
-        if password is not None:
-            #TODO(dan): fix dis
-            raise NotImplementedByController('PASS command')
-        self.create_config()
-        tls_config = ""
-        if ssl:
-            self.key_path = os.path.join(self.directory, 'ssl.key')
-            self.pem_path = os.path.join(self.directory, 'ssl.pem')
-            tls_config = 'tls-listeners:\n        ":{port}":\n            key: {key}\n            cert: {pem}'.format(
-                port=port,
-                key=self.key_path,
-                pem=self.pem_path,
-            )
-        assert self.proc is None
-        self.port = port
-        with self.open_file('server.yml') as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                directory=self.directory,
-                hostname=hostname,
-                port=port,
-                tls=tls_config,
-                ))
-        subprocess.call(['oragono', 'initdb',
-            '--conf', os.path.join(self.directory, 'server.yml'), '--quiet'])
-        subprocess.call(['oragono', 'mkcerts',
-            '--conf', os.path.join(self.directory, 'server.yml'), '--quiet'])
-        self.proc = subprocess.Popen(['oragono', 'run',
-            '--conf', os.path.join(self.directory, 'server.yml'), '--quiet'])
-
-    def registerUser(self, case, username, password=None):
-        # XXX: Move this somewhere else when
-        # https://github.com/ircv3/ircv3-specifications/pull/152 becomes
-        # part of the specification
-        client = case.addClient(show_io=False)
-        case.sendLine(client, 'CAP LS 302')
-        case.sendLine(client, 'NICK registration_user')
-        case.sendLine(client, 'USER r e g :user')
-        case.sendLine(client, 'CAP END')
-        while case.getRegistrationMessage(client).command != '001':
-            pass
-        case.getMessages(client)
-        case.sendLine(client, 'ACC REGISTER {} * {}'.format(
-            username, password))
-        msg = case.getMessage(client)
-        assert msg.command == '920', msg
-        case.sendLine(client, 'QUIT')
-        case.assertDisconnected(client)
-
-def get_irctest_controller_class():
-    return OragonoController

irctest/controllers/plexus4.py

@@ -0,0 +1,87 @@
+from typing import Set, Type
+
+from .base_hybrid import BaseHybridController
+
+TEMPLATE_CONFIG = """
+serverinfo {{
+    name = "My.Little.Server";
+    sid = "42X";
+    description = "test server";
+
+    # Hybrid defaults to 9
+    max_nick_length = 20;
+{ssl_config}
+}};
+
+general {{
+    throttle_count = 100;  # We need to connect lots of clients quickly
+    sasl_service = "SaslServ";
+
+    # Allow connections quickly
+    throttle_num = 100;
+
+    # Allow PART/QUIT reasons quickly
+    anti_spam_exit_message_time = 0;
+
+    # Allow all commands quickly
+    pace_wait_simple = 0;
+    pace_wait = 0;
+}};
+
+listen {{
+    defer_accept = yes;
+
+    host = "{hostname}";
+    port = {port};
+
+    flags = server;
+    port = {services_port};
+}};
+
+class {{
+    name = "server";
+    ping_time = 5 minutes;
+    connectfreq = 5 minutes;
+}};
+connect {{
+    name = "services.example.org";
+    host = "localhost";  # Used to validate incoming connection
+    port = 0;  # We don't need servers to connect to services
+    send_password = "password";
+    accept_password = "password";
+    class = "server";
+}};
+service {{
+    name = "services.example.org";
+}};
+
+auth {{
+    user = "*";
+    flags = exceed_limit;
+    {password_field}
+}};
+
+operator {{
+    name = "operuser";
+    user = "*@*";
+    password = "operpassword";
+    encrypted = no;
+    umodes = locops, servnotice, wallop;
+    flags = admin, connect, connect:remote, die, globops, kill, kill:remote,
+            kline, module, rehash, restart, set, unkline, unxline, wallops, xline;
+}};
+"""
+
+
+class Plexus4Controller(BaseHybridController):
+    software_name = "Hybrid"
+    binary_name = "ircd"
+    services_protocol = "plexus"
+
+    supported_sasl_mechanisms: Set[str] = set()
+
+    template_config = TEMPLATE_CONFIG
+
+
+def get_irctest_controller_class() -> Type[Plexus4Controller]:
+    return Plexus4Controller

irctest/controllers/snircd.py

@@ -0,0 +1,111 @@
+import os
+import subprocess
+from typing import Optional, Set, Type
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+
+TEMPLATE_CONFIG = """
+General {{
+    name = "My.Little.Server";
+    numeric = 42;
+    description = "test server";
+}};
+
+Port {{
+    vhost = "{hostname}";
+    port = {port};
+}};
+
+Class {{
+    name = "Client";
+    pingfreq = 5 minutes;
+    sendq = 160000;
+    maxlinks = 1024;
+}};
+
+Client {{
+    username = "*";
+    class = "Client";
+    {password_field}
+}};
+
+Operator {{
+    local = no;
+    host = "*@*";
+    password = "$PLAIN$operpassword";
+    name = "operuser";
+    class = "Client";
+}};
+
+features {{
+    "PPATH" = "{pidfile}";
+
+    # don't block notices by default, wtf
+    "AUTOCHANMODES_LIST" = "+tnC";
+}};
+"""
+
+
+class SnircdController(BaseServerController, DirectoryBasedController):
+    supports_sts = False
+    extban_mute_char = None
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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:
+            raise NotImplementedByController("Services")
+        assert self.proc is None
+        self.port = port
+        self.hostname = hostname
+        self.create_config()
+        password_field = 'password = "{}";'.format(password) if password else ""
+        assert self.directory
+        pidfile = os.path.join(self.directory, "ircd.pid")
+        with self.open_file("server.conf") as fd:
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    password_field=password_field,
+                    pidfile=pidfile,
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                "ircd",
+                "-n",  # don't detach
+                "-f",
+                os.path.join(self.directory, "server.conf"),
+                "-x",
+                "DEBUG",
+            ],
+            # stderr=subprocess.DEVNULL,
+        )
+
+
+def get_irctest_controller_class() -> Type[SnircdController]:
+    return SnircdController

irctest/controllers/solanum.py

@@ -0,0 +1,12 @@
+from typing import Type
+
+from .charybdis import CharybdisController
+
+
+class SolanumController(CharybdisController):
+    software_name = "Solanum"
+    binary_name = "solanum"
+
+
+def get_irctest_controller_class() -> Type[SolanumController]:
+    return SolanumController

irctest/controllers/sopel.py

@@ -1,9 +1,14 @@
 import os
-import tempfile
 import subprocess
+import tempfile
+from typing import Optional, TextIO, Type, cast
 
-from irctest.basecontrollers import BaseClientController
-from irctest.basecontrollers import NotImplementedByController
+from irctest import authentication, tls
+from irctest.basecontrollers import (
+    BaseClientController,
+    NotImplementedByController,
+    TestCaseControllerConfig,
+)
 
 TEMPLATE_CONFIG = """
 [core]
@@ -12,59 +17,64 @@ host = {hostname}
 use_ssl = false
 port = {port}
 owner = me
-channels = 
+channels =
 timeout = 5
 auth_username = {username}
 auth_password = {password}
 {auth_method}
 """
 
-class SopelController(BaseClientController):
-    software_name = 'Sopel'
-    supported_sasl_mechanisms = {
-            'PLAIN',
-            }
-    supported_capabilities = set()  # Not exhaustive
 
-    def __init__(self):
-        super().__init__()
-        self.filename = next(tempfile._get_candidate_names()) + '.cfg'
-        self.proc = None
-    def kill(self):
-        if self.proc:
-            self.proc.kill()
+class SopelController(BaseClientController):
+    software_name = "Sopel"
+    supported_sasl_mechanisms = {"PLAIN"}
+    supports_sts = False
+
+    def __init__(self, test_config: TestCaseControllerConfig):
+        super().__init__(test_config)
+        self.filename = next(tempfile._get_candidate_names()) + ".cfg"  # type: ignore
+
+    def kill(self) -> None:
+        super().kill()
         if self.filename:
             try:
-                os.unlink(os.path.join(os.path.expanduser('~/.sopel/'),
-                    self.filename))
-            except OSError: # File does not exist
+                os.unlink(os.path.join(os.path.expanduser("~/.sopel/"), self.filename))
+            except OSError:  #  File does not exist
                 pass
 
-    def open_file(self, filename, mode='a'):
-        return open(os.path.join(os.path.expanduser('~/.sopel/'), filename),
-                mode)
+    def open_file(self, filename: str, mode: str = "a") -> TextIO:
+        dir_path = os.path.expanduser("~/.sopel/")
+        os.makedirs(dir_path, exist_ok=True)
+        return cast(TextIO, open(os.path.join(dir_path, filename), mode))
 
-    def create_config(self):
-        with self.open_file(self.filename) as fd:
+    def create_config(self) -> None:
+        with self.open_file(self.filename):
             pass
 
-    def run(self, hostname, port, auth, tls_config):
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        auth: Optional[authentication.Authentication],
+        tls_config: Optional[tls.TlsConfig] = None,
+    ) -> None:
         # Runs a client with the config given as arguments
         if tls_config is not None:
-            raise NotImplementedByController(
-                    'TLS configuration')
+            raise NotImplementedByController("TLS configuration")
         assert self.proc is None
         self.create_config()
         with self.open_file(self.filename) as fd:
-            fd.write(TEMPLATE_CONFIG.format(
-                hostname=hostname,
-                port=port,
-                username=auth.username if auth else '',
-                password=auth.password if auth else '',
-                auth_method='auth_method = sasl' if auth else '',
-                ))
-        self.proc = subprocess.Popen(['sopel', '--quiet', '-c', self.filename])
+            fd.write(
+                TEMPLATE_CONFIG.format(
+                    hostname=hostname,
+                    port=port,
+                    username=auth.username if auth else "",
+                    password=auth.password if auth else "",
+                    auth_method="auth_method = sasl" if auth else "",
+                )
+            )
+        self.proc = subprocess.Popen(["sopel", "--quiet", "-c", self.filename])
 
-def get_irctest_controller_class():
+
+def get_irctest_controller_class() -> Type[SopelController]:
     return SopelController
-

irctest/controllers/unrealircd.py

@@ -0,0 +1,201 @@
+import os
+import subprocess
+from typing import Optional, Set, Type
+
+from irctest.basecontrollers import (
+    BaseServerController,
+    DirectoryBasedController,
+    NotImplementedByController,
+)
+from irctest.irc_utils.junkdrawer import find_hostname_and_port
+
+TEMPLATE_CONFIG = """
+include "modules.default.conf";
+include "operclass.default.conf";
+
+me {{
+    name "My.Little.Server";
+    info "ExampleNET Server";
+    sid "001";
+}}
+admin {{
+    "Bob Smith";
+    "bob";
+    "email@example.org";
+}}
+class clients {{
+    pingfreq 90;
+    maxclients 1000;
+    sendq 200k;
+    recvq 8000;
+}}
+class servers {{
+    pingfreq 60;
+    connfreq 15; /* try to connect every 15 seconds */
+    maxclients 10; /* max servers */
+    sendq 20M;
+}}
+allow {{
+    mask *;
+    class clients;
+    maxperip 50;
+        {password_field}
+}}
+listen {{
+    ip {hostname};
+    port {port};
+}}
+listen {{
+    ip {tls_hostname};
+    port {tls_port};
+    options {{ tls; }}
+        tls-options {{
+            certificate "{pem_path}";
+            key "{key_path}";
+        }};
+}}
+
+/* Special SSL/TLS servers-only port for linking */
+listen {{
+    ip {services_hostname};
+    port {services_port};
+    options {{ serversonly; }}
+}}
+
+link services.example.org {{
+    incoming {{
+        mask *;
+    }}
+    password "password";
+    class servers;
+}}
+ulines {{
+    services.example.org;
+}}
+
+set {{
+    sasl-server services.example.org;
+    kline-address "example@example.org";
+    network-name "ExampleNET";
+    default-server "irc.example.org";
+    help-channel "#Help";
+    cloak-keys {{ "aaaA1"; "bbbB2"; "cccC3"; }}
+    options {{
+        identd-check;  // Disable it, so it doesn't prefix idents with a tilde
+    }}
+    anti-flood {{
+        // Prevent throttling, especially test_buffering.py which
+        // triggers anti-flood with its very long lines
+        unknown-users {{
+            lag-penalty 1;
+            lag-penalty-bytes 10000;
+        }}
+    }}
+    modes-on-join "+H 100:1d";  // Enables CHATHISTORY
+}}
+
+tld {{
+    mask *;
+    motd "{empty_file}";
+    botmotd "{empty_file}";
+    rules "{empty_file}";
+}}
+
+oper "operuser" {{
+    password = "operpassword";
+    mask *;
+    class clients;
+    operclass netadmin;
+}}
+"""
+
+
+class UnrealircdController(BaseServerController, DirectoryBasedController):
+    software_name = "UnrealIRCd"
+    supported_sasl_mechanisms = {"PLAIN"}
+    supports_sts = False
+
+    extban_mute_char = "q"
+
+    def create_config(self) -> None:
+        super().create_config()
+        with self.open_file("server.conf"):
+            pass
+
+    def run(
+        self,
+        hostname: str,
+        port: int,
+        *,
+        password: Optional[str],
+        ssl: bool,
+        run_services: bool,
+        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()
+        (services_hostname, services_port) = find_hostname_and_port()
+
+        password_field = 'password "{}";'.format(password) if password else ""
+
+        self.gen_ssl()
+        if ssl:
+            (tls_hostname, tls_port) = (hostname, port)
+            (hostname, port) = (unused_hostname, unused_port)
+        else:
+            # Unreal refuses to start without TLS enabled
+            (tls_hostname, tls_port) = (unused_hostname, unused_port)
+
+        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(
+                    hostname=hostname,
+                    port=port,
+                    services_hostname=services_hostname,
+                    services_port=services_port,
+                    tls_hostname=tls_hostname,
+                    tls_port=tls_port,
+                    password_field=password_field,
+                    key_path=self.key_path,
+                    pem_path=self.pem_path,
+                    empty_file=os.path.join(self.directory, "empty.txt"),
+                )
+            )
+        self.proc = subprocess.Popen(
+            [
+                "unrealircd",
+                "-t",
+                "-F",  # BOOT_NOFORK
+                "-f",
+                os.path.join(self.directory, "unrealircd.conf"),
+            ],
+            # stdout=subprocess.DEVNULL,
+        )
+
+        if run_services:
+            self.wait_for_port()
+            self.services_controller = self.services_controller_class(
+                self.test_config, self
+            )
+            self.services_controller.run(
+                protocol="unreal4",
+                server_hostname=services_hostname,
+                server_port=services_port,
+            )
+
+
+def get_irctest_controller_class() -> Type[UnrealircdController]:
+    return UnrealircdController

irctest/exceptions.py

@@ -1,6 +1,6 @@
 class NoMessageException(AssertionError):
     pass
 
+
 class ConnectionClosed(Exception):
     pass
-

irctest/irc_utils/ambiguities.py

@@ -2,7 +2,10 @@
 Handles ambiguities of RFCs.
 """
 
-def normalize_namreply_params(params):
+from typing import List
+
+
+def normalize_namreply_params(params: List[str]) -> List[str]:
     # So… RFC 2812 says:
     #       "( "=" / "*" / "@" ) <channel>
     #       :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )
@@ -11,9 +14,10 @@ def normalize_namreply_params(params):
     # 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]
+        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/capabilities.py

@@ -1,10 +1,12 @@
-def cap_list_to_dict(l):
-    d = {}
-    for cap in l:
-        if '=' in cap:
-            (key, value) = cap.split('=', 1)
+from typing import Dict, List, Optional
+
+
+def cap_list_to_dict(caps: List[str]) -> Dict[str, Optional[str]]:
+    d: Dict[str, Optional[str]] = {}
+    for cap in caps:
+        if "=" in cap:
+            (key, value) = cap.split("=", 1)
+            d[key] = value
         else:
-            key = cap
-            value = None
-        d[key] = value
+            d[cap] = None
     return d

irctest/irc_utils/junkdrawer.py

@@ -0,0 +1,46 @@
+import datetime
+import re
+import secrets
+import socket
+from typing import Dict, Tuple
+
+# thanks jess!
+IRCV3_FORMAT_STRFTIME = "%Y-%m-%dT%H:%M:%S.%f%z"
+
+
+def ircv3_timestamp_to_unixtime(timestamp: str) -> float:
+    return datetime.datetime.strptime(timestamp, IRCV3_FORMAT_STRFTIME).timestamp()
+
+
+def random_name(base: str) -> str:
+    return base + "-" + secrets.token_hex(8)
+
+
+def find_hostname_and_port() -> Tuple[str, int]:
+    """Find available hostname/port to listen on."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(("", 0))
+    (hostname, port) = s.getsockname()
+    s.close()
+    return (hostname, port)
+
+
+"""
+Stolen from supybot:
+"""
+
+
+class MultipleReplacer:
+    """Return a callable that replaces all dict keys by the associated
+    value. More efficient than multiple .replace()."""
+
+    # We use an object instead of a lambda function because it avoids the
+    # need for using the staticmethod() on the lambda function if assigning
+    # it to a class in Python 3.
+    def __init__(self, dict_: Dict[str, str]):
+        self._dict = dict_
+        dict_ = dict([(re.escape(key), val) for key, val in dict_.items()])
+        self._matcher = re.compile("|".join(dict_.keys()))
+
+    def __call__(self, s: str) -> str:
+        return self._matcher.sub(lambda m: self._dict[m.group(0)], s)

irctest/irc_utils/message_parser.py

@@ -1,62 +1,76 @@
+import dataclasses
 import re
-import collections
-import supybot.utils
+from typing import Any, Dict, List, Optional
+
+from .junkdrawer import MultipleReplacer
 
 # http://ircv3.net/specs/core/message-tags-3.2.html#escaping-values
 TAG_ESCAPE = [
-    ('\\', '\\\\'), # \ -> \\
-    (' ', r'\s'),
-    (';', r'\:'),
-    ('\r', r'\r'),
-    ('\n', r'\n'),
-    ]
-unescape_tag_value = supybot.utils.str.MultipleReplacer(
-        dict(map(lambda x:(x[1],x[0]), TAG_ESCAPE)))
+    ("\\", "\\\\"),  # \ -> \\
+    (" ", r"\s"),
+    (";", r"\:"),
+    ("\r", r"\r"),
+    ("\n", r"\n"),
+]
+unescape_tag_value = MultipleReplacer(dict(map(lambda x: (x[1], x[0]), TAG_ESCAPE)))
 
 # TODO: validate host
-tag_key_validator = re.compile('(\S+/)?[a-zA-Z0-9-]+')
+tag_key_validator = re.compile(r"\+?(\S+/)?[a-zA-Z0-9-]+")
 
-def parse_tags(s):
-    tags = {}
-    for tag in s.split(';'):
-        if '=' not in tag:
+
+def parse_tags(s: str) -> Dict[str, Optional[str]]:
+    tags: Dict[str, Optional[str]] = {}
+    for tag in s.split(";"):
+        if "=" not in tag:
             tags[tag] = None
         else:
-            (key, value) = tag.split('=', 1)
-            assert tag_key_validator.match(key), \
-                    'Invalid tag key: {}'.format(key)
+            (key, value) = tag.split("=", 1)
+            assert tag_key_validator.match(key), "Invalid tag key: {}".format(key)
             tags[key] = unescape_tag_value(value)
     return tags
 
-Message = collections.namedtuple('Message',
-        'tags prefix command params')
 
-def parse_message(s):
+@dataclasses.dataclass(frozen=True)
+class HistoryMessage:
+    time: Any
+    msgid: Optional[str]
+    target: str
+    text: str
+
+
+@dataclasses.dataclass(frozen=True)
+class Message:
+    tags: Dict[str, Optional[str]]
+    prefix: Optional[str]
+    command: str
+    params: List[str]
+
+    def to_history_message(self) -> HistoryMessage:
+        return HistoryMessage(
+            time=self.tags.get("time"),
+            msgid=self.tags.get("msgid"),
+            target=self.params[0],
+            text=self.params[1],
+        )
+
+
+def parse_message(s: str) -> Message:
     """Parse a message according to
     http://tools.ietf.org/html/rfc1459#section-2.3.1
     and
     http://ircv3.net/specs/core/message-tags-3.2.html"""
-    assert s.endswith('\r\n'), 'Message does not end with CR LF: {!r}'.format(s)
-    s = s[0:-2]
-    if s.startswith('@'):
-        (tags, s) = s.split(' ', 1)
-        tags = parse_tags(tags[1:])
+    s = s.rstrip("\r\n")
+    if s.startswith("@"):
+        (tags_str, s) = s.split(" ", 1)
+        tags = parse_tags(tags_str[1:])
     else:
         tags = {}
-    if ' :' in s:
-        (other_tokens, trailing_param) = s.split(' :', 1)
-        tokens = list(filter(bool, other_tokens.split(' '))) + [trailing_param]
+    if " :" in s:
+        (other_tokens, trailing_param) = s.split(" :", 1)
+        tokens = list(filter(bool, other_tokens.split(" "))) + [trailing_param]
     else:
-        tokens = list(filter(bool, s.split(' ')))
-    if tokens[0].startswith(':'):
-        prefix = tokens.pop(0)[1:]
-    else:
-        prefix = None
+        tokens = list(filter(bool, s.split(" ")))
+    prefix = prefix = tokens.pop(0)[1:] if tokens[0].startswith(":") else None
     command = tokens.pop(0)
     params = tokens
-    return Message(
-            tags=tags,
-            prefix=prefix,
-            command=command,
-            params=params,
-            )
+    return Message(tags=tags, prefix=prefix, command=command, params=params)

irctest/irc_utils/sasl.py

@@ -0,0 +1,15 @@
+import base64
+
+
+def sasl_plain_blob(username: str, passphrase: str) -> str:
+    blob = base64.b64encode(
+        b"\x00".join(
+            (
+                username.encode("utf-8"),
+                username.encode("utf-8"),
+                passphrase.encode("utf-8"),
+            )
+        )
+    )
+    blobstr = blob.decode("ascii")
+    return f"AUTHENTICATE {blobstr}"

irctest/numerics.py

@@ -9,185 +9,197 @@
 # They're intended to represent a relatively-standard cross-section of the IRC
 # server ecosystem out there. Custom numerics will be marked as such.
 
-RPL_WELCOME                     = "001"
-RPL_YOURHOST                    = "002"
-RPL_CREATED                     = "003"
-RPL_MYINFO                      = "004"
-RPL_ISUPPORT                    = "005"
-RPL_SNOMASKIS                   = "008"
-RPL_BOUNCE                      = "010"
-RPL_TRACELINK                   = "200"
-RPL_TRACECONNECTING             = "201"
-RPL_TRACEHANDSHAKE              = "202"
-RPL_TRACEUNKNOWN                = "203"
-RPL_TRACEOPERATOR               = "204"
-RPL_TRACEUSER                   = "205"
-RPL_TRACESERVER                 = "206"
-RPL_TRACESERVICE                = "207"
-RPL_TRACENEWTYPE                = "208"
-RPL_TRACECLASS                  = "209"
-RPL_TRACERECONNECT              = "210"
-RPL_STATSLINKINFO               = "211"
-RPL_STATSCOMMANDS               = "212"
-RPL_ENDOFSTATS                  = "219"
-RPL_UMODEIS                     = "221"
-RPL_SERVLIST                    = "234"
-RPL_SERVLISTEND                 = "235"
-RPL_STATSUPTIME                 = "242"
-RPL_STATSOLINE                  = "243"
-RPL_LUSERCLIENT                 = "251"
-RPL_LUSEROP                     = "252"
-RPL_LUSERUNKNOWN                = "253"
-RPL_LUSERCHANNELS               = "254"
-RPL_LUSERME                     = "255"
-RPL_ADMINME                     = "256"
-RPL_ADMINLOC1                   = "257"
-RPL_ADMINLOC2                   = "258"
-RPL_ADMINEMAIL                  = "259"
-RPL_TRACELOG                    = "261"
-RPL_TRACEEND                    = "262"
-RPL_TRYAGAIN                    = "263"
-RPL_WHOISCERTFP                 = "276"
-RPL_AWAY                        = "301"
-RPL_USERHOST                    = "302"
-RPL_ISON                        = "303"
-RPL_UNAWAY                      = "305"
-RPL_NOWAWAY                     = "306"
-RPL_WHOISUSER                   = "311"
-RPL_WHOISSERVER                 = "312"
-RPL_WHOISOPERATOR               = "313"
-RPL_WHOWASUSER                  = "314"
-RPL_ENDOFWHO                    = "315"
-RPL_WHOISIDLE                   = "317"
-RPL_ENDOFWHOIS                  = "318"
-RPL_WHOISCHANNELS               = "319"
-RPL_LIST                        = "322"
-RPL_LISTEND                     = "323"
-RPL_CHANNELMODEIS               = "324"
-RPL_UNIQOPIS                    = "325"
-RPL_CHANNELCREATED              = "329"
-RPL_WHOISACCOUNT                = "330"
-RPL_NOTOPIC                     = "331"
-RPL_TOPIC                       = "332"
-RPL_TOPICTIME                   = "333"
-RPL_WHOISBOT                    = "335"
-RPL_WHOISACTUALLY               = "338"
-RPL_INVITING                    = "341"
-RPL_SUMMONING                   = "342"
-RPL_INVITELIST                  = "346"
-RPL_ENDOFINVITELIST             = "347"
-RPL_EXCEPTLIST                  = "348"
-RPL_ENDOFEXCEPTLIST             = "349"
-RPL_VERSION                     = "351"
-RPL_WHOREPLY                    = "352"
-RPL_NAMREPLY                    = "353"
-RPL_LINKS                       = "364"
-RPL_ENDOFLINKS                  = "365"
-RPL_ENDOFNAMES                  = "366"
-RPL_BANLIST                     = "367"
-RPL_ENDOFBANLIST                = "368"
-RPL_ENDOFWHOWAS                 = "369"
-RPL_INFO                        = "371"
-RPL_MOTD                        = "372"
-RPL_ENDOFINFO                   = "374"
-RPL_MOTDSTART                   = "375"
-RPL_ENDOFMOTD                   = "376"
-RPL_YOUREOPER                   = "381"
-RPL_REHASHING                   = "382"
-RPL_YOURESERVICE                = "383"
-RPL_TIME                        = "391"
-RPL_USERSSTART                  = "392"
-RPL_USERS                       = "393"
-RPL_ENDOFUSERS                  = "394"
-RPL_NOUSERS                     = "395"
-ERR_UNKNOWNERROR                = "400"
-ERR_NOSUCHNICK                  = "401"
-ERR_NOSUCHSERVER                = "402"
-ERR_NOSUCHCHANNEL               = "403"
-ERR_CANNOTSENDTOCHAN            = "404"
-ERR_TOOMANYCHANNELS             = "405"
-ERR_WASNOSUCHNICK               = "406"
-ERR_TOOMANYTARGETS              = "407"
-ERR_NOSUCHSERVICE               = "408"
-ERR_NOORIGIN                    = "409"
-ERR_INVALIDCAPCMD               = "410"
-ERR_NORECIPIENT                 = "411"
-ERR_NOTEXTTOSEND                = "412"
-ERR_NOTOPLEVEL                  = "413"
-ERR_WILDTOPLEVEL                = "414"
-ERR_BADMASK                     = "415"
-ERR_UNKNOWNCOMMAND              = "421"
-ERR_NOMOTD                      = "422"
-ERR_NOADMININFO                 = "423"
-ERR_FILEERROR                   = "424"
-ERR_NONICKNAMEGIVEN             = "431"
-ERR_ERRONEUSNICKNAME            = "432"
-ERR_NICKNAMEINUSE               = "433"
-ERR_NICKCOLLISION               = "436"
-ERR_UNAVAILRESOURCE             = "437"
-ERR_REG_UNAVAILABLE             = "440"
-ERR_USERNOTINCHANNEL            = "441"
-ERR_NOTONCHANNEL                = "442"
-ERR_USERONCHANNEL               = "443"
-ERR_NOLOGIN                     = "444"
-ERR_SUMMONDISABLED              = "445"
-ERR_USERSDISABLED               = "446"
-ERR_NOTREGISTERED               = "451"
-ERR_NEEDMOREPARAMS              = "461"
-ERR_ALREADYREGISTRED            = "462"
-ERR_NOPERMFORHOST               = "463"
-ERR_PASSWDMISMATCH              = "464"
-ERR_YOUREBANNEDCREEP            = "465"
-ERR_YOUWILLBEBANNED             = "466"
-ERR_KEYSET                      = "467"
-ERR_INVALIDUSERNAME             = "468"
-ERR_CHANNELISFULL               = "471"
-ERR_UNKNOWNMODE                 = "472"
-ERR_INVITEONLYCHAN              = "473"
-ERR_BANNEDFROMCHAN              = "474"
-ERR_BADCHANNELKEY               = "475"
-ERR_BADCHANMASK                 = "476"
-ERR_NOCHANMODES                 = "477"
-ERR_BANLISTFULL                 = "478"
-ERR_NOPRIVILEGES                = "481"
-ERR_CHANOPRIVSNEEDED            = "482"
-ERR_CANTKILLSERVER              = "483"
-ERR_RESTRICTED                  = "484"
-ERR_UNIQOPPRIVSNEEDED           = "485"
-ERR_NOOPERHOST                  = "491"
-ERR_UMODEUNKNOWNFLAG            = "501"
-ERR_USERSDONTMATCH              = "502"
-ERR_HELPNOTFOUND                = "524"
-ERR_CANNOTSENDRP                = "573"
-RPL_WHOISSECURE                 = "671"
-RPL_YOURLANGUAGESARE            = "687"
-RPL_WHOISLANGUAGE               = "690"
-RPL_HELPSTART                   = "704"
-RPL_HELPTXT                     = "705"
-RPL_ENDOFHELP                   = "706"
-ERR_NOPRIVS                     = "723"
-RPL_MONONLINE                   = "730"
-RPL_MONOFFLINE                  = "731"
-RPL_MONLIST                     = "732"
-RPL_ENDOFMONLIST                = "733"
-ERR_MONLISTFULL                 = "734"
-RPL_LOGGEDIN                    = "900"
-RPL_LOGGEDOUT                   = "901"
-ERR_NICKLOCKED                  = "902"
-RPL_SASLSUCCESS                 = "903"
-ERR_SASLFAIL                    = "904"
-ERR_SASLTOOLONG                 = "905"
-ERR_SASLABORTED                 = "906"
-ERR_SASLALREADY                 = "907"
-RPL_SASLMECHS                   = "908"
-RPL_REGISTRATION_SUCCESS        = "920"
-ERR_ACCOUNT_ALREADY_EXISTS      = "921"
-ERR_REG_UNSPECIFIED_ERROR       = "922"
-RPL_VERIFYSUCCESS               = "923"
-ERR_ACCOUNT_ALREADY_VERIFIED    = "924"
+RPL_WELCOME = "001"
+RPL_YOURHOST = "002"
+RPL_CREATED = "003"
+RPL_MYINFO = "004"
+RPL_ISUPPORT = "005"
+RPL_SNOMASKIS = "008"
+RPL_BOUNCE = "010"
+RPL_HELLO = "020"
+RPL_TRACELINK = "200"
+RPL_TRACECONNECTING = "201"
+RPL_TRACEHANDSHAKE = "202"
+RPL_TRACEUNKNOWN = "203"
+RPL_TRACEOPERATOR = "204"
+RPL_TRACEUSER = "205"
+RPL_TRACESERVER = "206"
+RPL_TRACESERVICE = "207"
+RPL_TRACENEWTYPE = "208"
+RPL_TRACECLASS = "209"
+RPL_TRACERECONNECT = "210"
+RPL_STATSLINKINFO = "211"
+RPL_STATSCOMMANDS = "212"
+RPL_ENDOFSTATS = "219"
+RPL_UMODEIS = "221"
+RPL_SERVLIST = "234"
+RPL_SERVLISTEND = "235"
+RPL_STATSUPTIME = "242"
+RPL_STATSOLINE = "243"
+RPL_LUSERCLIENT = "251"
+RPL_LUSEROP = "252"
+RPL_LUSERUNKNOWN = "253"
+RPL_LUSERCHANNELS = "254"
+RPL_LUSERME = "255"
+RPL_ADMINME = "256"
+RPL_ADMINLOC1 = "257"
+RPL_ADMINLOC2 = "258"
+RPL_ADMINEMAIL = "259"
+RPL_TRACELOG = "261"
+RPL_TRACEEND = "262"
+RPL_TRYAGAIN = "263"
+RPL_LOCALUSERS = "265"
+RPL_GLOBALUSERS = "266"
+RPL_WHOISCERTFP = "276"
+RPL_AWAY = "301"
+RPL_USERHOST = "302"
+RPL_ISON = "303"
+RPL_UNAWAY = "305"
+RPL_NOWAWAY = "306"
+RPL_WHOISREGNICK = "307"
+RPL_WHOISUSER = "311"
+RPL_WHOISSERVER = "312"
+RPL_WHOISOPERATOR = "313"
+RPL_WHOWASUSER = "314"
+RPL_ENDOFWHO = "315"
+RPL_WHOISIDLE = "317"
+RPL_ENDOFWHOIS = "318"
+RPL_WHOISCHANNELS = "319"
+RPL_WHOISSPECIAL = "320"
+RPL_LIST = "322"
+RPL_LISTEND = "323"
+RPL_CHANNELMODEIS = "324"
+RPL_UNIQOPIS = "325"
+RPL_CHANNELCREATED = "329"
+RPL_WHOISACCOUNT = "330"
+RPL_NOTOPIC = "331"
+RPL_TOPIC = "332"
+RPL_TOPICTIME = "333"
+RPL_WHOISBOT = "335"
+RPL_WHOISACTUALLY = "338"
+RPL_INVITING = "341"
+RPL_SUMMONING = "342"
+RPL_INVITELIST = "346"
+RPL_ENDOFINVITELIST = "347"
+RPL_EXCEPTLIST = "348"
+RPL_ENDOFEXCEPTLIST = "349"
+RPL_VERSION = "351"
+RPL_WHOREPLY = "352"
+RPL_NAMREPLY = "353"
+RPL_LINKS = "364"
+RPL_ENDOFLINKS = "365"
+RPL_ENDOFNAMES = "366"
+RPL_BANLIST = "367"
+RPL_ENDOFBANLIST = "368"
+RPL_ENDOFWHOWAS = "369"
+RPL_INFO = "371"
+RPL_MOTD = "372"
+RPL_ENDOFINFO = "374"
+RPL_MOTDSTART = "375"
+RPL_ENDOFMOTD = "376"
+RPL_WHOISHOST = "378"
+RPL_WHOISMODES = "379"
+RPL_YOUREOPER = "381"
+RPL_REHASHING = "382"
+RPL_YOURESERVICE = "383"
+RPL_TIME = "391"
+RPL_USERSSTART = "392"
+RPL_USERS = "393"
+RPL_ENDOFUSERS = "394"
+RPL_NOUSERS = "395"
+ERR_UNKNOWNERROR = "400"
+ERR_NOSUCHNICK = "401"
+ERR_NOSUCHSERVER = "402"
+ERR_NOSUCHCHANNEL = "403"
+ERR_CANNOTSENDTOCHAN = "404"
+ERR_TOOMANYCHANNELS = "405"
+ERR_WASNOSUCHNICK = "406"
+ERR_TOOMANYTARGETS = "407"
+ERR_NOSUCHSERVICE = "408"
+ERR_NOORIGIN = "409"
+ERR_INVALIDCAPCMD = "410"
+ERR_NORECIPIENT = "411"
+ERR_NOTEXTTOSEND = "412"
+ERR_NOTOPLEVEL = "413"
+ERR_WILDTOPLEVEL = "414"
+ERR_BADMASK = "415"
+ERR_INPUTTOOLONG = "417"
+ERR_UNKNOWNCOMMAND = "421"
+ERR_NOMOTD = "422"
+ERR_NOADMININFO = "423"
+ERR_FILEERROR = "424"
+ERR_NONICKNAMEGIVEN = "431"
+ERR_ERRONEUSNICKNAME = "432"
+ERR_NICKNAMEINUSE = "433"
+ERR_NICKCOLLISION = "436"
+ERR_UNAVAILRESOURCE = "437"
+ERR_REG_UNAVAILABLE = "440"
+ERR_USERNOTINCHANNEL = "441"
+ERR_NOTONCHANNEL = "442"
+ERR_USERONCHANNEL = "443"
+ERR_NOLOGIN = "444"
+ERR_SUMMONDISABLED = "445"
+ERR_USERSDISABLED = "446"
+ERR_NOTREGISTERED = "451"
+ERR_NEEDMOREPARAMS = "461"
+ERR_ALREADYREGISTRED = "462"
+ERR_NOPERMFORHOST = "463"
+ERR_PASSWDMISMATCH = "464"
+ERR_YOUREBANNEDCREEP = "465"
+ERR_YOUWILLBEBANNED = "466"
+ERR_KEYSET = "467"
+ERR_INVALIDUSERNAME = "468"
+ERR_LINKCHANNEL = "470"
+ERR_CHANNELISFULL = "471"
+ERR_UNKNOWNMODE = "472"
+ERR_INVITEONLYCHAN = "473"
+ERR_BANNEDFROMCHAN = "474"
+ERR_BADCHANNELKEY = "475"
+ERR_BADCHANMASK = "476"
+ERR_NOCHANMODES = "477"
+ERR_NEEDREGGEDNICK = "477"
+ERR_BANLISTFULL = "478"
+ERR_NOPRIVILEGES = "481"
+ERR_CHANOPRIVSNEEDED = "482"
+ERR_CANTKILLSERVER = "483"
+ERR_RESTRICTED = "484"
+ERR_UNIQOPPRIVSNEEDED = "485"
+ERR_NOOPERHOST = "491"
+ERR_UMODEUNKNOWNFLAG = "501"
+ERR_USERSDONTMATCH = "502"
+ERR_HELPNOTFOUND = "524"
+ERR_INVALIDKEY = "525"
+ERR_CANNOTSENDRP = "573"
+RPL_WHOISSECURE = "671"
+RPL_YOURLANGUAGESARE = "687"
+RPL_WHOISLANGUAGE = "690"
+ERR_INVALIDMODEPARAM = "696"
+RPL_HELPSTART = "704"
+RPL_HELPTXT = "705"
+RPL_ENDOFHELP = "706"
+ERR_NOPRIVS = "723"
+RPL_MONONLINE = "730"
+RPL_MONOFFLINE = "731"
+RPL_MONLIST = "732"
+RPL_ENDOFMONLIST = "733"
+ERR_MONLISTFULL = "734"
+RPL_LOGGEDIN = "900"
+RPL_LOGGEDOUT = "901"
+ERR_NICKLOCKED = "902"
+RPL_SASLSUCCESS = "903"
+ERR_SASLFAIL = "904"
+ERR_SASLTOOLONG = "905"
+ERR_SASLABORTED = "906"
+ERR_SASLALREADY = "907"
+RPL_SASLMECHS = "908"
+RPL_REGISTRATION_SUCCESS = "920"
+ERR_ACCOUNT_ALREADY_EXISTS = "921"
+ERR_REG_UNSPECIFIED_ERROR = "922"
+RPL_VERIFYSUCCESS = "923"
+ERR_ACCOUNT_ALREADY_VERIFIED = "924"
 ERR_ACCOUNT_INVALID_VERIFY_CODE = "925"
-RPL_REG_VERIFICATION_REQUIRED   = "927"
-ERR_REG_INVALID_CRED_TYPE       = "928"
-ERR_REG_INVALID_CALLBACK        = "929"
-ERR_TOOMANYLANGUAGES            = "981"
-ERR_NOLANGUAGE                  = "982"
+RPL_REG_VERIFICATION_REQUIRED = "927"
+ERR_REG_INVALID_CRED_TYPE = "928"
+ERR_REG_INVALID_CALLBACK = "929"
+ERR_TOOMANYLANGUAGES = "981"
+ERR_NOLANGUAGE = "982"

irctest/patma.py

@@ -0,0 +1,151 @@
+"""Pattern-matching utilities"""
+
+import dataclasses
+import re
+from typing import Dict, List, Optional, Union
+
+
+class Operator:
+    """Used as a wildcards and operators when matching message arguments
+    (see assertMessageMatch and match_list)"""
+
+    def __init__(self) -> None:
+        pass
+
+
+class AnyStr(Operator):
+    """Wildcard matching any string"""
+
+    def __repr__(self) -> str:
+        return "AnyStr"
+
+
+class AnyOptStr(Operator):
+    """Wildcard matching any string as well as None"""
+
+    def __repr__(self) -> str:
+        return "AnyOptStr"
+
+
+@dataclasses.dataclass(frozen=True)
+class StrRe(Operator):
+    regexp: str
+
+    def __repr__(self) -> str:
+        return f"StrRe(r'{self.regexp}')"
+
+
+@dataclasses.dataclass(frozen=True)
+class NotStrRe(Operator):
+    regexp: str
+
+    def __repr__(self) -> str:
+        return f"NotStrRe(r'{self.regexp}')"
+
+
+@dataclasses.dataclass(frozen=True)
+class RemainingKeys(Operator):
+    """Used in a dict pattern to match all remaining keys.
+    May only be present once."""
+
+    key: Operator
+
+    def __repr__(self) -> str:
+        return f"Keys({self.key!r})"
+
+
+ANYSTR = AnyStr()
+"""Singleton, spares two characters"""
+
+ANYDICT = {RemainingKeys(ANYSTR): AnyOptStr()}
+"""Matches any dictionary; useful to compare tags dict, eg.
+`match_dict(got_tags, {"label": "foo", **ANYDICT})`"""
+
+
+class _AnyListRemainder:
+    def __repr__(self) -> str:
+        return "*ANYLIST"
+
+
+ANYLIST = [_AnyListRemainder()]
+"""Matches any list remainder"""
+
+
+def match_string(got: Optional[str], expected: Union[str, Operator, None]) -> bool:
+    if isinstance(expected, AnyOptStr):
+        return True
+    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):
+            return False
+    elif isinstance(expected, NotStrRe):
+        if got is None or re.match(expected.regexp, got):
+            return False
+    elif isinstance(expected, Operator):
+        raise NotImplementedError(f"Unsupported operator: {expected}")
+    elif got != expected:
+        return False
+
+    return True
+
+
+def match_list(
+    got: List[Optional[str]], expected: List[Union[str, None, Operator]]
+) -> bool:
+    """Returns True iff the list are equal.
+
+    The ANYSTR operator can be used on the 'expected' side as a wildcard,
+    matching any *single* value; and StrRe("<regexp>") can be used to match regular
+    expressions"""
+    if expected[-1] is ANYLIST[0]:
+        expected = expected[0:-1]
+        got = got[0 : len(expected)]  # Ignore remaining
+    if len(got) != len(expected):
+        return False
+    return all(
+        match_string(got_value, expected_value)
+        for (got_value, expected_value) in zip(got, expected)
+    )
+
+
+def match_dict(
+    got: Dict[str, Optional[str]],
+    expected: Dict[Union[str, Operator], Union[str, Operator, None]],
+) -> bool:
+    """Returns True iff the list are equal.
+
+    The ANYSTR operator can be used on the 'expected' side as a wildcard,
+    matching any *single* value; and StrRe("<regexp>") can be used to match regular
+    expressions
+    Additionally, the Keys() operator can be used to match remaining keys, and
+    ANYDICT to match any remaining dict"""
+    got = dict(got)  # shallow copy, as we will remove keys
+
+    # 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():
+        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:
+            if expected_key not in got:
+                return False
+            got_value = got.pop(expected_key)
+            if not match_string(got_value, expected_value):
+                return False
+
+    if remaining_keys_wildcard:
+        (expected_key, expected_value) = remaining_keys_wildcard
+        for (key, value) in got.items():
+            if not match_string(key, expected_key):
+                return False
+            if not match_string(value, expected_value):
+                return False
+
+        return True
+    else:
+        # There should be nothing left unmatched in the dict
+        return got == {}

irctest/runner.py

@@ -1,60 +1,54 @@
 import unittest
-import operator
-import collections
+
 
 class NotImplementedByController(unittest.SkipTest, NotImplementedError):
-    def __str__(self):
-        return 'Not implemented by controller: {}'.format(self.args[0])
+    def __str__(self) -> str:
+        return "Not implemented by controller: {}".format(self.args[0])
+
 
 class ImplementationChoice(unittest.SkipTest):
-    def __str__(self):
-        return 'Choice in the implementation makes it impossible to ' \
-                'perform a test: {}'.format(self.args[0])
+    def __str__(self) -> str:
+        return (
+            "Choice in the implementation makes it impossible to "
+            "perform a test: {}".format(self.args[0])
+        )
+
 
 class OptionalExtensionNotSupported(unittest.SkipTest):
-    def __str__(self):
-        return 'Unsupported extension: {}'.format(self.args[0])
+    def __str__(self) -> str:
+        return "Unsupported extension: {}".format(self.args[0])
+
 
 class OptionalSaslMechanismNotSupported(unittest.SkipTest):
-    def __str__(self):
-        return 'Unsupported SASL mechanism: {}'.format(self.args[0])
+    def __str__(self) -> str:
+        return "Unsupported SASL mechanism: {}".format(self.args[0])
+
 
 class CapabilityNotSupported(unittest.SkipTest):
-    def __str__(self):
-        return 'Unsupported capability: {}'.format(self.args[0])
+    def __str__(self) -> str:
+        return "Unsupported capability: {}".format(self.args[0])
+
+
+class IsupportTokenNotSupported(unittest.SkipTest):
+    def __str__(self) -> str:
+        return "Unsupported ISUPPORT token: {}".format(self.args[0])
+
+
+class ChannelModeNotSupported(unittest.SkipTest):
+    def __str__(self) -> str:
+        return "Unsupported channel mode: {} ({})".format(self.args[0], self.args[1])
+
+
+class ExtbanNotSupported(unittest.SkipTest):
+    def __str__(self) -> str:
+        return "Unsupported extban: {} ({})".format(self.args[0], self.args[1])
+
 
 class NotRequiredBySpecifications(unittest.SkipTest):
-    def __str__(self):
-        return 'Tests not required by the set of tested specification(s).'
+    def __str__(self) -> str:
+        return "Tests not required by the set of tested specification(s)."
+
 
 class SkipStrictTest(unittest.SkipTest):
-    def __str__(self):
-        return 'Tests not required because strict tests are disabled.'
-
-class TextTestResult(unittest.TextTestResult):
-    def getDescription(self, test):
-        if hasattr(test, 'description'):
-            doc_first_lines = test.description()
-        else:
-            doc_first_lines = test.shortDescription()
-        return '\n'.join((str(test), doc_first_lines or ''))
-
-class TextTestRunner(unittest.TextTestRunner):
-    """Small wrapper around unittest.TextTestRunner that reports the
-    number of tests that were skipped because the software does not support
-    an optional feature."""
-    resultclass = TextTestResult
-
-    def run(self, test):
-        result = super().run(test)
-        assert self.resultclass is TextTestResult
-        if result.skipped:
-            print()
-            print('Some tests were skipped because the following optional '
-                    'specifications/mechanisms are not supported:')
-            msg_to_count = collections.defaultdict(lambda: 0)
-            for (test, msg) in result.skipped:
-                msg_to_count[msg] += 1
-            for (msg, count) in sorted(msg_to_count.items()):
-                print('\t{} ({} test(s))'.format(msg, count))
-        return result
+    def __str__(self) -> str:
+        return "Tests not required because strict tests are disabled."

irctest/scram/__init__.py

@@ -0,0 +1,2 @@
+from .scram import *
+from .exceptions import *

irctest/scram/core.py

@@ -0,0 +1,9 @@
+import uuid
+
+def default_nonce_factory():
+    """Generate a random string for digest authentication challenges.
+    The string should be cryptographicaly secure random pattern.
+    :return: the string generated.
+    :returntype: `bytes`
+    """
+    return uuid.uuid4().hex.encode("us-ascii")

irctest/scram/exceptions.py

@@ -0,0 +1,17 @@
+class ScramException(Exception):
+    pass
+
+class BadChallengeException(ScramException):
+    pass
+
+class ExtraChallengeException(ScramException):
+    pass
+
+class ServerScramError(ScramException):
+    pass
+
+class BadSuccessException(ScramException):
+    pass
+
+class NotAuthorizedException(ScramException):
+    pass

irctest/scram/scram.py

@@ -0,0 +1,561 @@
+#
+# (C) Copyright 2011 Jacek Konieczny <jajcus@jajcus.net>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License Version
+# 2.1 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+"""SCRAM authentication mechanisms for PyXMPP SASL implementation.
+
+Normative reference:
+  - :RFC:`5802`
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+__docformat__ = "restructuredtext en"
+
+import sys
+import re
+import logging
+import hashlib
+import hmac
+
+from binascii import a2b_base64
+from base64 import standard_b64encode
+
+from .core import default_nonce_factory
+from .exceptions import BadChallengeException, \
+        ExtraChallengeException, ServerScramError, BadSuccessException, \
+        NotAuthorizedException
+
+
+logger = logging.getLogger("pyxmpp2_scram")
+
+HASH_FACTORIES = {
+        "SHA-1": hashlib.sha1,      # pylint: disable=E1101
+        "SHA-224": hashlib.sha224,  # pylint: disable=E1101
+        "SHA-256": hashlib.sha256,  # pylint: disable=E1101
+        "SHA-384": hashlib.sha384,  # pylint: disable=E1101
+        "SHA-512": hashlib.sha512,  # pylint: disable=E1101
+        "MD-5": hashlib.md5,        # pylint: disable=E1101
+        }
+
+VALUE_CHARS_RE = re.compile(br"^[\x21-\x2B\x2D-\x7E]+$")
+_QUOTED_VALUE_RE = br"(?:[\x21-\x2B\x2D-\x7E]|=2C|=3D)+"
+
+CLIENT_FIRST_MESSAGE_RE = re.compile(
+        br"^(?P<gs2_header>(?:y|n|p=(?P<cb_name>[a-zA-z0-9.-]+)),"
+                        br"(?:a=(?P<authzid>" + _QUOTED_VALUE_RE + br"))?,)"
+        br"(?P<client_first_bare>(?P<mext>m=[^\000=]+,)?"
+                                br"n=(?P<username>" + _QUOTED_VALUE_RE + br"),"
+                                br"r=(?P<nonce>[\x21-\x2B\x2D-\x7E]+)"
+                                br"(?:,.*)?)$"
+                                )
+
+SERVER_FIRST_MESSAGE_RE = re.compile(
+                                br"^(?P<mext>m=[^\000=]+,)?"
+                                br"r=(?P<nonce>[\x21-\x2B\x2D-\x7E]+),"
+                                br"s=(?P<salt>[a-zA-Z0-9/+=]+),"
+                                br"i=(?P<iteration_count>\d+)"
+                                br"(?:,.*)?$"
+                                )
+
+CLIENT_FINAL_MESSAGE_RE = re.compile(
+        br"(?P<without_proof>c=(?P<cb>[a-zA-Z0-9/+=]+),"
+                                br"(?:r=(?P<nonce>[\x21-\x2B\x2D-\x7E]+))"
+                                br"(?:,.*)?)"
+        br",p=(?P<proof>[a-zA-Z0-9/+=]+)$"
+        )
+
+SERVER_FINAL_MESSAGE_RE = re.compile(
+        br"^(?:e=(?P<error>[^,]+)|v=(?P<verifier>[a-zA-Z0-9/+=]+)(?:,.*)?)$")
+
+class SCRAMOperations(object):
+    """Functions used during SCRAM authentication and defined in the RFC.
+
+    """
+    def __init__(self, hash_function_name):
+        self.hash_function_name = hash_function_name
+        self.hash_factory = HASH_FACTORIES[hash_function_name]
+        self.digest_size = self.hash_factory().digest_size
+
+    @staticmethod
+    def Normalize(str_):
+        """The Normalize(str) function.
+
+        This one also accepts Unicode string input (in the RFC only UTF-8
+        strings are used).
+        """
+        # pylint: disable=C0103
+        if isinstance(str_, bytes):
+            str_ = str_.decode("utf-8")
+        return str_.encode("utf-8")
+
+    def HMAC(self, key, str_):
+        """The HMAC(key, str) function."""
+        # pylint: disable=C0103
+        return hmac.new(key, str_, self.hash_factory).digest()
+
+    def H(self, str_):
+        """The H(str) function."""
+        # pylint: disable=C0103
+        return self.hash_factory(str_).digest()
+
+    if sys.version_info.major >= 3:
+        @staticmethod
+        # pylint: disable=C0103
+        def XOR(str1, str2):
+            """The XOR operator for two byte strings."""
+            return bytes(a ^ b for a, b in zip(str1, str2))
+    else:
+        @staticmethod
+        # pylint: disable=C0103
+        def XOR(str1, str2):
+            """The XOR operator for two byte strings."""
+            return "".join(chr(ord(a) ^ ord(b)) for a, b in zip(str1, str2))
+
+    def Hi(self, str_, salt, i):
+        """The Hi(str, salt, i) function."""
+        # pylint: disable=C0103
+        Uj = self.HMAC(str_, salt + b"\000\000\000\001") # U1
+        result = Uj
+        for _ in range(2, i + 1):
+            Uj = self.HMAC(str_, Uj)               # Uj = HMAC(str, Uj-1)
+            result = self.XOR(result,  Uj)         # ... XOR Uj-1 XOR Uj
+        return result
+
+    @staticmethod
+    def escape(data):
+        """Escape the ',' and '=' characters for 'a=' and 'n=' attributes.
+
+        Replaces '=' with '=3D' and ',' with '=2C'.
+
+        :Parameters:
+            - `data`: string to escape
+        :Types:
+            - `data`: `bytes`
+        """
+        return data.replace(b'=', b'=3D').replace(b',', b'=2C')
+
+    @staticmethod
+    def unescape(data):
+        """Unescape the ',' and '=' characters for 'a=' and 'n=' attributes.
+
+        Reverse of `escape`.
+
+        :Parameters:
+            - `data`: string to unescape
+        :Types:
+            - `data`: `bytes`
+        """
+        return data.replace(b'=2C', b',').replace(b'=3D', b'=')
+
+class SCRAMClientAuthenticator(SCRAMOperations):
+    """Provides SCRAM SASL authentication for a client.
+
+    :Ivariables:
+        - `password`: current authentication password
+        - `pformat`: current authentication password format
+        - `realm`: current authentication realm
+    """
+    # pylint: disable-msg=R0902
+    def __init__(self, hash_name, channel_binding):
+        """Initialize a `SCRAMClientAuthenticator` object.
+
+        :Parameters:
+            - `hash_function_name`: hash function name, e.g. ``"SHA-1"``
+            - `channel_binding`: `True` to enable channel binding
+        :Types:
+            - `hash_function_name`: `unicode`
+            - `channel_binding`: `bool`
+        """
+        SCRAMOperations.__init__(self, hash_name)
+        self.name = "SCRAM-{0}".format(hash_name)
+        if channel_binding:
+            self.name += "-PLUS"
+        self.channel_binding = channel_binding
+        self.username = None
+        self.password = None
+        self.authzid = None
+        self._c_nonce = None
+        self._server_first_message = False
+        self._client_first_message_bare = False
+        self._gs2_header = None
+        self._finished = False
+        self._auth_message = None
+        self._salted_password = None
+        self._cb_data = None
+
+    @classmethod
+    def are_properties_sufficient(cls, properties):
+        return "username" in properties and "password" in properties
+
+    def start(self, properties):
+        self.username = properties["username"]
+        self.password = properties["password"]
+        self.authzid = properties.get("authzid", "")
+        c_nonce = properties.get("nonce_factory", default_nonce_factory)()
+        if not VALUE_CHARS_RE.match(c_nonce):
+            c_nonce = standard_b64encode(c_nonce)
+        self._c_nonce = c_nonce
+
+        if self.channel_binding:
+            cb_data = properties.get("channel-binding")
+            if not cb_data:
+                raise ValueError("No channel binding data provided")
+            if "tls-unique" in cb_data:
+                cb_type = "tls-unique"
+            elif "tls-server-end-point" in cb_data:
+                cb_type = "tls-server-end-point"
+            elif cb_data:
+                cb_type = cb_data.keys()[0]
+            self._cb_data = cb_data[cb_type]
+            cb_flag = b"p=" + cb_type.encode("utf-8")
+        else:
+            plus_name = self.name + "-PLUS"
+            if plus_name in properties.get("enabled_mechanisms", []):
+                # -PLUS is enabled (supported) on our side,
+                # but was not selected - that means it was not included
+                # in the server features
+                cb_flag = b"y"
+            else:
+                cb_flag = b"n"
+
+        if self.authzid:
+            authzid = b"a=" + self.escape(self.authzid.encode("utf-8"))
+        else:
+            authzid = b""
+        gs2_header = cb_flag + b"," + authzid + b","
+        self._gs2_header = gs2_header
+        nonce = b"r=" + c_nonce
+        client_first_message_bare = (b"n=" +
+                self.escape(self.username.encode("utf-8")) + b"," + nonce)
+        self._client_first_message_bare = client_first_message_bare
+        client_first_message = gs2_header + client_first_message_bare
+        return client_first_message
+
+    def challenge(self, challenge):
+        """Process a challenge and return the response.
+
+        :Parameters:
+            - `challenge`: the challenge from server.
+        :Types:
+            - `challenge`: `bytes`
+
+        :return: the response
+        :returntype: bytes
+        :raises: `BadChallengeException`
+        """
+        # pylint: disable=R0911
+        if not challenge:
+            raise BadChallengeException('Empty challenge')
+
+        if self._server_first_message:
+            return self._final_challenge(challenge)
+
+        match = SERVER_FIRST_MESSAGE_RE.match(challenge)
+        if not match:
+            raise BadChallengeException("Bad challenge syntax: {0!r}".format(challenge))
+
+        self._server_first_message = challenge
+
+        mext = match.group("mext")
+        if mext:
+            raise BadChallengeException("Unsupported extension received: {0!r}".format(mext))
+
+        nonce = match.group("nonce")
+        if not nonce.startswith(self._c_nonce):
+            raise BadChallengeException("Nonce does not start with our nonce")
+
+        salt = match.group("salt")
+        try:
+            salt = a2b_base64(salt)
+        except ValueError:
+            raise BadChallengeException("Bad base64 encoding for salt: {0!r}".format(salt))
+
+        iteration_count = match.group("iteration_count")
+        try:
+            iteration_count = int(iteration_count)
+        except ValueError:
+            raise BadChallengeException("Bad iteration_count: {0!r}".format(iteration_count))
+
+        return self._make_response(nonce, salt, iteration_count)
+
+    def _make_response(self, nonce, salt, iteration_count):
+        """Make a response for the first challenge from the server.
+
+        :return: the response
+        :returntype: bytes
+        """
+        self._salted_password = self.Hi(self.Normalize(self.password), salt,
+                                                            iteration_count)
+        self.password = None # not needed any more
+        if self.channel_binding:
+            channel_binding = b"c=" + standard_b64encode(self._gs2_header +
+                                                                self._cb_data)
+        else:
+            channel_binding = b"c=" + standard_b64encode(self._gs2_header)
+
+        # pylint: disable=C0103
+        client_final_message_without_proof = (channel_binding + b",r=" + nonce)
+
+        client_key = self.HMAC(self._salted_password, b"Client Key")
+        stored_key = self.H(client_key)
+        auth_message = ( self._client_first_message_bare + b"," +
+                                    self._server_first_message + b"," +
+                                        client_final_message_without_proof )
+        self._auth_message = auth_message
+        client_signature = self.HMAC(stored_key, auth_message)
+        client_proof = self.XOR(client_key, client_signature)
+        proof = b"p=" + standard_b64encode(client_proof)
+        client_final_message = (client_final_message_without_proof + b"," +
+                                                                    proof)
+        return client_final_message
+
+    def _final_challenge(self, challenge):
+        """Process the second challenge from the server and return the
+        response.
+
+        :Parameters:
+            - `challenge`: the challenge from server.
+        :Types:
+            - `challenge`: `bytes`
+
+        :raises: `ExtraChallengeException`, `BadChallengeException`, `ServerScramError`, or `BadSuccessException`
+        """
+        if self._finished:
+            return ExtraChallengeException()
+
+        match = SERVER_FINAL_MESSAGE_RE.match(challenge)
+        if not match:
+            raise BadChallengeException("Bad final message syntax: {0!r}".format(challenge))
+
+        error = match.group("error")
+        if error:
+            raise ServerScramError("{0!r}".format(error))
+
+        verifier = match.group("verifier")
+        if not verifier:
+            raise BadSuccessException("No verifier value in the final message")
+
+        server_key = self.HMAC(self._salted_password, b"Server Key")
+        server_signature = self.HMAC(server_key, self._auth_message)
+        if server_signature != a2b_base64(verifier):
+            raise BadSuccessException("Server verifier does not match")
+
+        self._finished = True
+
+    def finish(self, data):
+        """Process success indicator from the server.
+
+        Process any addiitional data passed with the success.
+        Fail if the server was not authenticated.
+
+        :Parameters:
+            - `data`: an optional additional data with success.
+        :Types:
+            - `data`: `bytes`
+
+        :return: username and authzid
+        :returntype: `dict`
+        :raises: `BadSuccessException`"""
+        if not self._server_first_message:
+            raise BadSuccessException("Got success too early")
+        if self._finished:
+            return {"username": self.username, "authzid": self.authzid}
+        else:
+            self._final_challenge(data)
+            if self._finished:
+                return {"username": self.username,
+                                                    "authzid": self.authzid}
+            else:
+                raise BadSuccessException("Something went wrong when processing additional"
+                                                        " data with success?")
+
+class SCRAMServerAuthenticator(SCRAMOperations):
+    """Provides SCRAM SASL authentication for a server.
+    """
+    def __init__(self, hash_name, channel_binding, password_database):
+        """Initialize a `SCRAMClientAuthenticator` object.
+
+        :Parameters:
+            - `hash_function_name`: hash function name, e.g. ``"SHA-1"``
+            - `channel_binding`: `True` to enable channel binding
+        :Types:
+            - `hash_function_name`: `unicode`
+            - `channel_binding`: `bool`
+        """
+        SCRAMOperations.__init__(self, hash_name)
+        self.name = "SCRAM-{0}".format(hash_name)
+        if channel_binding:
+            self.name += "-PLUS"
+        self.channel_binding = channel_binding
+        self.properties = None
+        self.out_properties = None
+        self.password_database = password_database
+        self._client_first_message_bare = None
+        self._stored_key = None
+        self._server_key = None
+
+    def start(self, properties, initial_response):
+        self.properties = properties
+        self._client_first_message_bare = None
+        self.out_properties = {}
+        if not initial_response:
+            return b""
+        return self.response(initial_response)
+
+    def response(self, response):
+        if self._client_first_message_bare:
+            logger.debug("Client final message: {0!r}".format(response))
+            return self._handle_final_response(response)
+        else:
+            logger.debug("Client first message: {0!r}".format(response))
+            return self._handle_first_response(response)
+
+    def _handle_first_response(self, response):
+        match = CLIENT_FIRST_MESSAGE_RE.match(response)
+        if not match:
+            raise NotAuthorizedException("Bad response syntax: {0!r}".format(response))
+
+        mext = match.group("mext")
+        if mext:
+            raise NotAuthorizedException("Unsupported extension received: {0!r}".format(mext))
+
+        gs2_header = match.group("gs2_header")
+        cb_name = match.group("cb_name")
+        if self.channel_binding:
+            if not cb_name:
+                raise NotAuthorizedException("{0!r} used with no channel-binding"
+                                                            .format(self.name))
+            cb_name = cb_name.decode("utf-8")
+            if cb_name not in self.properties["channel-binding"]:
+                raise NotAuthorizedException("Channel binding data type {0!r} not available"
+                                                            .format(cb_name))
+        else:
+            if gs2_header.startswith(b'y'):
+                plus_name = self.name + "-PLUS"
+                if plus_name in self.properties.get("enabled_mechanisms", []):
+                    raise NotAuthorizedException("Channel binding downgrade attack detected")
+            elif gs2_header.startswith(b'p'):
+                # is this really an error?
+                raise NotAuthorizedException("Channel binding requested for {0!r}"
+                                                            .format(self.name))
+
+        authzid = match.group("authzid")
+        if authzid:
+            self.out_properties['authzid'] = self.unescape(authzid
+                                                            ).decode("utf-8")
+        else:
+            self.out_properties['authzid'] = None
+        username = self.unescape(match.group("username")).decode("utf-8")
+        self.out_properties['username'] = username
+
+        nonce_factory = self.properties.get("nonce_factory",
+                                                        default_nonce_factory)
+
+        properties = dict(self.properties)
+        properties.update(self.out_properties)
+
+        s_pformat = "SCRAM-{0}-SaltedPassword".format(self.hash_function_name)
+        k_pformat = "SCRAM-{0}-Keys".format(self.hash_function_name)
+        password, pformat = self.password_database.get_password(username,
+                                           (s_pformat, "plain"), properties)
+        if pformat == s_pformat:
+            if password is not None:
+                salt, iteration_count, salted_password = password
+            else:
+                logger.debug("No password for user {0!r}".format(username))
+        elif pformat != k_pformat:
+            salt = self.properties.get("SCRAM-salt")
+            if not salt:
+                salt = nonce_factory()
+            iteration_count = self.properties.get("SCRAM-iteration-count", 4096)
+            if pformat == "plain" and password is not None:
+                salted_password = self.Hi(self.Normalize(password), salt,
+                                                            iteration_count)
+            else:
+                logger.debug("No password for user {0!r}".format(username))
+                password = None
+                # to prevent timing attack, compute the key anyway
+                salted_password = self.Hi(self.Normalize(""), salt,
+                                                            iteration_count)
+        if pformat == k_pformat:
+            salt, iteration_count, stored_key, server_key = password
+        else:
+            client_key = self.HMAC(salted_password, b"Client Key")
+            stored_key = self.H(client_key)
+            server_key = self.HMAC(salted_password, b"Server Key")
+
+        if password is not None:
+            self._stored_key = stored_key
+            self._server_key = server_key
+        else:
+            self._stored_key = None
+            self._server_key = None
+
+        c_nonce = match.group("nonce")
+        s_nonce = nonce_factory()
+        if not VALUE_CHARS_RE.match(s_nonce):
+            s_nonce = standard_b64encode(s_nonce)
+        nonce = c_nonce + s_nonce
+        server_first_message = (
+                            b"r=" + nonce
+                            + b",s=" + standard_b64encode(salt)
+                            + b",i=" + str(iteration_count).encode("utf-8")
+                            )
+        self._nonce = nonce
+        self._cb_name  = cb_name
+        self._gs2_header = gs2_header
+        self._client_first_message_bare = match.group("client_first_bare")
+        self._server_first_message = server_first_message
+        return server_first_message
+
+    def _handle_final_response(self, response):
+        match = CLIENT_FINAL_MESSAGE_RE.match(response)
+        if not match:
+            raise NotAuthorizedException("Bad response syntax: {0!r}".format(response))
+        if match.group("nonce") != self._nonce:
+            raise NotAuthorizedException("Bad nonce in the final client response")
+        cb_input = a2b_base64(match.group("cb"))
+        if not cb_input.startswith(self._gs2_header):
+            raise NotAuthorizedException("GS2 header in the final response ({0!r}) doesn't"
+                    " match the one sent in the first message ({1!r})"
+                                        .format(cb_input, self._gs2_header))
+        if self._cb_name:
+            cb_data = cb_input[len(self._gs2_header):]
+            if cb_data != self.properties["channel-binding"][self._cb_name]:
+                raise NotAuthorizedException("Channel binding data doesn't match")
+
+        proof = a2b_base64(match.group("proof"))
+
+        auth_message = (self._client_first_message_bare + b"," +
+                                    self._server_first_message + b"," +
+                                        match.group("without_proof"))
+        if self._stored_key is None:
+            # compute something to prevent timing attack
+            client_signature = self.HMAC(b"", auth_message)
+            client_key = self.XOR(client_signature, proof)
+            self.H(client_key)
+            raise NotAuthorizedException("Authentication failed (bad username)")
+
+        client_signature = self.HMAC(self._stored_key, auth_message)
+        client_key = self.XOR(client_signature, proof)
+        if self.H(client_key) != self._stored_key:
+            raise NotAuthorizedException("Authentication failed")
+
+        server_signature = self.HMAC(self._server_key, auth_message)
+        server_final_message = b"v=" + standard_b64encode(server_signature)
+        return (self.out_properties, server_final_message)
+
+

irctest/self_tests/cases.py

@@ -0,0 +1,185 @@
+from typing import Dict, List, Tuple
+
+import pytest
+
+from irctest import cases
+from irctest.irc_utils.message_parser import parse_message
+from irctest.patma import ANYDICT, ANYSTR, AnyOptStr, NotStrRe, RemainingKeys, StrRe
+
+# fmt: off
+MESSAGE_SPECS: List[Tuple[Dict, List[str], List[str]]] = [
+    (
+        # the specification:
+        dict(
+            command="PRIVMSG",
+            params=["#chan", "hello"],
+        ),
+        # matches:
+        [
+            "PRIVMSG #chan hello",
+            "PRIVMSG #chan :hello",
+            "@tag1=bar PRIVMSG #chan :hello",
+            "@tag1=bar;tag2= PRIVMSG #chan :hello",
+            ":foo!baz@qux PRIVMSG #chan hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "PRIVMSG #chan hello2",
+            "PRIVMSG #chan2 hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            command="PRIVMSG",
+            params=["#chan", StrRe("hello.*")],
+        ),
+        # matches:
+        [
+            "PRIVMSG #chan hello",
+            "PRIVMSG #chan :hello",
+            "PRIVMSG #chan hello2",
+            "@tag1=bar PRIVMSG #chan :hello",
+            "@tag1=bar;tag2= PRIVMSG #chan :hello",
+            ":foo!baz@qux PRIVMSG #chan hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "PRIVMSG #chan :hi",
+            "PRIVMSG #chan2 hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            nick="foo",
+            command="PRIVMSG",
+        ),
+        # matches:
+        [
+            ":foo!baz@qux PRIVMSG #chan hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "PRIVMSG #chan :hi",
+            ":foo2!baz@qux PRIVMSG #chan hello",
+            "@tag1=bar :foo2!baz@qux PRIVMSG #chan :hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            tags={"tag1": "bar"},
+            command="PRIVMSG",
+            params=["#chan", "hello"],
+        ),
+        # matches:
+        [
+            "@tag1=bar PRIVMSG #chan :hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "@tag1=bar;tag2= PRIVMSG #chan :hello",
+            "@tag1=value1 PRIVMSG #chan :hello",
+            "PRIVMSG #chan hello",
+            ":foo!baz@qux PRIVMSG #chan hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            tags={"tag1": ANYSTR},
+            command="PRIVMSG",
+            params=["#chan", ANYSTR],
+        ),
+        # matches:
+        [
+            "@tag1=bar PRIVMSG #chan :hello",
+            "@tag1=value1 PRIVMSG #chan :hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "@tag1=bar;tag2= PRIVMSG #chan :hello",
+            "PRIVMSG #chan hello",
+            ":foo!baz@qux PRIVMSG #chan hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            tags={"tag1": "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",
+        ],
+        # and does not match:
+        [
+            "PRIVMG #chan :hello",
+            "@tag1=value1 PRIVMSG #chan :hello",
+            "PRIVMSG #chan hello2",
+            "PRIVMSG #chan2 hello",
+            ":foo!baz@qux PRIVMSG #chan hello",
+        ]
+    ),
+    (
+        # the specification:
+        dict(
+            tags={"tag1": "bar", RemainingKeys(NotStrRe("tag2")): AnyOptStr()},
+            command="PRIVMSG",
+            params=["#chan", "hello"],
+        ),
+        # matches:
+        [
+            "@tag1=bar PRIVMSG #chan :hello",
+            "@tag1=bar :foo!baz@qux PRIVMSG #chan :hello",
+            "@tag1=bar;tag3= PRIVMSG #chan :hello",
+        ],
+        # and does not match:
+        [
+            "PRIVMG #chan :hello",
+            "@tag1=value1 PRIVMSG #chan :hello",
+            "@tag1=bar;tag2= PRIVMSG #chan :hello",
+            "@tag1=bar;tag2=baz PRIVMSG #chan :hello",
+        ]
+    ),
+]
+# fmt: on
+
+
+class IrcTestCaseTestCase(cases._IrcTestCase):
+    @pytest.mark.parametrize(
+        "spec,msg",
+        [
+            pytest.param(spec, msg, id=f"{spec}-{msg}")
+            for (spec, positive_matches, _) in MESSAGE_SPECS
+            for msg in positive_matches
+        ],
+    )
+    def test_message_matching_positive(self, spec, msg):
+        assert not self.messageDiffers(parse_message(msg), **spec), msg
+        assert self.messageEqual(parse_message(msg), **spec), msg
+        self.assertMessageMatch(parse_message(msg), **spec), msg
+
+    @pytest.mark.parametrize(
+        "spec,msg",
+        [
+            pytest.param(spec, msg, id=f"{spec}-{msg}")
+            for (spec, _, negative_matches) in MESSAGE_SPECS
+            for msg in negative_matches
+        ],
+    )
+    def test_message_matching_negative(self, spec, msg):
+        assert self.messageDiffers(parse_message(msg), **spec), msg
+        assert not self.messageEqual(parse_message(msg), **spec), msg
+        with pytest.raises(AssertionError):
+            self.assertMessageMatch(parse_message(msg), **spec), msg

irctest/server_tests/account_tag.py

@@ -0,0 +1,70 @@
+"""
+<http://ircv3.net/specs/extensions/account-tag-3.2.html>
+"""
+
+from irctest import cases
+
+
+@cases.mark_services
+class AccountTagTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    def connectRegisteredClient(self, nick):
+        self.addClient()
+        self.sendLine(2, "CAP LS 302")
+        capabilities = self.getCapLs(2)
+        assert "sasl" in capabilities
+
+        self.sendLine(2, "USER f * * :Realname")
+        self.sendLine(2, "NICK {}".format(nick))
+        self.sendLine(2, "CAP REQ :sasl")
+        self.getRegistrationMessage(2)
+
+        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.sendLine(2, "USER f * * :Realname")
+        self.sendLine(2, "NICK {}".format(nick))
+        self.sendLine(2, "CAP END")
+        self.skipToWelcome(2)
+
+    @cases.mark_capabilities("account-tag")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testPrivmsg(self):
+        self.connectClient("foo", capabilities=["account-tag"], skip_if_cap_nak=True)
+        self.getMessages(1)
+        self.controller.registerUser(self, "jilles", "sesame")
+        self.connectRegisteredClient("bar")
+        self.sendLine(2, "PRIVMSG foo :hi")
+        self.getMessages(2)
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m, command="PRIVMSG", params=["foo", "hi"], tags={"account": "jilles"}
+        )
+
+    @cases.mark_capabilities("account-tag")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testInvite(self):
+        self.connectClient("foo", capabilities=["account-tag"], skip_if_cap_nak=True)
+        self.getMessages(1)
+        self.controller.registerUser(self, "jilles", "sesame")
+        self.connectRegisteredClient("bar")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(2)
+        self.sendLine(2, "INVITE foo #chan")
+        self.getMessages(2)
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m, command="INVITE", params=["foo", "#chan"], tags={"account": "jilles"}
+        )

irctest/server_tests/away.py

@@ -0,0 +1,136 @@
+from irctest import cases
+from irctest.numerics import RPL_AWAY, RPL_NOWAWAY, RPL_UNAWAY, RPL_USERHOST
+from irctest.patma import StrRe
+
+
+class AwayTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC2812", "Modern")
+    def testAway(self):
+        self.connectClient("bar")
+        self.sendLine(1, "AWAY :I'm not here right now")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
+
+        self.connectClient("qux")
+        self.sendLine(2, "PRIVMSG bar :what's up")
+        self.assertMessageMatch(
+            self.getMessage(2),
+            command=RPL_AWAY,
+            params=["qux", "bar", "I'm not here right now"],
+        )
+
+        self.sendLine(1, "AWAY")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_UNAWAY, [msg.command for msg in replies])
+
+        self.sendLine(2, "PRIVMSG bar :what's up")
+        replies = self.getMessages(2)
+        self.assertEqual(len(replies), 0)
+
+    @cases.mark_specifications("Modern")
+    def testAwayAck(self):
+        """
+        "The server acknowledges the change in away status by returning the
+        `RPL_NOWAWAY` and `RPL_UNAWAY` numerics."
+        -- https://github.com/ircdocs/modern-irc/pull/100
+        """
+        self.connectClient("bar")
+        self.sendLine(1, "AWAY :I'm not here right now")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
+
+        self.sendLine(1, "AWAY")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_UNAWAY, [msg.command for msg in replies])
+
+    @cases.mark_specifications("Modern")
+    def testAwayPrivmsg(self):
+        """
+        "Servers SHOULD notify clients when a user they're interacting with
+        is away when relevant"
+        -- https://github.com/ircdocs/modern-irc/pull/100
+
+        "<client> <nick> :<message>"
+        -- https://modern.ircdocs.horse/#rplaway-301
+        """
+        self.connectClient("bar")
+        self.connectClient("qux")
+
+        self.sendLine(2, "PRIVMSG bar :what's up")
+        self.assertEqual(self.getMessages(2), [])
+
+        self.sendLine(1, "AWAY :I'm not here right now")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
+
+        self.sendLine(2, "PRIVMSG bar :what's up")
+        self.assertMessageMatch(
+            self.getMessage(2),
+            command=RPL_AWAY,
+            params=["qux", "bar", "I'm not here right now"],
+        )
+
+    @cases.mark_specifications("Modern")
+    def testAwayWhois(self):
+        """
+        "Servers SHOULD notify clients when a user they're interacting with
+        is away when relevant"
+        -- https://github.com/ircdocs/modern-irc/pull/100
+
+        "<client> <nick> :<message>"
+        -- https://modern.ircdocs.horse/#rplaway-301
+        """
+        self.connectClient("bar")
+        self.connectClient("qux")
+
+        self.sendLine(2, "WHOIS bar")
+        msgs = [msg for msg in self.getMessages(2) if msg.command == RPL_AWAY]
+        self.assertEqual(
+            len(msgs),
+            0,
+            fail_msg="Expected no RPL_AWAY (301), got: {}",
+            extra_format=(msgs,),
+        )
+
+        self.sendLine(1, "AWAY :I'm not here right now")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
+
+        self.sendLine(2, "WHOIS bar")
+        msgs = [msg for msg in self.getMessages(2) if msg.command == RPL_AWAY]
+        self.assertEqual(
+            len(msgs),
+            1,
+            fail_msg="Expected one RPL_AWAY (301), got: {}",
+            extra_format=(msgs,),
+        )
+        self.assertMessageMatch(
+            msgs[0], command=RPL_AWAY, params=["qux", "bar", "I'm not here right now"]
+        )
+
+    @cases.mark_specifications("Modern")
+    def testAwayUserhost(self):
+        """
+        "Servers SHOULD notify clients when a user they're interacting with
+        is away when relevant"
+        -- https://github.com/ircdocs/modern-irc/pull/100
+
+        "<client> <nick> :<message>"
+        -- https://modern.ircdocs.horse/#rplaway-301
+        """
+        self.connectClient("bar")
+
+        self.connectClient("qux")
+        self.sendLine(2, "USERHOST bar")
+        self.assertMessageMatch(
+            self.getMessage(2), command=RPL_USERHOST, params=["qux", StrRe(r"bar=\+.*")]
+        )
+
+        self.sendLine(1, "AWAY :I'm not here right now")
+        replies = self.getMessages(1)
+        self.assertIn(RPL_NOWAWAY, [msg.command for msg in replies])
+
+        self.sendLine(2, "USERHOST bar")
+        self.assertMessageMatch(
+            self.getMessage(2), command=RPL_USERHOST, params=["qux", StrRe(r"bar=-.*")]
+        )

irctest/server_tests/away_notify.py

@@ -0,0 +1,62 @@
+"""
+<https://ircv3.net/specs/extensions/away-notify-3.1>
+"""
+
+from irctest import cases
+
+
+class AwayNotifyTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    @cases.mark_capabilities("away-notify")
+    def testAwayNotify(self):
+        """Basic away-notify test."""
+        self.connectClient("foo", capabilities=["away-notify"], skip_if_cap_nak=True)
+        self.getMessages(1)
+        self.joinChannel(1, "#chan")
+
+        self.connectClient("bar")
+        self.getMessages(2)
+        self.joinChannel(2, "#chan")
+        self.getMessages(2)
+        self.getMessages(1)
+
+        self.sendLine(2, "AWAY :i'm going away")
+        self.getMessages(2)
+
+        awayNotify = self.getMessage(1)
+        self.assertMessageMatch(awayNotify, command="AWAY", params=["i'm going away"])
+        self.assertTrue(
+            awayNotify.prefix.startswith("bar!"),
+            "Unexpected away-notify source: %s" % (awayNotify.prefix,),
+        )
+
+    @cases.mark_capabilities("away-notify")
+    def testAwayNotifyOnJoin(self):
+        """The away-notify specification states:
+        "Clients will be sent an AWAY message [...] when a user joins
+        and has an away message set."
+        """
+        self.connectClient("foo", capabilities=["away-notify"], skip_if_cap_nak=True)
+        self.getMessages(1)
+        self.joinChannel(1, "#chan")
+
+        self.connectClient("bar")
+        self.getMessages(2)
+        self.sendLine(2, "AWAY :i'm already away")
+        self.getMessages(2)
+
+        self.joinChannel(2, "#chan")
+        self.getMessages(2)
+
+        messages = [msg for msg in self.getMessages(1) if msg.command == "AWAY"]
+        self.assertEqual(
+            len(messages),
+            1,
+            "Someone away joined a channel, "
+            "but users in the channel did not get AWAY messages.",
+        )
+        awayNotify = messages[0]
+        self.assertMessageMatch(awayNotify, command="AWAY", params=["i'm already away"])
+        self.assertTrue(
+            awayNotify.prefix.startswith("bar!"),
+            "Unexpected away-notify source: %s" % (awayNotify.prefix,),
+        )

irctest/server_tests/bot_mode.py

@@ -0,0 +1,153 @@
+"""
+Draft bot mode specification, as defined in
+<https://ircv3.net/specs/extensions/bot-mode>
+"""
+
+from irctest import cases, runner
+from irctest.numerics import RPL_WHOISBOT
+from irctest.patma import ANYDICT, ANYSTR, StrRe
+
+
+@cases.mark_specifications("IRCv3")
+@cases.mark_isupport("BOT")
+class BotModeTestCase(cases.BaseServerTestCase):
+    def setUp(self):
+        super().setUp()
+        self.connectClient("modegettr")
+        if "BOT" not in self.server_support:
+            raise runner.IsupportTokenNotSupported("BOT")
+        self._mode_char = self.server_support["BOT"]
+
+    def _initBot(self):
+        self.assertEqual(
+            len(self._mode_char),
+            1,
+            fail_msg=(
+                f"BOT ISUPPORT token should be exactly one character, "
+                f"but is: {self._mode_char!r}"
+            ),
+        )
+
+        self.connectClient("botnick", "bot")
+
+        self.sendLine("bot", f"MODE botnick +{self._mode_char}")
+
+        # Check echoed mode
+        while True:
+            msg = self.getMessage("bot")
+            if msg.command != "NOTICE":
+                # Unreal sends the BOTMOTD here
+                self.assertMessageMatch(
+                    msg,
+                    command="MODE",
+                    params=["botnick", StrRe(r"\+?" + self._mode_char)],
+                )
+                break
+
+    def testBotMode(self):
+        self._initBot()
+
+    def testBotWhois(self):
+        self._initBot()
+
+        self.connectClient("usernick", "user")
+        self.sendLine("user", "WHOIS botnick")
+        messages = self.getMessages("user")
+        messages = [msg for msg in messages if msg.command == RPL_WHOISBOT]
+        self.assertEqual(
+            len(messages),
+            1,
+            msg=(
+                f"Expected exactly one RPL_WHOISBOT ({RPL_WHOISBOT}), "
+                f"got: {messages}"
+            ),
+        )
+
+        (message,) = messages
+        self.assertMessageMatch(
+            message, command=RPL_WHOISBOT, params=["usernick", "botnick", ANYSTR]
+        )
+
+    def testBotPrivateMessage(self):
+        self._initBot()
+
+        self.connectClient(
+            "usernick", "user", capabilities=["message-tags"], skip_if_cap_nak=True
+        )
+
+        self.sendLine("bot", "PRIVMSG usernick :beep boop")
+        self.getMessages("bot")  # Synchronizes
+
+        self.assertMessageMatch(
+            self.getMessage("user"),
+            command="PRIVMSG",
+            params=["usernick", "beep boop"],
+            tags={"draft/bot": None, **ANYDICT},
+        )
+
+    def testBotChannelMessage(self):
+        self._initBot()
+
+        self.connectClient(
+            "usernick", "user", capabilities=["message-tags"], skip_if_cap_nak=True
+        )
+
+        self.sendLine("bot", "JOIN #chan")
+        self.sendLine("user", "JOIN #chan")
+        self.getMessages("bot")
+        self.getMessages("user")
+
+        self.sendLine("bot", "PRIVMSG #chan :beep boop")
+        self.getMessages("bot")  # Synchronizes
+
+        self.assertMessageMatch(
+            self.getMessage("user"),
+            command="PRIVMSG",
+            params=["#chan", "beep boop"],
+            tags={"draft/bot": None, **ANYDICT},
+        )
+
+    def testBotWhox(self):
+        self._initBot()
+
+        self.connectClient(
+            "usernick", "user", capabilities=["message-tags"], skip_if_cap_nak=True
+        )
+
+        self.sendLine("bot", "JOIN #chan")
+        self.sendLine("user", "JOIN #chan")
+        self.getMessages("bot")
+        self.getMessages("user")
+
+        self.sendLine("user", "WHO #chan")
+        msg1 = self.getMessage("user")
+        self.assertMessageMatch(
+            msg1, command="352", fail_msg="Expected WHO response (352), got: {msg}"
+        )
+        msg2 = self.getMessage("user")
+        self.assertMessageMatch(
+            msg2, command="352", fail_msg="Expected WHO response (352), got: {msg}"
+        )
+
+        if msg1.params[5] == "botnick":
+            msg = msg1
+        elif msg2.params[5] == "botnick":
+            msg = msg2
+        else:
+            assert False, "No WHO response contained botnick"
+
+        self.assertMessageMatch(
+            msg,
+            command="352",
+            params=[
+                "usernick",
+                "#chan",
+                ANYSTR,  # ident
+                ANYSTR,  # hostname
+                ANYSTR,  # server
+                "botnick",
+                StrRe(f".*{self._mode_char}.*"),
+                ANYSTR,  # realname
+            ],
+            fail_msg="Expected WHO response with bot flag, got: {msg}",
+        )

irctest/server_tests/bouncer.py

@@ -0,0 +1,160 @@
+from irctest import cases
+from irctest.irc_utils.sasl import sasl_plain_blob
+from irctest.numerics import ERR_NICKNAMEINUSE, RPL_WELCOME
+from irctest.patma import ANYSTR, StrRe
+
+
+@cases.mark_services
+class BouncerTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testBouncer(self):
+        """Test basic bouncer functionality."""
+        self.controller.registerUser(self, "observer", "observerpassword")
+        self.controller.registerUser(self, "testuser", "mypassword")
+
+        self.connectClient(
+            "observer", password="observerpassword", capabilities=["sasl"]
+        )
+        self.joinChannel(1, "#chan")
+        self.sendLine(1, "CAP REQ :message-tags server-time")
+        self.getMessages(1)
+
+        self.addClient()
+        self.sendLine(2, "CAP LS 302")
+        self.sendLine(2, "AUTHENTICATE PLAIN")
+        self.sendLine(2, sasl_plain_blob("testuser", "mypassword"))
+        self.sendLine(2, "NICK testnick")
+        self.sendLine(2, "USER a 0 * a")
+        self.sendLine(2, "CAP REQ :server-time message-tags")
+        self.sendLine(2, "CAP END")
+        messages = self.getMessages(2)
+        welcomes = [message for message in messages if message.command == RPL_WELCOME]
+        self.assertEqual(len(welcomes), 1)
+        # should see a regburst for testnick
+        self.assertMessageMatch(welcomes[0], params=["testnick", ANYSTR])
+        self.joinChannel(2, "#chan")
+
+        self.addClient()
+        self.sendLine(3, "CAP LS 302")
+        self.sendLine(3, "AUTHENTICATE PLAIN")
+        self.sendLine(3, sasl_plain_blob("testuser", "mypassword"))
+        self.sendLine(3, "NICK testnick")
+        self.sendLine(3, "USER a 0 * a")
+        self.sendLine(3, "CAP REQ :server-time message-tags account-tag")
+        self.sendLine(3, "CAP END")
+        messages = self.getMessages(3)
+        welcomes = [message for message in messages if message.command == RPL_WELCOME]
+        self.assertEqual(len(welcomes), 1)
+        # should see the *same* regburst for testnick
+        self.assertMessageMatch(welcomes[0], params=["testnick", ANYSTR])
+        joins = [message for message in messages if message.command == "JOIN"]
+        # we should be automatically joined to #chan
+        self.assertMessageMatch(joins[0], params=["#chan"])
+
+        # disable multiclient in nickserv
+        self.sendLine(3, "NS SET MULTICLIENT OFF")
+        self.getMessages(3)
+
+        self.addClient()
+        self.sendLine(4, "CAP LS 302")
+        self.sendLine(4, "AUTHENTICATE PLAIN")
+        self.sendLine(4, sasl_plain_blob("testuser", "mypassword"))
+        self.sendLine(4, "NICK testnick")
+        self.sendLine(4, "USER a 0 * a")
+        self.sendLine(4, "CAP REQ :server-time message-tags")
+        self.sendLine(4, "CAP END")
+        # with multiclient disabled, we should not be able to attach to the nick
+        messages = self.getMessages(4)
+        welcomes = [message for message in messages if message.command == RPL_WELCOME]
+        self.assertEqual(len(welcomes), 0)
+        errors = [
+            message for message in messages if message.command == ERR_NICKNAMEINUSE
+        ]
+        self.assertEqual(len(errors), 1)
+
+        self.sendLine(3, "NS SET MULTICLIENT ON")
+        self.getMessages(3)
+        self.addClient()
+        self.sendLine(5, "CAP LS 302")
+        self.sendLine(5, "AUTHENTICATE PLAIN")
+        self.sendLine(5, sasl_plain_blob("testuser", "mypassword"))
+        self.sendLine(5, "NICK testnick")
+        self.sendLine(5, "USER a 0 * a")
+        self.sendLine(5, "CAP REQ server-time")
+        self.sendLine(5, "CAP END")
+        messages = self.getMessages(5)
+        welcomes = [message for message in messages if message.command == RPL_WELCOME]
+        self.assertEqual(len(welcomes), 1)
+
+        self.sendLine(1, "@+clientOnlyTag=Value PRIVMSG #chan :hey")
+        self.getMessages(1)
+        messagesfortwo = [
+            msg for msg in self.getMessages(2) if msg.command == "PRIVMSG"
+        ]
+        messagesforthree = [
+            msg for msg in self.getMessages(3) if msg.command == "PRIVMSG"
+        ]
+        self.assertEqual(len(messagesfortwo), 1)
+        self.assertEqual(len(messagesforthree), 1)
+        messagefortwo = messagesfortwo[0]
+        messageforthree = messagesforthree[0]
+        messageforfive = self.getMessage(5)
+        self.assertMessageMatch(messagefortwo, params=["#chan", "hey"])
+        self.assertMessageMatch(messageforthree, params=["#chan", "hey"])
+        self.assertMessageMatch(messageforfive, params=["#chan", "hey"])
+        self.assertIn("time", messagefortwo.tags)
+        self.assertIn("time", messageforthree.tags)
+        self.assertIn("time", messageforfive.tags)
+        # 3 has account-tag
+        self.assertIn("account", messageforthree.tags)
+        # should get same msgid
+        self.assertEqual(messagefortwo.tags["msgid"], messageforthree.tags["msgid"])
+        # 5 only has server-time, shouldn't get account or msgid tags
+        self.assertNotIn("account", messageforfive.tags)
+        self.assertNotIn("msgid", messageforfive.tags)
+
+        # test that copies of sent messages go out to other sessions
+        self.sendLine(2, "PRIVMSG observer :this is a direct message")
+        self.getMessages(2)
+        messageForRecipient = [
+            msg for msg in self.getMessages(1) if msg.command == "PRIVMSG"
+        ][0]
+        copyForOtherSession = [
+            msg for msg in self.getMessages(3) if msg.command == "PRIVMSG"
+        ][0]
+        self.assertEqual(messageForRecipient.params, copyForOtherSession.params)
+        self.assertEqual(
+            messageForRecipient.tags["msgid"], copyForOtherSession.tags["msgid"]
+        )
+
+        self.sendLine(2, "QUIT :two out")
+        quitLines = [msg for msg in self.getMessages(2) if msg.command == "QUIT"]
+        self.assertEqual(len(quitLines), 1)
+        self.assertMessageMatch(quitLines[0], params=[StrRe(".*two out.*")])
+        # neither the observer nor the other attached session should see a quit here
+        quitLines = [msg for msg in self.getMessages(1) if msg.command == "QUIT"]
+        self.assertEqual(quitLines, [])
+        quitLines = [msg for msg in self.getMessages(3) if msg.command == "QUIT"]
+        self.assertEqual(quitLines, [])
+
+        # session 3 should be untouched at this point
+        self.sendLine(1, "@+clientOnlyTag=Value PRIVMSG #chan :hey again")
+        self.getMessages(1)
+        messagesforthree = [
+            msg for msg in self.getMessages(3) if msg.command == "PRIVMSG"
+        ]
+        self.assertEqual(len(messagesforthree), 1)
+        self.assertMessageMatch(
+            messagesforthree[0], command="PRIVMSG", params=["#chan", "hey again"]
+        )
+
+        self.sendLine(5, "QUIT :five out")
+        self.getMessages(5)
+        self.sendLine(3, "QUIT :three out")
+        quitLines = [msg for msg in self.getMessages(3) if msg.command == "QUIT"]
+        self.assertEqual(len(quitLines), 1)
+        self.assertMessageMatch(quitLines[0], params=[StrRe(".*three out.*")])
+        # observer should see *this* quit
+        quitLines = [msg for msg in self.getMessages(1) if msg.command == "QUIT"]
+        self.assertEqual(len(quitLines), 1)
+        self.assertMessageMatch(quitLines[0], params=[StrRe(".*three out.*")])

irctest/server_tests/buffering.py

@@ -0,0 +1,134 @@
+"""Sends packets with various length to check the server reassembles them
+correctly. Also checks truncation"""
+
+import socket
+import time
+
+import pytest
+
+from irctest import cases
+from irctest.irc_utils import message_parser
+from irctest.numerics import ERR_INPUTTOOLONG
+from irctest.patma import ANYSTR
+
+
+def _sendWhole(self, line):
+    print("(repr) 1 -> S", repr(line.encode()))
+    self.clients[1].conn.sendall(line.encode())
+
+
+def _sendCharPerChar(self, line):
+    print("(repr) 1 -> S", repr(line.encode()))
+    for char in line:
+        self.clients[1].conn.sendall(char.encode())
+
+
+def _sendBytePerByte(self, line):
+    print("(repr) 1 -> S", repr(line.encode()))
+    for byte in line.encode():
+        self.clients[1].conn.sendall(bytes([byte]))
+
+
+class BufferingTestCase(cases.BaseServerTestCase):
+    @pytest.mark.parametrize(
+        "sender_function,colon",
+        [
+            pytest.param(_sendWhole, "", id="whole-no colon"),
+            pytest.param(_sendCharPerChar, "", id="charperchar-no colon"),
+            pytest.param(_sendBytePerByte, "", id="byteperbyte-no colon"),
+            pytest.param(_sendWhole, ":", id="whole-colon"),
+            pytest.param(_sendCharPerChar, ":", id="charperchar-colon"),
+            pytest.param(_sendBytePerByte, ":", id="byteperbyte-colon"),
+        ],
+    )
+    def testNoTags(self, sender_function, colon):
+        self.connectClient("nick1")
+        self.connectClient("nick2")
+
+        overhead = self.get_overhead(1, 2, colon=colon)
+        print(f"overhead is {overhead}")
+
+        line = f"PRIVMSG nick2 {colon}"
+        remaining_size = 512 - len(line) - len("\r\n")
+        emoji_size = len("😃".encode())
+        payloads = [
+            # one byte:
+            "a",
+            # one multi-byte char:
+            "😃",
+            # full payload, will be truncated
+            "a" * remaining_size,
+            "a" * (remaining_size - emoji_size) + "😃",
+            # full payload to recipient:
+            "a" * (remaining_size - overhead),
+            "a" * (remaining_size - emoji_size - overhead) + "😃",
+            # full payload to recipient plus one byte:
+            "a" * (remaining_size - overhead + 1),
+            "a" * (remaining_size - emoji_size - overhead + 1) + "😃",
+            # full payload to recipient plus two bytes:
+            "a" * (remaining_size - emoji_size - overhead + 1) + "😃",
+        ]
+        for payload in payloads:
+            sender_function(self, line + payload + "\r\n")
+            messages = self.getMessages(1)
+            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"),
+                    512 - overhead,
+                    "Got ERR_INPUTTOOLONG for a messag that should fit "
+                    "withing 512 characters.",
+                )
+                continue
+
+            received_line = self._getLine(2)
+            print("(repr) S -> 2", repr(received_line))
+            try:
+                decoded_line = received_line.decode()
+            except UnicodeDecodeError:
+                # server truncated a byte off the emoji at the end
+                if "UTF8ONLY" in self.server_support:
+                    # https://github.com/ircv3/ircv3-specifications/pull/432
+                    raise self.failureException(
+                        f"Server advertizes UTF8ONLY, but sent an invalid UTF8 "
+                        f"message: {received_line!r}"
+                    )
+                payload_intact = False
+            else:
+                msg = message_parser.parse_message(decoded_line)
+                self.assertMessageMatch(
+                    msg, command="PRIVMSG", params=["nick2", ANYSTR]
+                )
+                payload_intact = msg.params[1] == payload
+            if not payload_intact:
+                # truncated
+                self.assertLessEqual(len(received_line), 512, received_line)
+                if received_line.endswith(b"[CUT]\r\n"):
+                    # ngircd
+                    received_line = received_line[0:-7] + b"\r\n"
+                self.assertTrue(
+                    payload.encode().startswith(
+                        received_line.split(b" ")[-1].strip().lstrip(b":")
+                    ),
+                    f"expected payload to be a prefix of {payload!r}, "
+                    f"but got {payload!r}",
+                )
+
+    def get_overhead(self, client1, client2, colon):
+        self.sendLine(client1, f"PRIVMSG nick2 {colon}a\r\n")
+        line = self._getLine(client2)
+        return len(line) - len(f"PRIVMSG nick2 {colon}a\r\n")
+
+    def _getLine(self, client) -> bytes:
+        line = b""
+        for _ in range(30):
+            try:
+                data = self.clients[client].conn.recv(4096)
+            except socket.timeout:
+                data = b""
+            line += data
+            if data.endswith(b"\r\n"):
+                return line
+            time.sleep(0.1)
+            print(f"{client}: Waiting...")
+        return line

irctest/server_tests/cap.py

@@ -0,0 +1,174 @@
+from irctest import cases
+from irctest.patma import ANYSTR
+from irctest.runner import CapabilityNotSupported, ImplementationChoice
+
+
+class CapTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    @cases.mark_specifications("IRCv3")
+    def testNoReq(self):
+        """Test the server handles gracefully clients which do not send
+        REQs.
+
+        “Clients that support capabilities but do not wish to enter
+        negotiation SHOULD send CAP END upon connection to the server.”
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-end-subcommand>
+        """  # noqa
+        self.addClient(1)
+        self.sendLine(1, "CAP LS 302")
+        self.getCapLs(1)
+        self.sendLine(1, "USER foo foo foo :foo")
+        self.sendLine(1, "NICK foo")
+        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 testReqUnavailable(self):
+        """Test the server handles gracefully clients which request
+        capabilities that are not available.
+        <http://ircv3.net/specs/core/capability-negotiation-3.1.html>
+        """
+        self.addClient(1)
+        self.sendLine(1, "CAP LS 302")
+        self.getCapLs(1)
+        self.sendLine(1, "USER foo foo foo :foo")
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "CAP REQ :foo")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "NAK", "foo"],
+            fail_msg="Expected CAP NAK after requesting non-existing "
+            "capability, 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")
+    def testNakExactString(self):
+        """“The argument of the NAK subcommand MUST consist of at least the
+        first 100 characters of the capability list in the REQ subcommand which
+        triggered the NAK.”
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-nak-subcommand>
+        """  # noqa
+        self.addClient(1)
+        self.sendLine(1, "CAP LS 302")
+        self.getCapLs(1)
+        # Five should be enough to check there is no reordering, even
+        # alphabetical
+        self.sendLine(1, "CAP REQ :foo qux bar baz qux quux")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "NAK", "foo qux bar baz qux quux"],
+            fail_msg="Expected “CAP NAK :foo qux bar baz qux quux” after "
+            "sending “CAP REQ :foo qux bar baz qux quux”, but got {msg}.",
+        )
+
+    @cases.mark_specifications("IRCv3")
+    def testNakWhole(self):
+        """“The capability identifier set must be accepted as a whole, or
+        rejected entirely.”
+        -- <http://ircv3.net/specs/core/capability-negotiation-3.1.html#the-cap-req-subcommand>
+        """  # noqa
+        self.addClient(1)
+        self.sendLine(1, "CAP LS 302")
+        self.assertIn("multi-prefix", self.getCapLs(1))
+        self.sendLine(1, "CAP REQ :foo multi-prefix bar")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "NAK", "foo multi-prefix bar"],
+            fail_msg="Expected “CAP NAK :foo multi-prefix bar” after "
+            "sending “CAP REQ :foo multi-prefix bar”, but got {msg}.",
+        )
+        self.sendLine(1, "CAP REQ :multi-prefix bar")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "NAK", "multi-prefix bar"],
+            fail_msg="Expected “CAP NAK :multi-prefix bar” after "
+            "sending “CAP REQ :multi-prefix bar”, but got {msg}.",
+        )
+        self.sendLine(1, "CAP REQ :foo multi-prefix")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "NAK", "foo multi-prefix"],
+            fail_msg="Expected “CAP NAK :foo multi-prefix” after "
+            "sending “CAP REQ :foo multi-prefix”, but got {msg}.",
+        )
+        # TODO: make sure multi-prefix is not enabled at this point
+        self.sendLine(1, "CAP REQ :multi-prefix")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="CAP",
+            params=[ANYSTR, "ACK", "multi-prefix"],
+            fail_msg="Expected “CAP ACK :multi-prefix” after "
+            "sending “CAP REQ :multi-prefix”, but got {msg}.",
+        )
+
+    @cases.mark_specifications("IRCv3")
+    def testCapRemovalByClient(self):
+        """Test CAP LIST and removal of caps via CAP REQ :-tagname."""
+        cap1 = "echo-message"
+        cap2 = "server-time"
+        self.addClient(1)
+        self.connectClient("sender")
+        self.sendLine(1, "CAP LS 302")
+        m = self.getRegistrationMessage(1)
+        if not ({cap1, cap2} <= set(m.params[2].split())):
+            raise CapabilityNotSupported(f"{cap1} or {cap2}")
+        self.sendLine(1, f"CAP REQ :{cap1} {cap2}")
+        self.sendLine(1, "nick bar")
+        self.sendLine(1, "user user 0 * realname")
+        self.sendLine(1, "CAP END")
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(m, command="CAP", params=[ANYSTR, "ACK", ANYSTR])
+        self.assertEqual(
+            set(m.params[2].split()), {cap1, cap2}, "Didn't ACK both REQed caps"
+        )
+        self.skipToWelcome(1)
+
+        self.sendLine(1, "CAP LIST")
+        messages = self.getMessages(1)
+        cap_list = [m for m in messages if m.command == "CAP"][0]
+        enabled_caps = set(cap_list.params[2].split())
+        enabled_caps.discard("cap-notify")  # implicitly added by some impls
+        self.assertEqual(enabled_caps, {cap1, cap2})
+
+        self.sendLine(2, "PRIVMSG bar :hi")
+        self.getMessages(2)  # Synchronize
+
+        m = self.getMessage(1)
+        self.assertIn("time", m.tags, m)
+
+        # 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(m, command="CAP", params=[ANYSTR, "ACK", f"-{cap2}"]):
+            self.assertMessageMatch(
+                m, command="CAP", params=[ANYSTR, "NAK", f"-{cap2}"]
+            )
+            raise ImplementationChoice(f"Does not support CAP REQ -{cap2}")
+
+        # 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]
+        enabled_caps = set(cap_list.params[2].split())
+        enabled_caps.discard("cap-notify")  # implicitly added by some impls
+        self.assertEqual(enabled_caps, {cap1})
+        self.assertNotIn("time", cap_list.tags)

irctest/server_tests/channel.py

@@ -0,0 +1,61 @@
+import pytest
+
+from irctest import cases, client_mock, runner
+
+
+class ChannelCaseSensitivityTestCase(cases.BaseServerTestCase):
+    @pytest.mark.parametrize(
+        "casemapping,name1,name2",
+        [
+            ("ascii", "#Foo", "#foo"),
+            ("rfc1459", "#Foo", "#foo"),
+            ("rfc1459", "#F]|oo{", "#f}\\oo["),
+            ("rfc1459", "#F}o\\o[", "#f]o|o{"),
+        ],
+    )
+    @cases.mark_specifications("RFC1459", "RFC2812", strict=True)
+    def testChannelsEquivalent(self, casemapping, name1, name2):
+        self.connectClient("foo")
+        self.connectClient("bar")
+        if self.server_support["CASEMAPPING"] != casemapping:
+            raise runner.NotImplementedByController(
+                "Casemapping {} not implemented".format(casemapping)
+            )
+        self.joinClient(1, name1)
+        self.joinClient(2, name2)
+        try:
+            m = self.getMessage(1)
+            self.assertMessageMatch(m, command="JOIN", nick="bar")
+        except client_mock.NoMessageException:
+            raise AssertionError(
+                "Channel names {} and {} are not equivalent.".format(name1, name2)
+            )
+
+    @pytest.mark.parametrize(
+        "casemapping,name1,name2",
+        [
+            ("ascii", "#Foo", "#fooa"),
+            ("rfc1459", "#Foo", "#fooa"),
+        ],
+    )
+    @cases.mark_specifications("RFC1459", "RFC2812", strict=True)
+    def testChannelsNotEquivalent(self, casemapping, name1, name2):
+        self.connectClient("foo")
+        self.connectClient("bar")
+        if self.server_support["CASEMAPPING"] != casemapping:
+            raise runner.NotImplementedByController(
+                "Casemapping {} not implemented".format(casemapping)
+            )
+        self.joinClient(1, name1)
+        self.joinClient(2, name2)
+        try:
+            m = self.getMessage(1)
+        except client_mock.NoMessageException:
+            pass
+        else:
+            self.assertMessageMatch(
+                m, command="JOIN", nick="bar"
+            )  # This should always be true
+            raise AssertionError(
+                "Channel names {} and {} are equivalent.".format(name1, name2)
+            )

irctest/server_tests/channel_forward.py

@@ -0,0 +1,52 @@
+from irctest import cases
+from irctest.numerics import ERR_CHANOPRIVSNEEDED, ERR_INVALIDMODEPARAM, ERR_LINKCHANNEL
+
+MODERN_CAPS = [
+    "server-time",
+    "message-tags",
+    "batch",
+    "labeled-response",
+    "echo-message",
+    "account-tag",
+]
+
+
+class ChannelForwardingTestCase(cases.BaseServerTestCase):
+    """Test the +f channel forwarding mode."""
+
+    @cases.mark_specifications("Ergo")
+    def testChannelForwarding(self):
+        self.connectClient("bar", name="bar", capabilities=MODERN_CAPS)
+        self.connectClient("baz", name="baz", capabilities=MODERN_CAPS)
+        self.joinChannel("bar", "#bar")
+        self.joinChannel("bar", "#bar_two")
+        self.joinChannel("baz", "#baz")
+
+        self.sendLine("bar", "MODE #bar +f #nonexistent")
+        msg = self.getMessage("bar")
+        self.assertMessageMatch(msg, command=ERR_INVALIDMODEPARAM)
+
+        # need chanops in the target channel as well
+        self.sendLine("bar", "MODE #bar +f #baz")
+        responses = set(msg.command for msg in self.getMessages("bar"))
+        self.assertIn(ERR_CHANOPRIVSNEEDED, responses)
+
+        self.sendLine("bar", "MODE #bar +f #bar_two")
+        msg = self.getMessage("bar")
+        self.assertMessageMatch(msg, command="MODE", params=["#bar", "+f", "#bar_two"])
+
+        # can still join the channel fine
+        self.joinChannel("baz", "#bar")
+        self.sendLine("baz", "PART #bar")
+        self.getMessages("baz")
+
+        # now make it invite-only, which should cause forwarding
+        self.sendLine("bar", "MODE #bar +i")
+        self.getMessages("bar")
+
+        self.sendLine("baz", "JOIN #bar")
+        msgs = self.getMessages("baz")
+        forward = [msg for msg in msgs if msg.command == ERR_LINKCHANNEL]
+        self.assertEqual(forward[0].params[:3], ["baz", "#bar", "#bar_two"])
+        join = [msg for msg in msgs if msg.command == "JOIN"]
+        self.assertMessageMatch(join[0], params=["#bar_two"])

irctest/server_tests/channel_rename.py

@@ -0,0 +1,59 @@
+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"
+
+
+class ChannelRenameTestCase(cases.BaseServerTestCase):
+    """Basic tests for channel-rename."""
+
+    @cases.mark_specifications("Ergo")
+    def testChannelRename(self):
+        self.connectClient("bar", name="bar", capabilities=MODERN_CAPS + [RENAME_CAP])
+        self.connectClient("baz", name="baz", capabilities=MODERN_CAPS)
+        self.joinChannel("bar", "#bar")
+        self.joinChannel("baz", "#bar")
+        self.getMessages("bar")
+        self.getMessages("baz")
+
+        self.sendLine("bar", "RENAME #bar #qux :no reason")
+        self.assertMessageMatch(
+            self.getMessage("bar"),
+            command="RENAME",
+            params=["#bar", "#qux", "no reason"],
+        )
+        legacy_responses = self.getMessages("baz")
+        self.assertEqual(
+            1,
+            len(
+                [
+                    msg
+                    for msg in legacy_responses
+                    if msg.command == "PART" and msg.params[0] == "#bar"
+                ]
+            ),
+        )
+        self.assertEqual(
+            1,
+            len(
+                [
+                    msg
+                    for msg in legacy_responses
+                    if msg.command == "JOIN" and msg.params == ["#qux"]
+                ]
+            ),
+        )
+
+        self.joinChannel("baz", "#bar")
+        self.sendLine("baz", "MODE #bar +k beer")
+        self.assertNotIn(
+            ERR_CHANOPRIVSNEEDED, [msg.command for msg in self.getMessages("baz")]
+        )

irctest/server_tests/chathistory.py

@@ -0,0 +1,707 @@
+import secrets
+import time
+
+import pytest
+
+from irctest import cases
+from irctest.irc_utils.junkdrawer import random_name
+from irctest.patma import ANYSTR
+
+CHATHISTORY_CAP = "draft/chathistory"
+EVENT_PLAYBACK_CAP = "draft/event-playback"
+
+# Keep this in sync with validate_chathistory()
+SUBCOMMANDS = ["LATEST", "BEFORE", "AFTER", "BETWEEN", "AROUND"]
+
+MYSQL_PASSWORD = ""
+
+
+def validate_chathistory_batch(msgs):
+    batch_tag = None
+    closed_batch_tag = None
+    result = []
+    for msg in msgs:
+        if msg.command == "BATCH":
+            batch_param = msg.params[0]
+            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):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(chathistory=True)
+
+    def testInvalidTargets(self):
+        bar, pw = random_name("bar"), random_name("pw")
+        self.controller.registerUser(self, bar, pw)
+        self.connectClient(
+            bar,
+            name=bar,
+            capabilities=[
+                "batch",
+                "labeled-response",
+                "message-tags",
+                "server-time",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password=pw,
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(bar)
+
+        qux = random_name("qux")
+        real_chname = random_name("#real_channel")
+        self.connectClient(qux, name=qux)
+        self.joinChannel(qux, real_chname)
+        self.getMessages(qux)
+
+        # test a nonexistent channel
+        self.sendLine(bar, "CHATHISTORY LATEST #nonexistent_channel * 10")
+        msgs = self.getMessages(bar)
+        msgs = [msg for msg in msgs if msg.command != "MODE"]  # :NickServ MODE +r
+        self.assertMessageMatch(
+            msgs[0],
+            command="FAIL",
+            params=["CHATHISTORY", "INVALID_TARGET", "LATEST", ANYSTR, ANYSTR],
+        )
+
+        # as should a real channel to which one is not joined:
+        self.sendLine(bar, "CHATHISTORY LATEST %s * 10" % (real_chname,))
+        msgs = self.getMessages(bar)
+        self.assertMessageMatch(
+            msgs[0],
+            command="FAIL",
+            params=["CHATHISTORY", "INVALID_TARGET", "LATEST", ANYSTR, ANYSTR],
+        )
+
+    @pytest.mark.private_chathistory
+    def testMessagesToSelf(self):
+        bar, pw = random_name("bar"), random_name("pw")
+        self.controller.registerUser(self, bar, pw)
+        self.connectClient(
+            bar,
+            name=bar,
+            capabilities=[
+                "batch",
+                "labeled-response",
+                "message-tags",
+                "sasl",
+                "server-time",
+                CHATHISTORY_CAP,
+            ],
+            password=pw,
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(bar)
+
+        messages = []
+
+        self.sendLine(bar, "PRIVMSG %s :this is a privmsg sent to myself" % (bar,))
+        replies = [msg for msg in self.getMessages(bar) if msg.command == "PRIVMSG"]
+        self.assertEqual(len(replies), 1)
+        msg = replies[0]
+        self.assertMessageMatch(msg, params=[bar, "this is a privmsg sent to myself"])
+        messages.append(msg.to_history_message())
+
+        self.sendLine(bar, "CAP REQ echo-message")
+        self.getMessages(bar)
+        self.sendLine(
+            bar, "PRIVMSG %s :this is a second privmsg sent to myself" % (bar,)
+        )
+        replies = [msg for msg in self.getMessages(bar) if msg.command == "PRIVMSG"]
+        # two messages, the echo and the delivery
+        self.assertEqual(len(replies), 2)
+        self.assertMessageMatch(
+            replies[0], params=[bar, "this is a second privmsg sent to myself"]
+        )
+        messages.append(replies[0].to_history_message())
+        # messages should be otherwise identical
+        self.assertEqual(
+            replies[0].to_history_message(), replies[1].to_history_message()
+        )
+
+        self.sendLine(
+            bar,
+            "@label=xyz PRIVMSG %s :this is a third privmsg sent to myself" % (bar,),
+        )
+        replies = [msg for msg in self.getMessages(bar) if msg.command == "PRIVMSG"]
+        self.assertEqual(len(replies), 2)
+        # exactly one of the replies MUST be labeled
+        echo = [msg for msg in replies if msg.tags.get("label") == "xyz"][0]
+        delivery = [msg for msg in replies if msg.tags.get("label") is None][0]
+        self.assertMessageMatch(
+            echo, params=[bar, "this is a third privmsg sent to myself"]
+        )
+        messages.append(echo.to_history_message())
+        self.assertEqual(echo.to_history_message(), delivery.to_history_message())
+
+        self.sendLine(bar, "CHATHISTORY LATEST %s * 10" % (bar,))
+        replies = [msg for msg in self.getMessages(bar) if msg.command == "PRIVMSG"]
+        self.assertEqual([msg.to_history_message() for msg in replies], messages)
+
+    def validate_echo_messages(self, num_messages, echo_messages):
+        # sanity checks: should have received the correct number of echo messages,
+        # all with distinct time tags (because we slept) and msgids
+        self.assertEqual(len(echo_messages), num_messages)
+        self.assertEqual(len(set(msg.msgid for msg in echo_messages)), num_messages)
+        self.assertEqual(len(set(msg.time for msg in echo_messages)), num_messages)
+
+    @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
+    def testChathistory(self, subcommand):
+        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, "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.validate_chathistory(subcommand, echo_messages, 1, chname)
+
+    @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
+    def testChathistoryEventPlayback(self, subcommand):
+        self.connectClient(
+            "bar",
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+                EVENT_PLAYBACK_CAP,
+            ],
+            skip_if_cap_nak=True,
+        )
+        chname = "#chan" + secrets.token_hex(12)
+        self.joinChannel(1, chname)
+        self.getMessages(1)
+
+        NUM_MESSAGES = 10
+        echo_messages = []
+        for i in range(NUM_MESSAGES):
+            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.validate_chathistory(subcommand, echo_messages, 1, chname)
+
+    @pytest.mark.parametrize("subcommand", SUBCOMMANDS)
+    @pytest.mark.private_chathistory
+    def testChathistoryDMs(self, subcommand):
+        c1 = "foo" + secrets.token_hex(12)
+        c2 = "bar" + secrets.token_hex(12)
+        self.controller.registerUser(self, c1, "sesame1")
+        self.controller.registerUser(self, c2, "sesame2")
+        self.connectClient(
+            c1,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame1",
+            skip_if_cap_nak=True,
+        )
+        self.connectClient(
+            c2,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame2",
+        )
+        self.getMessages(1)
+        self.getMessages(2)
+
+        NUM_MESSAGES = 10
+        echo_messages = []
+        for i in range(NUM_MESSAGES):
+            user = (i % 2) + 1
+            if user == 1:
+                target = c2
+            else:
+                target = c1
+            self.getMessages(user)
+            self.sendLine(user, "PRIVMSG %s :this is message %d" % (target, i))
+            echo_messages.extend(
+                msg.to_history_message() for msg in self.getMessages(user)
+            )
+            time.sleep(0.002)
+
+        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 = "baz" + secrets.token_hex(12)
+        self.connectClient(
+            c3,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                CHATHISTORY_CAP,
+            ],
+            skip_if_cap_nak=True,
+        )
+        self.sendLine(
+            1, "PRIVMSG %s :this is a message in a separate conversation" % (c3,)
+        )
+        self.getMessages(1)
+        self.sendLine(
+            3, "PRIVMSG %s :i agree that this is a separate conversation" % (c1,)
+        )
+        # 3 received the first message as a delivery and the second as an echo
+        new_convo = [
+            msg.to_history_message()
+            for msg in self.getMessages(3)
+            if msg.command == "PRIVMSG"
+        ]
+        self.assertEqual(
+            [msg.text for msg in new_convo],
+            [
+                "this is a message in a separate conversation",
+                "i agree that this is a separate conversation",
+            ],
+        )
+
+        # messages should be stored and retrievable by c1,
+        # even though c3 is not registered
+        self.getMessages(1)
+        self.sendLine(1, "CHATHISTORY LATEST %s * 10" % (c3,))
+        results = [
+            msg.to_history_message()
+            for msg in self.getMessages(1)
+            if msg.command == "PRIVMSG"
+        ]
+        self.assertEqual(results, new_convo)
+
+        # additional messages with c3 should not show up in the c1-c2 history:
+        self.validate_chathistory(subcommand, echo_messages, 1, c2)
+        self.validate_chathistory(subcommand, echo_messages, 2, c1)
+        self.validate_chathistory(subcommand, echo_messages, 2, c1.upper())
+
+        # regression test for #833
+        self.sendLine(3, "QUIT")
+        self.assertDisconnected(3)
+        # register c3 as an account, then attempt to retrieve
+        # the conversation history with c1
+        self.controller.registerUser(self, c3, "sesame3")
+        self.connectClient(
+            c3,
+            name=c3,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame3",
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(c3)
+        self.sendLine(c3, "CHATHISTORY LATEST %s * 10" % (c1,))
+        results = [
+            msg.to_history_message()
+            for msg in self.getMessages(c3)
+            if msg.command == "PRIVMSG"
+        ]
+        # should get nothing
+        self.assertEqual(results, [])
+
+    def validate_chathistory(self, subcommand, echo_messages, user, chname):
+        # Keep this list of subcommands in sync with the SUBCOMMANDS global
+        method = getattr(self, f"_validate_chathistory_{subcommand}")
+        method(echo_messages, user, chname)
+
+    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 = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages, result)
+
+        self.sendLine(user, "CHATHISTORY LATEST %s * %d" % (chname, 5))
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[-5:], result)
+
+        self.sendLine(user, "CHATHISTORY LATEST %s * %d" % (chname, 1))
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[-1:], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY LATEST %s msgid=%s %d"
+            % (chname, echo_messages[4].msgid, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[5:], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY LATEST %s timestamp=%s %d"
+            % (chname, echo_messages[4].time, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[5:], result)
+
+    def _validate_chathistory_BEFORE(self, echo_messages, user, chname):
+        INCLUSIVE_LIMIT = len(echo_messages) * 2
+        self.sendLine(
+            user,
+            "CHATHISTORY BEFORE %s msgid=%s %d"
+            % (chname, echo_messages[6].msgid, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[:6], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY BEFORE %s timestamp=%s %d"
+            % (chname, echo_messages[6].time, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[:6], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY BEFORE %s timestamp=%s %d"
+            % (chname, echo_messages[6].time, 2),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[4:6], result)
+
+    def _validate_chathistory_AFTER(self, echo_messages, user, chname):
+        INCLUSIVE_LIMIT = len(echo_messages) * 2
+        self.sendLine(
+            user,
+            "CHATHISTORY AFTER %s msgid=%s %d"
+            % (chname, echo_messages[3].msgid, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[4:], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY AFTER %s timestamp=%s %d"
+            % (chname, echo_messages[3].time, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[4:], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY AFTER %s timestamp=%s %d" % (chname, echo_messages[3].time, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[4:7], result)
+
+    def _validate_chathistory_BETWEEN(self, echo_messages, user, chname):
+        INCLUSIVE_LIMIT = len(echo_messages) * 2
+        # BETWEEN forwards and backwards
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            % (
+                chname,
+                echo_messages[0].msgid,
+                echo_messages[-1].msgid,
+                INCLUSIVE_LIMIT,
+            ),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[1:-1], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            % (
+                chname,
+                echo_messages[-1].msgid,
+                echo_messages[0].msgid,
+                INCLUSIVE_LIMIT,
+            ),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[1:-1], result)
+
+        # BETWEEN forwards and backwards with a limit, should get
+        # different results this time
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            % (chname, echo_messages[0].msgid, echo_messages[-1].msgid, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[1:4], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s msgid=%s msgid=%s %d"
+            % (chname, echo_messages[-1].msgid, echo_messages[0].msgid, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[-4:-1], result)
+
+        # same stuff again but with timestamps
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+            % (chname, echo_messages[0].time, echo_messages[-1].time, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[1:-1], result)
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+            % (chname, echo_messages[-1].time, echo_messages[0].time, INCLUSIVE_LIMIT),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[1:-1], result)
+        self.sendLine(
+            user,
+            "CHATHISTORY BETWEEN %s timestamp=%s timestamp=%s %d"
+            % (chname, echo_messages[0].time, echo_messages[-1].time, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        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 = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[-4:-1], result)
+
+    def _validate_chathistory_AROUND(self, echo_messages, user, chname):
+        self.sendLine(
+            user,
+            "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)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY AROUND %s msgid=%s %d" % (chname, echo_messages[7].msgid, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertEqual(echo_messages[6:9], result)
+
+        self.sendLine(
+            user,
+            "CHATHISTORY AROUND %s timestamp=%s %d"
+            % (chname, echo_messages[7].time, 3),
+        )
+        result = validate_chathistory_batch(self.getMessages(user))
+        self.assertIn(echo_messages[7], result)
+
+    @pytest.mark.arbitrary_client_tags
+    def testChathistoryTagmsg(self):
+        c1 = "foo" + secrets.token_hex(12)
+        c2 = "bar" + secrets.token_hex(12)
+        chname = "#chan" + secrets.token_hex(12)
+        self.controller.registerUser(self, c1, "sesame1")
+        self.controller.registerUser(self, c2, "sesame2")
+        self.connectClient(
+            c1,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+                EVENT_PLAYBACK_CAP,
+            ],
+            password="sesame1",
+            skip_if_cap_nak=True,
+        )
+        self.connectClient(
+            c2,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame2",
+        )
+        self.joinChannel(1, chname)
+        self.joinChannel(2, chname)
+        self.getMessages(1)
+        self.getMessages(2)
+
+        self.sendLine(
+            1, "@+client-only-tag-test=success;+draft/persist TAGMSG %s" % (chname,)
+        )
+        echo = self.getMessages(1)[0]
+        msgid = echo.tags["msgid"]
+
+        def validate_tagmsg(msg, target, msgid):
+            self.assertMessageMatch(msg, command="TAGMSG", params=[target])
+            self.assertEqual(msg.tags["+client-only-tag-test"], "success")
+            self.assertEqual(msg.tags["msgid"], msgid)
+
+        validate_tagmsg(echo, chname, msgid)
+
+        relay = self.getMessages(2)
+        self.assertEqual(len(relay), 1)
+        validate_tagmsg(relay[0], chname, msgid)
+
+        self.sendLine(1, "CHATHISTORY LATEST %s * 10" % (chname,))
+        history_tagmsgs = [
+            msg for msg in self.getMessages(1) if msg.command == "TAGMSG"
+        ]
+        self.assertEqual(len(history_tagmsgs), 1)
+        validate_tagmsg(history_tagmsgs[0], chname, msgid)
+
+        # c2 doesn't have event-playback and MUST NOT receive replayed tagmsg
+        self.sendLine(2, "CHATHISTORY LATEST %s * 10" % (chname,))
+        history_tagmsgs = [
+            msg for msg in self.getMessages(2) if msg.command == "TAGMSG"
+        ]
+        self.assertEqual(len(history_tagmsgs), 0)
+
+        # now try a DM
+        self.sendLine(
+            1, "@+client-only-tag-test=success;+draft/persist TAGMSG %s" % (c2,)
+        )
+        echo = self.getMessages(1)[0]
+        msgid = echo.tags["msgid"]
+        validate_tagmsg(echo, c2, msgid)
+
+        relay = self.getMessages(2)
+        self.assertEqual(len(relay), 1)
+        validate_tagmsg(relay[0], c2, msgid)
+
+        self.sendLine(1, "CHATHISTORY LATEST %s * 10" % (c2,))
+        history_tagmsgs = [
+            msg for msg in self.getMessages(1) if msg.command == "TAGMSG"
+        ]
+        self.assertEqual(len(history_tagmsgs), 1)
+        validate_tagmsg(history_tagmsgs[0], c2, msgid)
+
+        # c2 doesn't have event-playback and MUST NOT receive replayed tagmsg
+        self.sendLine(2, "CHATHISTORY LATEST %s * 10" % (c1,))
+        history_tagmsgs = [
+            msg for msg in self.getMessages(2) if msg.command == "TAGMSG"
+        ]
+        self.assertEqual(len(history_tagmsgs), 0)
+
+    @pytest.mark.arbitrary_client_tags
+    @pytest.mark.private_chathistory
+    def testChathistoryDMClientOnlyTags(self):
+        # regression test for Ergo #1411
+        c1 = "foo" + secrets.token_hex(12)
+        c2 = "bar" + secrets.token_hex(12)
+        self.controller.registerUser(self, c1, "sesame1")
+        self.controller.registerUser(self, c2, "sesame2")
+        self.connectClient(
+            c1,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame1",
+            skip_if_cap_nak=True,
+        )
+        self.connectClient(
+            c2,
+            capabilities=[
+                "message-tags",
+                "server-time",
+                "echo-message",
+                "batch",
+                "labeled-response",
+                "sasl",
+                CHATHISTORY_CAP,
+            ],
+            password="sesame2",
+        )
+        self.getMessages(1)
+        self.getMessages(2)
+
+        echo_msgid = None
+
+        def validate_msg(msg):
+            self.assertMessageMatch(msg, command="PRIVMSG", params=[c2, "hi"])
+            self.assertEqual(msg.tags["+client-only-tag-test"], "success")
+            self.assertEqual(msg.tags["msgid"], echo_msgid)
+
+        self.sendLine(
+            1, "@+client-only-tag-test=success;+draft/persist PRIVMSG %s hi" % (c2,)
+        )
+        echo = self.getMessage(1)
+        echo_msgid = echo.tags["msgid"]
+        validate_msg(echo)
+        relay = self.getMessage(2)
+        validate_msg(relay)
+
+
+assert {f"_validate_chathistory_{cmd}" for cmd in SUBCOMMANDS} == {
+    meth_name
+    for meth_name in dir(ChathistoryTestCase)
+    if meth_name.startswith("_validate_chathistory_")
+}, "ChathistoryTestCase.validate_chathistory and SUBCOMMANDS are out of sync"

irctest/server_tests/chmodes/auditorium.py

@@ -0,0 +1,127 @@
+import math
+import time
+
+from irctest import cases
+from irctest.irc_utils.junkdrawer import ircv3_timestamp_to_unixtime
+from irctest.numerics import RPL_NAMREPLY
+
+MODERN_CAPS = [
+    "server-time",
+    "message-tags",
+    "batch",
+    "labeled-response",
+    "echo-message",
+    "account-tag",
+]
+
+
+class AuditoriumTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testAuditorium(self):
+        self.connectClient("bar", name="bar", capabilities=MODERN_CAPS)
+        self.joinChannel("bar", "#auditorium")
+        self.getMessages("bar")
+        self.sendLine("bar", "MODE #auditorium +u")
+        modelines = [msg for msg in self.getMessages("bar") if msg.command == "MODE"]
+        self.assertEqual(len(modelines), 1)
+        self.assertMessageMatch(modelines[0], params=["#auditorium", "+u"])
+
+        self.connectClient("guest1", name="guest1", capabilities=MODERN_CAPS)
+        self.joinChannel("guest1", "#auditorium")
+        self.getMessages("guest1")
+        # chanop should get a JOIN message
+        join_msgs = [msg for msg in self.getMessages("bar") if msg.command == "JOIN"]
+        self.assertEqual(len(join_msgs), 1)
+        self.assertMessageMatch(join_msgs[0], nick="guest1", params=["#auditorium"])
+
+        self.connectClient("guest2", name="guest2", capabilities=MODERN_CAPS)
+        self.joinChannel("guest2", "#auditorium")
+        self.getMessages("guest2")
+        # chanop should get a JOIN message
+        join_msgs = [msg for msg in self.getMessages("bar") if msg.command == "JOIN"]
+        self.assertEqual(len(join_msgs), 1)
+        join_msg = join_msgs[0]
+        self.assertMessageMatch(join_msg, nick="guest2", params=["#auditorium"])
+        # oragono/oragono#1642 ; msgid should be populated,
+        # and the time tag should be sane
+        self.assertTrue(join_msg.tags.get("msgid"))
+        self.assertLessEqual(
+            math.fabs(time.time() - ircv3_timestamp_to_unixtime(join_msg.tags["time"])),
+            60.0,
+        )
+        # fellow unvoiced participant should not
+        unvoiced_join_msgs = [
+            msg for msg in self.getMessages("guest1") if msg.command == "JOIN"
+        ]
+        self.assertEqual(len(unvoiced_join_msgs), 0)
+
+        self.connectClient("guest3", name="guest3", capabilities=MODERN_CAPS)
+        self.joinChannel("guest3", "#auditorium")
+        self.getMessages("guest3")
+
+        self.sendLine("bar", "PRIVMSG #auditorium hi")
+        echo_message = [
+            msg for msg in self.getMessages("bar") if msg.command == "PRIVMSG"
+        ][0]
+        self.assertEqual(echo_message, self.getMessages("guest1")[0])
+        self.assertEqual(echo_message, self.getMessages("guest2")[0])
+        self.assertEqual(echo_message, self.getMessages("guest3")[0])
+
+        # unvoiced users can speak
+        self.sendLine("guest1", "PRIVMSG #auditorium :hi you")
+        echo_message = [
+            msg for msg in self.getMessages("guest1") if msg.command == "PRIVMSG"
+        ][0]
+        self.assertEqual(self.getMessages("bar"), [echo_message])
+        self.assertEqual(self.getMessages("guest2"), [echo_message])
+        self.assertEqual(self.getMessages("guest3"), [echo_message])
+
+        def names(client):
+            self.sendLine(client, "NAMES #auditorium")
+            result = set()
+            for msg in self.getMessages(client):
+                if msg.command == RPL_NAMREPLY:
+                    result.update(msg.params[-1].split())
+            return result
+
+        self.assertEqual(names("bar"), {"@bar", "guest1", "guest2", "guest3"})
+        self.assertEqual(names("guest1"), {"@bar"})
+        self.assertEqual(names("guest2"), {"@bar"})
+        self.assertEqual(names("guest3"), {"@bar"})
+
+        self.sendLine("bar", "MODE #auditorium +v guest1")
+        modeLine = [msg for msg in self.getMessages("bar") if msg.command == "MODE"][0]
+        self.assertEqual(self.getMessages("guest1"), [modeLine])
+        self.assertEqual(self.getMessages("guest2"), [modeLine])
+        self.assertEqual(self.getMessages("guest3"), [modeLine])
+        self.assertEqual(names("bar"), {"@bar", "+guest1", "guest2", "guest3"})
+        self.assertEqual(names("guest2"), {"@bar", "+guest1"})
+        self.assertEqual(names("guest3"), {"@bar", "+guest1"})
+
+        self.sendLine("guest1", "PART #auditorium")
+        part = [msg for msg in self.getMessages("guest1") if msg.command == "PART"][0]
+        # everyone should see voiced PART
+        self.assertEqual(self.getMessages("bar")[0], part)
+        self.assertEqual(self.getMessages("guest2")[0], part)
+        self.assertEqual(self.getMessages("guest3")[0], part)
+
+        self.joinChannel("guest1", "#auditorium")
+        self.getMessages("guest1")
+        self.getMessages("bar")
+
+        self.sendLine("guest2", "PART #auditorium")
+        part = [msg for msg in self.getMessages("guest2") if msg.command == "PART"][0]
+        self.assertEqual(self.getMessages("bar"), [part])
+        # part should be hidden from unvoiced participants
+        self.assertEqual(self.getMessages("guest1"), [])
+        self.assertEqual(self.getMessages("guest3"), [])
+
+        self.sendLine("guest3", "QUIT")
+        self.assertDisconnected("guest3")
+        # quit should be hidden from unvoiced participants
+        self.assertEqual(
+            len([msg for msg in self.getMessages("bar") if msg.command == "QUIT"]), 1
+        )
+        self.assertEqual(
+            len([msg for msg in self.getMessages("guest1") if msg.command == "QUIT"]), 0
+        )

irctest/server_tests/chmodes/ban.py

@@ -0,0 +1,45 @@
+from irctest import cases
+from irctest.numerics import ERR_BANNEDFROMCHAN
+
+
+class BanModeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testBan(self):
+        """Basic ban operation"""
+        self.connectClient("chanop", name="chanop")
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", "MODE #chan +b bar!*@*")
+        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
+
+        self.connectClient("Bar", name="bar")
+        self.getMessages("bar")
+        self.sendLine("bar", "JOIN #chan")
+        self.assertMessageMatch(self.getMessage("bar"), command=ERR_BANNEDFROMCHAN)
+
+        self.sendLine("chanop", "MODE #chan -b bar!*@*")
+        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
+
+        self.sendLine("bar", "JOIN #chan")
+        self.assertMessageMatch(self.getMessage("bar"), command="JOIN")
+
+    @cases.mark_specifications("Ergo")
+    def testCaseInsensitive(self):
+        """Some clients allow unsetting modes if their argument matches
+        up to normalization"""
+        self.connectClient("chanop", name="chanop")
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", "MODE #chan +b BAR!*@*")
+        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
+
+        self.connectClient("Bar", name="bar")
+        self.getMessages("bar")
+        self.sendLine("bar", "JOIN #chan")
+        self.assertMessageMatch(self.getMessage("bar"), command=ERR_BANNEDFROMCHAN)
+
+        self.sendLine("chanop", "MODE #chan -b bar!*@*")
+        self.assertMessageMatch(self.getMessage("chanop"), command="MODE")
+
+        self.sendLine("bar", "JOIN #chan")
+        self.assertMessageMatch(self.getMessage("bar"), command="JOIN")

irctest/server_tests/chmodes/ergo.py

@@ -0,0 +1,124 @@
+from irctest import cases
+from irctest.numerics import ERR_CANNOTSENDTOCHAN, ERR_CHANOPRIVSNEEDED
+
+MODERN_CAPS = [
+    "server-time",
+    "message-tags",
+    "batch",
+    "labeled-response",
+    "echo-message",
+    "account-tag",
+]
+
+
+@cases.mark_services
+class RegisteredOnlySpeakModeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testRegisteredOnlySpeakMode(self):
+        self.controller.registerUser(self, "evan", "sesame")
+
+        # test the +M (only registered users and ops can speak) channel mode
+        self.connectClient("chanop", name="chanop")
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", "MODE #chan +M")
+        replies = self.getMessages("chanop")
+        modeLines = [line for line in replies if line.command == "MODE"]
+        self.assertMessageMatch(modeLines[0], command="MODE", params=["#chan", "+M"])
+
+        self.connectClient("baz", name="baz")
+        self.joinChannel("baz", "#chan")
+        self.getMessages("chanop")
+        # this message should be suppressed completely by +M
+        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"), [])
+
+        # +v exempts users from the registration requirement:
+        self.sendLine("chanop", "MODE #chan +v baz")
+        self.getMessages("chanop")
+        self.getMessages("baz")
+        self.sendLine("baz", "PRIVMSG #chan :hi again from baz")
+        replies = self.getMessages("baz")
+        # baz should not receive an error (or an echo)
+        self.assertEqual(replies, [])
+        replies = self.getMessages("chanop")
+        self.assertMessageMatch(
+            replies[0], command="PRIVMSG", params=["#chan", "hi again from baz"]
+        )
+
+        self.connectClient(
+            "evan",
+            name="evan",
+            account="evan",
+            password="sesame",
+            capabilities=["sasl"],
+        )
+        self.joinChannel("evan", "#chan")
+        self.getMessages("baz")
+        self.sendLine("evan", "PRIVMSG #chan :hi from evan")
+        replies = self.getMessages("evan")
+        # evan should not receive an error (or an echo)
+        self.assertEqual(replies, [])
+        replies = self.getMessages("baz")
+        self.assertMessageMatch(
+            replies[0], command="PRIVMSG", params=["#chan", "hi from evan"]
+        )
+
+
+class OpModeratedTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testOpModerated(self):
+        # test the +U channel mode
+        self.connectClient("chanop", name="chanop", capabilities=MODERN_CAPS)
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", "MODE #chan +U")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.connectClient("baz", name="baz", capabilities=MODERN_CAPS)
+        self.joinChannel("baz", "#chan")
+        self.sendLine("baz", "PRIVMSG #chan :hi from baz")
+        echo = self.getMessages("baz")[0]
+        self.assertMessageMatch(
+            echo, command="PRIVMSG", params=["#chan", "hi from baz"]
+        )
+        self.assertEqual(
+            [msg for msg in self.getMessages("chanop") if msg.command == "PRIVMSG"],
+            [echo],
+        )
+
+        self.connectClient("qux", name="qux", capabilities=MODERN_CAPS)
+        self.joinChannel("qux", "#chan")
+        self.sendLine("qux", "PRIVMSG #chan :hi from qux")
+        echo = self.getMessages("qux")[0]
+        self.assertMessageMatch(
+            echo, command="PRIVMSG", params=["#chan", "hi from qux"]
+        )
+        # message is relayed to chanop but not to unprivileged
+        self.assertEqual(
+            [msg for msg in self.getMessages("chanop") if msg.command == "PRIVMSG"],
+            [echo],
+        )
+        self.assertEqual(
+            [msg for msg in self.getMessages("baz") if msg.command == "PRIVMSG"], []
+        )
+
+        self.sendLine("chanop", "MODE #chan +v qux")
+        self.getMessages("chanop")
+        self.sendLine("qux", "PRIVMSG #chan :hi again from qux")
+        echo = [msg for msg in self.getMessages("qux") if msg.command == "PRIVMSG"][0]
+        self.assertMessageMatch(
+            echo, command="PRIVMSG", params=["#chan", "hi again from qux"]
+        )
+        self.assertEqual(
+            [msg for msg in self.getMessages("chanop") if msg.command == "PRIVMSG"],
+            [echo],
+        )
+        self.assertEqual(
+            [msg for msg in self.getMessages("baz") if msg.command == "PRIVMSG"], [echo]
+        )

irctest/server_tests/chmodes/key.py

@@ -0,0 +1,134 @@
+import pytest
+
+from irctest import cases
+from irctest.numerics import (
+    ERR_BADCHANNELKEY,
+    ERR_INVALIDKEY,
+    ERR_INVALIDMODEPARAM,
+    ERR_UNKNOWNERROR,
+)
+from irctest.patma import ANYSTR
+
+
+class KeyTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testKeyNormal(self):
+        self.connectClient("bar")
+        self.joinChannel(1, "#chan")
+        self.sendLine(1, "MODE #chan +k beer")
+        self.getMessages(1)
+
+        self.connectClient("qux")
+        self.getMessages(2)
+        self.sendLine(2, "JOIN #chan")
+        reply = self.getMessages(2)
+        self.assertNotIn("JOIN", {msg.command for msg in reply})
+        self.assertIn(ERR_BADCHANNELKEY, {msg.command for msg in reply})
+
+        self.sendLine(2, "JOIN #chan beer")
+        reply = self.getMessages(2)
+        self.assertMessageMatch(reply[0], command="JOIN", params=["#chan"])
+
+    @pytest.mark.parametrize(
+        "key",
+        ["passphrase with spaces", "long" * 100, ""],
+        ids=["spaces", "long", "empty"],
+    )
+    @cases.mark_specifications("RFC2812", "Modern")
+    def testKeyValidation(self, key):
+        """
+          key        =  1*23( %x01-05 / %x07-08 / %x0C / %x0E-1F / %x21-7F )
+                  ; any 7-bit US_ASCII character,
+                  ; except NUL, CR, LF, FF, h/v TABs, and " "
+        -- https://tools.ietf.org/html/rfc2812#page-8
+
+        "Servers may validate the value (eg. to forbid spaces, as they make it harder
+        to use the key in `JOIN` messages). If the value is invalid, they SHOULD
+        return [`ERR_INVALIDMODEPARAM`](#errinvalidmodeparam-696).
+        However, clients MUST be able to handle any of the following:
+
+        * [`ERR_INVALIDMODEPARAM`](#errinvalidmodeparam-696)
+        * [`ERR_INVALIDKEY`](#errinvalidkey-525)
+        * `MODE` echoed with a different key (eg. truncated or stripped of invalid
+          characters)
+        * the key changed ignored, and no `MODE` echoed if no other mode change
+          was valid.
+        "
+        -- https://modern.ircdocs.horse/#key-channel-mode
+        -- https://github.com/ircdocs/modern-irc/pull/111
+        """
+        self.connectClient("bar")
+        self.joinChannel(1, "#chan")
+        self.sendLine(1, f"MODE #chan +k :{key}")
+
+        # The spec requires no space; but doesn't say what to do
+        # if there is one.
+        # Let's check the various alternatives
+
+        replies = self.getMessages(1)
+        self.assertNotIn(
+            ERR_UNKNOWNERROR,
+            {msg.command for msg in replies},
+            fail_msg="Sending an invalid key caused an "
+            "ERR_UNKNOWNERROR instead of being handled explicitly "
+            "(eg. ERR_INVALIDMODEPARAM or truncation): {msg}",
+        )
+
+        commands = {msg.command for msg in replies}
+        if {ERR_INVALIDMODEPARAM, ERR_INVALIDKEY} & commands:
+            # First option: ERR_INVALIDMODEPARAM (eg. Ergo) or ERR_INVALIDKEY
+            # (eg. ircu2)
+            if ERR_INVALIDMODEPARAM in commands:
+                command = [
+                    msg for msg in replies if msg.command == ERR_INVALIDMODEPARAM
+                ]
+                self.assertEqual(len(command), 1, command)
+                self.assertMessageMatch(
+                    command[0],
+                    command=ERR_INVALIDMODEPARAM,
+                    params=["bar", "#chan", "k", "*", ANYSTR],
+                )
+            return
+
+        if not replies:
+            # MODE was ignored entirely
+            self.connectClient("foo")
+            self.sendLine(2, "JOIN #chan")
+            self.assertMessageMatch(
+                self.getMessage(2), command="JOIN", params=["#chan"]
+            )
+            return
+
+        # Second and third options: truncating the key (eg. UnrealIRCd)
+        # or replacing spaces (eg. Charybdis)
+        mode_commands = [msg for msg in replies if msg.command == "MODE"]
+        self.assertGreaterEqual(
+            len(mode_commands),
+            1,
+            fail_msg="Sending an invalid key (with a space) triggered "
+            "neither ERR_UNKNOWNERROR, ERR_INVALIDMODEPARAM, ERR_INVALIDKEY, "
+            " or a MODE. Only these: {}",
+            extra_format=(replies,),
+        )
+        self.assertLessEqual(
+            len(mode_commands),
+            1,
+            fail_msg="Sending an invalid key (with a space) triggered "
+            "multiple MODE responses: {}",
+            extra_format=(replies,),
+        )
+
+        mode_command = mode_commands[0]
+        if mode_command.params == ["#chan", "+k", "passphrase"]:
+            key = "passphrase"
+        elif mode_command.params == ["#chan", "+k", "passphrasewithspaces"]:
+            key = "passphrasewithspaces"
+        elif mode_command.params[2].startswith("longlonglong"):
+            key = mode_command.params[2]
+            assert mode_command.params == ["#chan", "+k", key]
+        elif mode_command.params == ["#chan", "+k", "passphrase with spaces"]:
+            raise self.failureException("Invalid key (with a space) was not rejected.")
+
+        self.connectClient("foo")
+        self.sendLine(2, f"JOIN #chan {key}")
+        self.assertMessageMatch(self.getMessage(2), command="JOIN", params=["#chan"])

irctest/server_tests/chmodes/moderated.py

@@ -0,0 +1,37 @@
+from irctest import cases
+from irctest.numerics import ERR_CANNOTSENDTOCHAN
+
+
+class ModeratedModeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC2812")
+    def testModeratedMode(self):
+        # test the +m channel mode
+        self.connectClient("chanop", name="chanop")
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", "MODE #chan +m")
+        replies = self.getMessages("chanop")
+        modeLines = [line for line in replies if line.command == "MODE"]
+        self.assertMessageMatch(modeLines[0], command="MODE", params=["#chan", "+m"])
+
+        self.connectClient("baz", name="baz")
+        self.joinChannel("baz", "#chan")
+        self.getMessages("chanop")
+        # this message should be suppressed completely by +m
+        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"), [])
+
+        # grant +v, user should be able to send messages
+        self.sendLine("chanop", "MODE #chan +v baz")
+        self.getMessages("chanop")
+        self.getMessages("baz")
+        self.sendLine("baz", "PRIVMSG #chan :hi again from baz")
+        self.getMessages("baz")
+        relays = self.getMessages("chanop")
+        relay = relays[0]
+        self.assertMessageMatch(
+            relay, command="PRIVMSG", params=["#chan", "hi again from baz"]
+        )

irctest/server_tests/chmodes/mute_extban.py

@@ -0,0 +1,267 @@
+from irctest import cases, runner
+from irctest.numerics import ERR_CANNOTSENDTOCHAN, ERR_CHANOPRIVSNEEDED
+from irctest.patma import ANYLIST, StrRe
+
+
+class MuteExtbanTestCase(cases.BaseServerTestCase):
+    """https://defs.ircdocs.horse/defs/isupport.html#extban
+
+    It magically guesses what char the IRCd uses for mutes."""
+
+    def char(self):
+        if self.controller.extban_mute_char is None:
+            raise runner.ExtbanNotSupported("", "mute")
+        else:
+            return self.controller.extban_mute_char
+
+    @cases.mark_specifications("Ergo")
+    def testISupport(self):
+        self.connectClient(1)  # Fetches ISUPPORT
+        isupport = self.server_support
+        token = isupport["EXTBAN"]
+        prefix, comma, types = token.partition(",")
+        self.assertIn(self.char(), types, f"Missing '{self.char()}' in ISUPPORT EXTBAN")
+        self.assertEqual(prefix, "")
+        self.assertEqual(comma, ",")
+
+    @cases.mark_specifications("ircdocs")
+    def testMuteExtban(self):
+        """Basic usage of mute"""
+        self.connectClient("chanop", name="chanop")
+
+        isupport = self.server_support
+        token = isupport.get("EXTBAN", "")
+        prefix, comma, types = token.partition(",")
+        if self.char() not in types:
+            raise runner.ExtbanNotSupported(self.char(), "mute")
+
+        clients = ("chanop", "bar")
+
+        # Mute "bar"
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", f"MODE #chan +b {prefix}{self.char()}:bar!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.connectClient("bar", name="bar", capabilities=["echo-message"])
+        self.joinChannel("bar", "#chan")
+
+        for client in clients:
+            self.getMessages(client)
+
+        # "bar" sees the MODE too
+        self.sendLine("bar", "MODE #chan +b")
+        self.assertMessageMatch(
+            self.getMessage("bar"),
+            command="367",
+            params=[
+                "bar",
+                "#chan",
+                f"{prefix}{self.char()}:bar!*@*",
+                StrRe("chanop(!.*)?"),
+                *ANYLIST,
+            ],
+        )
+        self.getMessages("bar")
+
+        # "bar" talks: rejected
+        self.sendLine("bar", "PRIVMSG #chan :hi from bar")
+        replies = self.getMessages("bar")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertNotIn("PRIVMSG", replies_cmds)
+        self.assertIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(self.getMessages("chanop"), [])
+
+        # remove mute on "bar" with -b
+        self.getMessages("chanop")
+        self.sendLine("chanop", f"MODE #chan -b {prefix}{self.char()}:bar!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        # "bar" can now talk
+        self.sendLine("bar", "PRIVMSG #chan :hi again from bar")
+        replies = self.getMessages("bar")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertIn("PRIVMSG", replies_cmds)
+        self.assertNotIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(
+            self.getMessages("chanop"),
+            [msg for msg in replies if msg.command == "PRIVMSG"],
+        )
+
+    @cases.mark_specifications("ircdocs")
+    def testMuteExtbanVoiced(self):
+        """Checks +v overrides the mute"""
+        self.connectClient("chanop", name="chanop")
+
+        isupport = self.server_support
+        token = isupport.get("EXTBAN", "")
+        prefix, comma, types = token.partition(",")
+        if self.char() not in types:
+            raise runner.ExtbanNotSupported(self.char(), "mute")
+
+        clients = ("chanop", "qux")
+
+        # Mute "qux"
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", f"MODE #chan +b {prefix}{self.char()}:qux!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.connectClient(
+            "qux", name="qux", ident="evan", capabilities=["echo-message"]
+        )
+        self.joinChannel("qux", "#chan")
+
+        for client in clients:
+            self.getMessages(client)
+
+        # "qux" talks: rejected
+        self.sendLine("qux", "PRIVMSG #chan :hi from qux")
+        replies = self.getMessages("qux")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertNotIn("PRIVMSG", replies_cmds)
+        self.assertIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(self.getMessages("chanop"), [])
+
+        for client in clients:
+            self.getMessages(client)
+
+        # +v grants an exemption to +b
+        self.sendLine("chanop", "MODE #chan +v qux")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        # so "qux" can now talk
+        self.sendLine("qux", "PRIVMSG #chan :hi again from qux")
+        replies = self.getMessages("qux")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertIn("PRIVMSG", replies_cmds)
+        self.assertNotIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(
+            self.getMessages("chanop"),
+            [msg for msg in replies if msg.command == "PRIVMSG"],
+        )
+
+    @cases.mark_specifications("ircdocs")
+    def testMuteExtbanExempt(self):
+        """Checks +e overrides the mute
+
+        <https://defs.ircdocs.horse/defs/chanmodes.html#e-ban-exception>"""
+        self.connectClient("chanop", name="chanop")
+
+        isupport = self.server_support
+        token = isupport.get("EXTBAN", "")
+        prefix, comma, types = token.partition(",")
+        if self.char() not in types:
+            raise runner.ExtbanNotSupported(self.char(), "mute")
+        if "e" not in self.server_support["CHANMODES"]:
+            raise runner.ChannelModeNotSupported(self.char(), "mute")
+
+        clients = ("chanop", "qux")
+
+        # Mute "qux"
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", f"MODE #chan +b {prefix}{self.char()}:qux!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.connectClient(
+            "qux", name="qux", ident="evan", capabilities=["echo-message"]
+        )
+        self.joinChannel("qux", "#chan")
+
+        for client in clients:
+            self.getMessages(client)
+
+        # "qux" talks: rejected
+        self.sendLine("qux", "PRIVMSG #chan :hi from qux")
+        replies = self.getMessages("qux")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertNotIn("PRIVMSG", replies_cmds)
+        self.assertIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(self.getMessages("chanop"), [])
+
+        for client in clients:
+            self.getMessages(client)
+
+        # +e grants an exemption to +b
+        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)
+
+        self.getMessages("qux")
+
+        # so "qux" can now talk
+        self.sendLine("qux", "PRIVMSG #chan :thanks for mute-excepting me")
+        replies = self.getMessages("qux")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertIn("PRIVMSG", replies_cmds)
+        self.assertNotIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(
+            self.getMessages("chanop"),
+            [msg for msg in replies if msg.command == "PRIVMSG"],
+        )
+
+    @cases.mark_specifications("Ergo")
+    def testCapitalization(self):
+        """
+        Regression test for oragono #1370: mutes not correctly enforced against
+        users with capital letters in their NUH
+
+        For consistency with regular -b, which allows unsetting up to
+        normalization
+        """
+        clients = ("chanop", "bar")
+
+        self.connectClient("chanop", name="chanop")
+
+        isupport = self.server_support
+        token = isupport.get("EXTBAN", "")
+        prefix, comma, types = token.partition(",")
+
+        self.joinChannel("chanop", "#chan")
+        self.getMessages("chanop")
+        self.sendLine("chanop", f"MODE #chan +b {prefix}{self.char()}:BAR!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.connectClient("Bar", name="bar", capabilities=["echo-message"])
+        self.joinChannel("bar", "#chan")
+
+        for client in clients:
+            self.getMessages(client)
+
+        self.sendLine("bar", "PRIVMSG #chan :hi from bar")
+        replies = self.getMessages("bar")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertNotIn("PRIVMSG", replies_cmds)
+        self.assertIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(self.getMessages("chanop"), [])
+
+        # remove mute with -b
+        self.sendLine("chanop", f"MODE #chan -b {prefix}{self.char()}:bar!*@*")
+        replies = {msg.command for msg in self.getMessages("chanop")}
+        self.assertIn("MODE", replies)
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        # "bar" can talk again
+        self.sendLine("bar", "PRIVMSG #chan :hi again from bar")
+        replies = self.getMessages("bar")
+        replies_cmds = {msg.command for msg in replies}
+        self.assertIn("PRIVMSG", replies_cmds)
+        self.assertNotIn(ERR_CANNOTSENDTOCHAN, replies_cmds)
+        self.assertEqual(
+            self.getMessages("chanop"),
+            [msg for msg in replies if msg.command == "PRIVMSG"],
+        )

irctest/server_tests/confusables.py

@@ -0,0 +1,35 @@
+from irctest import cases
+from irctest.numerics import ERR_NICKNAMEINUSE, RPL_WELCOME
+
+
+@cases.mark_services
+class ConfusablesTestCase(cases.BaseServerTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"].update(
+                {"nick-reservation": {"enabled": True, "method": "strict"}}
+            )
+        )
+
+    @cases.mark_specifications("Ergo")
+    def testConfusableNicks(self):
+        self.controller.registerUser(self, "evan", "sesame")
+
+        self.addClient(1)
+        # U+0435 in place of e:
+        self.sendLine(1, "NICK еvan")
+        self.sendLine(1, "USER a 0 * a")
+        messages = self.getMessages(1)
+        commands = set(msg.command for msg in messages)
+        self.assertNotIn(RPL_WELCOME, commands)
+        self.assertIn(ERR_NICKNAMEINUSE, commands)
+
+        self.connectClient(
+            "evan", name="evan", password="sesame", capabilities=["sasl"]
+        )
+        # should be able to switch to the confusable nick
+        self.sendLine("evan", "NICK еvan")
+        messages = self.getMessages("evan")
+        commands = set(msg.command for msg in messages)
+        self.assertIn("NICK", commands)

irctest/server_tests/connection_registration.py

@@ -0,0 +1,242 @@
+"""
+Tests section 4.1 of RFC 1459.
+<https://tools.ietf.org/html/rfc1459#section-4.1>
+"""
+
+from irctest import cases
+from irctest.client_mock import ConnectionClosed
+from irctest.numerics import ERR_NEEDMOREPARAMS
+from irctest.patma import ANYSTR, StrRe
+
+
+class PasswordedConnectionRegistrationTestCase(cases.BaseServerTestCase):
+    password = "testpassword"
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testPassBeforeNickuser(self):
+        self.addClient()
+        self.sendLine(1, "PASS {}".format(self.password))
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "USER username * * :Realname")
+
+        m = self.getRegistrationMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="001",
+            fail_msg="Did not get 001 after correct PASS+NICK+USER: {msg}",
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testNoPassword(self):
+        self.addClient()
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "USER username * * :Realname")
+        m = self.getRegistrationMessage(1)
+        self.assertNotEqual(
+            m.command, "001", msg="Got 001 after NICK+USER but missing PASS"
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testWrongPassword(self):
+        self.addClient()
+        self.sendLine(1, "PASS {}".format(self.password + "garbage"))
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "USER username * * :Realname")
+        m = self.getRegistrationMessage(1)
+        self.assertNotEqual(
+            m.command, "001", msg="Got 001 after NICK+USER but incorrect PASS"
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812", strict=True)
+    def testPassAfterNickuser(self):
+        """“The password can and must be set before any attempt to register
+        the connection is made.”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.1.1>
+
+        “The optional password can and MUST be set before any attempt to
+        register the connection is made.
+        Currently this requires that user send a PASS command before
+        sending the NICK/USER combination.”
+        -- <https://tools.ietf.org/html/rfc2812#section-3.1.1>
+        """
+        self.addClient()
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "USER username * * :Realname")
+        self.sendLine(1, "PASS {}".format(self.password))
+        m = self.getRegistrationMessage(1)
+        self.assertNotEqual(m.command, "001", "Got 001 after PASS sent after NICK+USER")
+
+
+class ConnectionRegistrationTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459")
+    def testQuitDisconnects(self):
+        """“The server must close the connection to a client which sends a
+        QUIT message.”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.1.3>
+        """
+        self.connectClient("foo")
+        self.getMessages(1)
+        self.sendLine(1, "QUIT")
+        with self.assertRaises(ConnectionClosed):
+            self.getMessages(1)  # Fetch remaining messages
+            self.getMessages(1)
+
+    @cases.mark_specifications("RFC2812")
+    def testQuitErrors(self):
+        """“A client session is terminated with a quit message.  The server
+        acknowledges this by sending an ERROR message to the client.”
+        -- <https://tools.ietf.org/html/rfc2812#section-3.1.7>
+        """
+        self.connectClient("foo")
+        self.getMessages(1)
+        self.sendLine(1, "QUIT")
+        while True:
+            try:
+                new_messages = self.getMessages(1)
+                if not new_messages:
+                    break
+                commands = {m.command for m in new_messages}
+            except ConnectionClosed:
+                break
+        self.assertIn(
+            "ERROR", commands, fail_msg="Did not receive ERROR as a reply to QUIT."
+        )
+
+    def testNickCollision(self):
+        """A user connects and requests the same nickname as an already
+        registered user.
+        """
+        self.connectClient("foo")
+        self.addClient()
+        self.sendLine(2, "NICK foo")
+        self.sendLine(2, "USER username * * :Realname")
+        m = self.getRegistrationMessage(2)
+        self.assertNotEqual(
+            m.command,
+            "001",
+            "Received 001 after registering with the nick of a " "registered user.",
+        )
+
+    def testEarlyNickCollision(self):
+        """Two users register simultaneously with the same nick."""
+        self.addClient()
+        self.addClient()
+        self.sendLine(1, "NICK foo")
+        self.sendLine(2, "NICK foo")
+        self.sendLine(1, "USER username * * :Realname")
+
+        try:
+            self.sendLine(2, "USER username * * :Realname")
+        except (ConnectionClosed, ConnectionResetError):
+            # Bahamut closes the connection here
+            pass
+
+        try:
+            m1 = self.getRegistrationMessage(1)
+        except (ConnectionClosed, ConnectionResetError):
+            # Unreal closes the connection, see
+            # https://bugs.unrealircd.org/view.php?id=5950
+            command1 = None
+        else:
+            command1 = m1.command
+
+        try:
+            m2 = self.getRegistrationMessage(2)
+        except (ConnectionClosed, ConnectionResetError):
+            # ditto
+            command2 = None
+        else:
+            command2 = m2.command
+
+        self.assertNotEqual(
+            (command1, command2),
+            ("001", "001"),
+            "Two concurrently registering requesting the same nickname "
+            "both got 001.",
+        )
+
+        self.assertIn(
+            "001",
+            (command1, command2),
+            "Two concurrently registering requesting the same nickname "
+            "neither got 001.",
+        )
+
+    def testEmptyRealname(self):
+        """
+        Syntax:
+        "<client> <command> :Not enough parameters"
+        -- https://defs.ircdocs.horse/defs/numerics.html#err-needmoreparams-461
+        -- https://modern.ircdocs.horse/#errneedmoreparams-461
+
+        Use of this numeric:
+        "The minimum length of `<username>` is 1, ie. it MUST not be empty.
+        If it is empty, the server SHOULD reject the command with ERR_NEEDMOREPARAMS
+        (even an empty parameter is provided)"
+        https://github.com/ircdocs/modern-irc/issues/85
+        """
+        self.addClient()
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "USER username * * :")
+        self.assertMessageMatch(
+            self.getRegistrationMessage(1),
+            command=ERR_NEEDMOREPARAMS,
+            params=[StrRe(r"(\*|foo)"), "USER", ANYSTR],
+        )
+
+    @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}",
+        )

irctest/server_tests/echo_message.py

@@ -0,0 +1,149 @@
+"""
+<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
+
+
+class EchoMessageTestCase(cases.BaseServerTestCase):
+    @pytest.mark.parametrize(
+        "command,solo,server_time",
+        [
+            ("PRIVMSG", False, False),
+            ("PRIVMSG", True, True),
+            ("PRIVMSG", False, True),
+            ("NOTICE", False, True),
+        ],
+    )
+    @cases.mark_capabilities("echo-message")
+    def testEchoMessage(self, command, solo, server_time):
+        """<http://ircv3.net/specs/extensions/echo-message-3.2.html>"""
+        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")
+
+        # TODO: check also without this
+        self.sendLine(
+            1,
+            "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")
+
+        if not solo:
+            capabilities = ["server-time"] if server_time else None
+            self.connectClient("qux", capabilities=capabilities)
+            self.sendLine(2, "JOIN #chan")
+
+        # Synchronize and clean
+        self.getMessages(1)
+        if not solo:
+            self.getMessages(2)
+            self.getMessages(1)
+
+        self.sendLine(1, "{} #chan :hello everyone".format(command))
+        m1 = self.getMessage(1)
+        self.assertMessageMatch(
+            m1,
+            command=command,
+            params=["#chan", "hello everyone"],
+            fail_msg="Did not echo “{} #chan :hello everyone”: {msg}",
+            extra_format=(command,),
+        )
+
+        if not solo:
+            m2 = self.getMessage(2)
+            self.assertMessageMatch(
+                m2,
+                command=command,
+                params=["#chan", "hello everyone"],
+                fail_msg="Did not propagate “{} #chan :hello everyone”: "
+                "after echoing it to the author: {msg}",
+                extra_format=(command,),
+            )
+            self.assertEqual(
+                m1.params,
+                m2.params,
+                fail_msg="Parameters of forwarded and echoed " "messages differ: {} {}",
+                extra_format=(m1, m2),
+            )
+            if server_time:
+                self.assertIn(
+                    "time",
+                    m1.tags,
+                    fail_msg="Echoed message is missing server time: {}",
+                    extra_format=(m1,),
+                )
+                self.assertIn(
+                    "time",
+                    m2.tags,
+                    fail_msg="Forwarded message is missing server time: {}",
+                    extra_format=(m2,),
+                )
+
+    @pytest.mark.arbitrary_client_tags
+    @cases.mark_capabilities(
+        "batch", "labeled-response", "echo-message", "message-tags"
+    )
+    def testDirectMessageEcho(self):
+        bar = random_name("bar")
+        self.connectClient(
+            bar,
+            name=bar,
+            capabilities=["batch", "labeled-response", "echo-message", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(bar)
+
+        qux = random_name("qux")
+        self.connectClient(
+            qux,
+            name=qux,
+            capabilities=["batch", "labeled-response", "echo-message", "message-tags"],
+        )
+        self.getMessages(qux)
+
+        self.sendLine(
+            bar,
+            "@label=xyz;+example-client-tag=example-value PRIVMSG %s :hi there"
+            % (qux,),
+        )
+        echo = self.getMessages(bar)[0]
+        delivery = self.getMessages(qux)[0]
+
+        self.assertMessageMatch(
+            echo,
+            command="PRIVMSG",
+            params=[qux, "hi there"],
+            tags={"label": "xyz", "+example-client-tag": "example-value", **ANYDICT},
+        )
+        self.assertMessageMatch(
+            delivery,
+            command="PRIVMSG",
+            params=[qux, "hi there"],
+            tags={"+example-client-tag": "example-value", **ANYDICT},
+        )
+
+        # Either both messages have a msgid, or neither does
+        self.assertEqual(delivery.tags.get("msgid"), echo.tags.get("msgid"))

irctest/server_tests/extended_join.py

@@ -0,0 +1,69 @@
+"""
+<http://ircv3.net/specs/extensions/extended-join-3.1.html>
+"""
+
+from irctest import cases
+
+
+@cases.mark_services
+class MetadataTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    def connectRegisteredClient(self, nick):
+        self.addClient()
+        self.sendLine(2, "CAP LS 302")
+        capabilities = self.getCapLs(2)
+        assert "sasl" in capabilities
+        self.requestCapabilities(2, ["sasl"], skip_if_cap_nak=False)
+        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.sendLine(2, "USER f * * :Realname")
+        self.sendLine(2, "NICK {}".format(nick))
+        self.sendLine(2, "CAP END")
+        self.skipToWelcome(2)
+
+    @cases.mark_capabilities("extended-join")
+    def testNotLoggedIn(self):
+        self.connectClient("foo", capabilities=["extended-join"], skip_if_cap_nak=True)
+        self.joinChannel(1, "#chan")
+        self.connectClient("bar")
+        self.joinChannel(2, "#chan")
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="JOIN",
+            params=["#chan", "*", "Realname"],
+            fail_msg="Expected “JOIN #chan * :Realname” after "
+            "unregistered user joined, got: {msg}",
+        )
+
+    @cases.mark_capabilities("extended-join")
+    @cases.OptionalityHelper.skipUnlessHasMechanism("PLAIN")
+    def testLoggedIn(self):
+        self.connectClient("foo", capabilities=["extended-join"], skip_if_cap_nak=True)
+        self.joinChannel(1, "#chan")
+
+        self.controller.registerUser(self, "jilles", "sesame")
+        self.connectRegisteredClient("bar")
+        self.joinChannel(2, "#chan")
+
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="JOIN",
+            params=["#chan", "jilles", "Realname"],
+            fail_msg="Expected “JOIN #chan * :Realname” after "
+            "nick “bar” logged in as “jilles” joined, got: {msg}",
+        )

irctest/server_tests/invite.py

@@ -0,0 +1,412 @@
+import pytest
+
+from irctest import cases
+from irctest.numerics import (
+    ERR_CHANOPRIVSNEEDED,
+    ERR_INVITEONLYCHAN,
+    ERR_NOSUCHNICK,
+    ERR_NOTONCHANNEL,
+    ERR_USERONCHANNEL,
+    RPL_INVITING,
+)
+from irctest.patma import ANYSTR, StrRe
+
+
+class InviteTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Modern")
+    def testInvites(self):
+        """Test some basic functionality related to INVITE and the +i mode.
+
+        https://modern.ircdocs.horse/#invite-only-channel-mode
+        https://modern.ircdocs.horse/#rplinviting-341
+        """
+        self.connectClient("foo")
+        self.joinChannel(1, "#chan")
+        self.sendLine(1, "MODE #chan +i")
+        self.getMessages(1)
+        self.sendLine(1, "INVITE bar #chan")
+        m = self.getMessage(1)
+        self.assertEqual(m.command, ERR_NOSUCHNICK)
+
+        self.connectClient("bar")
+        self.sendLine(2, "JOIN #chan")
+        m = self.getMessage(2)
+        self.assertEqual(m.command, ERR_INVITEONLYCHAN)
+
+        self.sendLine(1, "INVITE bar #chan")
+        m = self.getMessage(1)
+        # modern/ircv3 param order: inviter, invitee, channel
+        self.assertMessageMatch(m, command=RPL_INVITING, params=["foo", "bar", "#chan"])
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="INVITE", params=["bar", "#chan"])
+        self.assertTrue(m.prefix.startswith("foo"))  # nickmask of inviter
+
+        # we were invited, so join should succeed now
+        self.joinChannel(2, "#chan")
+
+    @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True)
+    def testInviteNonExistingChannelTransmitted(self):
+        """“There is no requirement that the channel the target user is being
+        invited to must exist or be a valid channel.”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.2.7>
+        and <https://tools.ietf.org/html/rfc2812#section-3.2.7>
+
+        “Only the user inviting and the user being invited will receive
+        notification of the invitation.”
+        -- <https://tools.ietf.org/html/rfc2812#section-3.2.7>
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.sendLine(1, "INVITE #chan bar")
+        self.getMessages(1)
+        messages = self.getMessages(2)
+        self.assertNotEqual(
+            messages,
+            [],
+            fail_msg="After using “INVITE #chan bar” while #chan does "
+            "not exist, “bar” received nothing.",
+        )
+        self.assertMessageMatch(
+            messages[0],
+            command="INVITE",
+            params=["#chan", "bar"],
+            fail_msg="After “foo” invited “bar” do non-existing channel "
+            "#chan, “bar” should have received “INVITE #chan bar” but "
+            "got this instead: {msg}",
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True)
+    def testInviteNonExistingChannelEchoed(self):
+        """“There is no requirement that the channel the target user is being
+        invited to must exist or be a valid channel.”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.2.7>
+        and <https://tools.ietf.org/html/rfc2812#section-3.2.7>
+
+        “Only the user inviting and the user being invited will receive
+        notification of the invitation.”
+        -- <https://tools.ietf.org/html/rfc2812#section-3.2.7>
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.sendLine(1, "INVITE #chan bar")
+        messages = self.getMessages(1)
+        self.assertNotEqual(
+            messages,
+            [],
+            fail_msg="After using “INVITE #chan bar” while #chan does "
+            "not exist, the author received nothing.",
+        )
+        self.assertMessageMatch(
+            messages[0],
+            command="INVITE",
+            params=["#chan", "bar"],
+            fail_msg="After “foo” invited “bar” do non-existing channel "
+            "#chan, “foo” should have received “INVITE #chan bar” but "
+            "got this instead: {msg}",
+        )
+
+    def _testInvite(self, opped, invite_only, modern):
+        """
+        "Only the user inviting and the user being invited will receive
+        notification of the invitation."
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.7
+
+        "      341    RPL_INVITING
+              "<channel> <nick>"
+
+         - Returned by the server to indicate that the
+           attempted INVITE message was successful and is
+           being passed onto the end client."
+        -- https://datatracker.ietf.org/doc/html/rfc1459
+        -- https://datatracker.ietf.org/doc/html/rfc2812
+
+        "When the invite is successful, the server MUST send a `RPL_INVITING`
+        numeric to the command issuer, and an `INVITE` message,
+        with the issuer as prefix, to the target user."
+        -- https://modern.ircdocs.horse/#invite-message
+
+        "### `RPL_INVITING (341)`
+
+        <client> <nick> <channel>
+
+        Sent as a reply to the [`INVITE`](#invite-message) command to indicate
+        that the attempt was successful and the client with the nickname `<nick>`
+        has been invited to `<channel>`.
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.getMessages(2)
+
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)
+
+        if invite_only:
+            self.sendLine(1, "MODE #chan +i")
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command="MODE",
+                params=["#chan", "+i"],
+            )
+
+        if not opped:
+            self.sendLine(1, "MODE #chan -o foo")
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command="MODE",
+                params=["#chan", "-o", "foo"],
+            )
+
+        self.sendLine(1, "INVITE bar #chan")
+        if modern:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=RPL_INVITING,
+                params=["foo", "bar", "#chan"],
+                fail_msg=f"After “foo” invited “bar” to a channel, “foo” should have "
+                f"received “{RPL_INVITING} foo #chan bar” but got this instead: "
+                f"{{msg}}",
+            )
+        else:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=RPL_INVITING,
+                params=["#chan", "bar"],
+                fail_msg=f"After “foo” invited “bar” to a channel, “foo” should have "
+                f"received “{RPL_INVITING} #chan bar” but got this instead: {{msg}}",
+            )
+
+        messages = self.getMessages(2)
+        self.assertNotEqual(
+            messages,
+            [],
+            fail_msg="After using “INVITE #chan bar”, “bar” received nothing.",
+        )
+        self.assertMessageMatch(
+            messages[0],
+            prefix=StrRe("foo!.*"),
+            command="INVITE",
+            params=["bar", "#chan"],
+            fail_msg="After “foo” invited “bar”, “bar” should have received "
+            "“INVITE bar #chan” but got this instead: {msg}",
+        )
+
+    @pytest.mark.parametrize("invite_only", [True, False])
+    @cases.mark_specifications("Modern")
+    def testInviteModern(self, invite_only):
+        self._testInvite(opped=True, invite_only=invite_only, modern=True)
+
+    @pytest.mark.parametrize("invite_only", [True, False])
+    @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True)
+    def testInviteRfc(self, invite_only):
+        self._testInvite(opped=True, invite_only=invite_only, modern=False)
+
+    @cases.mark_specifications("Modern", strict=True)
+    def testInviteUnoppedModern(self):
+        """Tests invites from unopped users on not-invite-only chans."""
+        self._testInvite(opped=False, invite_only=False, modern=True)
+
+    @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True, strict=True)
+    def testInviteUnoppedRfc(self, opped, invite_only):
+        """Tests invites from unopped users on not-invite-only chans."""
+        self._testInvite(opped=False, invite_only=False, modern=False)
+
+    @cases.mark_specifications("RFC2812", "Modern")
+    def testInviteNoNotificationForOtherMembers(self):
+        """
+        "Other channel members are not notified."
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.7
+
+        "Other channel members SHOULD NOT be notified."
+        -- https://modern.ircdocs.horse/#invite-message
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.connectClient("baz")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)
+
+        self.sendLine(3, "JOIN #chan")
+        self.getMessages(3)
+
+        self.sendLine(1, "INVITE bar #chan")
+        self.getMessages(1)
+
+        self.assertEqual(
+            self.getMessages(3),
+            [],
+            fail_msg="After foo used “INVITE #chan bar”, other channel members "
+            "were notified: {got}",
+        )
+
+    def _testInviteInviteOnly(self, modern):
+        """
+        "To invite a user to a channel which is invite only (MODE
+        +i), the client sending the invite must be recognised as being a
+        channel operator on the given channel."
+        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.7
+
+        "When the channel has invite-only
+        flag set, only channel operators may issue INVITE command."
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.7
+
+        "When the channel has [invite-only](#invite-only-channel-mode) mode set,
+        only channel operators may issue INVITE command.
+        Otherwise, the server MUST reject the command with the `ERR_CHANOPRIVSNEEDED`
+        numeric."
+        -- https://modern.ircdocs.horse/#invite-message
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.getMessages(2)
+
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)
+
+        self.sendLine(1, "MODE #chan +i")
+        self.assertMessageMatch(
+            self.getMessage(1),
+            command="MODE",
+            params=["#chan", "+i"],
+        )
+
+        self.sendLine(1, "MODE #chan -o foo")
+        self.assertMessageMatch(
+            self.getMessage(1),
+            command="MODE",
+            params=["#chan", "-o", "foo"],
+        )
+
+        self.sendLine(1, "INVITE bar #chan")
+        if modern:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=ERR_CHANOPRIVSNEEDED,
+                params=["foo", "#chan", ANYSTR],
+                fail_msg=f"After “foo” invited “bar” to a channel to an invite-only "
+                f"channel without being opped, “foo” should have received "
+                f"“{ERR_CHANOPRIVSNEEDED} foo #chan :*” but got this instead: {{msg}}",
+            )
+        else:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=ERR_CHANOPRIVSNEEDED,
+                params=["#chan", ANYSTR],
+                fail_msg=f"After “foo” invited “bar” to a channel to an invite-only "
+                f"channel without being opped, “foo” should have received "
+                f"“{ERR_CHANOPRIVSNEEDED} #chan :*” but got this instead: {{msg}}",
+            )
+
+    @cases.mark_specifications("Modern")
+    def testInviteInviteOnlyModern(self):
+        self._testInviteInviteOnly(modern=True)
+
+    @cases.mark_specifications("RFC1459", "RFC2812", deprecated=True)
+    def testInviteInviteOnlyRfc(self):
+        self._testInviteInviteOnly(modern=False)
+
+    @cases.mark_specifications("RFC2812", "Modern")
+    def _testInviteOnlyFromUsersInChannel(self, modern):
+        """
+        "if the channel exists, only members of the channel are allowed
+        to invite other users"
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.7
+
+        "       442    ERR_NOTONCHANNEL
+              "<channel> :You're not on that channel"
+
+         - Returned by the server whenever a client tries to
+           perform a channel affecting command for which the
+           client isn't a member.
+        "
+        -- https://datatracker.ietf.org/doc/html/rfc2812
+
+
+        " Only members of the channel are allowed to invite other users.
+        Otherwise, the server MUST reject the command with the `ERR_NOTONCHANNEL`
+        numeric."
+        -- https://modern.ircdocs.horse/#invite-message
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.connectClient("baz")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+
+        # Create the channel
+        self.sendLine(3, "JOIN #chan")
+        self.getMessages(3)
+
+        self.sendLine(1, "INVITE bar #chan")
+        if modern:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=ERR_NOTONCHANNEL,
+                params=["foo", "#chan", ANYSTR],
+                fail_msg=f"After “foo” invited “bar” to a channel it is not on "
+                f"#chan, “foo” should have received "
+                f"“ERR_NOTONCHANNEL ({ERR_NOTONCHANNEL}) foo #chan :*” but "
+                f"got this instead: {{msg}}",
+            )
+        else:
+            self.assertMessageMatch(
+                self.getMessage(1),
+                command=ERR_NOTONCHANNEL,
+                params=["#chan", ANYSTR],
+                fail_msg=f"After “foo” invited “bar” to a channel it is not on "
+                f"#chan, “foo” should have received "
+                f"“ERR_NOTONCHANNEL ({ERR_NOTONCHANNEL}) #chan :*” but "
+                f"got this instead: {{msg}}",
+            )
+
+        messages = self.getMessages(2)
+        self.assertEqual(
+            messages,
+            [],
+            fail_msg="After using “INVITE #chan bar” while the emitter is "
+            "not in #chan, “bar” received something.",
+        )
+
+    @cases.mark_specifications("Modern")
+    def testInviteOnlyFromUsersInChannelModern(self):
+        self._testInviteOnlyFromUsersInChannel(modern=True)
+
+    @cases.mark_specifications("RFC2812", deprecated=True)
+    def testInviteOnlyFromUsersInChannelRfc(self):
+        self._testInviteOnlyFromUsersInChannel(modern=False)
+
+    @cases.mark_specifications("Modern")
+    def testInviteAlreadyInChannel(self):
+        """
+        "If the user is already on the target channel,
+        the server MUST reject the command with the `ERR_USERONCHANNEL` numeric."
+        -- https://modern.ircdocs.horse/#invite-message
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.getMessages(2)
+
+        self.sendLine(1, "JOIN #chan")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(1)
+
+        self.sendLine(1, "INVITE bar #chan")
+
+        self.assertMessageMatch(
+            self.getMessage(1),
+            command=ERR_USERONCHANNEL,
+            params=["foo", "bar", "#chan", ANYSTR],
+        )

irctest/server_tests/isupport.py

@@ -0,0 +1,26 @@
+import re
+
+from irctest import cases, runner
+
+
+class IsupportTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Modern", "ircdocs")
+    @cases.mark_isupport("TARGMAX")
+    def testTargmax(self):
+        """
+        "Format: TARGMAX=[<command>:[limit]{,<command>:[limit]}]"
+        -- https://modern.ircdocs.horse/#targmax-parameter
+
+        "TARGMAX=[cmd:[number][,cmd:[number][,...]]]"
+        -- https://defs.ircdocs.horse/defs/isupport.html#targmax
+        """
+        self.connectClient("foo")
+
+        if "TARGMAX" not in self.server_support:
+            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
+            )

irctest/server_tests/join.py

@@ -0,0 +1,112 @@
+from irctest import cases
+from irctest.irc_utils import ambiguities
+
+
+class JoinTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812", strict=True)
+    def testJoinAllMessages(self):
+        """“If a JOIN is successful, the user receives a JOIN message as
+        confirmation and is then sent the channel's topic (using RPL_TOPIC) and
+        the list of users who are on the channel (using RPL_NAMREPLY), which
+        MUST include the user joining.”
+        -- <https://tools.ietf.org/html/rfc2812#section-3.2.1>
+
+        “If a JOIN is successful, the user is then sent the channel's topic
+        (using RPL_TOPIC) and the list of users who are on the channel (using
+        RPL_NAMREPLY), which must include the user joining.”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.2.1>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+        received_commands = {m.command for m in self.getMessages(1)}
+        expected_commands = {"353", "366"}  # RPL_NAMREPLY  # RPL_ENDOFNAMES
+        self.assertTrue(
+            expected_commands.issubset(received_commands),
+            "Server sent {} commands, but at least {} were expected.".format(
+                received_commands, expected_commands
+            ),
+        )
+
+    @cases.mark_specifications("RFC2812")
+    def testJoinNamreply(self):
+        """“353    RPL_NAMREPLY
+            "( "=" / "*" / "@" ) <channel>
+             :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )”
+        -- <https://tools.ietf.org/html/rfc2812#section-5.2>
+
+        This test makes a user join and check what is sent to them.
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+
+        for m in self.getMessages(1):
+            if m.command == "353":
+                self.assertIn(
+                    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: should contain only user "
+                    '"foo" with an optional "+" or "@" prefix, but got: '
+                    "{msg}",
+                )
+
+    def testJoinTwice(self):
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+        self.getMessages(1)
+        self.sendLine(1, "JOIN #chan")
+        # Note that there may be no message. Both RFCs require replies only
+        # if the join is successful, or has an error among the given set.
+        for m in self.getMessages(1):
+            if m.command == "353":
+                self.assertIn(
+                    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}",
+                )

irctest/server_tests/kick.py

@@ -0,0 +1,268 @@
+import pytest
+
+from irctest import cases, client_mock, runner
+from irctest.numerics import (
+    ERR_CHANOPRIVSNEEDED,
+    ERR_NOSUCHCHANNEL,
+    ERR_NOTONCHANNEL,
+    RPL_NAMREPLY,
+)
+from irctest.patma import ANYSTR
+
+
+class KickTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testKickSendsMessages(self):
+        """“Once a user has joined a channel, he receives information about
+        all commands his server receives affecting the channel.  This
+        includes […] KICK”
+        -- <https://tools.ietf.org/html/rfc1459#section-4.2.1>
+        and <https://tools.ietf.org/html/rfc2812#section-3.2.1>
+
+        "If a comment is given, this will be sent instead of the default message,
+        the nickname of the user targeted by the KICK."
+        -- https://modern.ircdocs.horse/#kick-message
+        """
+        self.connectClient("foo")
+        self.joinChannel(1, "#chan")
+
+        self.connectClient("bar")
+        self.joinChannel(2, "#chan")
+
+        self.connectClient("baz")
+        self.joinChannel(3, "#chan")
+
+        # TODO: check foo is an operator
+
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+        self.sendLine(1, "KICK #chan bar :bye")
+        try:
+            m = self.getMessage(1)
+            if m.command == "482":
+                raise runner.ImplementationChoice(
+                    "Channel creators are not opped by default."
+                )
+            self.assertMessageMatch(m, command="KICK")
+        except client_mock.NoMessageException:
+            # The RFCs do not say KICK must be echoed
+            pass
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="KICK", params=["#chan", "bar", "bye"])
+        m = self.getMessage(3)
+        self.assertMessageMatch(m, command="KICK", params=["#chan", "bar", "bye"])
+
+    def _testKickNoComment(self, check_default):
+        self.connectClient("foo")
+        self.joinChannel(1, "#chan")
+
+        self.connectClient("bar")
+        self.joinChannel(2, "#chan")
+
+        self.connectClient("baz")
+        self.joinChannel(3, "#chan")
+
+        # TODO: check foo is an operator
+
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+        self.sendLine(1, "KICK #chan bar")
+        try:
+            m = self.getMessage(1)
+            if m.command == "482":
+                raise runner.ImplementationChoice(
+                    "Channel creators are not opped by default."
+                )
+            self.assertMessageMatch(m, command="KICK")
+        except client_mock.NoMessageException:
+            # The RFCs do not say KICK must be echoed
+            pass
+        m2 = self.getMessage(2)
+        m3 = self.getMessage(3)
+        if check_default:
+            self.assertMessageMatch(m2, command="KICK", params=["#chan", "bar", "foo"])
+            self.assertMessageMatch(m3, command="KICK", params=["#chan", "bar", "foo"])
+        else:
+            self.assertMessageMatch(m2, command="KICK", params=["#chan", "bar", ANYSTR])
+            self.assertMessageMatch(m3, command="KICK", params=["#chan", "bar", ANYSTR])
+
+    @cases.mark_specifications("RFC2812")
+    def testKickDefaultComment(self):
+        """
+        "If a "comment" is
+        given, this will be sent instead of the default message, the nickname
+        of the user issuing the KICK."
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.8
+        """
+        self._testKickNoComment(check_default=True)
+
+    @cases.mark_specifications("Modern")
+    def testKickNoComment(self):
+        """
+        "If no comment is given, the server SHOULD use a default message instead."
+        -- https://modern.ircdocs.horse/#kick-message
+        """
+        self._testKickNoComment(check_default=False)
+
+    @cases.mark_specifications("RFC2812")
+    def testKickPrivileges(self):
+        """Test who has the ability to kick / what error codes are sent
+        for invalid kicks."""
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)
+
+        self.connectClient("bar")
+        self.sendLine(2, "JOIN #chan")
+
+        messages = self.getMessages(2)
+        names = set()
+        for message in messages:
+            if message.command == RPL_NAMREPLY:
+                names.update(set(message.params[-1].split()))
+        # assert foo is opped
+        self.assertIn("@foo", names, f"unexpected names: {names}")
+
+        self.connectClient("baz")
+
+        self.sendLine(3, "KICK #chan bar")
+        replies = set(m.command for m in self.getMessages(3))
+        self.assertTrue(
+            ERR_NOTONCHANNEL in replies
+            or ERR_CHANOPRIVSNEEDED in replies
+            or ERR_NOSUCHCHANNEL in replies,
+            f"did not receive acceptable error code for kick from outside channel: "
+            f"{replies}",
+        )
+
+        self.joinChannel(3, "#chan")
+        self.getMessages(3)
+        self.sendLine(3, "KICK #chan bar")
+        replies = set(m.command for m in self.getMessages(3))
+        # now we're a channel member so we should receive ERR_CHANOPRIVSNEEDED
+        self.assertIn(ERR_CHANOPRIVSNEEDED, replies)
+
+        self.sendLine(1, "MODE #chan +o baz")
+        self.getMessages(1)
+        # should be able to kick an unprivileged user:
+        self.sendLine(3, "KICK #chan bar")
+        # should be able to kick an operator:
+        self.sendLine(3, "KICK #chan foo")
+        baz_replies = set(m.command for m in self.getMessages(3))
+        self.assertNotIn(ERR_CHANOPRIVSNEEDED, baz_replies)
+        kick_targets = [m.params[1] for m in self.getMessages(1) if m.command == "KICK"]
+        # foo should see bar and foo being kicked
+        self.assertTrue(
+            any(target.startswith("foo") for target in kick_targets),
+            f"unexpected kick targets: {kick_targets}",
+        )
+        self.assertTrue(
+            any(target.startswith("bar") for target in kick_targets),
+            f"unexpected kick targets: {kick_targets}",
+        )
+
+    @cases.mark_specifications("RFC2812")
+    def testKickNonexistentChannel(self):
+        """“Kick command [...] Numeric replies: [...] ERR_NOSUCHCHANNEL."""
+        self.connectClient("nick")
+
+        self.connectClient("foo")
+        self.sendLine(1, "KICK #chan nick")
+        m = self.getMessage(1)
+        # should return ERR_NOSUCHCHANNEL
+        self.assertMessageMatch(m, command="403")
+
+    @pytest.mark.parametrize("multiple_targets", [True, False])
+    @cases.mark_specifications("RFC2812", "Modern", "ircdocs")
+    def testDoubleKickMessages(self, multiple_targets):
+        """“The server MUST NOT send KICK messages with multiple channels or
+        users to clients.  This is necessarily to maintain backward
+        compatibility with old client software.”
+        -- https://tools.ietf.org/html/rfc2812#section-3.2.8
+
+        "The server MUST NOT send KICK messages with multiple channels or
+        users to clients.
+        This is necessary to maintain backward compatibility with existing
+        client software."
+        -- https://modern.ircdocs.horse/#kick-message
+
+        "Servers MAY limit the number of target users per `KICK` command
+        via the [`TARGMAX` parameter of `RPL_ISUPPORT`](#targmax-parameter),
+        and silently drop targets if the number of targets exceeds the limit."
+        -- https://modern.ircdocs.horse/#kick-message
+
+        "If the "TARGMAX" parameter is not advertised or a value is not sent
+        then a client SHOULD assume that no commands except the "JOIN" and "PART"
+        commands accept multiple parameters."
+        -- https://defs.ircdocs.horse/defs/isupport.html#targmax
+
+        "If this parameter is not advertised or a value is not sent then a client
+        SHOULD assume that no commands except the `JOIN` and `PART` commands
+        accept multiple parameters."
+        -- https://github.com/ircdocs/modern-irc/pull/113
+
+        "If <limit> is not specified, then there is no maximum number of targets
+        for that command."
+        -- https://modern.ircdocs.horse/#targmax-parameter
+        """
+        self.connectClient("foo")
+        self.joinChannel(1, "#chan")
+
+        self.connectClient("bar")
+        self.joinChannel(2, "#chan")
+
+        self.connectClient("baz")
+        self.joinChannel(3, "#chan")
+
+        self.connectClient("qux")
+        self.joinChannel(4, "#chan")
+
+        targmax = dict(
+            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
+
+        # Synchronize
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+        self.getMessages(4)
+
+        if multiple_targets:
+            self.sendLine(1, "KICK #chan,#chan bar,baz :bye")
+        else:
+            self.sendLine(1, "KICK #chan bar,baz :bye")
+        try:
+            m = self.getMessage(1)
+            if m.command == "482":
+                raise runner.OptionalExtensionNotSupported(
+                    "Channel creators are not opped by default."
+                )
+        except client_mock.NoMessageException:
+            # The RFCs do not say KICK must be echoed
+            pass
+
+        mgroup = self.getMessages(4)
+        self.assertGreaterEqual(len(mgroup), 2, mgroup)
+        m1, m2 = mgroup[:2]
+
+        self.assertMessageMatch(m1, command="KICK", params=["#chan", ANYSTR, "bye"])
+        self.assertMessageMatch(m2, command="KICK", params=["#chan", ANYSTR, "bye"])
+
+        if (m1.params[1] == "bar" and m2.params[1] == "baz") or (
+            m1.params[1] == "baz" and m2.params[1] == "bar"
+        ):
+            ...  # success
+        else:
+            raise AssertionError(
+                "Middle params [{}, {}] are not correct.".format(
+                    m1.params[1], m2.params[1]
+                )
+            )

irctest/server_tests/labeled_responses.py

@@ -0,0 +1,504 @@
+"""
+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
+
+import pytest
+
+from irctest import cases
+from irctest.patma import ANYDICT, AnyOptStr, NotStrRe, RemainingKeys, StrRe
+
+
+class LabeledResponsesTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledPrivmsgResponsesToMultipleClients(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+        self.connectClient(
+            "carl",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(3)
+        self.connectClient(
+            "alice",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(4)
+
+        self.sendLine(1, "@label=12345 PRIVMSG bar,carl,alice :hi")
+        m = self.getMessage(1)
+        m2 = self.getMessage(2)
+        m3 = self.getMessage(3)
+        m4 = self.getMessage(4)
+
+        # ensure the label isn't sent to recipients
+        self.assertMessageMatch(m2, command="PRIVMSG", tags={})
+        self.assertMessageMatch(
+            m3,
+            command="PRIVMSG",
+            tags={},
+        )
+        self.assertMessageMatch(m4, command="PRIVMSG", tags={})
+
+        self.assertMessageMatch(
+            m, command="BATCH", fail_msg="No BATCH echo received after sending one out"
+        )
+
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledPrivmsgResponsesToClient(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        self.sendLine(1, "@label=12345 PRIVMSG bar :hi")
+        m = self.getMessage(1)
+        m2 = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(m2, command="PRIVMSG", tags={})
+
+        self.assertMessageMatch(m, command="PRIVMSG", tags={"label": "12345"})
+
+    @pytest.mark.react_tag
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledPrivmsgResponsesToChannel(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        # join channels
+        self.sendLine(1, "JOIN #test")
+        self.getMessages(1)
+        self.sendLine(2, "JOIN #test")
+        self.getMessages(2)
+        self.getMessages(1)
+
+        self.sendLine(
+            1, "@label=12345;+draft/reply=123;+draft/react=l😃l PRIVMSG #test :hi"
+        )
+        ms = self.getMessage(1)
+        mt = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(mt, command="PRIVMSG", tags={})
+
+        # ensure sender correctly receives msg
+        self.assertMessageMatch(ms, command="PRIVMSG", tags={"label": "12345"})
+
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledPrivmsgResponsesToSelf(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+
+        self.sendLine(1, "@label=12345 PRIVMSG foo :hi")
+        m1 = self.getMessage(1)
+        m2 = self.getMessage(1)
+
+        number_of_labels = 0
+        for m in [m1, m2]:
+            self.assertMessageMatch(
+                m,
+                command="PRIVMSG",
+                fail_msg="Got a message back that wasn't a PRIVMSG",
+            )
+            if "label" in m.tags:
+                number_of_labels += 1
+                self.assertEqual(
+                    m.tags["label"],
+                    "12345",
+                    m,
+                    fail_msg=(
+                        "Echo'd label doesn't match the label we sent "
+                        "(should be '12345'): {msg}"
+                    ),
+                )
+
+        self.assertEqual(
+            number_of_labels,
+            1,
+            m1,
+            fail_msg=(
+                "When sending a PRIVMSG to self with echo-message, "
+                "we only expect one message to contain the label. "
+                "Instead, {} messages had the label"
+            ).format(number_of_labels),
+        )
+
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledNoticeResponsesToClient(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        self.sendLine(1, "@label=12345 NOTICE bar :hi")
+        m = self.getMessage(1)
+        m2 = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(m2, command="NOTICE", tags={})
+
+        self.assertMessageMatch(m, command="NOTICE", tags={"label": "12345"})
+
+    @pytest.mark.react_tag
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledNoticeResponsesToChannel(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        # join channels
+        self.sendLine(1, "JOIN #test")
+        self.getMessages(1)
+        self.sendLine(2, "JOIN #test")
+        self.getMessages(2)
+        self.getMessages(1)
+
+        self.sendLine(
+            1, "@label=12345;+draft/reply=123;+draft/react=l😃l NOTICE #test :hi"
+        )
+        ms = self.getMessage(1)
+        mt = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(mt, command="NOTICE", tags={})
+
+        # ensure sender correctly receives msg
+        self.assertMessageMatch(ms, command="NOTICE", tags={"label": "12345"})
+
+    @cases.mark_capabilities("echo-message", "batch", "labeled-response")
+    def testLabeledNoticeResponsesToSelf(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+
+        self.sendLine(1, "@label=12345 NOTICE foo :hi")
+        m1 = self.getMessage(1)
+        m2 = self.getMessage(1)
+
+        number_of_labels = 0
+        for m in [m1, m2]:
+            self.assertMessageMatch(
+                m, command="NOTICE", fail_msg="Got a message back that wasn't a NOTICE"
+            )
+            if "label" in m.tags:
+                number_of_labels += 1
+                self.assertEqual(
+                    m.tags["label"],
+                    "12345",
+                    m,
+                    fail_msg=(
+                        "Echo'd label doesn't match the label we sent "
+                        "(should be '12345'): {msg}"
+                    ),
+                )
+
+        self.assertEqual(
+            number_of_labels,
+            1,
+            m1,
+            fail_msg=(
+                "When sending a NOTICE to self with echo-message, "
+                "we only expect one message to contain the label. "
+                "Instead, {} messages had the label"
+            ).format(number_of_labels),
+        )
+
+    @pytest.mark.react_tag
+    @cases.mark_capabilities(
+        "echo-message", "batch", "labeled-response", "message-tags"
+    )
+    def testLabeledTagMsgResponsesToClient(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        # Need to get a valid msgid because Unreal validates them
+        self.sendLine(1, "PRIVMSG bar :hi")
+        msgid = self.getMessage(1).tags["msgid"]
+        assert msgid == self.getMessage(2).tags["msgid"]
+
+        self.sendLine(
+            1, f"@label=12345;+draft/reply={msgid};+draft/react=l😃l TAGMSG bar"
+        )
+        m = self.getMessage(1)
+        m2 = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(
+            m2,
+            command="TAGMSG",
+            tags={
+                "+draft/reply": msgid,
+                "+draft/react": "l😃l",
+                RemainingKeys(NotStrRe("label")): AnyOptStr(),
+            },
+        )
+        self.assertNotIn(
+            "label",
+            m2.tags,
+            m2,
+            fail_msg=(
+                "When sending a TAGMSG with a label, "
+                "the target user shouldn't receive the label "
+                "(only the sending user should): {msg}"
+            ),
+        )
+
+        self.assertMessageMatch(
+            m,
+            command="TAGMSG",
+            tags={
+                "label": "12345",
+                "+draft/reply": msgid,
+                "+draft/react": "l😃l",
+                **ANYDICT,
+            },
+        )
+
+    @pytest.mark.react_tag
+    @cases.mark_capabilities(
+        "echo-message", "batch", "labeled-response", "message-tags"
+    )
+    def testLabeledTagMsgResponsesToChannel(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+        self.connectClient(
+            "bar",
+            capabilities=["echo-message", "batch", "labeled-response", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(2)
+
+        # join channels
+        self.sendLine(1, "JOIN #test")
+        self.getMessages(1)
+        self.sendLine(2, "JOIN #test")
+        self.getMessages(2)
+        self.getMessages(1)
+
+        # Need to get a valid msgid because Unreal validates them
+        self.sendLine(1, "PRIVMSG #test :hi")
+        msgid = self.getMessage(1).tags["msgid"]
+        assert msgid == self.getMessage(2).tags["msgid"]
+
+        self.sendLine(
+            1, f"@label=12345;+draft/reply={msgid};+draft/react=l😃l TAGMSG #test"
+        )
+        ms = self.getMessage(1)
+        mt = self.getMessage(2)
+
+        # ensure the label isn't sent to recipient
+        self.assertMessageMatch(
+            mt,
+            command="TAGMSG",
+            tags={
+                "+draft/reply": msgid,
+                "+draft/react": "l😃l",
+                RemainingKeys(NotStrRe("label")): AnyOptStr(),
+            },
+            fail_msg="No TAGMSG received by the target after sending one out",
+        )
+        self.assertNotIn(
+            "label",
+            mt.tags,
+            mt,
+            fail_msg=(
+                "When sending a TAGMSG with a label, "
+                "the target user shouldn't receive the label "
+                "(only the sending user should): {msg}"
+            ),
+        )
+
+        # ensure sender correctly receives msg
+        self.assertMessageMatch(
+            ms,
+            command="TAGMSG",
+            tags={"label": "12345", "+draft/reply": msgid, **ANYDICT},
+        )
+
+    @pytest.mark.react_tag
+    @cases.mark_capabilities(
+        "echo-message", "batch", "labeled-response", "message-tags"
+    )
+    def testLabeledTagMsgResponsesToSelf(self):
+        self.connectClient(
+            "foo",
+            capabilities=["echo-message", "batch", "labeled-response", "message-tags"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+
+        self.sendLine(1, "@label=12345;+draft/reply=123;+draft/react=l😃l TAGMSG foo")
+        m1 = self.getMessage(1)
+        m2 = self.getMessage(1)
+
+        number_of_labels = 0
+        for m in [m1, m2]:
+            self.assertMessageMatch(
+                m, command="TAGMSG", fail_msg="Got a message back that wasn't a TAGMSG"
+            )
+            if "label" in m.tags:
+                number_of_labels += 1
+                self.assertEqual(
+                    m.tags["label"],
+                    "12345",
+                    m,
+                    fail_msg=(
+                        "Echo'd label doesn't match the label we sent "
+                        "(should be '12345'): {msg}"
+                    ),
+                )
+
+        self.assertEqual(
+            number_of_labels,
+            1,
+            m1,
+            fail_msg=(
+                "When sending a TAGMSG to self with echo-message, "
+                "we only expect one message to contain the label. "
+                "Instead, {} messages had the label"
+            ).format(number_of_labels),
+        )
+
+    @cases.mark_capabilities("batch", "labeled-response", "message-tags", "server-time")
+    def testBatchedJoinMessages(self):
+        self.connectClient(
+            "bar",
+            capabilities=["batch", "labeled-response", "message-tags", "server-time"],
+            skip_if_cap_nak=True,
+        )
+        self.getMessages(1)
+
+        self.sendLine(1, "@label=12345 JOIN #xyz")
+        m = self.getMessages(1)
+
+        # we expect at least join and names lines, which must be batched
+        self.assertGreaterEqual(len(m), 3)
+
+        # valid BATCH start line:
+        batch_start = m[0]
+        self.assertMessageMatch(
+            batch_start,
+            command="BATCH",
+            params=[StrRe(r"\+.*"), "labeled-response"],
+        )
+        batch_id = batch_start.params[0][1:]
+        # batch id MUST be alphanumerics and hyphens
+        self.assertTrue(
+            re.match(r"^[A-Za-z0-9\-]+$", batch_id) is not None,
+            "batch id must be alphanumerics and hyphens, got %r" % (batch_id,),
+        )
+        self.assertEqual(batch_start.tags.get("label"), "12345")
+
+        # valid BATCH end line
+        batch_end = m[-1]
+        self.assertMessageMatch(batch_end, command="BATCH", params=["-" + batch_id])
+
+        # messages must have the BATCH tag
+        for message in m[1:-1]:
+            self.assertEqual(message.tags.get("batch"), batch_id)
+
+    @cases.mark_capabilities("labeled-response")
+    def testNoBatchForSingleMessage(self):
+        self.connectClient(
+            "bar", capabilities=["batch", "labeled-response"], skip_if_cap_nak=True
+        )
+        self.getMessages(1)
+
+        self.sendLine(1, "@label=98765 PING adhoctestline")
+        # no BATCH should be initiated for a one-line response,
+        # it should just be labeled
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="PONG", tags={"label": "98765"})
+        self.assertEqual(m.params[-1], "adhoctestline")
+
+    @cases.mark_capabilities("labeled-response")
+    def testEmptyBatchForNoResponse(self):
+        self.connectClient(
+            "bar", capabilities=["batch", "labeled-response"], skip_if_cap_nak=True
+        )
+        self.getMessages(1)
+
+        # PONG never receives a response
+        self.sendLine(1, "@label=98765 PONG adhoctestline")
+
+        # labeled-response: "Servers MUST respond with a labeled
+        # `ACK` message when a client sends a labeled command that normally
+        # produces no response."
+        ms = self.getMessages(1)
+        self.assertEqual(len(ms), 1)
+        ack = ms[0]
+
+        self.assertMessageMatch(ack, command="ACK", tags={"label": "98765"})

irctest/server_tests/list.py

@@ -0,0 +1,75 @@
+from irctest import cases
+
+
+class ListTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testListEmpty(self):
+        """<https://tools.ietf.org/html/rfc1459#section-4.2.6>
+        <https://tools.ietf.org/html/rfc2812#section-3.2.6>
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.getMessages(1)
+        self.sendLine(2, "LIST")
+        m = self.getMessage(2)
+        if m.command == "321":
+            # skip RPL_LISTSTART
+            m = self.getMessage(2)
+        while m.command == "322" and m.params[1] == "&SERVER":
+            # ngircd adds this pseudo-channel
+            m = self.getMessage(2)
+        self.assertNotEqual(
+            m.command,
+            "322",  # RPL_LIST
+            "LIST response gives (at least) one channel, whereas there " "is none.",
+        )
+        self.assertMessageMatch(
+            m,
+            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")
+    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>
+        """
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)
+        self.sendLine(2, "LIST")
+        m = self.getMessage(2)
+        if m.command == "321":
+            # skip RPL_LISTSTART
+            m = self.getMessage(2)
+        self.assertNotEqual(
+            m.command,
+            "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="322",  # RPL_LIST
+            fail_msg="Second reply to LIST is not 322 (RPL_LIST), "
+            "nor 323 (RPL_LISTEND) but: {msg}",
+        )
+        m = self.getMessage(2)
+        while m.command == "322" and m.params[1] == "&SERVER":
+            # ngircd adds this pseudo-channel
+            m = self.getMessage(2)
+        self.assertNotEqual(
+            m.command,
+            "322",  # RPL_LIST
+            fail_msg="LIST response gives (at least) two channels, "
+            "whereas there is only one.",
+        )
+        self.assertMessageMatch(
+            m,
+            command="323",  # RPL_LISTEND
+            fail_msg="Third reply to LIST is not 322 (RPL_LIST) "
+            "or 323 (RPL_LISTEND), or but: {msg}",
+        )

irctest/server_tests/lusers.py

@@ -0,0 +1,276 @@
+from dataclasses import dataclass
+import re
+from typing import Optional
+
+from irctest import cases
+from irctest.numerics import (
+    ERR_NOTREGISTERED,
+    RPL_GLOBALUSERS,
+    RPL_LOCALUSERS,
+    RPL_LUSERCHANNELS,
+    RPL_LUSERCLIENT,
+    RPL_LUSERME,
+    RPL_LUSEROP,
+    RPL_LUSERUNKNOWN,
+    RPL_YOUREOPER,
+)
+
+# 3 numbers, delimited by spaces, possibly negative (eek)
+LUSERCLIENT_REGEX = re.compile(r"^.*( [-0-9]* ).*( [-0-9]* ).*( [-0-9]* ).*$")
+# 2 numbers
+LUSERME_REGEX = re.compile(r"^.*?( [-0-9]* ).*( [-0-9]* ).*$")
+
+
+@dataclass
+class LusersResult:
+    GlobalVisible: Optional[int] = None
+    GlobalInvisible: Optional[int] = None
+    Servers: Optional[int] = None
+    Opers: Optional[int] = None
+    Unregistered: Optional[int] = None
+    Channels: Optional[int] = None
+    LocalTotal: Optional[int] = None
+    LocalMax: Optional[int] = None
+    GlobalTotal: Optional[int] = None
+    GlobalMax: Optional[int] = None
+
+
+class LusersTestCase(cases.BaseServerTestCase):
+    def assertLusersResult(self, lusers, unregistered, total, max_):
+        self.assertIn(lusers.Unregistered, (unregistered, None))
+        self.assertIn(lusers.GlobalTotal, (total, None))
+        self.assertIn(lusers.GlobalMax, (max_, None))
+
+        self.assertGreaterEqual(lusers.GlobalInvisible, 0)
+        self.assertGreaterEqual(lusers.GlobalVisible, 0)
+        self.assertLessEqual(lusers.GlobalInvisible, total)
+        self.assertLessEqual(lusers.GlobalVisible, total)
+        self.assertEqual(lusers.GlobalInvisible + lusers.GlobalVisible, total)
+
+        self.assertIn(lusers.LocalTotal, (total, None))
+        self.assertIn(lusers.LocalMax, (max_, None))
+
+    def getLusers(self, client):
+        self.sendLine(client, "LUSERS")
+        messages = self.getMessages(client)
+        by_numeric = dict((msg.command, msg) for msg in messages)
+
+        result = LusersResult()
+
+        # all of these take the nick as first param
+        for message in messages:
+            self.assertEqual(client, message.params[0])
+
+        luserclient = by_numeric[RPL_LUSERCLIENT]  # 251
+        self.assertEqual(len(luserclient.params), 2)
+        luserclient_param = luserclient.params[1]
+        try:
+            match = LUSERCLIENT_REGEX.match(luserclient_param)
+            result.GlobalVisible = int(match.group(1))
+            result.GlobalInvisible = int(match.group(2))
+            result.Servers = int(match.group(3))
+        except Exception:
+            raise ValueError("corrupt reply for 251 RPL_LUSERCLIENT", luserclient_param)
+
+        if RPL_LUSEROP in by_numeric:
+            result.Opers = int(by_numeric[RPL_LUSEROP].params[1])
+        if RPL_LUSERUNKNOWN in by_numeric:
+            result.Unregistered = int(by_numeric[RPL_LUSERUNKNOWN].params[1])
+        if RPL_LUSERCHANNELS in by_numeric:
+            result.Channels = int(by_numeric[RPL_LUSERCHANNELS].params[1])
+
+        # FIXME: RPL_LOCALUSERS and RPL_GLOBALUSERS are only in Modern, not in RFC2812
+        localusers = by_numeric[RPL_LOCALUSERS]
+        globalusers = by_numeric[RPL_GLOBALUSERS]
+        if len(localusers.params) == 4:
+            result.LocalTotal = int(localusers.params[1])
+            result.LocalMax = int(localusers.params[2])
+            result.GlobalTotal = int(globalusers.params[1])
+            result.GlobalMax = int(globalusers.params[2])
+        else:
+            # Arguments 1 and 2 are optional
+            self.assertEqual(len(localusers.params), 2)
+            result.LocalTotal = result.LocalMax = None
+            result.GlobalTotal = result.GlobalMax = None
+            return result
+
+        luserme = by_numeric[RPL_LUSERME]
+        self.assertEqual(len(luserme.params), 2)
+        luserme_param = luserme.params[1]
+        try:
+            match = LUSERME_REGEX.match(luserme_param)
+            localTotalFromUserme = int(match.group(1))
+            serversFromUserme = int(match.group(2))
+        except Exception:
+            raise ValueError("corrupt reply for 255 RPL_LUSERME", luserme_param)
+        self.assertEqual(result.LocalTotal, localTotalFromUserme)
+        # serversFromUserme is "servers i'm currently connected to", generally undefined
+        self.assertGreaterEqual(serversFromUserme, 0)
+
+        return result
+
+
+class BasicLusersTestCase(LusersTestCase):
+    @cases.mark_specifications("RFC2812")
+    def testLusers(self):
+        self.connectClient("bar", name="bar")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=1)
+
+        self.connectClient("qux", name="qux")
+        lusers = self.getLusers("qux")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+
+        self.sendLine("qux", "QUIT")
+        self.assertDisconnected("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=2)
+
+
+class LusersUnregisteredTestCase(LusersTestCase):
+    @cases.mark_specifications("RFC2812")
+    def testLusers(self):
+        self.doLusersTest()
+
+    def _synchronize(self, client_name):
+        """Synchronizes using a PING, but accept ERR_NOTREGISTERED as a response."""
+        self.sendLine(client_name, "PING PARAM")
+        for _ in range(1000):
+            msg = self.getRegistrationMessage(client_name)
+            if msg.command in (ERR_NOTREGISTERED, "PONG"):
+                break
+        else:
+            assert False, (
+                "Sent a PING before registration, "
+                "got neither PONG or ERR_NOTREGISTERED"
+            )
+
+    def doLusersTest(self):
+        self.connectClient("bar", name="bar")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=1)
+
+        self.addClient("qux")
+        self.sendLine("qux", "NICK qux")
+        self._synchronize("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=1, total=1, max_=1)
+
+        self.addClient("bat")
+        self.sendLine("bat", "NICK bat")
+        self._synchronize("bat")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=2, total=1, max_=1)
+
+        # complete registration on one client
+        self.sendLine("qux", "USER u s e r")
+        self.getRegistrationMessage("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=1, total=2, max_=2)
+
+        # QUIT the other without registering
+        self.sendLine("bat", "QUIT")
+        self.assertDisconnected("bat")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+
+
+class LusersUnregisteredDefaultInvisibleTestCase(LusersUnregisteredTestCase):
+    """Same as above but with +i as the default."""
+
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"].update(
+                {"default-user-modes": "+i"}
+            )
+        )
+
+    @cases.mark_specifications("Ergo")
+    def testLusers(self):
+        self.doLusersTest()
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+        self.assertEqual(lusers.GlobalInvisible, 2)
+        self.assertEqual(lusers.GlobalVisible, 0)
+
+
+class LuserOpersTestCase(LusersTestCase):
+    @cases.mark_specifications("Ergo")
+    def testLuserOpers(self):
+        self.connectClient("bar", name="bar")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=1)
+        self.assertIn(lusers.Opers, (0, None))
+
+        # add 1 oper
+        self.sendLine("bar", "OPER operuser operpassword")
+        msgs = self.getMessages("bar")
+        self.assertIn(RPL_YOUREOPER, {msg.command for msg in msgs})
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=1)
+        self.assertEqual(lusers.Opers, 1)
+
+        # now 2 opers
+        self.connectClient("qux", name="qux")
+        self.sendLine("qux", "OPER operuser operpassword")
+        self.getMessages("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+        self.assertEqual(lusers.Opers, 2)
+
+        # remove oper with MODE
+        self.sendLine("bar", "MODE bar -o")
+        msgs = self.getMessages("bar")
+        self.assertIn("MODE", {msg.command for msg in msgs})
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+        self.assertEqual(lusers.Opers, 1)
+
+        # remove oper by quit
+        self.sendLine("qux", "QUIT")
+        self.assertDisconnected("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=2)
+        self.assertEqual(lusers.Opers, 0)
+
+
+class ErgoInvisibleDefaultTestCase(LusersTestCase):
+    @staticmethod
+    def config() -> cases.TestCaseControllerConfig:
+        return cases.TestCaseControllerConfig(
+            ergo_config=lambda config: config["accounts"].update(
+                {"default-user-modes": "+i"}
+            )
+        )
+
+    @cases.mark_specifications("Ergo")
+    def testLusers(self):
+        self.connectClient("bar", name="bar")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=1)
+        self.assertEqual(lusers.GlobalInvisible, 1)
+        self.assertEqual(lusers.GlobalVisible, 0)
+
+        self.connectClient("qux", name="qux")
+        lusers = self.getLusers("qux")
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+        self.assertEqual(lusers.GlobalInvisible, 2)
+        self.assertEqual(lusers.GlobalVisible, 0)
+
+        # remove +i with MODE
+        self.sendLine("bar", "MODE bar -i")
+        msgs = self.getMessages("bar")
+        lusers = self.getLusers("bar")
+        self.assertIn("MODE", {msg.command for msg in msgs})
+        self.assertLusersResult(lusers, unregistered=0, total=2, max_=2)
+        self.assertEqual(lusers.GlobalInvisible, 1)
+        self.assertEqual(lusers.GlobalVisible, 1)
+
+        # disconnect invisible user
+        self.sendLine("qux", "QUIT")
+        self.assertDisconnected("qux")
+        lusers = self.getLusers("bar")
+        self.assertLusersResult(lusers, unregistered=0, total=1, max_=2)
+        self.assertEqual(lusers.GlobalInvisible, 0)
+        self.assertEqual(lusers.GlobalVisible, 1)

irctest/server_tests/message_tags.py

@@ -0,0 +1,196 @@
+"""
+https://ircv3.net/specs/extensions/message-tags.html
+"""
+
+import pytest
+
+from irctest import cases
+from irctest.irc_utils.message_parser import parse_message
+from irctest.numerics import ERR_INPUTTOOLONG
+from irctest.patma import ANYDICT, ANYSTR, StrRe
+
+
+class MessageTagsTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    @pytest.mark.arbitrary_client_tags
+    @cases.mark_capabilities("message-tags")
+    def testBasic(self):
+        def getAllMessages():
+            for name in ["alice", "bob", "carol", "dave"]:
+                self.getMessages(name)
+
+        def assertNoTags(line):
+            # tags start with '@', without tags we start with the prefix,
+            # which begins with ':'
+            self.assertEqual(line[0], ":")
+            msg = parse_message(line)
+            self.assertEqual(msg.tags, {})
+            return msg
+
+        self.connectClient(
+            "alice", name="alice", capabilities=["message-tags"], skip_if_cap_nak=True
+        )
+        self.joinChannel("alice", "#test")
+        self.connectClient(
+            "bob", name="bob", capabilities=["message-tags", "echo-message"]
+        )
+        self.joinChannel("bob", "#test")
+        self.connectClient("carol", name="carol")
+        self.joinChannel("carol", "#test")
+        self.connectClient("dave", name="dave", capabilities=["server-time"])
+        self.joinChannel("dave", "#test")
+        getAllMessages()
+
+        self.sendLine("alice", "@+baz=bat;fizz=buzz PRIVMSG #test hi")
+        self.getMessages("alice")
+        bob_msg = self.getMessage("bob")
+        carol_line = self.getMessage("carol", raw=True)
+        self.assertMessageMatch(
+            bob_msg,
+            command="PRIVMSG",
+            params=["#test", "hi"],
+            tags={"+baz": "bat", "msgid": ANYSTR, **ANYDICT},
+        )
+        # should not relay a non-client-only tag
+        self.assertNotIn("fizz", bob_msg.tags)
+        # carol MUST NOT receive tags
+        carol_msg = assertNoTags(carol_line)
+        self.assertMessageMatch(carol_msg, command="PRIVMSG", params=["#test", "hi"])
+        # dave SHOULD receive server-time tag
+        dave_msg = self.getMessage("dave")
+        self.assertMessageMatch(
+            dave_msg,
+            command="PRIVMSG",
+            params=["#test", "hi"],
+            tags={"time": ANYSTR, **ANYDICT},
+        )
+        # dave MUST NOT receive client-only tags
+        self.assertNotIn("+baz", dave_msg.tags)
+        getAllMessages()
+
+        self.sendLine("bob", "@+bat=baz;+fizz=buzz PRIVMSG #test :hi yourself")
+        bob_msg = self.getMessage("bob")  # bob has echo-message
+        alice_msg = self.getMessage("alice")
+        carol_line = self.getMessage("carol", raw=True)
+        carol_msg = assertNoTags(carol_line)
+        for msg in [alice_msg, bob_msg]:
+            self.assertMessageMatch(
+                msg,
+                command="PRIVMSG",
+                params=["#test", "hi yourself"],
+                tags={"+bat": "baz", "+fizz": "buzz", "msgid": ANYSTR, **ANYDICT},
+            )
+        self.assertMessageMatch(
+            carol_msg,
+            command="PRIVMSG",
+            params=["#test", "hi yourself"],
+        )
+        self.assertEqual(alice_msg.tags["msgid"], bob_msg.tags["msgid"])
+        getAllMessages()
+
+        # test TAGMSG and basic escaping
+        self.sendLine("bob", r"@+buzz=fizz\:buzz;cat=dog;+steel=wootz TAGMSG #test")
+        bob_msg = self.getMessage("bob")  # bob has echo-message
+        alice_msg = self.getMessage("alice")
+        # carol MUST NOT receive TAGMSG at all
+        self.assertEqual(self.getMessages("carol"), [])
+        # dave MUST NOT receive TAGMSG either, despite having server-time
+        self.assertEqual(self.getMessages("dave"), [])
+        for msg in [alice_msg, bob_msg]:
+            self.assertMessageMatch(
+                alice_msg,
+                command="TAGMSG",
+                params=["#test"],
+                tags={
+                    "+buzz": "fizz;buzz",
+                    "+steel": "wootz",
+                    "msgid": ANYSTR,
+                    **ANYDICT,
+                },
+            )
+            self.assertNotIn("cat", msg.tags)
+        self.assertEqual(alice_msg.tags["msgid"], bob_msg.tags["msgid"])
+
+    @pytest.mark.arbitrary_client_tags
+    @cases.mark_capabilities("message-tags")
+    @cases.mark_specifications("ircdocs")
+    def testLengthLimits(self):
+        self.connectClient(
+            "alice",
+            name="alice",
+            capabilities=["message-tags", "echo-message"],
+            skip_if_cap_nak=True,
+        )
+        self.joinChannel("alice", "#test")
+        self.connectClient("bob", name="bob", capabilities=["message-tags"])
+        self.joinChannel("bob", "#test")
+        self.getMessages("alice")
+        self.getMessages("bob")
+
+        # this is right at the limit of 4094 bytes of server tag data,
+        # 4096 bytes of client tag data (including the starting '@' and the final ' ')
+        max_tagmsg = "@foo=bar;+baz=%s TAGMSG #test" % ("a" * 4081,)
+        self.assertEqual(max_tagmsg.index("TAGMSG"), 4096)
+        self.sendLine("alice", max_tagmsg)
+        echo = self.getMessage("alice")
+        relay = self.getMessage("bob")
+        self.assertMessageMatch(
+            echo,
+            command="TAGMSG",
+            params=["#test"],
+            tags={"+baz": "a" * 4081, "msgid": StrRe(".+"), **ANYDICT},
+        )
+        self.assertMessageMatch(
+            relay,
+            command="TAGMSG",
+            params=["#test"],
+            tags={"+baz": "a" * 4081, "msgid": StrRe(".+"), **ANYDICT},
+        )
+        self.assertEqual(echo.tags["msgid"], relay.tags["msgid"])
+
+        excess_tagmsg = "@foo=bar;+baz=%s TAGMSG #test" % ("a" * 4082,)
+        self.assertEqual(excess_tagmsg.index("TAGMSG"), 4097)
+        self.sendLine("alice", excess_tagmsg)
+        reply = self.getMessage("alice")
+        self.assertEqual(reply.command, ERR_INPUTTOOLONG)
+        self.assertEqual(self.getMessages("bob"), [])
+
+        max_privmsg = "@foo=bar;+baz=%s PRIVMSG #test %s" % ("a" * 4081, "b" * 496)
+        # irctest adds the '\r\n' for us, this is right at the limit
+        self.assertEqual(len(max_privmsg), 4096 + (512 - 2))
+        self.sendLine("alice", max_privmsg)
+        echo = self.getMessage("alice")
+        # the server may still reject this message on the grounds that the final
+        # parameter is too long to be relayed without truncation, once alice's
+        # NUH is included. however, if the message was accepted, the tags MUST
+        # be relayed intact, because they are unquestionably valid. See the
+        # original context of ERR_INPUTTOOLONG:
+        # https://defs.ircdocs.horse/defs/numerics.html#err-inputtoolong-417
+        if echo.command != ERR_INPUTTOOLONG:
+            relay = self.getMessage("bob")
+            self.assertMessageMatch(
+                echo,
+                command="PRIVMSG",
+                params=["#test", StrRe("b{400,496}")],
+                tags={"+baz": "a" * 4081, "msgid": StrRe(".+"), **ANYDICT},
+            )
+            self.assertMessageMatch(
+                relay,
+                command="PRIVMSG",
+                params=["#test", StrRe("b{400,496}")],
+                tags={"+baz": "a" * 4081, "msgid": StrRe(".+"), **ANYDICT},
+            )
+            self.assertEqual(echo.tags["msgid"], relay.tags["msgid"])
+            # message may have been truncated
+            self.assertIn("b" * 400, echo.params[1])
+            self.assertEqual(echo.params[1].rstrip("b"), "")
+            self.assertIn("b" * 400, relay.params[1])
+            self.assertEqual(relay.params[1].rstrip("b"), "")
+
+        excess_privmsg = "@foo=bar;+baz=%s PRIVMSG #test %s" % ("a" * 4082, "b" * 495)
+        # TAGMSG data is over the limit, but we're within the overall limit for a line
+        self.assertEqual(excess_privmsg.index("PRIVMSG"), 4097)
+        self.assertEqual(len(excess_privmsg), 4096 + (512 - 2))
+        self.sendLine("alice", excess_privmsg)
+        reply = self.getMessage("alice")
+        self.assertEqual(reply.command, ERR_INPUTTOOLONG)
+        self.assertEqual(self.getMessages("bob"), [])

irctest/server_tests/messages.py

@@ -0,0 +1,243 @@
+"""
+Section 3.2 of RFC 2812
+<https://tools.ietf.org/html/rfc2812#section-3.3>
+"""
+
+from irctest import cases, runner
+from irctest.numerics import ERR_INPUTTOOLONG, ERR_NOPRIVILEGES, ERR_NOSUCHNICK
+
+
+class PrivmsgTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testPrivmsg(self):
+        """<https://tools.ietf.org/html/rfc2812#section-3.3.1>"""
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+        self.connectClient("bar")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(2)  # synchronize
+        self.sendLine(1, "PRIVMSG #chan :hello there")
+        self.getMessages(1)  # synchronize
+        pms = [msg for msg in self.getMessages(2) if msg.command == "PRIVMSG"]
+        self.assertEqual(len(pms), 1)
+        self.assertMessageMatch(
+            pms[0], command="PRIVMSG", params=["#chan", "hello there"]
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testPrivmsgNonexistentChannel(self):
+        """<https://tools.ietf.org/html/rfc2812#section-3.3.1>"""
+        self.connectClient("foo")
+        self.sendLine(1, "PRIVMSG #nonexistent :hello there")
+        msg = self.getMessage(1)
+        # ERR_NOSUCHNICK, ERR_NOSUCHCHANNEL, or ERR_CANNOTSENDTOCHAN
+        self.assertIn(msg.command, ("401", "403", "404"))
+
+
+class PrivmsgServermaskTestCase(cases.BaseServerTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.connectClient("chk", "chk")
+        self.sendLine("chk", "PRIVMSG $my.little.server :hello there")
+        msg = self.getMessage("chk")
+        if msg.command == ERR_NOSUCHNICK:
+            raise runner.NotImplementedByController("PRIVMSG to server mask")
+
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testPrivmsgServermask(self):
+        """
+        <https://datatracker.ietf.org/doc/html/rfc1459#section-4.4.1>
+        <https://datatracker.ietf.org/doc/html/rfc2812>
+        <https://github.com/ircdocs/modern-irc/pull/134>
+        """
+        self.connectClient("sender", "sender")
+        self.connectClient("user", "user")
+
+        self.sendLine("sender", "OPER operuser operpassword")
+        self.getMessages("sender")
+
+        self.sendLine("sender", "PRIVMSG $*.server :hello there")
+        self.getMessages("sender")
+        self.assertMessageMatch(
+            self.getMessage("user"),
+            command="PRIVMSG",
+            params=["$*.server", "hello there"],
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testPrivmsgServermaskNoMatch(self):
+        """
+        <https://datatracker.ietf.org/doc/html/rfc1459#section-4.4.1>
+        <https://datatracker.ietf.org/doc/html/rfc2812>
+        <https://github.com/ircdocs/modern-irc/pull/134>
+        """
+        self.connectClient("sender", "sender")
+        self.connectClient("user", "user")
+
+        self.sendLine("sender", "OPER operuser operpassword")
+        self.getMessages("sender")
+
+        self.sendLine("sender", "PRIVMSG $*.foobar :hello there")
+        messages = self.getMessages("sender")
+        self.assertEqual(len(messages), 0, messages)
+        messages = self.getMessages("user")
+        self.assertEqual(len(messages), 0, messages)
+
+    @cases.mark_specifications("Modern")
+    def testPrivmsgServermaskStar(self):
+        """
+        <https://github.com/ircdocs/modern-irc/pull/134>
+
+        Note: 1459 and 2812 explicitly forbid "$*" as target.
+        """
+        self.connectClient("sender", "sender")
+        self.connectClient("user", "user")
+
+        self.sendLine("sender", "OPER operuser operpassword")
+        self.getMessages("sender")
+
+        self.connectClient("user", "user")
+
+        self.sendLine("sender", "OPER operuser operpassword")
+        self.getMessages("sender")
+
+        self.sendLine("sender", "PRIVMSG $* :hello there")
+        self.getMessages("sender")
+        self.assertMessageMatch(
+            self.getMessage("user"), command="PRIVMSG", params=["$*", "hello there"]
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testPrivmsgServermaskNotOper(self):
+        """
+        <https://datatracker.ietf.org/doc/html/rfc1459#section-4.4.1>
+        <https://datatracker.ietf.org/doc/html/rfc2812>
+        <https://github.com/ircdocs/modern-irc/pull/134>
+        """
+        self.connectClient("sender", "sender")
+        self.connectClient("user", "user")
+
+        self.sendLine("sender", "PRIVMSG $*.foobar :hello there")
+        self.assertMessageMatch(self.getMessage("sender"), command=ERR_NOPRIVILEGES)
+
+        pms = [msg for msg in self.getMessages("user") if msg.command == "PRIVMSG"]
+        self.assertEqual(len(pms), 0)
+
+
+class NoticeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testNotice(self):
+        """<https://tools.ietf.org/html/rfc2812#section-3.3.2>"""
+        self.connectClient("foo")
+        self.sendLine(1, "JOIN #chan")
+        self.connectClient("bar")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(2)  # synchronize
+        self.sendLine(1, "NOTICE #chan :hello there")
+        self.getMessages(1)  # synchronize
+        notices = [msg for msg in self.getMessages(2) if msg.command == "NOTICE"]
+        self.assertEqual(len(notices), 1)
+        self.assertMessageMatch(
+            notices[0], command="NOTICE", params=["#chan", "hello there"]
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testNoticeNonexistentChannel(self):
+        """
+        "automatic replies must never be
+        sent in response to a NOTICE message.  This rule applies to servers
+        too - they must not send any error reply back to the client on
+        receipt of a notice"
+        <https://tools.ietf.org/html/rfc1459#section-4.4.2>
+
+        'automatic replies MUST NEVER be sent in response to a NOTICE message.
+        This rule applies to servers too - they MUST NOT send any error repl
+        back to the client on receipt of a notice."
+        <https://tools.ietf.org/html/rfc2812#section-3.3.2>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "NOTICE #nonexistent :hello there")
+        self.assertEqual(self.getMessages(1), [])
+
+
+class TagsTestCase(cases.BaseServerTestCase):
+    @cases.mark_capabilities("message-tags")
+    def testLineTooLong(self):
+        self.connectClient("bar", capabilities=["message-tags"], skip_if_cap_nak=True)
+        self.connectClient(
+            "recver", capabilities=["message-tags"], skip_if_cap_nak=True
+        )
+        self.joinChannel(1, "#xyz")
+        monsterMessage = "@+clientOnlyTagExample=" + "a" * 4096 + " PRIVMSG #xyz hi!"
+        self.sendLine(1, monsterMessage)
+        self.assertEqual(self.getMessages(2), [], "overflowing message was relayed")
+        replies = self.getMessages(1)
+        self.assertIn(ERR_INPUTTOOLONG, set(reply.command for reply in replies))
+
+
+class LengthLimitTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testLineAtLimit(self):
+        self.connectClient("bar", name="bar")
+        self.getMessages("bar")
+        line = "PING " + ("x" * (512 - 7))
+        # this line is exactly as the limit, after including \r\n:
+        self.assertEqual(len(line), 510)
+        # oragono should accept and process this message. the outgoing PONG
+        # will be truncated due to the addition of the server name as source
+        # and initial parameter; this is fine:
+        self.sendLine("bar", line)
+        result = self.getMessage("bar", synchronize=False)
+        self.assertMessageMatch(result, command="PONG")
+        self.assertIn("x" * 450, result.params[-1])
+
+    @cases.mark_specifications("Ergo")
+    def testLineBeyondLimit(self):
+        self.connectClient("bar", name="bar")
+        self.getMessages("bar")
+        line = "PING " + ("x" * (512 - 6))
+        # this line is one over the limit after including \r\n:
+        self.assertEqual(len(line), 511)
+        # oragono should reject this message for exceeding the length limit:
+        self.sendLine("bar", line)
+        result = self.getMessage("bar", synchronize=False)
+        self.assertMessageMatch(result, command=ERR_INPUTTOOLONG)
+        # we should not be disconnected and should be able to join a channel
+        self.joinChannel("bar", "#test_channel")
+
+
+class NoCTCPModeTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Ergo")
+    def testNoCTCPMode(self):
+        self.connectClient("bar", "bar")
+        self.connectClient("qux", "qux")
+        # CTCP is not blocked by default:
+        self.sendLine("qux", "PRIVMSG bar :\x01VERSION\x01")
+        self.getMessages("qux")
+        relay = [msg for msg in self.getMessages("bar") if msg.command == "PRIVMSG"][0]
+        self.assertMessageMatch(
+            relay, command="PRIVMSG", params=["bar", "\x01VERSION\x01"]
+        )
+
+        # set the no-CTCP user mode on bar:
+        self.sendLine("bar", "MODE bar +T")
+        replies = self.getMessages("bar")
+        umode_line = [msg for msg in replies if msg.command == "MODE"][0]
+        self.assertMessageMatch(umode_line, command="MODE", params=["bar", "+T"])
+
+        # CTCP is now blocked:
+        self.sendLine("qux", "PRIVMSG bar :\x01VERSION\x01")
+        self.getMessages("qux")
+        self.assertEqual(self.getMessages("bar"), [])
+
+        # normal PRIVMSG go through:
+        self.sendLine("qux", "PRIVMSG bar :please just tell me your client version")
+        self.getMessages("qux")
+        relay = self.getMessages("bar")[0]
+        self.assertMessageMatch(
+            relay,
+            command="PRIVMSG",
+            nick="qux",
+            params=["bar", "please just tell me your client version"],
+        )

irctest/server_tests/metadata.py

@@ -0,0 +1,245 @@
+"""
+Tests METADATA features.
+<http://ircv3.net/specs/core/metadata-3.2.html>
+"""
+
+from irctest import cases
+
+
+class MetadataTestCase(cases.BaseServerTestCase):
+    valid_metadata_keys = {"valid_key1", "valid_key2"}
+    invalid_metadata_keys = {"invalid_key1", "invalid_key2"}
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testInIsupport(self):
+        """“If METADATA is supported, it MUST be specified in RPL_ISUPPORT
+        using the METADATA key.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html>
+        """
+        self.addClient()
+        self.sendLine(1, "CAP LS 302")
+        self.getCapLs(1)
+        self.sendLine(1, "USER foo foo foo :foo")
+        self.sendLine(1, "NICK foo")
+        self.sendLine(1, "CAP END")
+        self.skipToWelcome(1)
+        m = self.getMessage(1)
+        while m.command != "005":  # RPL_ISUPPORT
+            m = self.getMessage(1)
+        self.assertIn(
+            "METADATA",
+            {x.split("=")[0] for x in m.params[1:-1]},
+            fail_msg="{item} missing from RPL_ISUPPORT",
+        )
+        self.getMessages(1)
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testGetOneUnsetValid(self):
+        """<http://ircv3.net/specs/core/metadata-3.2.html#metadata-get>"""
+        self.connectClient("foo")
+        self.sendLine(1, "METADATA * GET valid_key1")
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="766",  # ERR_NOMATCHINGKEY
+            fail_msg="Did not reply with 766 (ERR_NOMATCHINGKEY) to a "
+            "request to an unset valid METADATA key.",
+        )
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testGetTwoUnsetValid(self):
+        """“Multiple keys may be given. The response will be either RPL_KEYVALUE,
+        ERR_KEYINVALID or ERR_NOMATCHINGKEY for every key in order.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-get>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "METADATA * GET valid_key1 valid_key2")
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="766",  # ERR_NOMATCHINGKEY
+            fail_msg="Did not reply with 766 (ERR_NOMATCHINGKEY) to a "
+            "request to two unset valid METADATA key: {msg}",
+        )
+        self.assertEqual(
+            m.params[1],
+            "valid_key1",
+            m,
+            fail_msg="Response to “METADATA * GET valid_key1 valid_key2” "
+            "did not respond to valid_key1 first: {msg}",
+        )
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="766",  # ERR_NOMATCHINGKEY
+            fail_msg="Did not reply with two 766 (ERR_NOMATCHINGKEY) to a "
+            "request to two unset valid METADATA key: {msg}",
+        )
+        self.assertEqual(
+            m.params[1],
+            "valid_key2",
+            m,
+            fail_msg="Response to “METADATA * GET valid_key1 valid_key2” "
+            "did not respond to valid_key2 as second response: {msg}",
+        )
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testListNoSet(self):
+        """“This subcommand MUST list all currently-set metadata keys along
+        with their values. The response will be zero or more RPL_KEYVALUE
+        events, following by RPL_METADATAEND event.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-list>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "METADATA * LIST")
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="762",  # RPL_METADATAEND
+            fail_msg="Response to “METADATA * LIST” was not "
+            "762 (RPL_METADATAEND) but: {msg}",
+        )
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testListInvalidTarget(self):
+        """“In case of invalid target RPL_METADATAEND MUST NOT be sent.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-list>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "METADATA foobar LIST")
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="765",  # ERR_TARGETINVALID
+            fail_msg="Response to “METADATA <invalid target> LIST” was "
+            "not 765 (ERR_TARGETINVALID) but: {msg}",
+        )
+        commands = {m.command for m in self.getMessages(1)}
+        self.assertNotIn(
+            "762",
+            commands,
+            fail_msg="Sent “METADATA <invalid target> LIST”, got 765 "
+            "(ERR_TARGETINVALID), and then 762 (RPL_METADATAEND)",
+        )
+
+    def assertSetValue(self, target, key, value, displayable_value=None):
+        if displayable_value is None:
+            displayable_value = value
+        self.sendLine(1, "METADATA {} SET {} :{}".format(target, key, value))
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="761",  # RPL_KEYVALUE
+            fail_msg="Did not reply with 761 (RPL_KEYVALUE) to a valid "
+            "“METADATA * SET {} :{}”: {msg}",
+            extra_format=(key, displayable_value),
+        )
+        self.assertEqual(
+            m.params[1],
+            "valid_key1",
+            m,
+            fail_msg="Second param of 761 after setting “{expects}” to "
+            "“{}” is not “{expects}”: {msg}.",
+            extra_format=(displayable_value,),
+        )
+        self.assertEqual(
+            m.params[3],
+            value,
+            m,
+            fail_msg="Fourth param of 761 after setting “{0}” to "
+            "“{1}” is not “{1}”: {msg}.",
+            extra_format=(key, displayable_value),
+        )
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="762",  # RPL_METADATAEND
+            fail_msg="Did not send RPL_METADATAEND after setting "
+            "a valid METADATA key.",
+        )
+
+    def assertGetValue(self, target, key, value, displayable_value=None):
+        self.sendLine(1, "METADATA * GET {}".format(key))
+        m = self.getMessage(1)
+        self.assertMessageMatch(
+            m,
+            command="761",  # RPL_KEYVALUE
+            fail_msg="Did not reply with 761 (RPL_KEYVALUE) to a valid "
+            "“METADATA * GET” when the key is set is set: {msg}",
+        )
+        self.assertEqual(
+            m.params[1],
+            key,
+            m,
+            fail_msg="Second param of 761 after getting “{expects}” "
+            "(which is set) is not “{expects}”: {msg}.",
+        )
+        self.assertEqual(
+            m.params[3],
+            value,
+            m,
+            fail_msg="Fourth param of 761 after getting “{0}” "
+            "(which is set to “{1}”) is not ”{1}”: {msg}.",
+            extra_format=(key, displayable_value),
+        )
+
+    def assertSetGetValue(self, target, key, value, displayable_value=None):
+        self.assertSetValue(target, key, value, displayable_value)
+        self.assertGetValue(target, key, value, displayable_value)
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testSetGetValid(self):
+        """<http://ircv3.net/specs/core/metadata-3.2.html>"""
+        self.connectClient("foo")
+        self.assertSetGetValue("*", "valid_key1", "myvalue")
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testSetGetZeroCharInValue(self):
+        """“Values are unrestricted, except that they MUST be UTF-8.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-restrictions>
+        """
+        self.connectClient("foo")
+        self.assertSetGetValue("*", "valid_key1", "zero->\0<-zero", "zero->\\0<-zero")
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testSetGetHeartInValue(self):
+        """“Values are unrestricted, except that they MUST be UTF-8.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-restrictions>
+        """
+        heart = b"\xf0\x9f\x92\x9c".decode()
+        self.connectClient("foo")
+        self.assertSetGetValue(
+            "*",
+            "valid_key1",
+            "->{}<-".format(heart),
+            "zero->{}<-zero".format(heart.encode()),
+        )
+
+    @cases.mark_specifications("IRCv3", deprecated=True)
+    def testSetInvalidUtf8(self):
+        """“Values are unrestricted, except that they MUST be UTF-8.”
+        -- <http://ircv3.net/specs/core/metadata-3.2.html#metadata-restrictions>
+        """
+        self.connectClient("foo")
+        # Sending directly because it is not valid UTF-8 so Python would
+        # not like it
+        self.clients[1].conn.sendall(
+            b"METADATA * SET valid_key1 " b":invalid UTF-8 ->\xc3<-\r\n"
+        )
+        commands = {m.command for m in self.getMessages(1)}
+        self.assertNotIn(
+            "761",
+            commands,  # RPL_KEYVALUE
+            fail_msg="Setting METADATA key to a value containing invalid "
+            "UTF-8 was answered with 761 (RPL_KEYVALUE)",
+        )
+        self.clients[1].conn.sendall(
+            b"METADATA * SET valid_key1 " b":invalid UTF-8: \xc3\r\n"
+        )
+        commands = {m.command for m in self.getMessages(1)}
+        self.assertNotIn(
+            "761",
+            commands,  # RPL_KEYVALUE
+            fail_msg="Setting METADATA key to a value containing invalid "
+            "UTF-8 was answered with 761 (RPL_KEYVALUE)",
+        )

irctest/server_tests/monitor.py

@@ -0,0 +1,319 @@
+"""
+<http://ircv3.net/specs/core/monitor-3.2.html>
+"""
+
+from irctest import cases
+from irctest.basecontrollers import NotImplementedByController
+from irctest.client_mock import NoMessageException
+from irctest.numerics import (
+    RPL_ENDOFMONLIST,
+    RPL_MONLIST,
+    RPL_MONOFFLINE,
+    RPL_MONONLINE,
+)
+from irctest.patma import ANYSTR, StrRe
+
+
+class MonitorTestCase(cases.BaseServerTestCase):
+    def check_server_support(self):
+        if "MONITOR" not in self.server_support:
+            raise NotImplementedByController("MONITOR")
+
+    def assertMononline(self, client, nick, m=None):
+        if not m:
+            m = self.getMessage(client)
+        self.assertMessageMatch(
+            m,
+            command="730",  # RPL_MONONLINE
+            params=[ANYSTR, StrRe(nick + "(!.*)?")],
+            fail_msg="Unexpected notification that monitored nick “{}” "
+            "is online: {msg}",
+            extra_format=(nick,),
+        )
+
+    def assertMonoffline(self, client, nick, m=None):
+        if not m:
+            m = self.getMessage(client)
+        self.assertMessageMatch(
+            m,
+            command="731",  # RPL_MONOFFLINE
+            params=[ANYSTR, nick],
+            fail_msg="Unexpected notification that monitored nick “{}” "
+            "is offline: {msg}",
+            extra_format=(nick,),
+        )
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorOneDisconnected(self):
+        """“If any of the targets being added are online, the server will
+        generate RPL_MONONLINE numerics listing those targets that are
+        online.”
+        -- <http://ircv3.net/specs/core/monitor-3.2.html#monitor--targettarget2>
+        """
+        self.connectClient("foo")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR + bar")
+        self.assertMonoffline(1, "bar")
+        self.connectClient("bar")
+        self.assertMononline(1, "bar")
+        self.sendLine(2, "QUIT :bye")
+        try:
+            self.getMessages(2)
+        except ConnectionResetError:
+            pass
+        self.assertMonoffline(1, "bar")
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorOneConnection(self):
+        self.connectClient("foo")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR + bar")
+        self.getMessages(1)
+        self.connectClient("bar")
+        self.assertMononline(1, "bar")
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorOneConnected(self):
+        """“If any of the targets being added are offline, the server will
+        generate RPL_MONOFFLINE numerics listing those targets that are
+        online.”
+        -- <http://ircv3.net/specs/core/monitor-3.2.html#monitor--targettarget2>
+        """
+        self.connectClient("foo")
+        self.check_server_support()
+        self.connectClient("bar")
+        self.sendLine(1, "MONITOR + bar")
+        self.assertMononline(1, "bar")
+        self.sendLine(2, "QUIT :bye")
+        try:
+            self.getMessages(2)
+        except ConnectionResetError:
+            pass
+        self.assertMonoffline(1, "bar")
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorOneConnectionWithQuit(self):
+        self.connectClient("foo")
+        self.check_server_support()
+        self.connectClient("bar")
+        self.sendLine(1, "MONITOR + bar")
+        self.assertMononline(1, "bar")
+        self.sendLine(2, "QUIT :bye")
+        try:
+            self.getMessages(2)
+        except ConnectionResetError:
+            pass
+        self.assertMonoffline(1, "bar")
+        self.connectClient("bar")
+        self.assertMononline(1, "bar")
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorConnectedAndDisconnected(self):
+        """“If any of the targets being added are online, the server will
+        generate RPL_MONONLINE numerics listing those targets that are
+        online.
+
+        If any of the targets being added are offline, the server will
+        generate RPL_MONOFFLINE numerics listing those targets that are
+        online.”
+        -- <http://ircv3.net/specs/core/monitor-3.2.html#monitor--targettarget2>
+        """
+        self.connectClient("foo")
+        self.check_server_support()
+        self.connectClient("bar")
+        self.sendLine(1, "MONITOR + bar,baz")
+        m1 = self.getMessage(1)
+        m2 = self.getMessage(1)
+        commands = {m1.command, m2.command}
+        self.assertEqual(
+            commands,
+            {"730", "731"},
+            fail_msg="Did not send one 730 (RPL_MONONLINE) and one "
+            "731 (RPL_MONOFFLINE) after “MONITOR + bar,baz” when “bar” "
+            "is online and “baz” is offline. Sent this instead: {}",
+            extra_format=((m1, m2)),
+        )
+        if m1.command == "731":
+            (m1, m2) = (m2, m1)
+
+        self.assertMononline(None, "bar", m=m1)
+        self.assertMonoffline(None, "baz", m=m2)
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testUnmonitor(self):
+        self.connectClient("foo")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR + bar")
+        self.getMessages(1)
+        self.connectClient("bar")
+        self.assertMononline(1, "bar")
+        self.sendLine(1, "MONITOR - bar")
+        self.assertEqual(
+            self.getMessages(1),
+            [],
+            fail_msg="Got messages after “MONITOR - bar”: {got}",
+        )
+        self.sendLine(2, "QUIT :bye")
+        try:
+            self.getMessages(2)
+        except ConnectionResetError:
+            pass
+        self.assertEqual(
+            self.getMessages(1),
+            [],
+            fail_msg="Got messages after disconnection of unmonitored " "nick: {got}",
+        )
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorForbidsMasks(self):
+        """“The MONITOR implementation also enhances user privacy by
+        disallowing subscription to hostmasks, allowing users to avoid
+        nick-change stalking.”
+        -- <http://ircv3.net/specs/core/monitor-3.2.html#watch-vs-monitor>
+
+        “For this specification, ‘target’ MUST be a valid nick as determined
+        by the IRC daemon.”
+        -- <http://ircv3.net/specs/core/monitor-3.2.html#monitor-command>
+        """
+        self.connectClient("foo")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR + *!username@localhost")
+        self.sendLine(1, "MONITOR + *!username@127.0.0.1")
+        try:
+            m = self.getMessage(1)
+            self.assertNotEqual(
+                m.command,
+                "731",
+                m,
+                fail_msg="Got 731 (RPL_MONOFFLINE) after adding a monitor "
+                "on a mask: {msg}",
+            )
+        except NoMessageException:
+            pass
+        self.connectClient("bar")
+        try:
+            m = self.getMessage(1)
+        except NoMessageException:
+            pass
+        else:
+            raise AssertionError(
+                "Got message after client whose MONITORing "
+                "was requested via hostmask connected: {}".format(m)
+            )
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testTwoMonitoringOneRemove(self):
+        """Tests the following scenario:
+        * foo MONITORs qux
+        * bar MONITORs qux
+        * bar unMONITORs qux
+        * qux connects.
+        """
+        self.connectClient("foo")
+        self.check_server_support()
+        self.connectClient("bar")
+        self.sendLine(1, "MONITOR + qux")
+        self.sendLine(2, "MONITOR + qux")
+        self.getMessages(1)
+        self.getMessages(2)
+        self.sendLine(2, "MONITOR - qux")
+        messages = self.getMessages(2)
+        self.assertEqual(
+            messages,
+            [],
+            fail_msg="Got response to “MONITOR -”: {}",
+            extra_format=(messages,),
+        )
+        self.connectClient("qux")
+        self.getMessages(3)
+        messages = self.getMessages(1)
+        self.assertNotEqual(
+            messages,
+            [],
+            fail_msg="Received no message after MONITORed client " "connects.",
+        )
+        messages = self.getMessages(2)
+        self.assertEqual(
+            messages,
+            [],
+            fail_msg="Got response to unmonitored client: {}",
+            extra_format=(messages,),
+        )
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testMonitorList(self):
+        def checkMonitorSubjects(messages, client_nick, expected_targets):
+            # collect all the RPL_MONLIST nicks into a set:
+            result = set()
+            for message in messages:
+                if message.command == RPL_MONLIST:
+                    self.assertEqual(message.params[0], client_nick)
+                    result.update(message.params[1].split(","))
+            # finally, RPL_ENDOFMONLIST should be sent
+            self.assertEqual(messages[-1].command, RPL_ENDOFMONLIST)
+            self.assertEqual(messages[-1].params[0], client_nick)
+            self.assertEqual(result, expected_targets)
+
+        self.connectClient("bar")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR L")
+        checkMonitorSubjects(self.getMessages(1), "bar", set())
+
+        self.sendLine(1, "MONITOR + qux")
+        self.getMessages(1)
+        self.sendLine(1, "MONITOR L")
+        checkMonitorSubjects(self.getMessages(1), "bar", {"qux"})
+
+        self.sendLine(1, "MONITOR + bazbat")
+        self.getMessages(1)
+        self.sendLine(1, "MONITOR L")
+        checkMonitorSubjects(self.getMessages(1), "bar", {"qux", "bazbat"})
+
+        self.sendLine(1, "MONITOR - qux")
+        self.getMessages(1)
+        self.sendLine(1, "MONITOR L")
+        checkMonitorSubjects(self.getMessages(1), "bar", {"bazbat"})
+
+    @cases.mark_specifications("IRCv3")
+    @cases.mark_isupport("MONITOR")
+    def testNickChange(self):
+        # see oragono issue #1076: nickname changes must trigger RPL_MONOFFLINE
+        self.connectClient("bar")
+        self.check_server_support()
+        self.sendLine(1, "MONITOR + qux")
+        self.getMessages(1)
+
+        self.connectClient("baz")
+        self.getMessages(2)
+        self.assertEqual(self.getMessages(1), [])
+
+        self.sendLine(2, "NICK qux")
+        self.getMessages(2)
+        mononline = self.getMessages(1)[0]
+        self.assertEqual(mononline.command, RPL_MONONLINE)
+        self.assertEqual(len(mononline.params), 2, mononline.params)
+        self.assertIn(mononline.params[0], ("bar", "*"))
+        self.assertEqual(mononline.params[1].split("!")[0], "qux")
+
+        # no numerics for a case change
+        self.sendLine(2, "NICK QUX")
+        self.getMessages(2)
+        self.assertEqual(self.getMessages(1), [])
+
+        self.sendLine(2, "NICK bazbat")
+        self.getMessages(2)
+        monoffline = self.getMessages(1)[0]
+        # should get RPL_MONOFFLINE with the current unfolded nick
+        self.assertEqual(monoffline.command, RPL_MONOFFLINE)
+        self.assertEqual(len(monoffline.params), 2, monoffline.params)
+        self.assertIn(monoffline.params[0], ("bar", "*"))
+        self.assertEqual(monoffline.params[1].split("!")[0], "QUX")

irctest/server_tests/multi_prefix.py

@@ -0,0 +1,56 @@
+"""
+Tests multi-prefix.
+<http://ircv3.net/specs/extensions/multi-prefix-3.1.html>
+"""
+
+from irctest import cases
+from irctest.patma import ANYSTR
+
+
+class MultiPrefixTestCase(cases.BaseServerTestCase):
+    @cases.mark_capabilities("multi-prefix")
+    def testMultiPrefix(self):
+        """“When requested, the multi-prefix client capability will cause the
+        IRC server to send all possible prefixes which apply to a user in NAMES
+        and WHO output.
+
+        These prefixes MUST be in order of ‘rank’, from highest to lowest.
+        """
+        self.connectClient("foo", capabilities=["multi-prefix"])
+        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",
+            fail_msg="Expected NAMES response (353) with @+foo, got: {msg}",
+        )
+        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.assertTrue(
+            "@+" in msg.params[6],
+            'Expected WHO response (352) with "@+" in param 7, got: {msg}'.format(
+                msg=msg
+            ),
+        )

irctest/server_tests/multiline.py

@@ -0,0 +1,137 @@
+"""
+draft/multiline
+"""
+
+from irctest import cases
+from irctest.patma import ANYDICT, StrRe
+
+CAP_NAME = "draft/multiline"
+BATCH_TYPE = "draft/multiline"
+CONCAT_TAG = "draft/multiline-concat"
+
+base_caps = ["message-tags", "batch", "echo-message", "server-time", "labeled-response"]
+
+
+class MultilineTestCase(cases.BaseServerTestCase, cases.OptionalityHelper):
+    @cases.mark_capabilities("draft/multiline")
+    def testBasic(self):
+        self.connectClient(
+            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=True
+        )
+        self.joinChannel(1, "#test")
+        self.connectClient("bob", capabilities=(base_caps + [CAP_NAME]))
+        self.joinChannel(2, "#test")
+        self.connectClient("charlie", capabilities=base_caps)
+        self.joinChannel(3, "#test")
+
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+
+        self.sendLine(1, "@label=xyz BATCH +123 %s #test" % (BATCH_TYPE,))
+        self.sendLine(1, "@batch=123 PRIVMSG #test hello")
+        self.sendLine(1, "@batch=123 PRIVMSG #test :#how is ")
+        self.sendLine(1, "@batch=123;%s PRIVMSG #test :everyone?" % (CONCAT_TAG,))
+        self.sendLine(1, "BATCH -123")
+
+        echo = self.getMessages(1)
+        batchStart, batchEnd = echo[0], echo[-1]
+        self.assertMessageMatch(
+            batchStart,
+            command="BATCH",
+            params=[StrRe(r"\+.*"), BATCH_TYPE, "#test"],
+            tags={"label": "xyz", **ANYDICT},
+        )
+        self.assertEqual(batchStart.tags.get("label"), "xyz")
+        self.assertMessageMatch(batchEnd, command="BATCH", params=[StrRe("-.*")])
+        self.assertEqual(
+            batchStart.params[0][1:],
+            batchEnd.params[0][1:],
+            fail_msg="batch start and end do not match",
+        )
+        msgid = batchStart.tags.get("msgid")
+        time = batchStart.tags.get("time")
+        assert msgid
+        assert time
+        privmsgs = echo[1:-1]
+        for msg in privmsgs:
+            self.assertMessageMatch(msg, command="PRIVMSG")
+            self.assertNotIn("msgid", msg.tags)
+            self.assertNotIn("time", msg.tags)
+        self.assertIn(CONCAT_TAG, echo[3].tags)
+
+        relay = self.getMessages(2)
+        batchStart, batchEnd = relay[0], relay[-1]
+        self.assertMessageMatch(
+            batchStart, command="BATCH", params=[StrRe(r"\+.*"), BATCH_TYPE, "#test"]
+        )
+        batchTag = batchStart.params[0][1:]
+        self.assertMessageMatch(batchEnd, command="BATCH", params=["-" + batchTag])
+        self.assertEqual(batchStart.tags.get("msgid"), msgid)
+        self.assertEqual(batchStart.tags.get("time"), time)
+        privmsgs = relay[1:-1]
+        for msg in privmsgs:
+            self.assertMessageMatch(msg, command="PRIVMSG")
+            self.assertNotIn("msgid", msg.tags)
+            self.assertNotIn("time", msg.tags)
+            self.assertEqual(msg.tags.get("batch"), batchTag)
+        self.assertIn(CONCAT_TAG, relay[3].tags)
+
+        fallback_relay = self.getMessages(3)
+        relayed_fmsgids = []
+        for msg in fallback_relay:
+            self.assertMessageMatch(msg, command="PRIVMSG")
+            relayed_fmsgids.append(msg.tags.get("msgid"))
+            self.assertEqual(msg.tags.get("time"), time)
+            self.assertNotIn(CONCAT_TAG, msg.tags)
+        self.assertEqual(relayed_fmsgids, [msgid] + [None] * (len(fallback_relay) - 1))
+
+    @cases.mark_capabilities("draft/multiline")
+    def testBlankLines(self):
+        self.connectClient(
+            "alice", capabilities=(base_caps + [CAP_NAME]), skip_if_cap_nak=True
+        )
+        self.joinChannel(1, "#test")
+        self.connectClient("bob", capabilities=(base_caps + [CAP_NAME]))
+        self.joinChannel(2, "#test")
+        self.connectClient("charlie", capabilities=base_caps)
+        self.joinChannel(3, "#test")
+
+        self.getMessages(1)
+        self.getMessages(2)
+        self.getMessages(3)
+
+        self.sendLine(
+            1, "@label=xyz;+client-only-tag BATCH +123 %s #test" % (BATCH_TYPE,)
+        )
+        self.sendLine(1, "@batch=123 PRIVMSG #test :")
+        self.sendLine(1, "@batch=123 PRIVMSG #test :#how is ")
+        self.sendLine(1, "@batch=123;%s PRIVMSG #test :everyone?" % (CONCAT_TAG,))
+        self.sendLine(1, "BATCH -123")
+        self.getMessages(1)
+
+        relay = self.getMessages(2)
+        batch_start = relay[0]
+        privmsgs = relay[1:-1]
+        self.assertEqual(len(privmsgs), 3)
+        self.assertMessageMatch(privmsgs[0], command="PRIVMSG", params=["#test", ""])
+        self.assertMessageMatch(
+            privmsgs[1], command="PRIVMSG", params=["#test", "#how is "]
+        )
+        self.assertMessageMatch(
+            privmsgs[2], command="PRIVMSG", params=["#test", "everyone?"]
+        )
+        self.assertIn("+client-only-tag", batch_start.tags)
+        msgid = batch_start.tags["msgid"]
+
+        fallback_relay = self.getMessages(3)
+        self.assertEqual(len(fallback_relay), 2)
+        self.assertMessageMatch(
+            fallback_relay[0], command="PRIVMSG", params=["#test", "#how is "]
+        )
+        self.assertMessageMatch(
+            fallback_relay[1], command="PRIVMSG", params=["#test", "everyone?"]
+        )
+        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)

irctest/server_tests/names.py

@@ -0,0 +1,49 @@
+from irctest import cases
+from irctest.numerics import RPL_ENDOFNAMES
+from irctest.patma import ANYSTR
+
+
+class NamesTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testNamesInvalidChannel(self):
+        """
+        "There is no error reply for bad channel names."
+        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
+
+        "If the channel name is invalid or the channel does not exist,
+        one `RPL_ENDOFNAMES` numeric containing the given channel name
+        should be returned."
+        -- https://modern.ircdocs.horse/#names-message
+        """
+        self.connectClient("foo")
+        self.getMessages(1)
+
+        self.sendLine(1, "NAMES invalid")
+        self.assertMessageMatch(
+            self.getMessage(1),
+            command=RPL_ENDOFNAMES,
+            params=["foo", "invalid", ANYSTR],
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812", "Modern")
+    def testNamesNonexistingChannel(self):
+        """
+        "There is no error reply for bad channel names."
+        -- https://datatracker.ietf.org/doc/html/rfc1459#section-4.2.5
+        -- https://datatracker.ietf.org/doc/html/rfc2812#section-3.2.5
+
+        "If the channel name is invalid or the channel does not exist,
+        one `RPL_ENDOFNAMES` numeric containing the given channel name
+        should be returned."
+        -- https://modern.ircdocs.horse/#names-message
+        """
+        self.connectClient("foo")
+        self.getMessages(1)
+
+        self.sendLine(1, "NAMES #nonexisting")
+        self.assertMessageMatch(
+            self.getMessage(1),
+            command=RPL_ENDOFNAMES,
+            params=["foo", "#nonexisting", ANYSTR],
+        )

irctest/server_tests/part.py

@@ -0,0 +1,148 @@
+import time
+
+from irctest import cases
+
+
+class PartTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testPartNotInEmptyChannel(self):
+        """“442     ERR_NOTONCHANNEL
+            "<channel> :You're not on that channel"
+
+        - Returned by the server whenever a client tries to
+          perform a channel effecting command for which the
+          client isn't a member.”
+          -- <https://tools.ietf.org/html/rfc1459#section-6.1>
+          and <https://tools.ietf.org/html/rfc2812#section-5.2>
+
+        According to RFCs, ERR_NOSUCHCHANNEL should only be used for invalid
+        channel names:
+        “403     ERR_NOSUCHCHANNEL
+          "<channel name> :No such channel"
+
+        - Used to indicate the given channel name is invalid.”
+        -- <https://tools.ietf.org/html/rfc1459#section-6.1>
+        and <https://tools.ietf.org/html/rfc2812#section-5.2>
+
+        However, many implementations use 479 instead, so let's allow it.
+        <http://danieloaks.net/irc-defs/defs/ircnumerics.html#403>
+        <http://danieloaks.net/irc-defs/defs/ircnumerics.html#479>
+        """
+        self.connectClient("foo")
+        self.sendLine(1, "PART #chan")
+        m = self.getMessage(1)
+        self.assertIn(
+            m.command,
+            {"442", "403"},
+            m,  # ERR_NOTONCHANNEL, ERR_NOSUCHCHANNEL
+            fail_msg="Expected ERR_NOTONCHANNEL (442) or "
+            "ERR_NOSUCHCHANNEL (403) after PARTing an empty channel "
+            "one is not on, but got: {msg}",
+        )
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testPartNotInNonEmptyChannel(self):
+        self.connectClient("foo")
+        self.connectClient("bar")
+        self.sendLine(1, "JOIN #chan")
+        self.getMessages(1)  # Synchronize
+        self.sendLine(2, "PART #chan")
+        m = self.getMessage(2)
+        self.assertMessageMatch(
+            m,
+            command="442",  # ERR_NOTONCHANNEL
+            fail_msg="Expected ERR_NOTONCHANNEL (442) "
+            "after PARTing a non-empty channel "
+            "one is not on, but got: {msg}",
+        )
+        self.assertEqual(self.getMessages(2), [])
+
+    testPartNotInNonEmptyChannel.__doc__ = testPartNotInEmptyChannel.__doc__
+
+    @cases.mark_specifications("RFC1459", "RFC2812")
+    def testBasicPart(self):
+        self.connectClient("bar")
+        self.sendLine(1, "JOIN #chan")
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        self.connectClient("baz")
+        self.sendLine(2, "JOIN #chan")
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        # skip the rest of the JOIN burst:
+        self.getMessages(1)
+        self.getMessages(2)
+
+        self.sendLine(1, "PART #chan")
+        # both the PART'ing client and the other channel member should receive
+        # a PART line:
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="PART")
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="PART")
+
+    @cases.mark_specifications("RFC2812")
+    def testBasicPartRfc2812(self):
+        """
+        “If a "Part Message" is given, this will be sent
+        instead of the default message, the nickname.”
+        """
+        self.connectClient("bar")
+        self.sendLine(1, "JOIN #chan")
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        self.connectClient("baz")
+        self.sendLine(2, "JOIN #chan")
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        # skip the rest of the JOIN burst:
+        self.getMessages(1)
+        self.getMessages(2)
+
+        # Despite `anti_spam_exit_message_time = 0`, hybrid does not immediately
+        # allow custom PART reasons.
+        time.sleep(1)
+
+        self.sendLine(1, "PART #chan :bye everyone")
+        # both the PART'ing client and the other channel member should receive
+        # a PART line:
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="PART", params=["#chan", "bye everyone"])
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="PART", params=["#chan", "bye everyone"])
+
+    @cases.mark_specifications("RFC2812")
+    def testPartMessage(self):
+        """
+        “If a "Part Message" is given, this will be sent
+        instead of the default message, the nickname.”
+        """
+        self.connectClient("bar")
+        self.sendLine(1, "JOIN #chan")
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        self.connectClient("baz")
+        self.sendLine(2, "JOIN #chan")
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="JOIN", params=["#chan"])
+
+        # skip the rest of the JOIN burst:
+        self.getMessages(1)
+        self.getMessages(2)
+
+        # Despite `anti_spam_exit_message_time = 0`, hybrid does not immediately
+        # allow custom PART reasons.
+        time.sleep(1)
+
+        self.sendLine(1, "PART #chan :bye everyone")
+        # both the PART'ing client and the other channel member should receive
+        # a PART line:
+        m = self.getMessage(1)
+        self.assertMessageMatch(m, command="PART", params=["#chan", "bye everyone"])
+        m = self.getMessage(2)
+        self.assertMessageMatch(m, command="PART", params=["#chan", "bye everyone"])

irctest/server_tests/pingpong.py

@@ -0,0 +1,42 @@
+from irctest import cases
+from irctest.numerics import ERR_NEEDMOREPARAMS, ERR_NOORIGIN
+from irctest.patma import ANYSTR
+
+
+class PingPongTestCase(cases.BaseServerTestCase):
+    @cases.mark_specifications("Modern")
+    def testPing(self):
+        """https://github.com/ircdocs/modern-irc/pull/99"""
+        self.connectClient("foo")
+        self.sendLine(1, "PING abcdef")
+        self.assertMessageMatch(
+            self.getMessage(1), command="PONG", params=["My.Little.Server", "abcdef"]
+        )
+
+    @cases.mark_specifications("Modern")
+    def testPingNoToken(self):
+        """https://github.com/ircdocs/modern-irc/pull/99"""
+        self.connectClient("foo")
+        self.sendLine(1, "PING")
+        m = self.getMessage(1)
+        if m.command == ERR_NOORIGIN:
+            self.assertMessageMatch(m, command=ERR_NOORIGIN, params=["foo", ANYSTR])
+        else:
+            self.assertMessageMatch(
+                m, command=ERR_NEEDMOREPARAMS, params=["foo", "PING", ANYSTR]
+            )
+
+    @cases.mark_specifications("Modern")
+    def testPingEmptyToken(self):
+        """https://github.com/ircdocs/modern-irc/pull/99"""
+        self.connectClient("foo")
+        self.sendLine(1, "PING :")
+        m = self.getMessage(1)
+        if m.command == "PONG":
+            self.assertMessageMatch(m, command="PONG", params=["My.Little.Server", ""])
+        elif m.command == ERR_NOORIGIN:
+            self.assertMessageMatch(m, command=ERR_NOORIGIN, params=["foo", ANYSTR])
+        else:
+            self.assertMessageMatch(
+                m, command=ERR_NEEDMOREPARAMS, params=["foo", "PING", ANYSTR]
+            )

irctest/server_tests/quit.py

@@ -0,0 +1,60 @@
+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")
+    def testQuit(self):
+        """“Once a user has joined a channel, he receives information about
+        all commands his server receives affecting the channel.  This
+        includes [...] QUIT”
+        <https://tools.ietf.org/html/rfc2812#section-3.2.1>
+        """
+        self.connectClient("bar")
+        self.joinChannel(1, "#chan")
+        self.connectClient("qux")
+        self.sendLine(2, "JOIN #chan")
+        self.getMessages(2)
+
+        self.getMessages(1)
+
+        # Despite `anti_spam_exit_message_time = 0`, hybrid does not immediately
+        # allow custom PART reasons.
+        time.sleep(1)
+
+        self.sendLine(2, "QUIT :qux out")
+        self.getMessages(2)
+        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, [])