Merge branch 'release/0.5.0'

Author: Cobular

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: JakeCover

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"
+    open-pull-requests-limit: 2

.github/workflows/publish-to-test-pypi.yml

@@ -0,0 +1,40 @@
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+
+on:
+  release:
+    types:
+      - created
+
+jobs:
+  build-n-publish:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@2
+      - name: Set up Python 3.9
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.9
+    - name: Install pypa/build
+      run: >-
+        python -m
+        pip install
+        build
+    - name: Build a binary wheel and a source tarball
+      run: >-
+        python -m
+        build
+        --sdist
+        --wheel
+        --outdir dist/
+        .
+    - name: Publish distribution 📦 to Test PyPI
+      uses: pypa/gh-action-pypi-publish@master
+      with:
+        password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        repository_url: https://test.pypi.org/legacy/
+    - name: Publish distribution 📦 to PyPI
+      if: startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@master
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/run_tests.yml

@@ -0,0 +1,55 @@
+# Tests distest on 3.9 only. Faster, so run every push
+name: Run Tests (single version)
+
+on:
+  push:
+    branches-ignore: [ develop, master, release/**, dependabot/** ]
+  pull_request:
+    branches-ignore: [ develop ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install .
+
+      - name: Test with distest
+        run: |
+          ./run_tests.sh
+        env:
+          TARGET_ID: "582625299611648042"
+          CHANNEL: "586041924129914910"
+          TESTER_TOKEN: ${{ secrets.TESTER_TOKEN }}
+          TARGET_TOKEN: ${{ secrets.TARGET_TOKEN }}
+
+
+  test_docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          clean: false
+          fetch-depth: 20
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -r requirements-dev.txt
+          pip install .
+      - name: Test Docs
+        run: ./test_sphinx.sh
+        shell: bash

.github/workflows/run_tests_matrix.yml

@@ -0,0 +1,59 @@
+# Runs tests on many versions of python, slower so only run on develop
+name: Run Tests Matrix
+
+on:
+  push:
+    branches: [ develop, master, release/**, dependabot/** ]
+  pull_request:
+    branches: [ develop ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.6, 3.7, 3.8, 3.9]
+      max-parallel: 1
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install .
+
+    - name: Test with distest
+      run: |
+        ./run_tests.sh
+      env:
+        TARGET_ID: "582625299611648042"
+        CHANNEL: "586041924129914910"
+        TESTER_TOKEN: ${{ secrets.TESTER_TOKEN }}
+        TARGET_TOKEN: ${{ secrets.TARGET_TOKEN }}
+
+  test_docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          clean: false
+          fetch-depth: 20
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -r requirements-dev.txt
+          pip install .
+      - name: Test Docs
+        run: ./test_sphinx.sh
+        shell: bash

.gitignore

@@ -1,8 +1,10 @@
+.run
+
 # Compiled python modules.
 *.py[cod]
 
 # virtualenv
-/venv/
+/venv*
 
 # Setuptools distribution folder.
 /dist/
@@ -91,3 +93,4 @@ fkjdfkasdfkh\.txt
 docs/build/
 
 .idea/
+.run/

distest/TestInterface/__init__.py

@@ -1,4 +1,6 @@
 import enum
+import discord
+from typing import Optional
 
 
 class TestResult(enum.Enum):
@@ -48,17 +50,17 @@ class TestInterface:
         ``Message`` to be passed to them. This allows for more flexibility when you need it and an easier
         option when you don't.
 
-    :param discord.Client client: The discord client of the tester.
+    :param DiscordCliInterface client: The discord client of the tester.
     :param discord.TextChannel channel: The discord channel in which to run the tests.
     :param discord.Member target: The bot we're testing.
     """
 
     def __init__(self, client, channel, target):
         self.client = client
-        self.channel = channel
-        self.target = target
-        self.voice_client = None
-        self.voice_channel = None
+        self.channel: discord.TextChannel = channel
+        self.target: discord.Member = target
+        self.voice_client: Optional[discord.VoiceClient] = None
+        self.voice_channel: Optional[discord.VoiceChannel] = None
 
     # Imported Methods
     from ._helpers import send_message, _check_message, edit_message

distest/TestInterface/_oddballs.py

@@ -1,4 +1,5 @@
 from concurrent.futures import _base
+from asyncio.exceptions import TimeoutError, CancelledError
 from discord import Reaction
 from distest.exceptions import (
     UnexpectedResponseError,
@@ -16,7 +17,7 @@ async def ensure_silence(self):
         await self.client.wait_for(
             "message", timeout=self.client.timeout, check=self._check_message
         )
-    except _base.TimeoutError:
+    except (_base.TimeoutError, TimeoutError, CancelledError):
         pass
     else:
         raise UnexpectedResponseError

distest/__init__.py

@@ -139,6 +139,6 @@ def run_command_line_bot(target, token, tests, channel_id, stats, collector, tim
         :param TestCollector collector: The collector that gathered our tests.
         :param int timeout: The amount of time to wait for responses before failing tests.
     """
-    bot = DiscordCliInterface(target, collector, tests, channel_id, stats, timeout)
-    failed = bot.run(token)  # returns True if a test failed
+    m_bot = DiscordCliInterface(target, collector, tests, channel_id, stats, timeout)
+    failed = m_bot.run(token)  # returns True if a test failed
     sys.exit(1 if failed else 0)  # Calls sys.exit based on the state of `failed`

distest/bot.py

@@ -8,6 +8,7 @@
 :py:class:`DiscordCliInterface` is a subclass of :py:class:`DiscordInteractiveInterface` and simply contains logic to
 start the bot when it wakes up
 """
+
 import discord
 
 from .TestInterface import TestResult, Test, TestInterface
@@ -24,6 +25,7 @@
 
 intents = discord.Intents.default()
 intents.members = True
+intents.presences = True
 
 
 class DiscordBot(discord.Client):
@@ -50,18 +52,21 @@ def _find_target(self, server: discord.Guild) -> discord.Member:
         for member in server.members:
             if self._target_name == member.id:
                 if member.status == discord.Status.offline:
-                    print("Looks like the target bot is on the server but offline, you might want to check on that!")
+                    print("Looks like the target bot is on the server but offline, "
+                          "you might want to check on that!")
                 return member
+        print("Looks like I can't see any server members! You may need to enable the privileged gateway intent, see "
+              "here for how to do so: https://discordpy.readthedocs.io/en/latest/intents.html")
         raise KeyError("Could not find member with id {}".format(self._target_name))
 
     async def run_test(
-        self, test: Test, channel: discord.TextChannel, stop_error=False
+            self, test: Test, channel: discord.TextChannel, stop_error=False
     ) -> TestResult:
         """ Run a single test in a given channel.
 
             Updates the test with the result and returns it
 
-            :param Test test: The :py:class:`Test` that is to be run
+            :param Test test: The :py:class:`Test <distest.TestInterface.Test>` that is to be run
             :param discord.TextChannel channel: The
             :param stop_error: Weather or not to stop the program on error. Not currently in use.
             :return: Result of the test
@@ -128,9 +133,9 @@ async def _build_stats(self, tests) -> str:
             if test.result is TestResult.UNRUN:
                 response += "⚫ Not run\n"
             elif test.result is TestResult.SUCCESS:
-                response += "✔️ Passed\n"
+                response += "✓ Passed\n"
             elif test.result is TestResult.FAILED:
-                response += "❌ Failed\n"
+                response += "✘ Failed\n"
                 self.failure = True
         response += "```\n"
         return response
@@ -217,7 +222,6 @@ def __init__(self, target_id, collector, test, channel_id, stats, timeout):
         self._stats = stats
         self._channel = None
 
-    #
     def run(self, token) -> int:
         """ Override of the default run() that returns failure state after completion.
         Allows the failure to cascade back up until it is processed into an exit code by