Merge branch 'main' into cleanrework

13 files changed, 1381 insertions, 242 deletions

diff --git a/tests/README.md b/tests/README.md
index 4f62edd68..b7fddfaa2 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -4,6 +4,14 @@ Our bot is one of the most important tools we have for running our community. As
 
 _**Note:** This is a practical guide to getting started with writing tests for our bot, not a general introduction to writing unit tests in Python. If you're looking for a more general introduction, you can take a look at the [Additional resources](#additional-resources) section at the bottom of this page._
 
+### Table of contents:
+- [Tools](#tools)
+- [Running tests](#running-tests)  
+- [Writing tests](#writing-tests)
+- [Mocking](#mocking)
+- [Some considerations](#some-considerations)
+- [Additional resources](#additional-resources)
+
 ## Tools
 
 We are using the following modules and packages for our unit tests:
@@ -11,14 +19,42 @@ We are using the following modules and packages for our unit tests:
 - [unittest](https://docs.python.org/3/library/unittest.html) (standard library)
 - [unittest.mock](https://docs.python.org/3/library/unittest.mock.html) (standard library)
 - [coverage.py](https://coverage.readthedocs.io/en/stable/)
+- [pytest-cov](https://pytest-cov.readthedocs.io/en/latest/index.html)
+
+We also use the following package as a test runner:
+- [pytest](https://docs.pytest.org/en/6.2.x/)
+
+To ensure the results you obtain on your personal machine are comparable to those generated in the CI, please make sure to run your tests with the virtual environment defined by our [Poetry Project](/pyproject.toml). To run your tests with `poetry`, we've provided the following "script" shortcuts:
 
-To ensure the results you obtain on your personal machine are comparable to those generated in the Azure pipeline, please make sure to run your tests with the virtual environment defined by our [Pipfile](/Pipfile). To run your tests with `pipenv`, we've provided two "scripts" shortcuts:
+- `poetry run task test-nocov` will run `pytest`.
+- `poetry run task test` will run `pytest` with `pytest-cov`.
+- `poetry run task test path/to/test.py` will run a specific test.
+- `poetry run task report` will generate a coverage report of the tests you've run with `poetry run task test`. If you append the `-m` flag to this command, the report will include the lines and branches not covered by tests in addition to the test coverage report.
 
-- `pipenv run test` will run `unittest` with `coverage.py`
-- `pipenv run test path/to/test.py` will run a specific test.
-- `pipenv run report` will generate a coverage report of the tests you've run with `pipenv run test`. If you append the `-m` flag to this command, the report will include the lines and branches not covered by tests in addition to the test coverage report.
+If you want a coverage report, make sure to run the tests with `poetry run task test` *first*.
+
+## Running tests
+There are multiple ways to run the tests, which one you use will be determined by your goal, and stage in development.
+
+When actively developing, you'll most likely be working on one portion of the codebase, and as a result, won't need to run the entire test suite.
+To run just one file, and save time, you can use the following command:
+```shell
+poetry run task test-nocov <path/to/file.py>
+```
 
-If you want a coverage report, make sure to run the tests with `pipenv run test` *first*.
+For example:
+```shell
+poetry run task test-nocov tests/bot/exts/test_cogs.py
+```
+will run the test suite in the `test_cogs` file.
+
+If you'd like to collect coverage as well, you can append `--cov` to the command above.
+
+
+If you're done and are preparing to commit and push your code, it's a good idea to run the entire test suite as a sanity check:
+```shell
+poetry run task test
+```
 
 ## Writing tests
 
@@ -114,7 +150,7 @@ class BotCogTests(unittest.TestCase):
 
 ### Mocking coroutines
 
-By default, the `unittest.mock.Mock` and `unittest.mock.MagicMock` classes cannot mock coroutines, since the `__call__` method they provide is synchronous. In anticipation of the `AsyncMock` that will be [introduced in Python 3.8](https://docs.python.org/3.9/whatsnew/3.8.html#unittest), we have added an `AsyncMock` helper to [`helpers.py`](/tests/helpers.py). Do note that this drop-in replacement only implements an asynchronous `__call__` method, not the additional assertions that will come with the new `AsyncMock` type in Python 3.8.
+By default, the `unittest.mock.Mock` and `unittest.mock.MagicMock` classes cannot mock coroutines, since the `__call__` method they provide is synchronous. The [`AsyncMock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.AsyncMock) that has been [introduced in Python 3.8](https://docs.python.org/3.9/whatsnew/3.8.html#unittest) is an asynchronous version of `MagicMock` that can be used anywhere a coroutine is expected.
 
 ### Special mocks for some `discord.py` types
 
diff --git a/tests/bot/exts/backend/test_error_handler.py b/tests/bot/exts/backend/test_error_handler.py
new file mode 100644
index 000000000..2b0549b98
--- /dev/null
+++ b/tests/bot/exts/backend/test_error_handler.py
@@ -0,0 +1,614 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, call, patch
+
+from discord.ext.commands import errors
+
+from bot.api import ResponseCodeError
+from bot.errors import InvalidInfractedUserError, LockedResourceError
+from bot.exts.backend.error_handler import ErrorHandler, setup
+from bot.exts.info.tags import Tags
+from bot.exts.moderation.silence import Silence
+from bot.utils.checks import InWhitelistCheckFailure
+from tests.helpers import MockBot, MockContext, MockGuild, MockRole, MockTextChannel
+
+
+class ErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for error handler functionality."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext(bot=self.bot)
+
+    async def test_error_handler_already_handled(self):
+        """Should not do anything when error is already handled by local error handler."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        error = errors.CommandError()
+        error.handled = "foo"
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_command_not_found_error_not_invoked_by_handler(self):
+        """Should try first (un)silence channel, when fail, try to get tag."""
+        error = errors.CommandNotFound()
+        test_cases = (
+            {
+                "try_silence_return": True,
+                "called_try_get_tag": False
+            },
+            {
+                "try_silence_return": False,
+                "called_try_get_tag": False
+            },
+            {
+                "try_silence_return": False,
+                "called_try_get_tag": True
+            }
+        )
+        cog = ErrorHandler(self.bot)
+        cog.try_silence = AsyncMock()
+        cog.try_get_tag = AsyncMock()
+
+        for case in test_cases:
+            with self.subTest(try_silence_return=case["try_silence_return"], try_get_tag=case["called_try_get_tag"]):
+                self.ctx.reset_mock()
+                cog.try_silence.reset_mock(return_value=True)
+                cog.try_get_tag.reset_mock()
+
+                cog.try_silence.return_value = case["try_silence_return"]
+                self.ctx.channel.id = 1234
+
+                self.assertIsNone(await cog.on_command_error(self.ctx, error))
+
+                if case["try_silence_return"]:
+                    cog.try_get_tag.assert_not_awaited()
+                    cog.try_silence.assert_awaited_once()
+                else:
+                    cog.try_silence.assert_awaited_once()
+                    cog.try_get_tag.assert_awaited_once()
+
+                self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_command_not_found_error_invoked_by_handler(self):
+        """Should do nothing when error is `CommandNotFound` and have attribute `invoked_from_error_handler`."""
+        ctx = MockContext(bot=self.bot, invoked_from_error_handler=True)
+
+        cog = ErrorHandler(self.bot)
+        cog.try_silence = AsyncMock()
+        cog.try_get_tag = AsyncMock()
+
+        error = errors.CommandNotFound()
+
+        self.assertIsNone(await cog.on_command_error(ctx, error))
+
+        cog.try_silence.assert_not_awaited()
+        cog.try_get_tag.assert_not_awaited()
+        self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_user_input_error(self):
+        """Should await `ErrorHandler.handle_user_input_error` when error is `UserInputError`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        cog.handle_user_input_error = AsyncMock()
+        error = errors.UserInputError()
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        cog.handle_user_input_error.assert_awaited_once_with(self.ctx, error)
+
+    async def test_error_handler_check_failure(self):
+        """Should await `ErrorHandler.handle_check_failure` when error is `CheckFailure`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        cog.handle_check_failure = AsyncMock()
+        error = errors.CheckFailure()
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        cog.handle_check_failure.assert_awaited_once_with(self.ctx, error)
+
+    async def test_error_handler_command_on_cooldown(self):
+        """Should send error with `ctx.send` when error is `CommandOnCooldown`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        error = errors.CommandOnCooldown(10, 9)
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        self.ctx.send.assert_awaited_once_with(error)
+
+    async def test_error_handler_command_invoke_error(self):
+        """Should call `handle_api_error` or `handle_unexpected_error` depending on original error."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_api_error = AsyncMock()
+        cog.handle_unexpected_error = AsyncMock()
+        test_cases = (
+            {
+                "args": (self.ctx, errors.CommandInvokeError(ResponseCodeError(AsyncMock()))),
+                "expect_mock_call": cog.handle_api_error
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(TypeError)),
+                "expect_mock_call": cog.handle_unexpected_error
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(LockedResourceError("abc", "test"))),
+                "expect_mock_call": "send"
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(InvalidInfractedUserError(self.ctx.author))),
+                "expect_mock_call": "send"
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(args=case["args"], expect_mock_call=case["expect_mock_call"]):
+                self.ctx.send.reset_mock()
+                self.assertIsNone(await cog.on_command_error(*case["args"]))
+                if case["expect_mock_call"] == "send":
+                    self.ctx.send.assert_awaited_once()
+                else:
+                    case["expect_mock_call"].assert_awaited_once_with(
+                        self.ctx, case["args"][1].original
+                    )
+
+    async def test_error_handler_conversion_error(self):
+        """Should call `handle_api_error` or `handle_unexpected_error` depending on original error."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_api_error = AsyncMock()
+        cog.handle_unexpected_error = AsyncMock()
+        cases = (
+            {
+                "error": errors.ConversionError(AsyncMock(), ResponseCodeError(AsyncMock())),
+                "mock_function_to_call": cog.handle_api_error
+            },
+            {
+                "error": errors.ConversionError(AsyncMock(), TypeError),
+                "mock_function_to_call": cog.handle_unexpected_error
+            }
+        )
+
+        for case in cases:
+            with self.subTest(**case):
+                self.assertIsNone(await cog.on_command_error(self.ctx, case["error"]))
+                case["mock_function_to_call"].assert_awaited_once_with(self.ctx, case["error"].original)
+
+    async def test_error_handler_two_other_errors(self):
+        """Should call `handle_unexpected_error` if error is `MaxConcurrencyReached` or `ExtensionError`."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_unexpected_error = AsyncMock()
+        errs = (
+            errors.MaxConcurrencyReached(1, MagicMock()),
+            errors.ExtensionError(name="foo")
+        )
+
+        for err in errs:
+            with self.subTest(error=err):
+                cog.handle_unexpected_error.reset_mock()
+                self.assertIsNone(await cog.on_command_error(self.ctx, err))
+                cog.handle_unexpected_error.assert_awaited_once_with(self.ctx, err)
+
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_error_handler_other_errors(self, log_mock):
+        """Should `log.debug` other errors."""
+        cog = ErrorHandler(self.bot)
+        error = errors.DisabledCommand()  # Use this just as a other error
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        log_mock.debug.assert_called_once()
+
+
+class TrySilenceTests(unittest.IsolatedAsyncioTestCase):
+    """Test for helper functions that handle `CommandNotFound` error."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.silence = Silence(self.bot)
+        self.bot.get_command.return_value = self.silence.silence
+        self.ctx = MockContext(bot=self.bot)
+        self.cog = ErrorHandler(self.bot)
+
+    async def test_try_silence_context_invoked_from_error_handler(self):
+        """Should set `Context.invoked_from_error_handler` to `True`."""
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_silence(self.ctx)
+        self.assertTrue(hasattr(self.ctx, "invoked_from_error_handler"))
+        self.assertTrue(self.ctx.invoked_from_error_handler)
+
+    async def test_try_silence_get_command(self):
+        """Should call `get_command` with `silence`."""
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_silence(self.ctx)
+        self.bot.get_command.assert_called_once_with("silence")
+
+    async def test_try_silence_no_permissions_to_run(self):
+        """Should return `False` because missing permissions."""
+        self.ctx.invoked_with = "foo"
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=False)
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+    async def test_try_silence_no_permissions_to_run_command_error(self):
+        """Should return `False` because `CommandError` raised (no permissions)."""
+        self.ctx.invoked_with = "foo"
+        self.bot.get_command.return_value.can_run = AsyncMock(side_effect=errors.CommandError())
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+    async def test_try_silence_silence_duration(self):
+        """Should run silence command with correct duration argument."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+        test_cases = ("shh", "shhh", "shhhhhh", "shhhhhhhhhhhhhhhhhhh")
+
+        for case in test_cases:
+            with self.subTest(message=case):
+                self.ctx.reset_mock()
+                self.ctx.invoked_with = case
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(
+                    self.bot.get_command.return_value,
+                    duration_or_channel=None,
+                    duration=min(case.count("h")*2, 15),
+                    kick=False
+                )
+
+    async def test_try_silence_silence_arguments(self):
+        """Should run silence with the correct channel, duration, and kick arguments."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+
+        test_cases = (
+            (MockTextChannel(), None),  # None represents the case when no argument is passed
+            (MockTextChannel(), False),
+            (MockTextChannel(), True)
+        )
+
+        for channel, kick in test_cases:
+            with self.subTest(kick=kick, channel=channel):
+                self.ctx.reset_mock()
+                self.ctx.invoked_with = "shh"
+
+                self.ctx.message.content = f"!shh {channel.name} {kick if kick is not None else ''}"
+                self.ctx.guild.text_channels = [channel]
+
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(
+                    self.bot.get_command.return_value,
+                    duration_or_channel=channel,
+                    duration=4,
+                    kick=(kick if kick is not None else False)
+                )
+
+    async def test_try_silence_silence_message(self):
+        """If the words after the command could not be converted to a channel, None should be passed as channel."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+        self.ctx.invoked_with = "shh"
+        self.ctx.message.content = "!shh not_a_channel true"
+
+        self.assertTrue(await self.cog.try_silence(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(
+            self.bot.get_command.return_value,
+            duration_or_channel=None,
+            duration=4,
+            kick=False
+        )
+
+    async def test_try_silence_unsilence(self):
+        """Should call unsilence command with correct duration and channel arguments."""
+        self.silence.silence.can_run = AsyncMock(return_value=True)
+        test_cases = (
+            ("unshh", None),
+            ("unshhhhh", None),
+            ("unshhhhhhhhh", None),
+            ("unshh", MockTextChannel())
+        )
+
+        for invoke, channel in test_cases:
+            with self.subTest(message=invoke, channel=channel):
+                self.bot.get_command.side_effect = (self.silence.silence, self.silence.unsilence)
+                self.ctx.reset_mock()
+
+                self.ctx.invoked_with = invoke
+                self.ctx.message.content = f"!{invoke}"
+                if channel is not None:
+                    self.ctx.message.content += f" {channel.name}"
+                    self.ctx.guild.text_channels = [channel]
+
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence, channel=channel)
+
+    async def test_try_silence_unsilence_message(self):
+        """If the words after the command could not be converted to a channel, None should be passed as channel."""
+        self.silence.silence.can_run = AsyncMock(return_value=True)
+        self.bot.get_command.side_effect = (self.silence.silence, self.silence.unsilence)
+
+        self.ctx.invoked_with = "unshh"
+        self.ctx.message.content = "!unshh not_a_channel"
+
+        self.assertTrue(await self.cog.try_silence(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence, channel=None)
+
+    async def test_try_silence_no_match(self):
+        """Should return `False` when message don't match."""
+        self.ctx.invoked_with = "foo"
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+
+class TryGetTagTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for `try_get_tag` function."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext()
+        self.tag = Tags(self.bot)
+        self.cog = ErrorHandler(self.bot)
+        self.bot.get_command.return_value = self.tag.get_command
+
+    async def test_try_get_tag_get_command(self):
+        """Should call `Bot.get_command` with `tags get` argument."""
+        self.bot.get_command.reset_mock()
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_get_tag(self.ctx)
+        self.bot.get_command.assert_called_once_with("tags get")
+
+    async def test_try_get_tag_invoked_from_error_handler(self):
+        """`self.ctx` should have `invoked_from_error_handler` `True`."""
+        self.ctx.invoked_from_error_handler = False
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_get_tag(self.ctx)
+        self.assertTrue(self.ctx.invoked_from_error_handler)
+
+    async def test_try_get_tag_no_permissions(self):
+        """Test how to handle checks failing."""
+        self.tag.get_command.can_run = AsyncMock(return_value=False)
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+
+    async def test_try_get_tag_command_error(self):
+        """Should call `on_command_error` when `CommandError` raised."""
+        err = errors.CommandError()
+        self.tag.get_command.can_run = AsyncMock(side_effect=err)
+        self.cog.on_command_error = AsyncMock()
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.cog.on_command_error.assert_awaited_once_with(self.ctx, err)
+
+    @patch("bot.exts.backend.error_handler.TagNameConverter")
+    async def test_try_get_tag_convert_success(self, tag_converter):
+        """Converting tag should successful."""
+        self.ctx.invoked_with = "foo"
+        tag_converter.convert = AsyncMock(return_value="foo")
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        tag_converter.convert.assert_awaited_once_with(self.ctx, "foo")
+        self.ctx.invoke.assert_awaited_once()
+
+    @patch("bot.exts.backend.error_handler.TagNameConverter")
+    async def test_try_get_tag_convert_fail(self, tag_converter):
+        """Converting tag should raise `BadArgument`."""
+        self.ctx.reset_mock()
+        self.ctx.invoked_with = "bar"
+        tag_converter.convert = AsyncMock(side_effect=errors.BadArgument())
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.ctx.invoke.assert_not_awaited()
+
+    async def test_try_get_tag_ctx_invoke(self):
+        """Should call `ctx.invoke` with proper args/kwargs."""
+        self.ctx.reset_mock()
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(self.tag.get_command, tag_name="foo")
+
+    async def test_dont_call_suggestion_tag_sent(self):
+        """Should never call command suggestion if tag is already sent."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=True)
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_not_awaited()
+
+    @patch("bot.exts.backend.error_handler.MODERATION_ROLES", new=[1234])
+    async def test_dont_call_suggestion_if_user_mod(self):
+        """Should not call command suggestion if user is a mod."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=False)
+        self.ctx.author.roles = [MockRole(id=1234)]
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_not_awaited()
+
+    async def test_call_suggestion(self):
+        """Should call command suggestion if user is not a mod."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=False)
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_awaited_once_with(self.ctx, "foo")
+
+
+class IndividualErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Individual error categories handler tests."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext(bot=self.bot)
+        self.cog = ErrorHandler(self.bot)
+
+    async def test_handle_input_error_handler_errors(self):
+        """Should handle each error probably."""
+        test_cases = (
+            {
+                "error": errors.MissingRequiredArgument(MagicMock()),
+                "call_prepared": True
+            },
+            {
+                "error": errors.TooManyArguments(),
+                "call_prepared": True
+            },
+            {
+                "error": errors.BadArgument(),
+                "call_prepared": True
+            },
+            {
+                "error": errors.BadUnionArgument(MagicMock(), MagicMock(), MagicMock()),
+                "call_prepared": True
+            },
+            {
+                "error": errors.ArgumentParsingError(),
+                "call_prepared": False
+            },
+            {
+                "error": errors.UserInputError(),
+                "call_prepared": True
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], call_prepared=case["call_prepared"]):
+                self.ctx.reset_mock()
+                self.assertIsNone(await self.cog.handle_user_input_error(self.ctx, case["error"]))
+                self.ctx.send.assert_awaited_once()
+                if case["call_prepared"]:
+                    self.ctx.send_help.assert_awaited_once()
+                else:
+                    self.ctx.send_help.assert_not_awaited()
+
+    async def test_handle_check_failure_errors(self):
+        """Should await `ctx.send` when error is check failure."""
+        test_cases = (
+            {
+                "error": errors.BotMissingPermissions(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.BotMissingRole(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.BotMissingAnyRole(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.NoPrivateMessage(),
+                "call_ctx_send": True
+            },
+            {
+                "error": InWhitelistCheckFailure(1234),
+                "call_ctx_send": True
+            },
+            {
+                "error": ResponseCodeError(MagicMock()),
+                "call_ctx_send": False
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], call_ctx_send=case["call_ctx_send"]):
+                self.ctx.reset_mock()
+                await self.cog.handle_check_failure(self.ctx, case["error"])
+                if case["call_ctx_send"]:
+                    self.ctx.send.assert_awaited_once()
+                else:
+                    self.ctx.send.assert_not_awaited()
+
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_handle_api_error(self, log_mock):
+        """Should `ctx.send` on HTTP error codes, `log.debug|warning` depends on code."""
+        test_cases = (
+            {
+                "error": ResponseCodeError(AsyncMock(status=400)),
+                "log_level": "debug"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=404)),
+                "log_level": "debug"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=550)),
+                "log_level": "warning"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=1000)),
+                "log_level": "warning"
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], log_level=case["log_level"]):
+                self.ctx.reset_mock()
+                log_mock.reset_mock()
+                await self.cog.handle_api_error(self.ctx, case["error"])
+                self.ctx.send.assert_awaited_once()
+                if case["log_level"] == "warning":
+                    log_mock.warning.assert_called_once()
+                else:
+                    log_mock.debug.assert_called_once()
+
+    @patch("bot.exts.backend.error_handler.push_scope")
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_handle_unexpected_error(self, log_mock, push_scope_mock):
+        """Should `ctx.send` this error, error log this and sent to Sentry."""
+        for case in (None, MockGuild()):
+            with self.subTest(guild=case):
+                self.ctx.reset_mock()
+                log_mock.reset_mock()
+                push_scope_mock.reset_mock()
+
+                self.ctx.guild = case
+                await self.cog.handle_unexpected_error(self.ctx, errors.CommandError())
+
+                self.ctx.send.assert_awaited_once()
+                log_mock.error.assert_called_once()
+                push_scope_mock.assert_called_once()
+
+                set_tag_calls = [
+                    call("command", self.ctx.command.qualified_name),
+                    call("message_id", self.ctx.message.id),
+                    call("channel_id", self.ctx.channel.id),
+                ]
+                set_extra_calls = [
+                    call("full_message", self.ctx.message.content)
+                ]
+                if case:
+                    url = (
+                        f"https://discordapp.com/channels/"
+                        f"{self.ctx.guild.id}/{self.ctx.channel.id}/{self.ctx.message.id}"
+                    )
+                    set_extra_calls.append(call("jump_to", url))
+
+                push_scope_mock.set_tag.has_calls(set_tag_calls)
+                push_scope_mock.set_extra.has_calls(set_extra_calls)
+
+
+class OtherErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Other `ErrorHandler` tests."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext()
+
+    async def test_get_help_command_command_specified(self):
+        """Should return coroutine of help command of specified command."""
+        self.ctx.command = "foo"
+        result = ErrorHandler.get_help_command(self.ctx)
+        expected = self.ctx.send_help("foo")
+        self.assertEqual(result.__qualname__, expected.__qualname__)
+        self.assertEqual(result.cr_frame.f_locals, expected.cr_frame.f_locals)
+
+        # Await coroutines to avoid warnings
+        await result
+        await expected
+
+    async def test_get_help_command_no_command_specified(self):
+        """Should return coroutine of help command."""
+        self.ctx.command = None
+        result = ErrorHandler.get_help_command(self.ctx)
+        expected = self.ctx.send_help()
+        self.assertEqual(result.__qualname__, expected.__qualname__)
+        self.assertEqual(result.cr_frame.f_locals, expected.cr_frame.f_locals)
+
+        # Await coroutines to avoid warnings
+        await result
+        await expected
+
+
+class ErrorHandlerSetupTests(unittest.TestCase):
+    """Tests for `ErrorHandler` `setup` function."""
+
+    def test_setup(self):
+        """Should call `bot.add_cog` with `ErrorHandler`."""
+        bot = MockBot()
+        setup(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/exts/filters/test_antimalware.py b/tests/bot/exts/filters/test_antimalware.py
index 3393c6cdc..06d78de9d 100644
--- a/tests/bot/exts/filters/test_antimalware.py
+++ b/tests/bot/exts/filters/test_antimalware.py
@@ -104,24 +104,39 @@ class AntiMalwareCogTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(embed.description, antimalware.PY_EMBED_DESCRIPTION)
 
     async def test_txt_file_redirect_embed_description(self):
-        """A message containing a .txt file should result in the correct embed."""
-        attachment = MockAttachment(filename="python.txt")
-        self.message.attachments = [attachment]
-        self.message.channel.send = AsyncMock()
-        antimalware.TXT_EMBED_DESCRIPTION = Mock()
-        antimalware.TXT_EMBED_DESCRIPTION.format.return_value = "test"
-
-        await self.cog.on_message(self.message)
-        self.message.channel.send.assert_called_once()
-        args, kwargs = self.message.channel.send.call_args
-        embed = kwargs.pop("embed")
-        cmd_channel = self.bot.get_channel(Channels.bot_commands)
+        """A message containing a .txt/.json/.csv file should result in the correct embed."""
+        test_values = (
+            ("text", ".txt"),
+            ("json", ".json"),
+            ("csv", ".csv"),
+        )
 
-        self.assertEqual(embed.description, antimalware.TXT_EMBED_DESCRIPTION.format.return_value)
-        antimalware.TXT_EMBED_DESCRIPTION.format.assert_called_with(cmd_channel_mention=cmd_channel.mention)
+        for file_name, disallowed_extension in test_values:
+            with self.subTest(file_name=file_name, disallowed_extension=disallowed_extension):
+
+                attachment = MockAttachment(filename=f"{file_name}{disallowed_extension}")
+                self.message.attachments = [attachment]
+                self.message.channel.send = AsyncMock()
+                antimalware.TXT_EMBED_DESCRIPTION = Mock()
+                antimalware.TXT_EMBED_DESCRIPTION.format.return_value = "test"
+
+                await self.cog.on_message(self.message)
+                self.message.channel.send.assert_called_once()
+                args, kwargs = self.message.channel.send.call_args
+                embed = kwargs.pop("embed")
+                cmd_channel = self.bot.get_channel(Channels.bot_commands)
+
+                self.assertEqual(
+                    embed.description,
+                    antimalware.TXT_EMBED_DESCRIPTION.format.return_value
+                )
+                antimalware.TXT_EMBED_DESCRIPTION.format.assert_called_with(
+                    blocked_extension=disallowed_extension,
+                    cmd_channel_mention=cmd_channel.mention
+                )
 
     async def test_other_disallowed_extension_embed_description(self):
-        """Test the description for a non .py/.txt disallowed extension."""
+        """Test the description for a non .py/.txt/.json/.csv disallowed extension."""
         attachment = MockAttachment(filename="python.disallowed")
         self.message.attachments = [attachment]
         self.message.channel.send = AsyncMock()
diff --git a/tests/bot/exts/info/test_help.py b/tests/bot/exts/info/test_help.py
new file mode 100644
index 000000000..604c69671
--- /dev/null
+++ b/tests/bot/exts/info/test_help.py
@@ -0,0 +1,23 @@
+import unittest
+
+import rapidfuzz
+
+from bot.exts.info import help
+from tests.helpers import MockBot, MockContext, autospec
+
+
+class HelpCogTests(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        """Attach an instance of the cog to the class for tests."""
+        self.bot = MockBot()
+        self.cog = help.Help(self.bot)
+        self.ctx = MockContext(bot=self.bot)
+        self.bot.help_command.context = self.ctx
+
+    @autospec(help.CustomHelpCommand, "get_all_help_choices", return_value={"help"}, pass_mocks=False)
+    async def test_help_fuzzy_matching(self):
+        """Test fuzzy matching of commands when called from help."""
+        result = await self.bot.help_command.command_not_found("holp")
+
+        match = {"help": rapidfuzz.fuzz.ratio("help", "holp")}
+        self.assertEqual(match, result.possible_matches)
diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index a996ce477..0aa41d889 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -262,7 +262,6 @@ class UserInfractionHelperMethodTests(unittest.IsolatedAsyncioTestCase):
         await self._method_subtests(self.cog.user_nomination_counts, test_values, header)
 
 
[email protected]("bot.exts.info.information.time_since", new=unittest.mock.MagicMock(return_value="1 year ago"))
 @unittest.mock.patch("bot.exts.info.information.constants.MODERATION_CHANNELS", new=[50])
 class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the creation of the `!user` embed."""
@@ -281,6 +280,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         """The embed should use the string representation of the user if they don't have a nick."""
         ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
+        user.public_flags = unittest.mock.MagicMock(verified_bot=False)
         user.nick = None
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
@@ -297,6 +297,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         """The embed should use the nick if it's available."""
         ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
+        user.public_flags = unittest.mock.MagicMock(verified_bot=False)
         user.nick = "Cat lover"
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
@@ -345,7 +346,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(
             textwrap.dedent(f"""
-                Created: {"1 year ago"}
+                Created: {"<t:1:R>"}
                 Profile: {user.mention}
                 ID: {user.id}
             """).strip(),
@@ -354,7 +355,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(
             textwrap.dedent(f"""
-                Joined: {"1 year ago"}
+                Joined: {"<t:1:R>"}
                 Verified: {"True"}
                 Roles: &Moderators
             """).strip(),
@@ -377,7 +378,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(
             textwrap.dedent(f"""
-                Created: {"1 year ago"}
+                Created: {"<t:1:R>"}
                 Profile: {user.mention}
                 ID: {user.id}
             """).strip(),
@@ -386,7 +387,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(
             textwrap.dedent(f"""
-                Joined: {"1 year ago"}
+                Joined: {"<t:1:R>"}
                 Roles: &Moderators
             """).strip(),
             embed.fields[1].value
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 08f39cd50..b9d527770 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -74,7 +74,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should call voice ban applying function without expiry."""
         self.cog.apply_voice_ban = AsyncMock()
         self.assertIsNone(await self.cog.voiceban(self.cog, self.ctx, self.user, reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar")
+        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
 
     async def test_temporary_voice_ban(self):
         """Should call voice ban applying function with expiry."""
@@ -184,7 +184,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
         user = MockUser()
         await self.cog.voiceban(self.cog, self.ctx, user, reason=None)
-        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True)
+        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True, expires_at=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
         # Test action
diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index ee9ff650c..5f95ced9f 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -213,7 +213,7 @@ class ModerationUtilsTests(unittest.IsolatedAsyncioTestCase):
                         type="Mute",
                         expires="N/A",
                         reason="foo bar" * 4000
-                    )[:2045] + "...",
+                    )[:4093] + "...",
                     colour=Colours.soft_red,
                     url=utils.RULES_URL
                 ).set_author(
diff --git a/tests/bot/exts/moderation/test_modlog.py b/tests/bot/exts/moderation/test_modlog.py
index f8f142484..79e04837d 100644
--- a/tests/bot/exts/moderation/test_modlog.py
+++ b/tests/bot/exts/moderation/test_modlog.py
@@ -25,5 +25,5 @@ class ModLogTests(unittest.IsolatedAsyncioTestCase):
         )
         embed = self.channel.send.call_args[1]["embed"]
         self.assertEqual(
-            embed.description, ("foo bar" * 3000)[:2045] + "..."
+            embed.description, ("foo bar" * 3000)[:4093] + "..."
         )
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index fa5fc9e81..59a5893ef 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -1,15 +1,26 @@
 import asyncio
+import itertools
 import unittest
 from datetime import datetime, timezone
+from typing import List, Tuple
 from unittest import mock
-from unittest.mock import Mock
+from unittest.mock import AsyncMock, Mock
 
 from async_rediscache import RedisSession
 from discord import PermissionOverwrite
 
-from bot.constants import Channels, Guild, Roles
+from bot.constants import Channels, Guild, MODERATION_ROLES, Roles
 from bot.exts.moderation import silence
-from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
+from tests.helpers import (
+    MockBot,
+    MockContext,
+    MockGuild,
+    MockMember,
+    MockRole,
+    MockTextChannel,
+    MockVoiceChannel,
+    autospec
+)
 
 redis_session = None
 redis_loop = asyncio.get_event_loop()
@@ -149,7 +160,7 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(self.cog._init_task.cancelled())
 
     @autospec("discord.ext.commands", "has_any_role")
-    @mock.patch.object(silence, "MODERATION_ROLES", new=(1, 2, 3))
+    @mock.patch.object(silence.constants, "MODERATION_ROLES", new=(1, 2, 3))
     async def test_cog_check(self, role_check):
         """Role check was called with `MODERATION_ROLES`"""
         ctx = MockContext()
@@ -159,6 +170,170 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         role_check.assert_called_once_with(*(1, 2, 3))
         role_check.return_value.predicate.assert_awaited_once_with(ctx)
 
+    async def test_force_voice_sync(self):
+        """Tests the _force_voice_sync helper function."""
+        await self.cog._async_init()
+
+        # Create a regular member, and one member for each of the moderation roles
+        moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
+        members = [MockMember(), *moderation_members]
+
+        channel = MockVoiceChannel(members=members)
+
+        await self.cog._force_voice_sync(channel)
+        for member in members:
+            if member in moderation_members:
+                member.move_to.assert_not_called()
+            else:
+                self.assertEqual(member.move_to.call_count, 2)
+                calls = member.move_to.call_args_list
+
+                # Tests that the member was moved to the afk channel, and back.
+                self.assertEqual((channel.guild.afk_channel,), calls[0].args)
+                self.assertEqual((channel,), calls[1].args)
+
+    async def test_force_voice_sync_no_channel(self):
+        """Test to ensure _force_voice_sync can create its own voice channel if one is not available."""
+        await self.cog._async_init()
+
+        channel = MockVoiceChannel(guild=MockGuild(afk_channel=None))
+        new_channel = MockVoiceChannel(delete=AsyncMock())
+        channel.guild.create_voice_channel.return_value = new_channel
+
+        await self.cog._force_voice_sync(channel)
+
+        # Check channel creation
+        overwrites = {
+            channel.guild.default_role: PermissionOverwrite(speak=False, connect=False, view_channel=False)
+        }
+        channel.guild.create_voice_channel.assert_awaited_once_with("mute-temp", overwrites=overwrites)
+
+        # Check bot deleted channel
+        new_channel.delete.assert_awaited_once()
+
+    async def test_voice_kick(self):
+        """Test to ensure kick function can remove all members from a voice channel."""
+        await self.cog._async_init()
+
+        # Create a regular member, and one member for each of the moderation roles
+        moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
+        members = [MockMember(), *moderation_members]
+
+        channel = MockVoiceChannel(members=members)
+        await self.cog._kick_voice_members(channel)
+
+        for member in members:
+            if member in moderation_members:
+                member.move_to.assert_not_called()
+            else:
+                self.assertEqual((None,), member.move_to.call_args_list[0].args)
+
+    @staticmethod
+    def create_erroneous_members() -> Tuple[List[MockMember], List[MockMember]]:
+        """
+        Helper method to generate a list of members that error out on move_to call.
+
+        Returns the list of erroneous members,
+        as well as a list of regular and erroneous members combined, in that order.
+        """
+        erroneous_member = MockMember(move_to=AsyncMock(side_effect=Exception()))
+        members = [MockMember(), erroneous_member]
+
+        return erroneous_member, members
+
+    async def test_kick_move_to_error(self):
+        """Test to ensure move_to gets called on all members during kick, even if some fail."""
+        await self.cog._async_init()
+        _, members = self.create_erroneous_members()
+
+        await self.cog._kick_voice_members(MockVoiceChannel(members=members))
+        for member in members:
+            member.move_to.assert_awaited_once()
+
+    async def test_sync_move_to_error(self):
+        """Test to ensure move_to gets called on all members during sync, even if some fail."""
+        await self.cog._async_init()
+        failing_member, members = self.create_erroneous_members()
+
+        await self.cog._force_voice_sync(MockVoiceChannel(members=members))
+        for member in members:
+            self.assertEqual(member.move_to.call_count, 1 if member == failing_member else 2)
+
+
+class SilenceArgumentParserTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the silence argument parser utility function."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.cog = silence.Silence(self.bot)
+        self.cog._init_task = asyncio.Future()
+        self.cog._init_task.set_result(None)
+
+    @autospec(silence.Silence, "send_message", pass_mocks=False)
+    @autospec(silence.Silence, "_set_silence_overwrites", return_value=False, pass_mocks=False)
+    @autospec(silence.Silence, "parse_silence_args")
+    async def test_command(self, parser_mock):
+        """Test that the command passes in the correct arguments for different calls."""
+        test_cases = (
+            (),
+            (15, ),
+            (MockTextChannel(),),
+            (MockTextChannel(), 15),
+        )
+
+        ctx = MockContext()
+        parser_mock.return_value = (ctx.channel, 10)
+
+        for case in test_cases:
+            with self.subTest("Test command converters", args=case):
+                await self.cog.silence.callback(self.cog, ctx, *case)
+
+                try:
+                    first_arg = case[0]
+                except IndexError:
+                    # Default value when the first argument is not passed
+                    first_arg = None
+
+                try:
+                    second_arg = case[1]
+                except IndexError:
+                    # Default value when the second argument is not passed
+                    second_arg = 10
+
+                parser_mock.assert_called_with(ctx, first_arg, second_arg)
+
+    async def test_no_arguments(self):
+        """Test the parser when no arguments are passed to the command."""
+        ctx = MockContext()
+        channel, duration = self.cog.parse_silence_args(ctx, None, 10)
+
+        self.assertEqual(ctx.channel, channel)
+        self.assertEqual(10, duration)
+
+    async def test_channel_only(self):
+        """Test the parser when just the channel argument is passed."""
+        expected_channel = MockTextChannel()
+        actual_channel, duration = self.cog.parse_silence_args(MockContext(), expected_channel, 10)
+
+        self.assertEqual(expected_channel, actual_channel)
+        self.assertEqual(10, duration)
+
+    async def test_duration_only(self):
+        """Test the parser when just the duration argument is passed."""
+        ctx = MockContext()
+        channel, duration = self.cog.parse_silence_args(ctx, 15, 10)
+
+        self.assertEqual(ctx.channel, channel)
+        self.assertEqual(15, duration)
+
+    async def test_all_args(self):
+        """Test the parser when both channel and duration are passed."""
+        expected_channel = MockTextChannel()
+        actual_channel, duration = self.cog.parse_silence_args(MockContext(), expected_channel, 15)
+
+        self.assertEqual(expected_channel, actual_channel)
+        self.assertEqual(15, duration)
+
 
 @autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class RescheduleTests(unittest.IsolatedAsyncioTestCase):
@@ -235,6 +410,16 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog.notifier.add_channel.assert_not_called()
 
 
+def voice_sync_helper(function):
+    """Helper wrapper to test the sync and kick functions for voice channels."""
+    @autospec(silence.Silence, "_force_voice_sync", "_kick_voice_members", "_set_silence_overwrites")
+    async def inner(self, sync, kick, overwrites):
+        overwrites.return_value = True
+        await function(self, MockContext(), sync, kick)
+
+    return inner
+
+
 @autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the silence command and its related helper methods."""
@@ -242,7 +427,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "Scheduler", "SilenceNotifier", pass_mocks=False)
     def setUp(self) -> None:
-        self.bot = MockBot()
+        self.bot = MockBot(get_channel=lambda _: MockTextChannel())
         self.cog = silence.Silence(self.bot)
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
@@ -252,56 +437,127 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
-        self.channel = MockTextChannel()
-        self.overwrite = PermissionOverwrite(stream=True, send_messages=True, add_reactions=False)
-        self.channel.overwrites_for.return_value = self.overwrite
+        self.text_channel = MockTextChannel()
+        self.text_overwrite = PermissionOverwrite(send_messages=True, add_reactions=False)
+        self.text_channel.overwrites_for.return_value = self.text_overwrite
+
+        self.voice_channel = MockVoiceChannel()
+        self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
+        self.voice_channel.overwrites_for.return_value = self.voice_overwrite
 
     async def test_sent_correct_message(self):
-        """Appropriate failure/success message was sent by the command."""
+        """Appropriate failure/success message was sent by the command to the correct channel."""
+        # The following test tuples are made up of:
+        # duration, expected message, and the success of the _set_silence_overwrites function
         test_cases = (
             (0.0001, silence.MSG_SILENCE_SUCCESS.format(duration=0.0001), True,),
             (None, silence.MSG_SILENCE_PERMANENT, True,),
             (5, silence.MSG_SILENCE_FAIL, False,),
         )
-        for duration, message, was_silenced in test_cases:
-            ctx = MockContext()
+
+        targets = (MockTextChannel(), MockVoiceChannel(), None)
+
+        for (duration, message, was_silenced), target in itertools.product(test_cases, targets):
             with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=was_silenced):
-                with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
-                    await self.cog.silence.callback(self.cog, ctx, duration)
-                    ctx.send.assert_called_once_with(message)
+                with self.subTest(was_silenced=was_silenced, target=target, message=message):
+                    with mock.patch.object(self.cog, "send_message") as send_message:
+                        ctx = MockContext()
+                        await self.cog.silence.callback(self.cog, ctx, target, duration)
+                        send_message.assert_called_once_with(
+                            message,
+                            ctx.channel,
+                            target or ctx.channel,
+                            alert_target=was_silenced
+                        )
+
+    @voice_sync_helper
+    async def test_sync_called(self, ctx, sync, kick):
+        """Tests if silence command calls sync on a voice channel."""
+        channel = MockVoiceChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=False)
+
+        sync.assert_awaited_once_with(self.cog, channel)
+        kick.assert_not_called()
+
+    @voice_sync_helper
+    async def test_kick_called(self, ctx, sync, kick):
+        """Tests if silence command calls kick on a voice channel."""
+        channel = MockVoiceChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=True)
+
+        kick.assert_awaited_once_with(channel)
+        sync.assert_not_called()
+
+    @voice_sync_helper
+    async def test_sync_not_called(self, ctx, sync, kick):
+        """Tests that silence command does not call sync on a text channel."""
+        channel = MockTextChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=False)
+
+        sync.assert_not_called()
+        kick.assert_not_called()
+
+    @voice_sync_helper
+    async def test_kick_not_called(self, ctx, sync, kick):
+        """Tests that silence command does not call kick on a text channel."""
+        channel = MockTextChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=True)
+
+        sync.assert_not_called()
+        kick.assert_not_called()
 
     async def test_skipped_already_silenced(self):
         """Permissions were not set and `False` was returned for an already silenced channel."""
         subtests = (
-            (False, PermissionOverwrite(send_messages=False, add_reactions=False)),
-            (True, PermissionOverwrite(send_messages=True, add_reactions=True)),
-            (True, PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (False, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (True, MockTextChannel(), PermissionOverwrite(send_messages=True, add_reactions=True)),
+            (True, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (False, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
+            (True, MockVoiceChannel(), PermissionOverwrite(connect=True, speak=True)),
+            (True, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
         )
 
-        for contains, overwrite in subtests:
-            with self.subTest(contains=contains, overwrite=overwrite):
+        for contains, channel, overwrite in subtests:
+            with self.subTest(contains=contains, is_text=isinstance(channel, MockTextChannel), overwrite=overwrite):
                 self.cog.scheduler.__contains__.return_value = contains
-                channel = MockTextChannel()
                 channel.overwrites_for.return_value = overwrite
 
                 self.assertFalse(await self.cog._set_silence_overwrites(channel))
                 channel.set_permissions.assert_not_called()
 
-    async def test_silenced_channel(self):
+    async def test_silenced_text_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-        self.assertTrue(await self.cog._set_silence_overwrites(self.channel))
-        self.assertFalse(self.overwrite.send_messages)
-        self.assertFalse(self.overwrite.add_reactions)
-        self.channel.set_permissions.assert_awaited_once_with(
+        self.assertTrue(await self.cog._set_silence_overwrites(self.text_channel))
+        self.assertFalse(self.text_overwrite.send_messages)
+        self.assertFalse(self.text_overwrite.add_reactions)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite
+            overwrite=self.text_overwrite
         )
 
-    async def test_preserved_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed."""
-        prev_overwrite_dict = dict(self.overwrite)
-        await self.cog._set_silence_overwrites(self.channel)
-        new_overwrite_dict = dict(self.overwrite)
+    async def test_silenced_voice_channel_speak(self):
+        """Channel had `speak` permissions revoked for verified role."""
+        self.assertTrue(await self.cog._set_silence_overwrites(self.voice_channel))
+        self.assertFalse(self.voice_overwrite.speak)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite
+        )
+
+    async def test_silenced_voice_channel_full(self):
+        """Channel had `speak` and `connect` permissions revoked for verified role."""
+        self.assertTrue(await self.cog._set_silence_overwrites(self.voice_channel, kick=True))
+        self.assertFalse(self.voice_overwrite.speak or self.voice_overwrite.connect)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite
+        )
+
+    async def test_preserved_other_overwrites_text(self):
+        """Channel's other unrelated overwrites were not changed for a text channel mute."""
+        prev_overwrite_dict = dict(self.text_overwrite)
+        await self.cog._set_silence_overwrites(self.text_channel)
+        new_overwrite_dict = dict(self.text_overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
         del prev_overwrite_dict['send_messages']
@@ -311,6 +567,20 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
+    async def test_preserved_other_overwrites_voice(self):
+        """Channel's other unrelated overwrites were not changed for a voice channel mute."""
+        prev_overwrite_dict = dict(self.voice_overwrite)
+        await self.cog._set_silence_overwrites(self.voice_channel)
+        new_overwrite_dict = dict(self.voice_overwrite)
+
+        # Remove 'connect' & 'speak' keys because they were changed by the method.
+        del prev_overwrite_dict['connect']
+        del prev_overwrite_dict['speak']
+        del new_overwrite_dict['connect']
+        del new_overwrite_dict['speak']
+
+        self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
     async def test_temp_not_added_to_notifier(self):
         """Channel was not added to notifier if a duration was set for the silence."""
         with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
@@ -320,7 +590,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_indefinite_added_to_notifier(self):
         """Channel was added to notifier if a duration was not set for the silence."""
         with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
-            await self.cog.silence.callback(self.cog, MockContext(), None)
+            await self.cog.silence.callback(self.cog, MockContext(), None, None)
             self.cog.notifier.add_channel.assert_called_once()
 
     async def test_silenced_not_added_to_notifier(self):
@@ -332,8 +602,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_cached_previous_overwrites(self):
         """Channel's previous overwrites were cached."""
         overwrite_json = '{"send_messages": true, "add_reactions": false}'
-        await self.cog._set_silence_overwrites(self.channel)
-        self.cog.previous_overwrites.set.assert_called_once_with(self.channel.id, overwrite_json)
+        await self.cog._set_silence_overwrites(self.text_channel)
+        self.cog.previous_overwrites.set.assert_awaited_once_with(self.text_channel.id, overwrite_json)
 
     @autospec(silence, "datetime")
     async def test_cached_unsilence_time(self, datetime_mock):
@@ -343,7 +613,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         timestamp = now_timestamp + duration * 60
         datetime_mock.now.return_value = datetime.fromtimestamp(now_timestamp, tz=timezone.utc)
 
-        ctx = MockContext(channel=self.channel)
+        ctx = MockContext(channel=self.text_channel)
         await self.cog.silence.callback(self.cog, ctx, duration)
 
         self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, timestamp)
@@ -351,26 +621,33 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_cached_indefinite_time(self):
         """A value of -1 was cached for a permanent silence."""
-        ctx = MockContext(channel=self.channel)
-        await self.cog.silence.callback(self.cog, ctx, None)
+        ctx = MockContext(channel=self.text_channel)
+        await self.cog.silence.callback(self.cog, ctx, None, None)
         self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, -1)
 
     async def test_scheduled_task(self):
         """An unsilence task was scheduled."""
-        ctx = MockContext(channel=self.channel, invoke=mock.MagicMock())
+        ctx = MockContext(channel=self.text_channel, invoke=mock.MagicMock())
 
         await self.cog.silence.callback(self.cog, ctx, 5)
 
         args = (300, ctx.channel.id, ctx.invoke.return_value)
         self.cog.scheduler.schedule_later.assert_called_once_with(*args)
-        ctx.invoke.assert_called_once_with(self.cog.unsilence)
+        ctx.invoke.assert_called_once_with(self.cog.unsilence, channel=ctx.channel)
 
     async def test_permanent_not_scheduled(self):
         """A task was not scheduled for a permanent silence."""
-        ctx = MockContext(channel=self.channel)
-        await self.cog.silence.callback(self.cog, ctx, None)
+        ctx = MockContext(channel=self.text_channel)
+        await self.cog.silence.callback(self.cog, ctx, None, None)
         self.cog.scheduler.schedule_later.assert_not_called()
 
+    async def test_indefinite_silence(self):
+        """Test silencing a channel forever."""
+        with mock.patch.object(self.cog, "_schedule_unsilence") as unsilence:
+            ctx = MockContext(channel=self.text_channel)
+            await self.cog.silence.callback(self.cog, ctx, -1)
+            unsilence.assert_awaited_once_with(ctx, ctx.channel, None)
+
 
 @autospec(silence.Silence, "unsilence_timestamps", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
@@ -391,9 +668,13 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.cog.scheduler.__contains__.return_value = True
         overwrites_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
-        self.channel = MockTextChannel()
-        self.overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
-        self.channel.overwrites_for.return_value = self.overwrite
+        self.text_channel = MockTextChannel()
+        self.text_overwrite = PermissionOverwrite(send_messages=False, add_reactions=False)
+        self.text_channel.overwrites_for.return_value = self.text_overwrite
+
+        self.voice_channel = MockVoiceChannel()
+        self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
+        self.voice_channel.overwrites_for.return_value = self.voice_overwrite
 
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
@@ -401,88 +682,128 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         test_cases = (
             (True, silence.MSG_UNSILENCE_SUCCESS, unsilenced_overwrite),
             (False, silence.MSG_UNSILENCE_FAIL, unsilenced_overwrite),
-            (False, silence.MSG_UNSILENCE_MANUAL, self.overwrite),
+            (False, silence.MSG_UNSILENCE_MANUAL, self.text_overwrite),
             (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(send_messages=False)),
             (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(add_reactions=False)),
         )
-        for was_unsilenced, message, overwrite in test_cases:
+
+        targets = (None, MockTextChannel())
+
+        for (was_unsilenced, message, overwrite), target in itertools.product(test_cases, targets):
             ctx = MockContext()
-            with self.subTest(was_unsilenced=was_unsilenced, message=message, overwrite=overwrite):
-                with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
-                    ctx.channel.overwrites_for.return_value = overwrite
-                    await self.cog.unsilence.callback(self.cog, ctx)
-                    ctx.channel.send.assert_called_once_with(message)
+            ctx.channel.overwrites_for.return_value = overwrite
+            if target:
+                target.overwrites_for.return_value = overwrite
+
+            with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
+                with mock.patch.object(self.cog, "send_message") as send_message:
+                    with self.subTest(was_unsilenced=was_unsilenced, overwrite=overwrite, target=target):
+                        await self.cog.unsilence.callback(self.cog, ctx, channel=target)
+
+                        call_args = (message, ctx.channel, target or ctx.channel)
+                        send_message.assert_awaited_once_with(*call_args, alert_target=was_unsilenced)
 
     async def test_skipped_already_unsilenced(self):
         """Permissions were not set and `False` was returned for an already unsilenced channel."""
         self.cog.scheduler.__contains__.return_value = False
         self.cog.previous_overwrites.get.return_value = None
-        channel = MockTextChannel()
 
-        self.assertFalse(await self.cog._unsilence(channel))
-        channel.set_permissions.assert_not_called()
+        for channel in (MockVoiceChannel(), MockTextChannel()):
+            with self.subTest(channel=channel):
+                self.assertFalse(await self.cog._unsilence(channel))
+                channel.set_permissions.assert_not_called()
 
-    async def test_restored_overwrites(self):
-        """Channel's `send_message` and `add_reactions` overwrites were restored."""
-        await self.cog._unsilence(self.channel)
-        self.channel.set_permissions.assert_awaited_once_with(
+    async def test_restored_overwrites_text(self):
+        """Text channel's `send_message` and `add_reactions` overwrites were restored."""
+        await self.cog._unsilence(self.text_channel)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite,
+            overwrite=self.text_overwrite,
+        )
+
+        # Recall that these values are determined by the fixture.
+        self.assertTrue(self.text_overwrite.send_messages)
+        self.assertFalse(self.text_overwrite.add_reactions)
+
+    async def test_restored_overwrites_voice(self):
+        """Voice channel's `connect` and `speak` overwrites were restored."""
+        await self.cog._unsilence(self.voice_channel)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite,
         )
 
         # Recall that these values are determined by the fixture.
-        self.assertTrue(self.overwrite.send_messages)
-        self.assertFalse(self.overwrite.add_reactions)
+        self.assertTrue(self.voice_overwrite.connect)
+        self.assertTrue(self.voice_overwrite.speak)
 
-    async def test_cache_miss_used_default_overwrites(self):
-        """Both overwrites were set to None due previous values not being found in the cache."""
+    async def test_cache_miss_used_default_overwrites_text(self):
+        """Text overwrites were set to None due previous values not being found in the cache."""
         self.cog.previous_overwrites.get.return_value = None
 
-        await self.cog._unsilence(self.channel)
-        self.channel.set_permissions.assert_awaited_once_with(
+        await self.cog._unsilence(self.text_channel)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite,
+            overwrite=self.text_overwrite,
+        )
+
+        self.assertIsNone(self.text_overwrite.send_messages)
+        self.assertIsNone(self.text_overwrite.add_reactions)
+
+    async def test_cache_miss_used_default_overwrites_voice(self):
+        """Voice overwrites were set to None due previous values not being found in the cache."""
+        self.cog.previous_overwrites.get.return_value = None
+
+        await self.cog._unsilence(self.voice_channel)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite,
         )
 
-        self.assertIsNone(self.overwrite.send_messages)
-        self.assertIsNone(self.overwrite.add_reactions)
+        self.assertIsNone(self.voice_overwrite.connect)
+        self.assertIsNone(self.voice_overwrite.speak)
 
-    async def test_cache_miss_sent_mod_alert(self):
-        """A message was sent to the mod alerts channel."""
+    async def test_cache_miss_sent_mod_alert_text(self):
+        """A message was sent to the mod alerts channel upon muting a text channel."""
         self.cog.previous_overwrites.get.return_value = None
+        await self.cog._unsilence(self.text_channel)
+        self.cog._mod_alerts_channel.send.assert_awaited_once()
 
-        await self.cog._unsilence(self.channel)
+    async def test_cache_miss_sent_mod_alert_voice(self):
+        """A message was sent to the mod alerts channel upon muting a voice channel."""
+        self.cog.previous_overwrites.get.return_value = None
+        await self.cog._unsilence(MockVoiceChannel())
         self.cog._mod_alerts_channel.send.assert_awaited_once()
 
     async def test_removed_notifier(self):
         """Channel was removed from `notifier`."""
-        await self.cog._unsilence(self.channel)
-        self.cog.notifier.remove_channel.assert_called_once_with(self.channel)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.notifier.remove_channel.assert_called_once_with(self.text_channel)
 
     async def test_deleted_cached_overwrite(self):
         """Channel was deleted from the overwrites cache."""
-        await self.cog._unsilence(self.channel)
-        self.cog.previous_overwrites.delete.assert_awaited_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.previous_overwrites.delete.assert_awaited_once_with(self.text_channel.id)
 
     async def test_deleted_cached_time(self):
         """Channel was deleted from the timestamp cache."""
-        await self.cog._unsilence(self.channel)
-        self.cog.unsilence_timestamps.delete.assert_awaited_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.unsilence_timestamps.delete.assert_awaited_once_with(self.text_channel.id)
 
     async def test_cancelled_task(self):
         """The scheduled unsilence task should be cancelled."""
-        await self.cog._unsilence(self.channel)
-        self.cog.scheduler.cancel.assert_called_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.scheduler.cancel.assert_called_once_with(self.text_channel.id)
 
-    async def test_preserved_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed, including cache misses."""
+    async def test_preserved_other_overwrites_text(self):
+        """Text channel's other unrelated overwrites were not changed, including cache misses."""
         for overwrite_json in ('{"send_messages": true, "add_reactions": null}', None):
             with self.subTest(overwrite_json=overwrite_json):
                 self.cog.previous_overwrites.get.return_value = overwrite_json
 
-                prev_overwrite_dict = dict(self.overwrite)
-                await self.cog._unsilence(self.channel)
-                new_overwrite_dict = dict(self.overwrite)
+                prev_overwrite_dict = dict(self.text_overwrite)
+                await self.cog._unsilence(self.text_channel)
+                new_overwrite_dict = dict(self.text_overwrite)
 
                 # Remove these keys because they were modified by the unsilence.
                 del prev_overwrite_dict['send_messages']
@@ -491,3 +812,114 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
                 del new_overwrite_dict['add_reactions']
 
                 self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
+    async def test_preserved_other_overwrites_voice(self):
+        """Voice channel's other unrelated overwrites were not changed, including cache misses."""
+        for overwrite_json in ('{"connect": true, "speak": true}', None):
+            with self.subTest(overwrite_json=overwrite_json):
+                self.cog.previous_overwrites.get.return_value = overwrite_json
+
+                prev_overwrite_dict = dict(self.voice_overwrite)
+                await self.cog._unsilence(self.voice_channel)
+                new_overwrite_dict = dict(self.voice_overwrite)
+
+                # Remove these keys because they were modified by the unsilence.
+                del prev_overwrite_dict['connect']
+                del prev_overwrite_dict['speak']
+                del new_overwrite_dict['connect']
+                del new_overwrite_dict['speak']
+
+                self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
+    async def test_unsilence_role(self):
+        """Tests unsilence_wrapper applies permission to the correct role."""
+        test_cases = (
+            (MockTextChannel(), self.cog.bot.get_guild(Guild.id).default_role),
+            (MockVoiceChannel(), self.cog.bot.get_guild(Guild.id).get_role(Roles.voice_verified))
+        )
+
+        for channel, role in test_cases:
+            with self.subTest(channel=channel, role=role):
+                await self.cog._unsilence_wrapper(channel, MockContext())
+                channel.overwrites_for.assert_called_with(role)
+
+
+class SendMessageTests(unittest.IsolatedAsyncioTestCase):
+    """Unittests for the send message helper function."""
+
+    def setUp(self) -> None:
+        self.bot = MockBot()
+        self.cog = silence.Silence(self.bot)
+
+        self.text_channels = [MockTextChannel() for _ in range(2)]
+        self.bot.get_channel.return_value = self.text_channels[1]
+
+        self.voice_channel = MockVoiceChannel()
+
+    async def test_send_to_channel(self):
+        """Tests a basic case for the send function."""
+        message = "Test basic message."
+        await self.cog.send_message(message, *self.text_channels, alert_target=False)
+
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_send_to_multiple_channels(self):
+        """Tests sending messages to two channels."""
+        message = "Test basic message."
+        await self.cog.send_message(message, *self.text_channels, alert_target=True)
+
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_awaited_once_with(message)
+
+    async def test_duration_replacement(self):
+        """Tests that the channel name was set correctly for one target channel."""
+        message = "Current. The following should be replaced: {channel}."
+        await self.cog.send_message(message, *self.text_channels, alert_target=False)
+
+        updated_message = message.format(channel=self.text_channels[0].mention)
+        self.text_channels[0].send.assert_awaited_once_with(updated_message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_name_replacement_multiple_channels(self):
+        """Tests that the channel name was set correctly for two channels."""
+        message = "Current. The following should be replaced: {channel}."
+        await self.cog.send_message(message, *self.text_channels, alert_target=True)
+
+        self.text_channels[0].send.assert_awaited_once_with(message.format(channel=self.text_channels[0].mention))
+        self.text_channels[1].send.assert_awaited_once_with(message.format(channel="current channel"))
+
+    async def test_silence_voice(self):
+        """Tests that the correct message was sent when a voice channel is muted without alerting."""
+        message = "This should show up just here."
+        await self.cog.send_message(message, self.text_channels[0], self.voice_channel, alert_target=False)
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_silence_voice_alert(self):
+        """Tests that the correct message was sent when a voice channel is muted with alerts."""
+        with unittest.mock.patch.object(silence, "VOICE_CHANNELS") as mock_voice_channels:
+            mock_voice_channels.get.return_value = self.text_channels[1].id
+
+            message = "This should show up as {channel}."
+            await self.cog.send_message(message, self.text_channels[0], self.voice_channel, alert_target=True)
+
+        updated_message = message.format(channel=self.voice_channel.mention)
+        self.text_channels[0].send.assert_awaited_once_with(updated_message)
+        self.text_channels[1].send.assert_awaited_once_with(updated_message)
+
+        mock_voice_channels.get.assert_called_once_with(self.voice_channel.id)
+
+    async def test_silence_voice_sibling_channel(self):
+        """Tests silencing a voice channel from the related text channel."""
+        with unittest.mock.patch.object(silence, "VOICE_CHANNELS") as mock_voice_channels:
+            mock_voice_channels.get.return_value = self.text_channels[1].id
+
+            message = "This should show up as {channel}."
+            await self.cog.send_message(message, self.text_channels[1], self.voice_channel, alert_target=True)
+
+            updated_message = message.format(channel=self.voice_channel.mention)
+            self.text_channels[1].send.assert_awaited_once_with(updated_message)
+
+            mock_voice_channels.get.assert_called_once_with(self.voice_channel.id)
+            self.bot.get_channel.assert_called_once_with(self.text_channels[1].id)
diff --git a/tests/bot/exts/utils/test_jams.py b/tests/bot/exts/utils/test_jams.py
index 85d6a1173..368a15476 100644
--- a/tests/bot/exts/utils/test_jams.py
+++ b/tests/bot/exts/utils/test_jams.py
@@ -2,10 +2,24 @@ import unittest
 from unittest.mock import AsyncMock, MagicMock, create_autospec
 
 from discord import CategoryChannel
+from discord.ext.commands import BadArgument
 
 from bot.constants import Roles
 from bot.exts.utils import jams
-from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole, MockTextChannel
+from tests.helpers import (
+    MockAttachment, MockBot, MockCategoryChannel, MockContext,
+    MockGuild, MockMember, MockRole, MockTextChannel
+)
+
+TEST_CSV = b"""\
+Team Name,Team Member Discord ID,Team Leader
+Annoyed Alligators,12345,Y
+Annoyed Alligators,54321,N
+Oscillating Otters,12358,Y
+Oscillating Otters,74832,N
+Oscillating Otters,19903,N
+Annoyed Alligators,11111,N
+"""
 
 
 def get_mock_category(channel_count: int, name: str) -> CategoryChannel:
@@ -17,8 +31,8 @@ def get_mock_category(channel_count: int, name: str) -> CategoryChannel:
     return category
 
 
-class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
-    """Tests for `createteam` command."""
+class JamCodejamCreateTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for `codejam create` command."""
 
     def setUp(self):
         self.bot = MockBot()
@@ -28,60 +42,64 @@ class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext(bot=self.bot, author=self.command_user, guild=self.guild)
         self.cog = jams.CodeJams(self.bot)
 
-    async def test_too_small_amount_of_team_members_passed(self):
-        """Should `ctx.send` and exit early when too small amount of members."""
-        for case in (1, 2):
-            with self.subTest(amount_of_members=case):
-                self.cog.create_channels = AsyncMock()
-                self.cog.add_roles = AsyncMock()
+    async def test_message_without_attachments(self):
+        """If no link or attachments are provided, commands.BadArgument should be raised."""
+        self.ctx.message.attachments = []
 
-                self.ctx.reset_mock()
-                members = (MockMember() for _ in range(case))
-                await self.cog.createteam(self.cog, self.ctx, "foo", members)
+        with self.assertRaises(BadArgument):
+            await self.cog.create(self.cog, self.ctx, None)
 
-                self.ctx.send.assert_awaited_once()
-                self.cog.create_channels.assert_not_awaited()
-                self.cog.add_roles.assert_not_awaited()
+    async def test_result_sending(self):
+        """Should call `ctx.send` when everything goes right."""
+        self.ctx.message.attachments = [MockAttachment()]
+        self.ctx.message.attachments[0].read = AsyncMock()
+        self.ctx.message.attachments[0].read.return_value = TEST_CSV
+
+        team_leaders = MockRole()
+
+        self.guild.get_member.return_value = MockMember()
 
-    async def test_duplicate_members_provided(self):
-        """Should `ctx.send` and exit early because duplicate members provided and total there is only 1 member."""
-        self.cog.create_channels = AsyncMock()
+        self.ctx.guild.create_role = AsyncMock()
+        self.ctx.guild.create_role.return_value = team_leaders
+        self.cog.create_team_channel = AsyncMock()
+        self.cog.create_team_leader_channel = AsyncMock()
         self.cog.add_roles = AsyncMock()
 
-        member = MockMember()
-        await self.cog.createteam(self.cog, self.ctx, "foo", (member for _ in range(5)))
+        await self.cog.create(self.cog, self.ctx, None)
 
+        self.cog.create_team_channel.assert_awaited()
+        self.cog.create_team_leader_channel.assert_awaited_once_with(
+            self.ctx.guild, team_leaders
+        )
         self.ctx.send.assert_awaited_once()
-        self.cog.create_channels.assert_not_awaited()
-        self.cog.add_roles.assert_not_awaited()
-
-    async def test_result_sending(self):
-        """Should call `ctx.send` when everything goes right."""
-        self.cog.create_channels = AsyncMock()
-        self.cog.add_roles = AsyncMock()
 
-        members = [MockMember() for _ in range(5)]
-        await self.cog.createteam(self.cog, self.ctx, "foo", members)
+    async def test_link_returning_non_200_status(self):
+        """When the URL passed returns a non 200 status, it should send a message informing them."""
+        self.bot.http_session.get.return_value = mock = MagicMock()
+        mock.status = 404
+        await self.cog.create(self.cog, self.ctx, "https://not-a-real-link.com")
 
-        self.cog.create_channels.assert_awaited_once()
-        self.cog.add_roles.assert_awaited_once()
         self.ctx.send.assert_awaited_once()
 
     async def test_category_doesnt_exist(self):
         """Should create a new code jam category."""
         subtests = (
             [],
-            [get_mock_category(jams.MAX_CHANNELS - 1, jams.CATEGORY_NAME)],
+            [get_mock_category(jams.MAX_CHANNELS, jams.CATEGORY_NAME)],
             [get_mock_category(jams.MAX_CHANNELS - 2, "other")],
         )
 
+        self.cog.send_status_update = AsyncMock()
+
         for categories in subtests:
+            self.cog.send_status_update.reset_mock()
             self.guild.reset_mock()
             self.guild.categories = categories
 
             with self.subTest(categories=categories):
                 actual_category = await self.cog.get_category(self.guild)
 
+                self.cog.send_status_update.assert_called_once()
                 self.guild.create_category_channel.assert_awaited_once()
                 category_overwrites = self.guild.create_category_channel.call_args[1]["overwrites"]
 
@@ -103,62 +121,47 @@ class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_channel_overwrites(self):
         """Should have correct permission overwrites for users and roles."""
-        leader = MockMember()
-        members = [leader] + [MockMember() for _ in range(4)]
+        leader = (MockMember(), True)
+        members = [leader] + [(MockMember(), False) for _ in range(4)]
         overwrites = self.cog.get_overwrites(members, self.guild)
 
-        # Leader permission overwrites
-        self.assertTrue(overwrites[leader].manage_messages)
-        self.assertTrue(overwrites[leader].read_messages)
-        self.assertTrue(overwrites[leader].manage_webhooks)
-        self.assertTrue(overwrites[leader].connect)
-
-        # Other members permission overwrites
-        for member in members[1:]:
+        for member, _ in members:
             self.assertTrue(overwrites[member].read_messages)
-            self.assertTrue(overwrites[member].connect)
-
-        # Everyone role overwrite
-        self.assertFalse(overwrites[self.guild.default_role].read_messages)
-        self.assertFalse(overwrites[self.guild.default_role].connect)
 
     async def test_team_channels_creation(self):
-        """Should create new voice and text channel for team."""
-        members = [MockMember() for _ in range(5)]
+        """Should create a text channel for a team."""
+        team_leaders = MockRole()
+        members = [(MockMember(), True)] + [(MockMember(), False) for _ in range(5)]
+        category = MockCategoryChannel()
+        category.create_text_channel = AsyncMock()
 
         self.cog.get_overwrites = MagicMock()
         self.cog.get_category = AsyncMock()
-        self.ctx.guild.create_text_channel.return_value = MockTextChannel(mention="foobar-channel")
-        actual = await self.cog.create_channels(self.guild, "my-team", members)
+        self.cog.get_category.return_value = category
+        self.cog.add_team_leader_roles = AsyncMock()
 
-        self.assertEqual("foobar-channel", actual)
+        await self.cog.create_team_channel(self.guild, "my-team", members, team_leaders)
+        self.cog.add_team_leader_roles.assert_awaited_once_with(members, team_leaders)
         self.cog.get_overwrites.assert_called_once_with(members, self.guild)
         self.cog.get_category.assert_awaited_once_with(self.guild)
 
-        self.guild.create_text_channel.assert_awaited_once_with(
+        category.create_text_channel.assert_awaited_once_with(
             "my-team",
-            overwrites=self.cog.get_overwrites.return_value,
-            category=self.cog.get_category.return_value
-        )
-        self.guild.create_voice_channel.assert_awaited_once_with(
-            "My Team",
-            overwrites=self.cog.get_overwrites.return_value,
-            category=self.cog.get_category.return_value
+            overwrites=self.cog.get_overwrites.return_value
         )
 
     async def test_jam_roles_adding(self):
         """Should add team leader role to leader and jam role to every team member."""
         leader_role = MockRole(name="Team Leader")
-        jam_role = MockRole(name="Jammer")
-        self.guild.get_role.side_effect = [leader_role, jam_role]
 
         leader = MockMember()
-        members = [leader] + [MockMember() for _ in range(4)]
-        await self.cog.add_roles(self.guild, members)
+        members = [(leader, True)] + [(MockMember(), False) for _ in range(4)]
+        await self.cog.add_team_leader_roles(members, leader_role)
 
-        leader.add_roles.assert_any_await(leader_role)
-        for member in members:
-            member.add_roles.assert_any_await(jam_role)
+        leader.add_roles.assert_awaited_once_with(leader_role)
+        for member, is_leader in members:
+            if not is_leader:
+                member.add_roles.assert_not_awaited()
 
 
 class CodeJamSetup(unittest.TestCase):
diff --git a/tests/bot/test_converters.py b/tests/bot/test_converters.py
index 4af84dde5..2a1c4e543 100644
--- a/tests/bot/test_converters.py
+++ b/tests/bot/test_converters.py
@@ -291,7 +291,7 @@ class ConverterTests(unittest.IsolatedAsyncioTestCase):
             ("10", 10),
             ("5m", 5),
             ("5M", 5),
-            ("forever", None),
+            ("forever", -1),
         )
         converter = HushDurationConverter()
         for minutes_string, expected_minutes in test_values:
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 694d3a40f..8edffd1c9 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -1,7 +1,5 @@
-import asyncio
 import unittest
 from datetime import datetime, timezone
-from unittest.mock import AsyncMock, patch
 
 from dateutil.relativedelta import relativedelta
 
@@ -54,18 +52,7 @@ class TimeTests(unittest.TestCase):
 
     def test_format_infraction(self):
         """Testing format_infraction."""
-        self.assertEqual(time.format_infraction('2019-12-12T00:01:00Z'), '2019-12-12 00:01')
-
-    @patch('asyncio.sleep', new_callable=AsyncMock)
-    def test_wait_until(self, mock):
-        """Testing wait_until."""
-        start = datetime(2019, 1, 1, 0, 0)
-        then = datetime(2019, 1, 1, 0, 10)
-
-        # No return value
-        self.assertIs(asyncio.run(time.wait_until(then, start)), None)
-
-        mock.assert_called_once_with(10 * 60)
+        self.assertEqual(time.format_infraction('2019-12-12T00:01:00Z'), '<t:1576108860:f>')
 
     def test_format_infraction_with_duration_none_expiry(self):
         """format_infraction_with_duration should work for None expiry."""
@@ -85,10 +72,10 @@ class TimeTests(unittest.TestCase):
     def test_format_infraction_with_duration_custom_units(self):
         """format_infraction_with_duration should work for custom max_units."""
         test_cases = (
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 5, 5), 6,
-             '2019-12-12 00:01 (11 hours, 55 minutes and 55 seconds)'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 4, 25, 20, 15), 20,
-             '2019-11-23 20:09 (6 months, 28 days, 23 hours and 54 minutes)')
+            ('3000-12-12T00:01:00Z', datetime(3000, 12, 11, 12, 5, 5), 6,
+             '<t:32533488060:f> (11 hours, 55 minutes and 55 seconds)'),
+            ('3000-11-23T20:09:00Z', datetime(3000, 4, 25, 20, 15), 20,
+             '<t:32531918940:f> (6 months, 28 days, 23 hours and 54 minutes)')
         )
 
         for expiry, date_from, max_units, expected in test_cases:
@@ -98,16 +85,16 @@ class TimeTests(unittest.TestCase):
     def test_format_infraction_with_duration_normal_usage(self):
         """format_infraction_with_duration should work for normal usage, across various durations."""
         test_cases = (
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 2, '2019-12-12 00:01 (12 hours and 55 seconds)'),
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 1, '2019-12-12 00:01 (12 hours)'),
-            ('2019-12-12T00:00:00Z', datetime(2019, 12, 11, 23, 59), 2, '2019-12-12 00:00 (1 minute)'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 11, 15, 20, 15), 2, '2019-11-23 20:09 (7 days and 23 hours)'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 4, 25, 20, 15), 2, '2019-11-23 20:09 (6 months and 28 days)'),
-            ('2019-11-23T20:58:00Z', datetime(2019, 11, 23, 20, 53), 2, '2019-11-23 20:58 (5 minutes)'),
-            ('2019-11-24T00:00:00Z', datetime(2019, 11, 23, 23, 59, 0), 2, '2019-11-24 00:00 (1 minute)'),
-            ('2019-11-23T23:59:00Z', datetime(2017, 7, 21, 23, 0), 2, '2019-11-23 23:59 (2 years and 4 months)'),
+            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 2, '<t:1576108860:f> (12 hours and 55 seconds)'),
+            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 1, '<t:1576108860:f> (12 hours)'),
+            ('2019-12-12T00:00:00Z', datetime(2019, 12, 11, 23, 59), 2, '<t:1576108800:f> (1 minute)'),
+            ('2019-11-23T20:09:00Z', datetime(2019, 11, 15, 20, 15), 2, '<t:1574539740:f> (7 days and 23 hours)'),
+            ('2019-11-23T20:09:00Z', datetime(2019, 4, 25, 20, 15), 2, '<t:1574539740:f> (6 months and 28 days)'),
+            ('2019-11-23T20:58:00Z', datetime(2019, 11, 23, 20, 53), 2, '<t:1574542680:f> (5 minutes)'),
+            ('2019-11-24T00:00:00Z', datetime(2019, 11, 23, 23, 59, 0), 2, '<t:1574553600:f> (1 minute)'),
+            ('2019-11-23T23:59:00Z', datetime(2017, 7, 21, 23, 0), 2, '<t:1574553540:f> (2 years and 4 months)'),
             ('2019-11-23T23:59:00Z', datetime(2019, 11, 23, 23, 49, 5), 2,
-             '2019-11-23 23:59 (9 minutes and 55 seconds)'),
+             '<t:1574553540:f> (9 minutes and 55 seconds)'),
             (None, datetime(2019, 11, 23, 23, 49, 5), 2, None),
         )
 
@@ -117,45 +104,30 @@ class TimeTests(unittest.TestCase):
 
     def test_until_expiration_with_duration_none_expiry(self):
         """until_expiration should work for None expiry."""
-        test_cases = (
-            (None, None, None, None),
-
-            # To make sure that now and max_units are not touched
-            (None, 'Why hello there!', None, None),
-            (None, None, float('inf'), None),
-            (None, 'Why hello there!', float('inf'), None),
-        )
-
-        for expiry, now, max_units, expected in test_cases:
-            with self.subTest(expiry=expiry, now=now, max_units=max_units, expected=expected):
-                self.assertEqual(time.until_expiration(expiry, now, max_units), expected)
+        self.assertEqual(time.until_expiration(None), None)
 
     def test_until_expiration_with_duration_custom_units(self):
         """until_expiration should work for custom max_units."""
         test_cases = (
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 5, 5), 6, '11 hours, 55 minutes and 55 seconds'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 4, 25, 20, 15), 20, '6 months, 28 days, 23 hours and 54 minutes')
+            ('3000-12-12T00:01:00Z', '<t:32533488060:R>'),
+            ('3000-11-23T20:09:00Z', '<t:32531918940:R>')
         )
 
-        for expiry, now, max_units, expected in test_cases:
-            with self.subTest(expiry=expiry, now=now, max_units=max_units, expected=expected):
-                self.assertEqual(time.until_expiration(expiry, now, max_units), expected)
+        for expiry, expected in test_cases:
+            with self.subTest(expiry=expiry, expected=expected):
+                self.assertEqual(time.until_expiration(expiry,), expected)
 
     def test_until_expiration_normal_usage(self):
         """until_expiration should work for normal usage, across various durations."""
         test_cases = (
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 2, '12 hours and 55 seconds'),
-            ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5), 1, '12 hours'),
-            ('2019-12-12T00:00:00Z', datetime(2019, 12, 11, 23, 59), 2, '1 minute'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 11, 15, 20, 15), 2, '7 days and 23 hours'),
-            ('2019-11-23T20:09:00Z', datetime(2019, 4, 25, 20, 15), 2, '6 months and 28 days'),
-            ('2019-11-23T20:58:00Z', datetime(2019, 11, 23, 20, 53), 2, '5 minutes'),
-            ('2019-11-24T00:00:00Z', datetime(2019, 11, 23, 23, 59, 0), 2, '1 minute'),
-            ('2019-11-23T23:59:00Z', datetime(2017, 7, 21, 23, 0), 2, '2 years and 4 months'),
-            ('2019-11-23T23:59:00Z', datetime(2019, 11, 23, 23, 49, 5), 2, '9 minutes and 55 seconds'),
-            (None, datetime(2019, 11, 23, 23, 49, 5), 2, None),
+            ('3000-12-12T00:01:00Z', '<t:32533488060:R>'),
+            ('3000-12-12T00:01:00Z', '<t:32533488060:R>'),
+            ('3000-12-12T00:00:00Z', '<t:32533488000:R>'),
+            ('3000-11-23T20:09:00Z', '<t:32531918940:R>'),
+            ('3000-11-23T20:09:00Z', '<t:32531918940:R>'),
+            (None, None),
         )
 
-        for expiry, now, max_units, expected in test_cases:
-            with self.subTest(expiry=expiry, now=now, max_units=max_units, expected=expected):
-                self.assertEqual(time.until_expiration(expiry, now, max_units), expected)
+        for expiry, expected in test_cases:
+            with self.subTest(expiry=expiry, expected=expected):
+                self.assertEqual(time.until_expiration(expiry), expected)
diff --git a/tests/helpers.py b/tests/helpers.py
index 496363ae3..3978076ed 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -16,7 +16,6 @@ from bot.async_stats import AsyncStatsClient
 from bot.bot import Bot
 from tests._autospec import autospec  # noqa: F401 other modules import it via this module
 
-
 for logger in logging.Logger.manager.loggerDict.values():
     # Set all loggers to CRITICAL by default to prevent screen clutter during testing
 
@@ -320,7 +319,10 @@ channel_data = {
 }
 state = unittest.mock.MagicMock()
 guild = unittest.mock.MagicMock()
-channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
+text_channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
+
+channel_data["type"] = "VoiceChannel"
+voice_channel_instance = discord.VoiceChannel(state=state, guild=guild, data=channel_data)
 
 
 class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
@@ -330,7 +332,24 @@ class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     Instances of this class will follow the specifications of `discord.TextChannel` instances. For
     more information, see the `MockGuild` docstring.
     """
-    spec_set = channel_instance
+    spec_set = text_channel_instance
+
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
+
+        if 'mention' not in kwargs:
+            self.mention = f"#{self.name}"
+
+
+class MockVoiceChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
+    """
+    A MagicMock subclass to mock VoiceChannel objects.
+
+    Instances of this class will follow the specifications of `discord.VoiceChannel` instances. For
+    more information, see the `MockGuild` docstring.
+    """
+    spec_set = voice_channel_instance
 
     def __init__(self, **kwargs) -> None:
         default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
@@ -361,6 +380,27 @@ class MockDMChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
         super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
 
+# Create CategoryChannel instance to get a realistic MagicMock of `discord.CategoryChannel`
+category_channel_data = {
+    'id': 1,
+    'type': discord.ChannelType.category,
+    'name': 'category',
+    'position': 1,
+}
+
+state = unittest.mock.MagicMock()
+guild = unittest.mock.MagicMock()
+category_channel_instance = discord.CategoryChannel(
+    state=state, guild=guild, data=category_channel_data
+)
+
+
+class MockCategoryChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id)}
+        super().__init__(**collections.ChainMap(default_kwargs, kwargs))
+
+
 # Create a Message instance to get a realistic MagicMock of `discord.Message`
 message_data = {
     'id': 1,
@@ -385,6 +425,7 @@ message_instance = discord.Message(state=state, channel=channel, data=message_da
 
 # Create a Context instance to get a realistic MagicMock of `discord.ext.commands.Context`
 context_instance = Context(message=unittest.mock.MagicMock(), prefix=unittest.mock.MagicMock())
+context_instance.invoked_from_error_handler = None
 
 
 class MockContext(CustomMockMixin, unittest.mock.MagicMock):
@@ -402,6 +443,8 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
         self.guild = kwargs.get('guild', MockGuild())
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
+        self.message = kwargs.get('message', MockMessage())
+        self.invoked_from_error_handler = kwargs.get('invoked_from_error_handler', False)
 
 
 attachment_instance = discord.Attachment(data=unittest.mock.MagicMock(id=1), state=unittest.mock.MagicMock())