Merge branch 'master' of https://github.com/python-discord/bot into help-refactor

 Conflicts:

	bot/cogs/help.py

25 files changed, 2639 insertions, 0 deletions

diff --git a/tests/bot/__init__.py b/tests/bot/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/__init__.py
diff --git a/tests/bot/cogs/__init__.py b/tests/bot/cogs/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/cogs/__init__.py
diff --git a/tests/bot/cogs/sync/__init__.py b/tests/bot/cogs/sync/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/cogs/sync/__init__.py
diff --git a/tests/bot/cogs/sync/test_roles.py b/tests/bot/cogs/sync/test_roles.py
new file mode 100644
index 000000000..27ae27639
--- /dev/null
+++ b/tests/bot/cogs/sync/test_roles.py
@@ -0,0 +1,126 @@
+import unittest
+
+from bot.cogs.sync.syncers import Role, get_roles_for_sync
+
+
+class GetRolesForSyncTests(unittest.TestCase):
+    """Tests constructing the roles to synchronize with the site."""
+
+    def test_get_roles_for_sync_empty_return_for_equal_roles(self):
+        """No roles should be synced when no diff is found."""
+        api_roles = {Role(id=41, name='name', colour=33, permissions=0x8, position=1)}
+        guild_roles = {Role(id=41, name='name', colour=33, permissions=0x8, position=1)}
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (set(), set(), set())
+        )
+
+    def test_get_roles_for_sync_returns_roles_to_update_with_non_id_diff(self):
+        """Roles to be synced are returned when non-ID attributes differ."""
+        api_roles = {Role(id=41, name='old name', colour=35, permissions=0x8, position=1)}
+        guild_roles = {Role(id=41, name='new name', colour=33, permissions=0x8, position=2)}
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (set(), guild_roles, set())
+        )
+
+    def test_get_roles_only_returns_roles_that_require_update(self):
+        """Roles that require an update should be returned as the second tuple element."""
+        api_roles = {
+            Role(id=41, name='old name', colour=33, permissions=0x8, position=1),
+            Role(id=53, name='other role', colour=55, permissions=0, position=3)
+        }
+        guild_roles = {
+            Role(id=41, name='new name', colour=35, permissions=0x8, position=2),
+            Role(id=53, name='other role', colour=55, permissions=0, position=3)
+        }
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (
+                set(),
+                {Role(id=41, name='new name', colour=35, permissions=0x8, position=2)},
+                set(),
+            )
+        )
+
+    def test_get_roles_returns_new_roles_in_first_tuple_element(self):
+        """Newly created roles are returned as the first tuple element."""
+        api_roles = {
+            Role(id=41, name='name', colour=35, permissions=0x8, position=1),
+        }
+        guild_roles = {
+            Role(id=41, name='name', colour=35, permissions=0x8, position=1),
+            Role(id=53, name='other role', colour=55, permissions=0, position=2)
+        }
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (
+                {Role(id=53, name='other role', colour=55, permissions=0, position=2)},
+                set(),
+                set(),
+            )
+        )
+
+    def test_get_roles_returns_roles_to_update_and_new_roles(self):
+        """Newly created and updated roles should be returned together."""
+        api_roles = {
+            Role(id=41, name='old name', colour=35, permissions=0x8, position=1),
+        }
+        guild_roles = {
+            Role(id=41, name='new name', colour=40, permissions=0x16, position=2),
+            Role(id=53, name='other role', colour=55, permissions=0, position=3)
+        }
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (
+                {Role(id=53, name='other role', colour=55, permissions=0, position=3)},
+                {Role(id=41, name='new name', colour=40, permissions=0x16, position=2)},
+                set(),
+            )
+        )
+
+    def test_get_roles_returns_roles_to_delete(self):
+        """Roles to be deleted should be returned as the third tuple element."""
+        api_roles = {
+            Role(id=41, name='name', colour=35, permissions=0x8, position=1),
+            Role(id=61, name='to delete', colour=99, permissions=0x9, position=2),
+        }
+        guild_roles = {
+            Role(id=41, name='name', colour=35, permissions=0x8, position=1),
+        }
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (
+                set(),
+                set(),
+                {Role(id=61, name='to delete', colour=99, permissions=0x9, position=2)},
+            )
+        )
+
+    def test_get_roles_returns_roles_to_delete_update_and_new_roles(self):
+        """When roles were added, updated, and removed, all of them are returned properly."""
+        api_roles = {
+            Role(id=41, name='not changed', colour=35, permissions=0x8, position=1),
+            Role(id=61, name='to delete', colour=99, permissions=0x9, position=2),
+            Role(id=71, name='to update', colour=99, permissions=0x9, position=3),
+        }
+        guild_roles = {
+            Role(id=41, name='not changed', colour=35, permissions=0x8, position=1),
+            Role(id=81, name='to create', colour=99, permissions=0x9, position=4),
+            Role(id=71, name='updated', colour=101, permissions=0x5, position=3),
+        }
+
+        self.assertEqual(
+            get_roles_for_sync(guild_roles, api_roles),
+            (
+                {Role(id=81, name='to create', colour=99, permissions=0x9, position=4)},
+                {Role(id=71, name='updated', colour=101, permissions=0x5, position=3)},
+                {Role(id=61, name='to delete', colour=99, permissions=0x9, position=2)},
+            )
+        )
diff --git a/tests/bot/cogs/sync/test_users.py b/tests/bot/cogs/sync/test_users.py
new file mode 100644
index 000000000..ccaf67490
--- /dev/null
+++ b/tests/bot/cogs/sync/test_users.py
@@ -0,0 +1,84 @@
+import unittest
+
+from bot.cogs.sync.syncers import User, get_users_for_sync
+
+
+def fake_user(**kwargs):
+    kwargs.setdefault('id', 43)
+    kwargs.setdefault('name', 'bob the test man')
+    kwargs.setdefault('discriminator', 1337)
+    kwargs.setdefault('avatar_hash', None)
+    kwargs.setdefault('roles', (666,))
+    kwargs.setdefault('in_guild', True)
+    return User(**kwargs)
+
+
+class GetUsersForSyncTests(unittest.TestCase):
+    """Tests constructing the users to synchronize with the site."""
+
+    def test_get_users_for_sync_returns_nothing_for_empty_params(self):
+        """When no users are given, none are returned."""
+        self.assertEqual(
+            get_users_for_sync({}, {}),
+            (set(), set())
+        )
+
+    def test_get_users_for_sync_returns_nothing_for_equal_users(self):
+        """When no users are updated, none are returned."""
+        api_users = {43: fake_user()}
+        guild_users = {43: fake_user()}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            (set(), set())
+        )
+
+    def test_get_users_for_sync_returns_users_to_update_on_non_id_field_diff(self):
+        """When a non-ID-field differs, the user to update is returned."""
+        api_users = {43: fake_user()}
+        guild_users = {43: fake_user(name='new fancy name')}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            (set(), {fake_user(name='new fancy name')})
+        )
+
+    def test_get_users_for_sync_returns_users_to_create_with_new_ids_on_guild(self):
+        """When new users join the guild, they are returned as the first tuple element."""
+        api_users = {43: fake_user()}
+        guild_users = {43: fake_user(), 63: fake_user(id=63)}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            ({fake_user(id=63)}, set())
+        )
+
+    def test_get_users_for_sync_updates_in_guild_field_on_user_leave(self):
+        """When a user leaves the guild, the `in_guild` flag is updated to `False`."""
+        api_users = {43: fake_user(), 63: fake_user(id=63)}
+        guild_users = {43: fake_user()}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            (set(), {fake_user(id=63, in_guild=False)})
+        )
+
+    def test_get_users_for_sync_updates_and_creates_users_as_needed(self):
+        """When one user left and another one was updated, both are returned."""
+        api_users = {43: fake_user()}
+        guild_users = {63: fake_user(id=63)}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            ({fake_user(id=63)}, {fake_user(in_guild=False)})
+        )
+
+    def test_get_users_for_sync_does_not_duplicate_update_users(self):
+        """When the API knows a user the guild doesn't, nothing is performed."""
+        api_users = {43: fake_user(in_guild=False)}
+        guild_users = {}
+
+        self.assertEqual(
+            get_users_for_sync(guild_users, api_users),
+            (set(), set())
+        )
diff --git a/tests/bot/cogs/test_antispam.py b/tests/bot/cogs/test_antispam.py
new file mode 100644
index 000000000..ce5472c71
--- /dev/null
+++ b/tests/bot/cogs/test_antispam.py
@@ -0,0 +1,35 @@
+import unittest
+
+from bot.cogs import antispam
+
+
+class AntispamConfigurationValidationTests(unittest.TestCase):
+    """Tests validation of the antispam cog configuration."""
+
+    def test_default_antispam_config_is_valid(self):
+        """The default antispam configuration is valid."""
+        validation_errors = antispam.validate_config()
+        self.assertEqual(validation_errors, {})
+
+    def test_unknown_rule_returns_error(self):
+        """Configuring an unknown rule returns an error."""
+        self.assertEqual(
+            antispam.validate_config({'invalid-rule': {}}),
+            {'invalid-rule': "`invalid-rule` is not recognized as an antispam rule."}
+        )
+
+    def test_missing_keys_returns_error(self):
+        """Not configuring required keys returns an error."""
+        keys = (('interval', 'max'), ('max', 'interval'))
+        for configured_key, unconfigured_key in keys:
+            with self.subTest(
+                configured_key=configured_key,
+                unconfigured_key=unconfigured_key
+            ):
+                config = {'burst': {configured_key: 10}}
+                error = f"Key `{unconfigured_key}` is required but not set for rule `burst`"
+
+                self.assertEqual(
+                    antispam.validate_config(config),
+                    {'burst': error}
+                )
diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
new file mode 100644
index 000000000..d07b2bce1
--- /dev/null
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -0,0 +1,584 @@
+import asyncio
+import logging
+import typing
+import unittest
+from unittest.mock import MagicMock, patch
+
+import discord
+
+from bot import constants
+from bot.cogs import duck_pond
+from tests import base
+from tests import helpers
+
+MODULE_PATH = "bot.cogs.duck_pond"
+
+
+class DuckPondTests(base.LoggingTestCase):
+    """Tests for DuckPond functionality."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Sets up the objects that only have to be initialized once."""
+        cls.nonstaff_member = helpers.MockMember(name="Non-staffer")
+
+        cls.staff_role = helpers.MockRole(name="Staff role", id=constants.STAFF_ROLES[0])
+        cls.staff_member = helpers.MockMember(name="staffer", roles=[cls.staff_role])
+
+        cls.checkmark_emoji = "\N{White Heavy Check Mark}"
+        cls.thumbs_up_emoji = "\N{Thumbs Up Sign}"
+        cls.unicode_duck_emoji = "\N{Duck}"
+        cls.duck_pond_emoji = helpers.MockPartialEmoji(id=constants.DuckPond.custom_emojis[0])
+        cls.non_duck_custom_emoji = helpers.MockPartialEmoji(id=123)
+
+    def setUp(self):
+        """Sets up the objects that need to be refreshed before each test."""
+        self.bot = helpers.MockBot(user=helpers.MockMember(id=46692))
+        self.cog = duck_pond.DuckPond(bot=self.bot)
+
+    def test_duck_pond_correctly_initializes(self):
+        """`__init__ should set `bot` and `webhook_id` attributes and schedule `fetch_webhook`."""
+        bot = helpers.MockBot()
+        cog = MagicMock()
+
+        duck_pond.DuckPond.__init__(cog, bot)
+
+        self.assertEqual(cog.bot, bot)
+        self.assertEqual(cog.webhook_id, constants.Webhooks.duck_pond)
+        bot.loop.create_loop.called_once_with(cog.fetch_webhook())
+
+    def test_fetch_webhook_succeeds_without_connectivity_issues(self):
+        """The `fetch_webhook` method waits until `READY` event and sets the `webhook` attribute."""
+        self.bot.fetch_webhook.return_value = "dummy webhook"
+        self.cog.webhook_id = 1
+
+        asyncio.run(self.cog.fetch_webhook())
+
+        self.bot.wait_until_ready.assert_called_once()
+        self.bot.fetch_webhook.assert_called_once_with(1)
+        self.assertEqual(self.cog.webhook, "dummy webhook")
+
+    def test_fetch_webhook_logs_when_unable_to_fetch_webhook(self):
+        """The `fetch_webhook` method should log an exception when it fails to fetch the webhook."""
+        self.bot.fetch_webhook.side_effect = discord.HTTPException(response=MagicMock(), message="Not found.")
+        self.cog.webhook_id = 1
+
+        log = logging.getLogger('bot.cogs.duck_pond')
+        with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+            asyncio.run(self.cog.fetch_webhook())
+
+        self.bot.wait_until_ready.assert_called_once()
+        self.bot.fetch_webhook.assert_called_once_with(1)
+
+        self.assertEqual(len(log_watcher.records), 1)
+
+        record = log_watcher.records[0]
+        self.assertEqual(record.levelno, logging.ERROR)
+
+    def test_is_staff_returns_correct_values_based_on_instance_passed(self):
+        """The `is_staff` method should return correct values based on the instance passed."""
+        test_cases = (
+            (helpers.MockUser(name="User instance"), False),
+            (helpers.MockMember(name="Member instance without staff role"), False),
+            (helpers.MockMember(name="Member instance with staff role", roles=[self.staff_role]), True)
+        )
+
+        for user, expected_return in test_cases:
+            actual_return = self.cog.is_staff(user)
+            with self.subTest(user_type=user.name, expected_return=expected_return, actual_return=actual_return):
+                self.assertEqual(expected_return, actual_return)
+
+    @helpers.async_test
+    async def test_has_green_checkmark_correctly_detects_presence_of_green_checkmark_emoji(self):
+        """The `has_green_checkmark` method should only return `True` if one is present."""
+        test_cases = (
+            (
+                "No reactions", helpers.MockMessage(), False
+            ),
+            (
+                "No green check mark reactions",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
+                    helpers.MockReaction(emoji=self.thumbs_up_emoji, users=[self.bot.user])
+                ]),
+                False
+            ),
+            (
+                "Green check mark reaction, but not from our bot",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
+                    helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member])
+                ]),
+                False
+            ),
+            (
+                "Green check mark reaction, with one from the bot",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
+                    helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member, self.bot.user])
+                ]),
+                True
+            )
+        )
+
+        for description, message, expected_return in test_cases:
+            actual_return = await self.cog.has_green_checkmark(message)
+            with self.subTest(
+                test_case=description,
+                expected_return=expected_return,
+                actual_return=actual_return
+            ):
+                self.assertEqual(expected_return, actual_return)
+
+    def test_send_webhook_correctly_passes_on_arguments(self):
+        """The `send_webhook` method should pass the arguments to the webhook correctly."""
+        self.cog.webhook = helpers.MockAsyncWebhook()
+
+        content = "fake content"
+        username = "fake username"
+        avatar_url = "fake avatar_url"
+        embed = "fake embed"
+
+        asyncio.run(self.cog.send_webhook(content, username, avatar_url, embed))
+
+        self.cog.webhook.send.assert_called_once_with(
+            content=content,
+            username=username,
+            avatar_url=avatar_url,
+            embed=embed
+        )
+
+    def test_send_webhook_logs_when_sending_message_fails(self):
+        """The `send_webhook` method should catch a `discord.HTTPException` and log accordingly."""
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        self.cog.webhook.send.side_effect = discord.HTTPException(response=MagicMock(), message="Something failed.")
+
+        log = logging.getLogger('bot.cogs.duck_pond')
+        with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+            asyncio.run(self.cog.send_webhook())
+
+        self.assertEqual(len(log_watcher.records), 1)
+
+        record = log_watcher.records[0]
+        self.assertEqual(record.levelno, logging.ERROR)
+
+    def _get_reaction(
+        self,
+        emoji: typing.Union[str, helpers.MockEmoji],
+        staff: int = 0,
+        nonstaff: int = 0
+    ) -> helpers.MockReaction:
+        staffers = [helpers.MockMember(roles=[self.staff_role]) for _ in range(staff)]
+        nonstaffers = [helpers.MockMember() for _ in range(nonstaff)]
+        return helpers.MockReaction(emoji=emoji, users=staffers + nonstaffers)
+
+    @helpers.async_test
+    async def test_count_ducks_correctly_counts_the_number_of_eligible_duck_emojis(self):
+        """The `count_ducks` method should return the number of unique staffers who gave a duck."""
+        test_cases = (
+            # Simple test cases
+            # A message without reactions should return 0
+            (
+                "No reactions",
+                helpers.MockMessage(),
+                0
+            ),
+            # A message with a non-duck reaction from a non-staffer should return 0
+            (
+                "Non-duck reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.thumbs_up_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a non-duck reaction from a staffer should return 0
+            (
+                "Non-duck reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.non_duck_custom_emoji, staff=1)]),
+                0
+            ),
+            # A message with a non-duck reaction from a non-staffer and staffer should return 0
+            (
+                "Non-duck reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.thumbs_up_emoji, staff=1, nonstaff=1)]),
+                0
+            ),
+            # A message with a unicode duck reaction from a non-staffer should return 0
+            (
+                "Unicode Duck Reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a unicode duck reaction from a staffer should return 1
+            (
+                "Unicode Duck Reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, staff=1)]),
+                1
+            ),
+            # A message with a unicode duck reaction from a non-staffer and staffer should return 1
+            (
+                "Unicode Duck Reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, staff=1, nonstaff=1)]),
+                1
+            ),
+            # A message with a duckpond duck reaction from a non-staffer should return 0
+            (
+                "Duckpond Duck Reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a duckpond duck reaction from a staffer should return 1
+            (
+                "Duckpond Duck Reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=1)]),
+                1
+            ),
+            # A message with a duckpond duck reaction from a non-staffer and staffer should return 1
+            (
+                "Duckpond Duck Reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=1, nonstaff=1)]),
+                1
+            ),
+
+            # Complex test cases
+            # A message with duckpond duck reactions from 3 staffers and 2 non-staffers returns 3
+            (
+                "Duckpond Duck Reaction from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2)]),
+                3
+            ),
+            # A staffer with multiple duck reactions only counts once
+            (
+                "Two different duck reactions from the same staffer",
+                helpers.MockMessage(
+                    reactions=[
+                        helpers.MockReaction(emoji=self.duck_pond_emoji, users=[self.staff_member]),
+                        helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.staff_member]),
+                    ]
+                ),
+                1
+            ),
+            # A non-string emoji does not count (to test the `isinstance(reaction.emoji, str)` elif)
+            (
+                "Reaction with non-Emoji/str emoij from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=100, staff=3, nonstaff=2)]),
+                0
+            ),
+            # We correctly sum when multiple reactions are provided.
+            (
+                "Duckpond Duck Reaction from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(
+                    reactions=[
+                        self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2),
+                        self._get_reaction(emoji=self.unicode_duck_emoji, staff=4, nonstaff=9),
+                    ]
+                ),
+                3 + 4
+            ),
+        )
+
+        for description, message, expected_count in test_cases:
+            actual_count = await self.cog.count_ducks(message)
+            with self.subTest(test_case=description, expected_count=expected_count, actual_count=actual_count):
+                self.assertEqual(expected_count, actual_count)
+
+    @helpers.async_test
+    async def test_relay_message_correctly_relays_content_and_attachments(self):
+        """The `relay_message` method should correctly relay message content and attachments."""
+        send_webhook_path = f"{MODULE_PATH}.DuckPond.send_webhook"
+        send_attachments_path = f"{MODULE_PATH}.send_attachments"
+
+        self.cog.webhook = helpers.MockAsyncWebhook()
+
+        test_values = (
+            (helpers.MockMessage(clean_content="", attachments=[]), False, False),
+            (helpers.MockMessage(clean_content="message", attachments=[]), True, False),
+            (helpers.MockMessage(clean_content="", attachments=["attachment"]), False, True),
+            (helpers.MockMessage(clean_content="message", attachments=["attachment"]), True, True),
+        )
+
+        for message, expect_webhook_call, expect_attachment_call in test_values:
+            with patch(send_webhook_path, new_callable=helpers.AsyncMock) as send_webhook:
+                with patch(send_attachments_path, new_callable=helpers.AsyncMock) as send_attachments:
+                    with self.subTest(clean_content=message.clean_content, attachments=message.attachments):
+                        await self.cog.relay_message(message)
+
+                        self.assertEqual(expect_webhook_call, send_webhook.called)
+                        self.assertEqual(expect_attachment_call, send_attachments.called)
+
+                        message.add_reaction.assert_called_once_with(self.checkmark_emoji)
+
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @helpers.async_test
+    async def test_relay_message_handles_irretrievable_attachment_exceptions(self, send_attachments):
+        """The `relay_message` method should handle irretrievable attachments."""
+        message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
+        side_effects = (discord.errors.Forbidden(MagicMock(), ""), discord.errors.NotFound(MagicMock(), ""))
+
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        log = logging.getLogger("bot.cogs.duck_pond")
+
+        for side_effect in side_effects:
+            send_attachments.side_effect = side_effect
+            with patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock) as send_webhook:
+                with self.subTest(side_effect=type(side_effect).__name__):
+                    with self.assertNotLogs(logger=log, level=logging.ERROR):
+                        await self.cog.relay_message(message)
+
+                    self.assertEqual(send_webhook.call_count, 2)
+
+    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @helpers.async_test
+    async def test_relay_message_handles_attachment_http_error(self, send_attachments, send_webhook):
+        """The `relay_message` method should handle irretrievable attachments."""
+        message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
+
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        log = logging.getLogger("bot.cogs.duck_pond")
+
+        side_effect = discord.HTTPException(MagicMock(), "")
+        send_attachments.side_effect = side_effect
+        with self.subTest(side_effect=type(side_effect).__name__):
+            with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+                await self.cog.relay_message(message)
+
+            send_webhook.assert_called_once_with(
+                content=message.clean_content,
+                username=message.author.display_name,
+                avatar_url=message.author.avatar_url
+            )
+
+            self.assertEqual(len(log_watcher.records), 1)
+
+            record = log_watcher.records[0]
+            self.assertEqual(record.levelno, logging.ERROR)
+
+    def _mock_payload(self, label: str, is_custom_emoji: bool, id_: int, emoji_name: str):
+        """Creates a mock `on_raw_reaction_add` payload with the specified emoji data."""
+        payload = MagicMock(name=label)
+        payload.emoji.is_custom_emoji.return_value = is_custom_emoji
+        payload.emoji.id = id_
+        payload.emoji.name = emoji_name
+        return payload
+
+    @helpers.async_test
+    async def test_payload_has_duckpond_emoji_correctly_detects_relevant_emojis(self):
+        """The `on_raw_reaction_add` event handler should ignore irrelevant emojis."""
+        test_values = (
+            # Custom Emojis
+            (
+                self._mock_payload(
+                    label="Custom Duckpond Emoji",
+                    is_custom_emoji=True,
+                    id_=constants.DuckPond.custom_emojis[0],
+                    emoji_name=""
+                ),
+                True
+            ),
+            (
+                self._mock_payload(
+                    label="Custom Non-Duckpond Emoji",
+                    is_custom_emoji=True,
+                    id_=123,
+                    emoji_name=""
+                ),
+                False
+            ),
+            # Unicode Emojis
+            (
+                self._mock_payload(
+                    label="Unicode Duck Emoji",
+                    is_custom_emoji=False,
+                    id_=1,
+                    emoji_name=self.unicode_duck_emoji
+                ),
+                True
+            ),
+            (
+                self._mock_payload(
+                    label="Unicode Non-Duck Emoji",
+                    is_custom_emoji=False,
+                    id_=1,
+                    emoji_name=self.thumbs_up_emoji
+                ),
+                False
+            ),
+        )
+
+        for payload, expected_return in test_values:
+            actual_return = self.cog._payload_has_duckpond_emoji(payload)
+            with self.subTest(case=payload._mock_name, expected_return=expected_return, actual_return=actual_return):
+                self.assertEqual(expected_return, actual_return)
+
+    @patch(f"{MODULE_PATH}.discord.utils.get")
+    @patch(f"{MODULE_PATH}.DuckPond._payload_has_duckpond_emoji", new=MagicMock(return_value=False))
+    def test_on_raw_reaction_add_returns_early_with_payload_without_duck_emoji(self, utils_get):
+        """The `on_raw_reaction_add` method should return early if the payload does not contain a duck emoji."""
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_add(payload=MagicMock())))
+
+        # Ensure we've returned before making an unnecessary API call in the lines of code after the emoji check
+        utils_get.assert_not_called()
+
+    def _raw_reaction_mocks(self, channel_id, message_id, user_id):
+        """Sets up mocks for tests of the `on_raw_reaction_add` event listener."""
+        channel = helpers.MockTextChannel(id=channel_id)
+        self.bot.get_all_channels.return_value = (channel,)
+
+        message = helpers.MockMessage(id=message_id)
+
+        channel.fetch_message.return_value = message
+
+        member = helpers.MockMember(id=user_id, roles=[self.staff_role])
+        message.guild.members = (member,)
+
+        payload = MagicMock(channel_id=channel_id, message_id=message_id, user_id=user_id)
+
+        return channel, message, member, payload
+
+    @helpers.async_test
+    async def test_on_raw_reaction_add_returns_for_bot_and_non_staff_members(self):
+        """The `on_raw_reaction_add` event handler should return for bot users or non-staff members."""
+        channel_id = 1234
+        message_id = 2345
+        user_id = 3456
+
+        channel, message, _, payload = self._raw_reaction_mocks(channel_id, message_id, user_id)
+
+        test_cases = (
+            ("non-staff member", helpers.MockMember(id=user_id)),
+            ("bot staff member", helpers.MockMember(id=user_id, roles=[self.staff_role], bot=True)),
+        )
+
+        payload.emoji = self.duck_pond_emoji
+
+        for description, member in test_cases:
+            message.guild.members = (member, )
+            with self.subTest(test_case=description), patch(f"{MODULE_PATH}.DuckPond.has_green_checkmark") as checkmark:
+                checkmark.side_effect = AssertionError(
+                    "Expected method to return before calling `self.has_green_checkmark`."
+                )
+                self.assertIsNone(await self.cog.on_raw_reaction_add(payload))
+
+                # Check that we did make it past the payload checks
+                channel.fetch_message.assert_called_once()
+                channel.fetch_message.reset_mock()
+
+    @patch(f"{MODULE_PATH}.DuckPond.is_staff")
+    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock)
+    def test_on_raw_reaction_add_returns_on_message_with_green_checkmark_placed_by_bot(self, count_ducks, is_staff):
+        """The `on_raw_reaction_add` event should return when the message has a green check mark placed by the bot."""
+        channel_id = 31415926535
+        message_id = 27182818284
+        user_id = 16180339887
+
+        channel, message, member, payload = self._raw_reaction_mocks(channel_id, message_id, user_id)
+
+        payload.emoji = helpers.MockPartialEmoji(name=self.unicode_duck_emoji)
+        payload.emoji.is_custom_emoji.return_value = False
+
+        message.reactions = [helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.bot.user])]
+
+        is_staff.return_value = True
+        count_ducks.side_effect = AssertionError("Expected method to return before calling `self.count_ducks`")
+
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_add(payload)))
+
+        # Assert that we've made it past `self.is_staff`
+        is_staff.assert_called_once()
+
+    @helpers.async_test
+    async def test_on_raw_reaction_add_does_not_relay_below_duck_threshold(self):
+        """The `on_raw_reaction_add` listener should not relay messages or attachments below the duck threshold."""
+        test_cases = (
+            (constants.DuckPond.threshold - 1, False),
+            (constants.DuckPond.threshold, True),
+            (constants.DuckPond.threshold + 1, True),
+        )
+
+        channel, message, member, payload = self._raw_reaction_mocks(channel_id=3, message_id=4, user_id=5)
+
+        payload.emoji = self.duck_pond_emoji
+
+        for duck_count, should_relay in test_cases:
+            with patch(f"{MODULE_PATH}.DuckPond.relay_message", new_callable=helpers.AsyncMock) as relay_message:
+                with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+                    count_ducks.return_value = duck_count
+                    with self.subTest(duck_count=duck_count, should_relay=should_relay):
+                        await self.cog.on_raw_reaction_add(payload)
+
+                        # Confirm that we've made it past counting
+                        count_ducks.assert_called_once()
+
+                        # Did we relay a message?
+                        has_relayed = relay_message.called
+                        self.assertEqual(has_relayed, should_relay)
+
+                        if should_relay:
+                            relay_message.assert_called_once_with(message)
+
+    @helpers.async_test
+    async def test_on_raw_reaction_remove_prevents_removal_of_green_checkmark_depending_on_the_duck_count(self):
+        """The `on_raw_reaction_remove` listener prevents removal of the check mark on messages with enough ducks."""
+        checkmark = helpers.MockPartialEmoji(name=self.checkmark_emoji)
+
+        message = helpers.MockMessage(id=1234)
+
+        channel = helpers.MockTextChannel(id=98765)
+        channel.fetch_message.return_value = message
+
+        self.bot.get_all_channels.return_value = (channel, )
+
+        payload = MagicMock(channel_id=channel.id, message_id=message.id, emoji=checkmark)
+
+        test_cases = (
+            (constants.DuckPond.threshold - 1, False),
+            (constants.DuckPond.threshold, True),
+            (constants.DuckPond.threshold + 1, True),
+        )
+        for duck_count, should_re_add_checkmark in test_cases:
+            with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+                count_ducks.return_value = duck_count
+                with self.subTest(duck_count=duck_count, should_re_add_checkmark=should_re_add_checkmark):
+                    await self.cog.on_raw_reaction_remove(payload)
+
+                    # Check if we fetched the message
+                    channel.fetch_message.assert_called_once_with(message.id)
+
+                    # Check if we actually counted the number of ducks
+                    count_ducks.assert_called_once_with(message)
+
+                    has_re_added_checkmark = message.add_reaction.called
+                    self.assertEqual(should_re_add_checkmark, has_re_added_checkmark)
+
+                    if should_re_add_checkmark:
+                        message.add_reaction.assert_called_once_with(self.checkmark_emoji)
+                        message.add_reaction.reset_mock()
+
+                    # reset mocks
+                    channel.fetch_message.reset_mock()
+                    message.reset_mock()
+
+    def test_on_raw_reaction_remove_ignores_removal_of_non_checkmark_reactions(self):
+        """The `on_raw_reaction_remove` listener should ignore the removal of non-check mark emojis."""
+        channel = helpers.MockTextChannel(id=98765)
+
+        channel.fetch_message.side_effect = AssertionError(
+            "Expected method to return before calling `channel.fetch_message`"
+        )
+
+        self.bot.get_all_channels.return_value = (channel, )
+
+        payload = MagicMock(emoji=helpers.MockPartialEmoji(name=self.thumbs_up_emoji), channel_id=channel.id)
+
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_remove(payload)))
+
+        channel.fetch_message.assert_not_called()
+
+
+class DuckPondSetupTests(unittest.TestCase):
+    """Tests setup of the `DuckPond` cog."""
+
+    def test_setup(self):
+        """Setup of the extension should call add_cog."""
+        bot = helpers.MockBot()
+        duck_pond.setup(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/cogs/test_information.py b/tests/bot/cogs/test_information.py
new file mode 100644
index 000000000..4496a2ae0
--- /dev/null
+++ b/tests/bot/cogs/test_information.py
@@ -0,0 +1,582 @@
+import asyncio
+import textwrap
+import unittest
+import unittest.mock
+
+import discord
+
+from bot import constants
+from bot.cogs import information
+from bot.decorators import InChannelCheckFailure
+from tests import helpers
+
+
+COG_PATH = "bot.cogs.information.Information"
+
+
+class InformationCogTests(unittest.TestCase):
+    """Tests the Information cog."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.moderator_role = helpers.MockRole(name="Moderator", id=constants.Roles.moderator)
+
+    def setUp(self):
+        """Sets up fresh objects for each test."""
+        self.bot = helpers.MockBot()
+
+        self.cog = information.Information(self.bot)
+
+        self.ctx = helpers.MockContext()
+        self.ctx.author.roles.append(self.moderator_role)
+
+    def test_roles_command_command(self):
+        """Test if the `role_info` command correctly returns the `moderator_role`."""
+        self.ctx.guild.roles.append(self.moderator_role)
+
+        self.cog.roles_info.can_run = helpers.AsyncMock()
+        self.cog.roles_info.can_run.return_value = True
+
+        coroutine = self.cog.roles_info.callback(self.cog, self.ctx)
+
+        self.assertIsNone(asyncio.run(coroutine))
+        self.ctx.send.assert_called_once()
+
+        _, kwargs = self.ctx.send.call_args
+        embed = kwargs.pop('embed')
+
+        self.assertEqual(embed.title, "Role information")
+        self.assertEqual(embed.colour, discord.Colour.blurple())
+        self.assertEqual(embed.description, f"`{self.moderator_role.id}` - {self.moderator_role.mention}\n")
+        self.assertEqual(embed.footer.text, "Total roles: 1")
+
+    def test_role_info_command(self):
+        """Tests the `role info` command."""
+        dummy_role = helpers.MockRole(
+            name="Dummy",
+            id=112233445566778899,
+            colour=discord.Colour.blurple(),
+            position=10,
+            members=[self.ctx.author],
+            permissions=discord.Permissions(0)
+        )
+
+        admin_role = helpers.MockRole(
+            name="Admins",
+            id=998877665544332211,
+            colour=discord.Colour.red(),
+            position=3,
+            members=[self.ctx.author],
+            permissions=discord.Permissions(0),
+        )
+
+        self.ctx.guild.roles.append([dummy_role, admin_role])
+
+        self.cog.role_info.can_run = helpers.AsyncMock()
+        self.cog.role_info.can_run.return_value = True
+
+        coroutine = self.cog.role_info.callback(self.cog, self.ctx, dummy_role, admin_role)
+
+        self.assertIsNone(asyncio.run(coroutine))
+
+        self.assertEqual(self.ctx.send.call_count, 2)
+
+        (_, dummy_kwargs), (_, admin_kwargs) = self.ctx.send.call_args_list
+
+        dummy_embed = dummy_kwargs["embed"]
+        admin_embed = admin_kwargs["embed"]
+
+        self.assertEqual(dummy_embed.title, "Dummy info")
+        self.assertEqual(dummy_embed.colour, discord.Colour.blurple())
+
+        self.assertEqual(dummy_embed.fields[0].value, str(dummy_role.id))
+        self.assertEqual(dummy_embed.fields[1].value, f"#{dummy_role.colour.value:0>6x}")
+        self.assertEqual(dummy_embed.fields[2].value, "0.63 0.48 218")
+        self.assertEqual(dummy_embed.fields[3].value, "1")
+        self.assertEqual(dummy_embed.fields[4].value, "10")
+        self.assertEqual(dummy_embed.fields[5].value, "0")
+
+        self.assertEqual(admin_embed.title, "Admins info")
+        self.assertEqual(admin_embed.colour, discord.Colour.red())
+
+    @unittest.mock.patch('bot.cogs.information.time_since')
+    def test_server_info_command(self, time_since_patch):
+        time_since_patch.return_value = '2 days ago'
+
+        self.ctx.guild = helpers.MockGuild(
+            features=('lemons', 'apples'),
+            region="The Moon",
+            roles=[self.moderator_role],
+            channels=[
+                discord.TextChannel(
+                    state={},
+                    guild=self.ctx.guild,
+                    data={'id': 42, 'name': 'lemons-offering', 'position': 22, 'type': 'text'}
+                ),
+                discord.CategoryChannel(
+                    state={},
+                    guild=self.ctx.guild,
+                    data={'id': 5125, 'name': 'the-lemon-collection', 'position': 22, 'type': 'category'}
+                ),
+                discord.VoiceChannel(
+                    state={},
+                    guild=self.ctx.guild,
+                    data={'id': 15290, 'name': 'listen-to-lemon', 'position': 22, 'type': 'voice'}
+                )
+            ],
+            members=[
+                *(helpers.MockMember(status='online') for _ in range(2)),
+                *(helpers.MockMember(status='idle') for _ in range(1)),
+                *(helpers.MockMember(status='dnd') for _ in range(4)),
+                *(helpers.MockMember(status='offline') for _ in range(3)),
+            ],
+            member_count=1_234,
+            icon_url='a-lemon.jpg',
+        )
+
+        coroutine = self.cog.server_info.callback(self.cog, self.ctx)
+        self.assertIsNone(asyncio.run(coroutine))
+
+        time_since_patch.assert_called_once_with(self.ctx.guild.created_at, precision='days')
+        _, kwargs = self.ctx.send.call_args
+        embed = kwargs.pop('embed')
+        self.assertEqual(embed.colour, discord.Colour.blurple())
+        self.assertEqual(
+            embed.description,
+            textwrap.dedent(
+                f"""
+                **Server information**
+                Created: {time_since_patch.return_value}
+                Voice region: {self.ctx.guild.region}
+                Features: {', '.join(self.ctx.guild.features)}
+
+                **Counts**
+                Members: {self.ctx.guild.member_count:,}
+                Roles: {len(self.ctx.guild.roles)}
+                Text: 1
+                Voice: 1
+                Channel categories: 1
+
+                **Members**
+                {constants.Emojis.status_online} 2
+                {constants.Emojis.status_idle} 1
+                {constants.Emojis.status_dnd} 4
+                {constants.Emojis.status_offline} 3
+                """
+            )
+        )
+        self.assertEqual(embed.thumbnail.url, 'a-lemon.jpg')
+
+
+class UserInfractionHelperMethodTests(unittest.TestCase):
+    """Tests for the helper methods of the `!user` command."""
+
+    def setUp(self):
+        """Common set-up steps done before for each test."""
+        self.bot = helpers.MockBot()
+        self.bot.api_client.get = helpers.AsyncMock()
+        self.cog = information.Information(self.bot)
+        self.member = helpers.MockMember(id=1234)
+
+    def test_user_command_helper_method_get_requests(self):
+        """The helper methods should form the correct get requests."""
+        test_values = (
+            {
+                "helper_method": self.cog.basic_user_infraction_counts,
+                "expected_args": ("bot/infractions", {'hidden': 'False', 'user__id': str(self.member.id)}),
+            },
+            {
+                "helper_method": self.cog.expanded_user_infraction_counts,
+                "expected_args": ("bot/infractions", {'user__id': str(self.member.id)}),
+            },
+            {
+                "helper_method": self.cog.user_nomination_counts,
+                "expected_args": ("bot/nominations", {'user__id': str(self.member.id)}),
+            },
+        )
+
+        for test_value in test_values:
+            helper_method = test_value["helper_method"]
+            endpoint, params = test_value["expected_args"]
+
+            with self.subTest(method=helper_method, endpoint=endpoint, params=params):
+                asyncio.run(helper_method(self.member))
+                self.bot.api_client.get.assert_called_once_with(endpoint, params=params)
+                self.bot.api_client.get.reset_mock()
+
+    def _method_subtests(self, method, test_values, default_header):
+        """Helper method that runs the subtests for the different helper methods."""
+        for test_value in test_values:
+            api_response = test_value["api response"]
+            expected_lines = test_value["expected_lines"]
+
+            with self.subTest(method=method, api_response=api_response, expected_lines=expected_lines):
+                self.bot.api_client.get.return_value = api_response
+
+                expected_output = "\n".join(default_header + expected_lines)
+                actual_output = asyncio.run(method(self.member))
+
+                self.assertEqual(expected_output, actual_output)
+
+    def test_basic_user_infraction_counts_returns_correct_strings(self):
+        """The method should correctly list both the total and active number of non-hidden infractions."""
+        test_values = (
+            # No infractions means zero counts
+            {
+                "api response": [],
+                "expected_lines": ["Total: 0", "Active: 0"],
+            },
+            # Simple, single-infraction dictionaries
+            {
+                "api response": [{"type": "ban", "active": True}],
+                "expected_lines": ["Total: 1", "Active: 1"],
+            },
+            {
+                "api response": [{"type": "ban", "active": False}],
+                "expected_lines": ["Total: 1", "Active: 0"],
+            },
+            # Multiple infractions with various `active` status
+            {
+                "api response": [
+                    {"type": "ban", "active": True},
+                    {"type": "kick", "active": False},
+                    {"type": "ban", "active": True},
+                    {"type": "ban", "active": False},
+                ],
+                "expected_lines": ["Total: 4", "Active: 2"],
+            },
+        )
+
+        header = ["**Infractions**"]
+
+        self._method_subtests(self.cog.basic_user_infraction_counts, test_values, header)
+
+    def test_expanded_user_infraction_counts_returns_correct_strings(self):
+        """The method should correctly list the total and active number of all infractions split by infraction type."""
+        test_values = (
+            {
+                "api response": [],
+                "expected_lines": ["This user has never received an infraction."],
+            },
+            # Shows non-hidden inactive infraction as expected
+            {
+                "api response": [{"type": "kick", "active": False, "hidden": False}],
+                "expected_lines": ["Kicks: 1"],
+            },
+            # Shows non-hidden active infraction as expected
+            {
+                "api response": [{"type": "mute", "active": True, "hidden": False}],
+                "expected_lines": ["Mutes: 1 (1 active)"],
+            },
+            # Shows hidden inactive infraction as expected
+            {
+                "api response": [{"type": "superstar", "active": False, "hidden": True}],
+                "expected_lines": ["Superstars: 1"],
+            },
+            # Shows hidden active infraction as expected
+            {
+                "api response": [{"type": "ban", "active": True, "hidden": True}],
+                "expected_lines": ["Bans: 1 (1 active)"],
+            },
+            # Correctly displays tally of multiple infractions of mixed properties in alphabetical order
+            {
+                "api response": [
+                    {"type": "kick", "active": False, "hidden": True},
+                    {"type": "ban", "active": True, "hidden": True},
+                    {"type": "superstar", "active": True, "hidden": True},
+                    {"type": "mute", "active": True, "hidden": True},
+                    {"type": "ban", "active": False, "hidden": False},
+                    {"type": "note", "active": False, "hidden": True},
+                    {"type": "note", "active": False, "hidden": True},
+                    {"type": "warn", "active": False, "hidden": False},
+                    {"type": "note", "active": False, "hidden": True},
+                ],
+                "expected_lines": [
+                    "Bans: 2 (1 active)",
+                    "Kicks: 1",
+                    "Mutes: 1 (1 active)",
+                    "Notes: 3",
+                    "Superstars: 1 (1 active)",
+                    "Warns: 1",
+                ],
+            },
+        )
+
+        header = ["**Infractions**"]
+
+        self._method_subtests(self.cog.expanded_user_infraction_counts, test_values, header)
+
+    def test_user_nomination_counts_returns_correct_strings(self):
+        """The method should list the number of active and historical nominations for the user."""
+        test_values = (
+            {
+                "api response": [],
+                "expected_lines": ["This user has never been nominated."],
+            },
+            {
+                "api response": [{'active': True}],
+                "expected_lines": ["This user is **currently** nominated (1 nomination in total)."],
+            },
+            {
+                "api response": [{'active': True}, {'active': False}],
+                "expected_lines": ["This user is **currently** nominated (2 nominations in total)."],
+            },
+            {
+                "api response": [{'active': False}],
+                "expected_lines": ["This user has 1 historical nomination, but is currently not nominated."],
+            },
+            {
+                "api response": [{'active': False}, {'active': False}],
+                "expected_lines": ["This user has 2 historical nominations, but is currently not nominated."],
+            },
+
+        )
+
+        header = ["**Nominations**"]
+
+        self._method_subtests(self.cog.user_nomination_counts, test_values, header)
+
+
[email protected]("bot.cogs.information.time_since", new=unittest.mock.MagicMock(return_value="1 year ago"))
[email protected]("bot.cogs.information.constants.MODERATION_CHANNELS", new=[50])
+class UserEmbedTests(unittest.TestCase):
+    """Tests for the creation of the `!user` embed."""
+
+    def setUp(self):
+        """Common set-up steps done before for each test."""
+        self.bot = helpers.MockBot()
+        self.bot.api_client.get = helpers.AsyncMock()
+        self.cog = information.Information(self.bot)
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_uses_string_representation_of_user_in_title_if_nick_is_not_available(self):
+        """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.nick = None
+        user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
+
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        self.assertEqual(embed.title, "Mr. Hemlock")
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_uses_nick_in_title_if_available(self):
+        """The embed should use the nick if it's available."""
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
+        user = helpers.MockMember()
+        user.nick = "Cat lover"
+        user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
+
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        self.assertEqual(embed.title, "Cat lover (Mr. Hemlock)")
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_ignores_everyone_role(self):
+        """Created `!user` embeds should not contain mention of the @everyone-role."""
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
+        admins_role = helpers.MockRole(name='Admins')
+        admins_role.colour = 100
+
+        # A `MockMember` has the @Everyone role by default; we add the Admins to that.
+        user = helpers.MockMember(roles=[admins_role], top_role=admins_role)
+
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        self.assertIn("&Admins", embed.description)
+        self.assertNotIn("&Everyone", embed.description)
+
+    @unittest.mock.patch(f"{COG_PATH}.expanded_user_infraction_counts", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch(f"{COG_PATH}.user_nomination_counts", new_callable=helpers.AsyncMock)
+    def test_create_user_embed_expanded_information_in_moderation_channels(self, nomination_counts, infraction_counts):
+        """The embed should contain expanded infractions and nomination info in mod channels."""
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=50))
+
+        moderators_role = helpers.MockRole(name='Moderators')
+        moderators_role.colour = 100
+
+        infraction_counts.return_value = "expanded infractions info"
+        nomination_counts.return_value = "nomination info"
+
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        infraction_counts.assert_called_once_with(user)
+        nomination_counts.assert_called_once_with(user)
+
+        self.assertEqual(
+            textwrap.dedent(f"""
+                **User Information**
+                Created: {"1 year ago"}
+                Profile: {user.mention}
+                ID: {user.id}
+
+                **Member Information**
+                Joined: {"1 year ago"}
+                Roles: &Moderators
+
+                expanded infractions info
+
+                nomination info
+            """).strip(),
+            embed.description
+        )
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new_callable=helpers.AsyncMock)
+    def test_create_user_embed_basic_information_outside_of_moderation_channels(self, infraction_counts):
+        """The embed should contain only basic infraction data outside of mod channels."""
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=100))
+
+        moderators_role = helpers.MockRole(name='Moderators')
+        moderators_role.colour = 100
+
+        infraction_counts.return_value = "basic infractions info"
+
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        infraction_counts.assert_called_once_with(user)
+
+        self.assertEqual(
+            textwrap.dedent(f"""
+                **User Information**
+                Created: {"1 year ago"}
+                Profile: {user.mention}
+                ID: {user.id}
+
+                **Member Information**
+                Joined: {"1 year ago"}
+                Roles: &Moderators
+
+                basic infractions info
+            """).strip(),
+            embed.description
+        )
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_uses_top_role_colour_when_user_has_roles(self):
+        """The embed should be created with the colour of the top role, if a top role is available."""
+        ctx = helpers.MockContext()
+
+        moderators_role = helpers.MockRole(name='Moderators')
+        moderators_role.colour = 100
+
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        self.assertEqual(embed.colour, discord.Colour(moderators_role.colour))
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_uses_blurple_colour_when_user_has_no_roles(self):
+        """The embed should be created with a blurple colour if the user has no assigned roles."""
+        ctx = helpers.MockContext()
+
+        user = helpers.MockMember(id=217)
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        self.assertEqual(embed.colour, discord.Colour.blurple())
+
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    def test_create_user_embed_uses_png_format_of_user_avatar_as_thumbnail(self):
+        """The embed thumbnail should be set to the user's avatar in `png` format."""
+        ctx = helpers.MockContext()
+
+        user = helpers.MockMember(id=217)
+        user.avatar_url_as.return_value = "avatar url"
+        embed = asyncio.run(self.cog.create_user_embed(ctx, user))
+
+        user.avatar_url_as.assert_called_once_with(format="png")
+        self.assertEqual(embed.thumbnail.url, "avatar url")
+
+
[email protected]("bot.cogs.information.constants")
+class UserCommandTests(unittest.TestCase):
+    """Tests for the `!user` command."""
+
+    def setUp(self):
+        """Set up steps executed before each test is run."""
+        self.bot = helpers.MockBot()
+        self.cog = information.Information(self.bot)
+
+        self.moderator_role = helpers.MockRole(name="Moderators", id=2, position=10)
+        self.flautist_role = helpers.MockRole(name="Flautists", id=3, position=2)
+        self.bassist_role = helpers.MockRole(name="Bassists", id=4, position=3)
+
+        self.author = helpers.MockMember(id=1, name="syntaxaire")
+        self.moderator = helpers.MockMember(id=2, name="riffautae", roles=[self.moderator_role])
+        self.target = helpers.MockMember(id=3, name="__fluzz__")
+
+    def test_regular_member_cannot_target_another_member(self, constants):
+        """A regular user should not be able to use `!user` targeting another user."""
+        constants.MODERATION_ROLES = [self.moderator_role.id]
+
+        ctx = helpers.MockContext(author=self.author)
+
+        asyncio.run(self.cog.user_info.callback(self.cog, ctx, self.target))
+
+        ctx.send.assert_called_once_with("You may not use this command on users other than yourself.")
+
+    def test_regular_member_cannot_use_command_outside_of_bot_commands(self, constants):
+        """A regular user should not be able to use this command outside of bot-commands."""
+        constants.MODERATION_ROLES = [self.moderator_role.id]
+        constants.STAFF_ROLES = [self.moderator_role.id]
+        constants.Channels.bot = 50
+
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=100))
+
+        msg = "Sorry, but you may only use this command within <#50>."
+        with self.assertRaises(InChannelCheckFailure, msg=msg):
+            asyncio.run(self.cog.user_info.callback(self.cog, ctx))
+
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    def test_regular_user_may_use_command_in_bot_commands_channel(self, create_embed, constants):
+        """A regular user should be allowed to use `!user` targeting themselves in bot-commands."""
+        constants.STAFF_ROLES = [self.moderator_role.id]
+        constants.Channels.bot = 50
+
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=50))
+
+        asyncio.run(self.cog.user_info.callback(self.cog, ctx))
+
+        create_embed.assert_called_once_with(ctx, self.author)
+        ctx.send.assert_called_once()
+
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    def test_regular_user_can_explicitly_target_themselves(self, create_embed, constants):
+        """A user should target itself with `!user` when a `user` argument was not provided."""
+        constants.STAFF_ROLES = [self.moderator_role.id]
+        constants.Channels.bot = 50
+
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=50))
+
+        asyncio.run(self.cog.user_info.callback(self.cog, ctx, self.author))
+
+        create_embed.assert_called_once_with(ctx, self.author)
+        ctx.send.assert_called_once()
+
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    def test_staff_members_can_bypass_channel_restriction(self, create_embed, constants):
+        """Staff members should be able to bypass the bot-commands channel restriction."""
+        constants.STAFF_ROLES = [self.moderator_role.id]
+        constants.Channels.bot = 50
+
+        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(id=200))
+
+        asyncio.run(self.cog.user_info.callback(self.cog, ctx))
+
+        create_embed.assert_called_once_with(ctx, self.moderator)
+        ctx.send.assert_called_once()
+
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    def test_moderators_can_target_another_member(self, create_embed, constants):
+        """A moderator should be able to use `!user` targeting another user."""
+        constants.MODERATION_ROLES = [self.moderator_role.id]
+        constants.STAFF_ROLES = [self.moderator_role.id]
+
+        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(id=50))
+
+        asyncio.run(self.cog.user_info.callback(self.cog, ctx, self.target))
+
+        create_embed.assert_called_once_with(ctx, self.target)
+        ctx.send.assert_called_once()
diff --git a/tests/bot/cogs/test_security.py b/tests/bot/cogs/test_security.py
new file mode 100644
index 000000000..9d1a62f7e
--- /dev/null
+++ b/tests/bot/cogs/test_security.py
@@ -0,0 +1,54 @@
+import unittest
+from unittest.mock import MagicMock
+
+from discord.ext.commands import NoPrivateMessage
+
+from bot.cogs import security
+from tests.helpers import MockBot, MockContext
+
+
+class SecurityCogTests(unittest.TestCase):
+    """Tests the `Security` cog."""
+
+    def setUp(self):
+        """Attach an instance of the cog to the class for tests."""
+        self.bot = MockBot()
+        self.cog = security.Security(self.bot)
+        self.ctx = MockContext()
+
+    def test_check_additions(self):
+        """The cog should add its checks after initialization."""
+        self.bot.check.assert_any_call(self.cog.check_on_guild)
+        self.bot.check.assert_any_call(self.cog.check_not_bot)
+
+    def test_check_not_bot_returns_false_for_humans(self):
+        """The bot check should return `True` when invoked with human authors."""
+        self.ctx.author.bot = False
+        self.assertTrue(self.cog.check_not_bot(self.ctx))
+
+    def test_check_not_bot_returns_true_for_robots(self):
+        """The bot check should return `False` when invoked with robotic authors."""
+        self.ctx.author.bot = True
+        self.assertFalse(self.cog.check_not_bot(self.ctx))
+
+    def test_check_on_guild_raises_when_outside_of_guild(self):
+        """When invoked outside of a guild, `check_on_guild` should cause an error."""
+        self.ctx.guild = None
+
+        with self.assertRaises(NoPrivateMessage, msg="This command cannot be used in private messages."):
+            self.cog.check_on_guild(self.ctx)
+
+    def test_check_on_guild_returns_true_inside_of_guild(self):
+        """When invoked inside of a guild, `check_on_guild` should return `True`."""
+        self.ctx.guild = "lemon's lemonade stand"
+        self.assertTrue(self.cog.check_on_guild(self.ctx))
+
+
+class SecurityCogLoadTests(unittest.TestCase):
+    """Tests loading the `Security` cog."""
+
+    def test_security_cog_load(self):
+        """Setup of the extension should call add_cog."""
+        bot = MagicMock()
+        security.setup(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/cogs/test_token_remover.py b/tests/bot/cogs/test_token_remover.py
new file mode 100644
index 000000000..a54b839d7
--- /dev/null
+++ b/tests/bot/cogs/test_token_remover.py
@@ -0,0 +1,131 @@
+import asyncio
+import logging
+import unittest
+from unittest.mock import MagicMock
+
+from discord import Colour
+
+from bot.cogs.token_remover import (
+    DELETION_MESSAGE_TEMPLATE,
+    TokenRemover,
+    setup as setup_cog,
+)
+from bot.constants import Channels, Colours, Event, Icons
+from tests.helpers import AsyncMock, MockBot, MockMessage
+
+
+class TokenRemoverTests(unittest.TestCase):
+    """Tests the `TokenRemover` cog."""
+
+    def setUp(self):
+        """Adds the cog, a bot, and a message to the instance for usage in tests."""
+        self.bot = MockBot()
+        self.bot.get_cog.return_value = MagicMock()
+        self.bot.get_cog.return_value.send_log_message = AsyncMock()
+        self.cog = TokenRemover(bot=self.bot)
+
+        self.msg = MockMessage(id=555, content='')
+        self.msg.author.__str__ = MagicMock()
+        self.msg.author.__str__.return_value = 'lemon'
+        self.msg.author.bot = False
+        self.msg.author.avatar_url_as.return_value = 'picture-lemon.png'
+        self.msg.author.id = 42
+        self.msg.author.mention = '@lemon'
+        self.msg.channel.mention = "#lemonade-stand"
+
+    def test_is_valid_user_id_is_true_for_numeric_content(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        # MTIz = base64(123)
+        self.assertTrue(TokenRemover.is_valid_user_id('MTIz'))
+
+    def test_is_valid_user_id_is_false_for_alphabetic_content(self):
+        """A string decoding to alphabetic characters is not a valid user ID."""
+        # YWJj = base64(abc)
+        self.assertFalse(TokenRemover.is_valid_user_id('YWJj'))
+
+    def test_is_valid_timestamp_is_true_for_valid_timestamps(self):
+        """A string decoding to a valid timestamp should be recognized as such."""
+        self.assertTrue(TokenRemover.is_valid_timestamp('DN9r_A'))
+
+    def test_is_valid_timestamp_is_false_for_invalid_values(self):
+        """A string not decoding to a valid timestamp should not be recognized as such."""
+        # MTIz = base64(123)
+        self.assertFalse(TokenRemover.is_valid_timestamp('MTIz'))
+
+    def test_mod_log_property(self):
+        """The `mod_log` property should ask the bot to return the `ModLog` cog."""
+        self.bot.get_cog.return_value = 'lemon'
+        self.assertEqual(self.cog.mod_log, self.bot.get_cog.return_value)
+        self.bot.get_cog.assert_called_once_with('ModLog')
+
+    def test_ignores_bot_messages(self):
+        """When the message event handler is called with a bot message, nothing is done."""
+        self.msg.author.bot = True
+        coroutine = self.cog.on_message(self.msg)
+        self.assertIsNone(asyncio.run(coroutine))
+
+    def test_ignores_messages_without_tokens(self):
+        """Messages without anything looking like a token are ignored."""
+        for content in ('', 'lemon wins'):
+            with self.subTest(content=content):
+                self.msg.content = content
+                coroutine = self.cog.on_message(self.msg)
+                self.assertIsNone(asyncio.run(coroutine))
+
+    def test_ignores_messages_with_invalid_tokens(self):
+        """Messages with values that are invalid tokens are ignored."""
+        for content in ('foo.bar.baz', 'x.y.'):
+            with self.subTest(content=content):
+                self.msg.content = content
+                coroutine = self.cog.on_message(self.msg)
+                self.assertIsNone(asyncio.run(coroutine))
+
+    def test_censors_valid_tokens(self):
+        """Valid tokens are censored."""
+        cases = (
+            # (content, censored_token)
+            ('MTIz.DN9R_A.xyz', 'MTIz.DN9R_A.xxx'),
+        )
+
+        for content, censored_token in cases:
+            with self.subTest(content=content, censored_token=censored_token):
+                self.msg.content = content
+                coroutine = self.cog.on_message(self.msg)
+                with self.assertLogs(logger='bot.cogs.token_remover', level=logging.DEBUG) as cm:
+                    self.assertIsNone(asyncio.run(coroutine))  # no return value
+
+                [line] = cm.output
+                log_message = (
+                    "Censored a seemingly valid token sent by "
+                    "lemon (`42`) in #lemonade-stand, "
+                    f"token was `{censored_token}`"
+                )
+                self.assertIn(log_message, line)
+
+                self.msg.delete.assert_called_once_with()
+                self.msg.channel.send.assert_called_once_with(
+                    DELETION_MESSAGE_TEMPLATE.format(mention='@lemon')
+                )
+                self.bot.get_cog.assert_called_with('ModLog')
+                self.msg.author.avatar_url_as.assert_called_once_with(static_format='png')
+
+                mod_log = self.bot.get_cog.return_value
+                mod_log.ignore.assert_called_once_with(Event.message_delete, self.msg.id)
+                mod_log.send_log_message.assert_called_once_with(
+                    icon_url=Icons.token_removed,
+                    colour=Colour(Colours.soft_red),
+                    title="Token removed!",
+                    text=log_message,
+                    thumbnail='picture-lemon.png',
+                    channel_id=Channels.mod_alerts
+                )
+
+
+class TokenRemoverSetupTests(unittest.TestCase):
+    """Tests setup of the `TokenRemover` cog."""
+
+    def test_setup(self):
+        """Setup of the extension should call add_cog."""
+        bot = MockBot()
+        setup_cog(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/patches/__init__.py b/tests/bot/patches/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/patches/__init__.py
diff --git a/tests/bot/resources/__init__.py b/tests/bot/resources/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/resources/__init__.py
diff --git a/tests/bot/resources/test_resources.py b/tests/bot/resources/test_resources.py
new file mode 100644
index 000000000..73937cfa6
--- /dev/null
+++ b/tests/bot/resources/test_resources.py
@@ -0,0 +1,17 @@
+import json
+import unittest
+from pathlib import Path
+
+
+class ResourceValidationTests(unittest.TestCase):
+    """Validates resources used by the bot."""
+    def test_stars_valid(self):
+        """The resource `bot/resources/stars.json` should contain a list of strings."""
+        path = Path('bot', 'resources', 'stars.json')
+        content = path.read_text()
+        data = json.loads(content)
+
+        self.assertIsInstance(data, list)
+        for name in data:
+            with self.subTest(name=name):
+                self.assertIsInstance(name, str)
diff --git a/tests/bot/rules/__init__.py b/tests/bot/rules/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/rules/__init__.py
diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
new file mode 100644
index 000000000..d7187f315
--- /dev/null
+++ b/tests/bot/rules/test_attachments.py
@@ -0,0 +1,98 @@
+import unittest
+from typing import List, NamedTuple, Tuple
+
+from bot.rules import attachments
+from tests.helpers import MockMessage, async_test
+
+
+class Case(NamedTuple):
+    recent_messages: List[MockMessage]
+    culprit: Tuple[str]
+    total_attachments: int
+
+
+def msg(author: str, total_attachments: int) -> MockMessage:
+    """Builds a message with `total_attachments` attachments."""
+    return MockMessage(author=author, attachments=list(range(total_attachments)))
+
+
+class AttachmentRuleTests(unittest.TestCase):
+    """Tests applying the `attachments` antispam rule."""
+
+    def setUp(self):
+        self.config = {"max": 5}
+
+    @async_test
+    async def test_allows_messages_without_too_many_attachments(self):
+        """Messages without too many attachments are allowed as-is."""
+        cases = (
+            [msg("bob", 0), msg("bob", 0), msg("bob", 0)],
+            [msg("bob", 2), msg("bob", 2)],
+            [msg("bob", 2), msg("alice", 2), msg("bob", 2)],
+        )
+
+        for recent_messages in cases:
+            last_message = recent_messages[0]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                config=self.config
+            ):
+                self.assertIsNone(
+                    await attachments.apply(last_message, recent_messages, self.config)
+                )
+
+    @async_test
+    async def test_disallows_messages_with_too_many_attachments(self):
+        """Messages with too many attachments trigger the rule."""
+        cases = (
+            Case(
+                [msg("bob", 4), msg("bob", 0), msg("bob", 6)],
+                ("bob",),
+                10
+            ),
+            Case(
+                [msg("bob", 4), msg("alice", 6), msg("bob", 2)],
+                ("bob",),
+                6
+            ),
+            Case(
+                [msg("alice", 6)],
+                ("alice",),
+                6
+            ),
+            (
+                [msg("alice", 1) for _ in range(6)],
+                ("alice",),
+                6
+            ),
+        )
+
+        for recent_messages, culprit, total_attachments in cases:
+            last_message = recent_messages[0]
+            relevant_messages = tuple(
+                msg
+                for msg in recent_messages
+                if (
+                    msg.author == last_message.author
+                    and len(msg.attachments) > 0
+                )
+            )
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                relevant_messages=relevant_messages,
+                total_attachments=total_attachments,
+                config=self.config
+            ):
+                desired_output = (
+                    f"sent {total_attachments} attachments in {self.config['max']}s",
+                    culprit,
+                    relevant_messages
+                )
+                self.assertTupleEqual(
+                    await attachments.apply(last_message, recent_messages, self.config),
+                    desired_output
+                )
diff --git a/tests/bot/rules/test_links.py b/tests/bot/rules/test_links.py
new file mode 100644
index 000000000..02a5d5501
--- /dev/null
+++ b/tests/bot/rules/test_links.py
@@ -0,0 +1,97 @@
+import unittest
+from typing import List, NamedTuple, Tuple
+
+from bot.rules import links
+from tests.helpers import MockMessage, async_test
+
+
+class Case(NamedTuple):
+    recent_messages: List[MockMessage]
+    culprit: Tuple[str]
+    total_links: int
+
+
+def msg(author: str, total_links: int) -> MockMessage:
+    """Makes a message with `total_links` links."""
+    content = " ".join(["https://pydis.com"] * total_links)
+    return MockMessage(author=author, content=content)
+
+
+class LinksTests(unittest.TestCase):
+    """Tests applying the `links` rule."""
+
+    def setUp(self):
+        self.config = {
+            "max": 2,
+            "interval": 10
+        }
+
+    @async_test
+    async def test_links_within_limit(self):
+        """Messages with an allowed amount of links."""
+        cases = (
+            [msg("bob", 0)],
+            [msg("bob", 2)],
+            [msg("bob", 3)],  # Filter only applies if len(messages_with_links) > 1
+            [msg("bob", 1), msg("bob", 1)],
+            [msg("bob", 2), msg("alice", 2)]  # Only messages from latest author count
+        )
+
+        for recent_messages in cases:
+            last_message = recent_messages[0]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                config=self.config
+            ):
+                self.assertIsNone(
+                    await links.apply(last_message, recent_messages, self.config)
+                )
+
+    @async_test
+    async def test_links_exceeding_limit(self):
+        """Messages with a a higher than allowed amount of links."""
+        cases = (
+            Case(
+                [msg("bob", 1), msg("bob", 2)],
+                ("bob",),
+                3
+            ),
+            Case(
+                [msg("alice", 1), msg("alice", 1), msg("alice", 1)],
+                ("alice",),
+                3
+            ),
+            Case(
+                [msg("alice", 2), msg("bob", 3), msg("alice", 1)],
+                ("alice",),
+                3
+            )
+        )
+
+        for recent_messages, culprit, total_links in cases:
+            last_message = recent_messages[0]
+            relevant_messages = tuple(
+                msg
+                for msg in recent_messages
+                if msg.author == last_message.author
+            )
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                relevant_messages=relevant_messages,
+                culprit=culprit,
+                total_links=total_links,
+                config=self.config
+            ):
+                desired_output = (
+                    f"sent {total_links} links in {self.config['interval']}s",
+                    culprit,
+                    relevant_messages
+                )
+                self.assertTupleEqual(
+                    await links.apply(last_message, recent_messages, self.config),
+                    desired_output
+                )
diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
new file mode 100644
index 000000000..ad49ead32
--- /dev/null
+++ b/tests/bot/rules/test_mentions.py
@@ -0,0 +1,95 @@
+import unittest
+from typing import List, NamedTuple, Tuple
+
+from bot.rules import mentions
+from tests.helpers import MockMessage, async_test
+
+
+class Case(NamedTuple):
+    recent_messages: List[MockMessage]
+    culprit: Tuple[str]
+    total_mentions: int
+
+
+def msg(author: str, total_mentions: int) -> MockMessage:
+    """Makes a message with `total_mentions` mentions."""
+    return MockMessage(author=author, mentions=list(range(total_mentions)))
+
+
+class TestMentions(unittest.TestCase):
+    """Tests applying the `mentions` antispam rule."""
+
+    def setUp(self):
+        self.config = {
+            "max": 2,
+            "interval": 10
+        }
+
+    @async_test
+    async def test_mentions_within_limit(self):
+        """Messages with an allowed amount of mentions."""
+        cases = (
+            [msg("bob", 0)],
+            [msg("bob", 2)],
+            [msg("bob", 1), msg("bob", 1)],
+            [msg("bob", 1), msg("alice", 2)]
+        )
+
+        for recent_messages in cases:
+            last_message = recent_messages[0]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                config=self.config
+            ):
+                self.assertIsNone(
+                    await mentions.apply(last_message, recent_messages, self.config)
+                )
+
+    @async_test
+    async def test_mentions_exceeding_limit(self):
+        """Messages with a higher than allowed amount of mentions."""
+        cases = (
+            Case(
+                [msg("bob", 3)],
+                ("bob",),
+                3
+            ),
+            Case(
+                [msg("alice", 2), msg("alice", 0), msg("alice", 1)],
+                ("alice",),
+                3
+            ),
+            Case(
+                [msg("bob", 2), msg("alice", 3), msg("bob", 2)],
+                ("bob",),
+                4
+            )
+        )
+
+        for recent_messages, culprit, total_mentions in cases:
+            last_message = recent_messages[0]
+            relevant_messages = tuple(
+                msg
+                for msg in recent_messages
+                if msg.author == last_message.author
+            )
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                relevant_messages=relevant_messages,
+                culprit=culprit,
+                total_mentions=total_mentions,
+                cofig=self.config
+            ):
+                desired_output = (
+                    f"sent {total_mentions} mentions in {self.config['interval']}s",
+                    culprit,
+                    relevant_messages
+                )
+                self.assertTupleEqual(
+                    await mentions.apply(last_message, recent_messages, self.config),
+                    desired_output
+                )
diff --git a/tests/bot/test_api.py b/tests/bot/test_api.py
new file mode 100644
index 000000000..5a88adc5c
--- /dev/null
+++ b/tests/bot/test_api.py
@@ -0,0 +1,136 @@
+import logging
+import unittest
+from unittest.mock import MagicMock, patch
+
+from bot import api
+from tests.base import LoggingTestCase
+from tests.helpers import async_test
+
+
+class APIClientTests(unittest.TestCase):
+    """Tests for the bot's API client."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Sets up the shared fixtures for the tests."""
+        cls.error_api_response = MagicMock()
+        cls.error_api_response.status = 999
+
+    def test_loop_is_not_running_by_default(self):
+        """The event loop should not be running by default."""
+        self.assertFalse(api.loop_is_running())
+
+    @async_test
+    async def test_loop_is_running_in_async_context(self):
+        """The event loop should be running in an async context."""
+        self.assertTrue(api.loop_is_running())
+
+    def test_response_code_error_default_initialization(self):
+        """Test the default initialization of `ResponseCodeError` without `text` or `json`"""
+        error = api.ResponseCodeError(response=self.error_api_response)
+
+        self.assertIs(error.status, self.error_api_response.status)
+        self.assertEqual(error.response_json, {})
+        self.assertEqual(error.response_text, "")
+        self.assertIs(error.response, self.error_api_response)
+
+    def test_responde_code_error_string_representation_default_initialization(self):
+        """Test the string representation of `ResponseCodeError` initialized without text or json."""
+        error = api.ResponseCodeError(response=self.error_api_response)
+        self.assertEqual(str(error), f"Status: {self.error_api_response.status} Response: ")
+
+    def test_response_code_error_initialization_with_json(self):
+        """Test the initialization of `ResponseCodeError` with json."""
+        json_data = {'hello': 'world'}
+        error = api.ResponseCodeError(
+            response=self.error_api_response,
+            response_json=json_data,
+        )
+        self.assertEqual(error.response_json, json_data)
+        self.assertEqual(error.response_text, "")
+
+    def test_response_code_error_string_representation_with_nonempty_response_json(self):
+        """Test the string representation of `ResponseCodeError` initialized with json."""
+        json_data = {'hello': 'world'}
+        error = api.ResponseCodeError(
+            response=self.error_api_response,
+            response_json=json_data
+        )
+        self.assertEqual(str(error), f"Status: {self.error_api_response.status} Response: {json_data}")
+
+    def test_response_code_error_initialization_with_text(self):
+        """Test the initialization of `ResponseCodeError` with text."""
+        text_data = 'Lemon will eat your soul'
+        error = api.ResponseCodeError(
+            response=self.error_api_response,
+            response_text=text_data,
+        )
+        self.assertEqual(error.response_text, text_data)
+        self.assertEqual(error.response_json, {})
+
+    def test_response_code_error_string_representation_with_nonempty_response_text(self):
+        """Test the string representation of `ResponseCodeError` initialized with text."""
+        text_data = 'Lemon will eat your soul'
+        error = api.ResponseCodeError(
+            response=self.error_api_response,
+            response_text=text_data
+        )
+        self.assertEqual(str(error), f"Status: {self.error_api_response.status} Response: {text_data}")
+
+
+class LoggingHandlerTests(LoggingTestCase):
+    """Tests the bot's API Log Handler."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.debug_log_record = logging.LogRecord(
+            name='my.logger', level=logging.DEBUG,
+            pathname='my/logger.py', lineno=666,
+            msg="Lemon wins", args=(),
+            exc_info=None
+        )
+
+        cls.trace_log_record = logging.LogRecord(
+            name='my.logger', level=logging.TRACE,
+            pathname='my/logger.py', lineno=666,
+            msg="This will not be logged", args=(),
+            exc_info=None
+        )
+
+    def setUp(self):
+        self.log_handler = api.APILoggingHandler(None)
+
+    def test_emit_appends_to_queue_with_stopped_event_loop(self):
+        """Test if `APILoggingHandler.emit` appends to queue when the event loop is not running."""
+        with patch("bot.api.APILoggingHandler.ship_off") as ship_off:
+            # Patch `ship_off` to ease testing against the return value of this coroutine.
+            ship_off.return_value = 42
+            self.log_handler.emit(self.debug_log_record)
+
+        self.assertListEqual(self.log_handler.queue, [42])
+
+    def test_emit_ignores_less_than_debug(self):
+        """`APILoggingHandler.emit` should not queue logs with a log level lower than DEBUG."""
+        self.log_handler.emit(self.trace_log_record)
+        self.assertListEqual(self.log_handler.queue, [])
+
+    def test_schedule_queued_tasks_for_empty_queue(self):
+        """`APILoggingHandler` should not schedule anything when the queue is empty."""
+        with self.assertNotLogs(level=logging.DEBUG):
+            self.log_handler.schedule_queued_tasks()
+
+    def test_schedule_queued_tasks_for_nonempty_queue(self):
+        """`APILoggingHandler` should schedule logs when the queue is not empty."""
+        log = logging.getLogger("bot.api")
+
+        with self.assertLogs(logger=log, level=logging.DEBUG) as logs, patch('asyncio.create_task') as create_task:
+            self.log_handler.queue = [555]
+            self.log_handler.schedule_queued_tasks()
+            self.assertListEqual(self.log_handler.queue, [])
+            create_task.assert_called_once_with(555)
+
+            [record] = logs.records
+            self.assertEqual(record.message, "Scheduled 1 pending logging tasks.")
+            self.assertEqual(record.levelno, logging.DEBUG)
+            self.assertEqual(record.name, 'bot.api')
+            self.assertIn('via_handler', record.__dict__)
diff --git a/tests/bot/test_constants.py b/tests/bot/test_constants.py
new file mode 100644
index 000000000..dae7c066c
--- /dev/null
+++ b/tests/bot/test_constants.py
@@ -0,0 +1,26 @@
+import inspect
+import unittest
+
+from bot import constants
+
+
+class ConstantsTests(unittest.TestCase):
+    """Tests for our constants."""
+
+    def test_section_configuration_matches_type_specification(self):
+        """The section annotations should match the actual types of the sections."""
+
+        sections = (
+            cls
+            for (name, cls) in inspect.getmembers(constants)
+            if hasattr(cls, 'section') and isinstance(cls, type)
+        )
+        for section in sections:
+            for name, annotation in section.__annotations__.items():
+                with self.subTest(section=section, name=name, annotation=annotation):
+                    value = getattr(section, name)
+
+                    if getattr(annotation, '_name', None) in ('Dict', 'List'):
+                        self.skipTest("Cannot validate containers yet.")
+
+                    self.assertIsInstance(value, annotation)
diff --git a/tests/bot/test_converters.py b/tests/bot/test_converters.py
new file mode 100644
index 000000000..b2b78d9dd
--- /dev/null
+++ b/tests/bot/test_converters.py
@@ -0,0 +1,273 @@
+import asyncio
+import datetime
+import unittest
+from unittest.mock import MagicMock, patch
+
+from dateutil.relativedelta import relativedelta
+from discord.ext.commands import BadArgument
+
+from bot.converters import (
+    Duration,
+    ISODateTime,
+    TagContentConverter,
+    TagNameConverter,
+    ValidPythonIdentifier,
+)
+
+
+class ConverterTests(unittest.TestCase):
+    """Tests our custom argument converters."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.context = MagicMock
+        cls.context.author = 'bob'
+
+        cls.fixed_utc_now = datetime.datetime.fromisoformat('2019-01-01T00:00:00')
+
+    def test_tag_content_converter_for_valid(self):
+        """TagContentConverter should return correct values for valid input."""
+        test_values = (
+            ('hello', 'hello'),
+            ('  h ello  ', 'h ello'),
+        )
+
+        for content, expected_conversion in test_values:
+            with self.subTest(content=content, expected_conversion=expected_conversion):
+                conversion = asyncio.run(TagContentConverter.convert(self.context, content))
+                self.assertEqual(conversion, expected_conversion)
+
+    def test_tag_content_converter_for_invalid(self):
+        """TagContentConverter should raise the proper exception for invalid input."""
+        test_values = (
+            ('', "Tag contents should not be empty, or filled with whitespace."),
+            ('   ', "Tag contents should not be empty, or filled with whitespace."),
+        )
+
+        for value, exception_message in test_values:
+            with self.subTest(tag_content=value, exception_message=exception_message):
+                with self.assertRaises(BadArgument, msg=exception_message):
+                    asyncio.run(TagContentConverter.convert(self.context, value))
+
+    def test_tag_name_converter_for_valid(self):
+        """TagNameConverter should return the correct values for valid tag names."""
+        test_values = (
+            ('tracebacks', 'tracebacks'),
+            ('Tracebacks', 'tracebacks'),
+            ('  Tracebacks  ', 'tracebacks'),
+        )
+
+        for name, expected_conversion in test_values:
+            with self.subTest(name=name, expected_conversion=expected_conversion):
+                conversion = asyncio.run(TagNameConverter.convert(self.context, name))
+                self.assertEqual(conversion, expected_conversion)
+
+    def test_tag_name_converter_for_invalid(self):
+        """TagNameConverter should raise the correct exception for invalid tag names."""
+        test_values = (
+            ('👋', "Don't be ridiculous, you can't use that character!"),
+            ('', "Tag names should not be empty, or filled with whitespace."),
+            ('  ', "Tag names should not be empty, or filled with whitespace."),
+            ('42', "Tag names can't be numbers."),
+            ('x' * 128, "Are you insane? That's way too long!"),
+        )
+
+        for invalid_name, exception_message in test_values:
+            with self.subTest(invalid_name=invalid_name, exception_message=exception_message):
+                with self.assertRaises(BadArgument, msg=exception_message):
+                    asyncio.run(TagNameConverter.convert(self.context, invalid_name))
+
+    def test_valid_python_identifier_for_valid(self):
+        """ValidPythonIdentifier returns valid identifiers unchanged."""
+        test_values = ('foo', 'lemon')
+
+        for name in test_values:
+            with self.subTest(identifier=name):
+                conversion = asyncio.run(ValidPythonIdentifier.convert(self.context, name))
+                self.assertEqual(name, conversion)
+
+    def test_valid_python_identifier_for_invalid(self):
+        """ValidPythonIdentifier raises the proper exception for invalid identifiers."""
+        test_values = ('nested.stuff', '#####')
+
+        for name in test_values:
+            with self.subTest(identifier=name):
+                exception_message = f'`{name}` is not a valid Python identifier'
+                with self.assertRaises(BadArgument, msg=exception_message):
+                    asyncio.run(ValidPythonIdentifier.convert(self.context, name))
+
+    def test_duration_converter_for_valid(self):
+        """Duration returns the correct `datetime` for valid duration strings."""
+        test_values = (
+            # Simple duration strings
+            ('1Y', {"years": 1}),
+            ('1y', {"years": 1}),
+            ('1year', {"years": 1}),
+            ('1years', {"years": 1}),
+            ('1m', {"months": 1}),
+            ('1month', {"months": 1}),
+            ('1months', {"months": 1}),
+            ('1w', {"weeks": 1}),
+            ('1W', {"weeks": 1}),
+            ('1week', {"weeks": 1}),
+            ('1weeks', {"weeks": 1}),
+            ('1d', {"days": 1}),
+            ('1D', {"days": 1}),
+            ('1day', {"days": 1}),
+            ('1days', {"days": 1}),
+            ('1h', {"hours": 1}),
+            ('1H', {"hours": 1}),
+            ('1hour', {"hours": 1}),
+            ('1hours', {"hours": 1}),
+            ('1M', {"minutes": 1}),
+            ('1minute', {"minutes": 1}),
+            ('1minutes', {"minutes": 1}),
+            ('1s', {"seconds": 1}),
+            ('1S', {"seconds": 1}),
+            ('1second', {"seconds": 1}),
+            ('1seconds', {"seconds": 1}),
+
+            # Complex duration strings
+            (
+                '1y1m1w1d1H1M1S',
+                {
+                    "years": 1,
+                    "months": 1,
+                    "weeks": 1,
+                    "days": 1,
+                    "hours": 1,
+                    "minutes": 1,
+                    "seconds": 1
+                }
+            ),
+            ('5y100S', {"years": 5, "seconds": 100}),
+            ('2w28H', {"weeks": 2, "hours": 28}),
+
+            # Duration strings with spaces
+            ('1 year 2 months', {"years": 1, "months": 2}),
+            ('1d 2H', {"days": 1, "hours": 2}),
+            ('1 week2 days', {"weeks": 1, "days": 2}),
+        )
+
+        converter = Duration()
+
+        for duration, duration_dict in test_values:
+            expected_datetime = self.fixed_utc_now + relativedelta(**duration_dict)
+
+            with patch('bot.converters.datetime') as mock_datetime:
+                mock_datetime.utcnow.return_value = self.fixed_utc_now
+
+                with self.subTest(duration=duration, duration_dict=duration_dict):
+                    converted_datetime = asyncio.run(converter.convert(self.context, duration))
+                    self.assertEqual(converted_datetime, expected_datetime)
+
+    def test_duration_converter_for_invalid(self):
+        """Duration raises the right exception for invalid duration strings."""
+        test_values = (
+            # Units in wrong order
+            ('1d1w'),
+            ('1s1y'),
+
+            # Duplicated units
+            ('1 year 2 years'),
+            ('1 M 10 minutes'),
+
+            # Unknown substrings
+            ('1MVes'),
+            ('1y3breads'),
+
+            # Missing amount
+            ('ym'),
+
+            # Incorrect whitespace
+            (" 1y"),
+            ("1S "),
+            ("1y  1m"),
+
+            # Garbage
+            ('Guido van Rossum'),
+            ('lemon lemon lemon lemon lemon lemon lemon'),
+        )
+
+        converter = Duration()
+
+        for invalid_duration in test_values:
+            with self.subTest(invalid_duration=invalid_duration):
+                exception_message = f'`{invalid_duration}` is not a valid duration string.'
+                with self.assertRaises(BadArgument, msg=exception_message):
+                    asyncio.run(converter.convert(self.context, invalid_duration))
+
+    def test_isodatetime_converter_for_valid(self):
+        """ISODateTime converter returns correct datetime for valid datetime string."""
+        test_values = (
+            # `YYYY-mm-ddTHH:MM:SSZ` | `YYYY-mm-dd HH:MM:SSZ`
+            ('2019-09-02T02:03:05Z', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 02:03:05Z', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+
+            # `YYYY-mm-ddTHH:MM:SS±HH:MM` | `YYYY-mm-dd HH:MM:SS±HH:MM`
+            ('2019-09-02T03:18:05+01:15', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 03:18:05+01:15', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02T00:48:05-01:15', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 00:48:05-01:15', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+
+            # `YYYY-mm-ddTHH:MM:SS±HHMM` | `YYYY-mm-dd HH:MM:SS±HHMM`
+            ('2019-09-02T03:18:05+0115', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 03:18:05+0115', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02T00:48:05-0115', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 00:48:05-0115', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+
+            # `YYYY-mm-ddTHH:MM:SS±HH` | `YYYY-mm-dd HH:MM:SS±HH`
+            ('2019-09-02 03:03:05+01', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02T01:03:05-01', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+
+            # `YYYY-mm-ddTHH:MM:SS` | `YYYY-mm-dd HH:MM:SS`
+            ('2019-09-02T02:03:05', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+            ('2019-09-02 02:03:05', datetime.datetime(2019, 9, 2, 2, 3, 5)),
+
+            # `YYYY-mm-ddTHH:MM` | `YYYY-mm-dd HH:MM`
+            ('2019-11-12T09:15', datetime.datetime(2019, 11, 12, 9, 15)),
+            ('2019-11-12 09:15', datetime.datetime(2019, 11, 12, 9, 15)),
+
+            # `YYYY-mm-dd`
+            ('2019-04-01', datetime.datetime(2019, 4, 1)),
+
+            # `YYYY-mm`
+            ('2019-02-01', datetime.datetime(2019, 2, 1)),
+
+            # `YYYY`
+            ('2025', datetime.datetime(2025, 1, 1)),
+        )
+
+        converter = ISODateTime()
+
+        for datetime_string, expected_dt in test_values:
+            with self.subTest(datetime_string=datetime_string, expected_dt=expected_dt):
+                converted_dt = asyncio.run(converter.convert(self.context, datetime_string))
+                self.assertIsNone(converted_dt.tzinfo)
+                self.assertEqual(converted_dt, expected_dt)
+
+    def test_isodatetime_converter_for_invalid(self):
+        """ISODateTime converter raises the correct exception for invalid datetime strings."""
+        test_values = (
+            # Make sure it doesn't interfere with the Duration converter
+            ('1Y'),
+            ('1d'),
+            ('1H'),
+
+            # Check if it fails when only providing the optional time part
+            ('10:10:10'),
+            ('10:00'),
+
+            # Invalid date format
+            ('19-01-01'),
+
+            # Other non-valid strings
+            ('fisk the tag master'),
+        )
+
+        converter = ISODateTime()
+        for datetime_string in test_values:
+            with self.subTest(datetime_string=datetime_string):
+                exception_message = f"`{datetime_string}` is not a valid ISO-8601 datetime string"
+                with self.assertRaises(BadArgument, msg=exception_message):
+                    asyncio.run(converter.convert(self.context, datetime_string))
diff --git a/tests/bot/test_pagination.py b/tests/bot/test_pagination.py
new file mode 100644
index 000000000..0a734b505
--- /dev/null
+++ b/tests/bot/test_pagination.py
@@ -0,0 +1,36 @@
+from unittest import TestCase
+
+from bot import pagination
+
+
+class LinePaginatorTests(TestCase):
+    """Tests functionality of the `LinePaginator`."""
+
+    def setUp(self):
+        """Create a paginator for the test method."""
+        self.paginator = pagination.LinePaginator(prefix='', suffix='', max_size=30)
+
+    def test_add_line_raises_on_too_long_lines(self):
+        """`add_line` should raise a `RuntimeError` for too long lines."""
+        message = f"Line exceeds maximum page size {self.paginator.max_size - 2}"
+        with self.assertRaises(RuntimeError, msg=message):
+            self.paginator.add_line('x' * self.paginator.max_size)
+
+    def test_add_line_works_on_small_lines(self):
+        """`add_line` should allow small lines to be added."""
+        self.paginator.add_line('x' * (self.paginator.max_size - 3))
+
+
+class ImagePaginatorTests(TestCase):
+    """Tests functionality of the `ImagePaginator`."""
+
+    def setUp(self):
+        """Create a paginator for the test method."""
+        self.paginator = pagination.ImagePaginator()
+
+    def test_add_image_appends_image(self):
+        """`add_image` appends the image to the image list."""
+        image = 'lemon'
+        self.paginator.add_image(image)
+
+        assert self.paginator.images == [image]
diff --git a/tests/bot/test_utils.py b/tests/bot/test_utils.py
new file mode 100644
index 000000000..58ae2a81a
--- /dev/null
+++ b/tests/bot/test_utils.py
@@ -0,0 +1,52 @@
+import unittest
+
+from bot import utils
+
+
+class CaseInsensitiveDictTests(unittest.TestCase):
+    """Tests for the `CaseInsensitiveDict` container."""
+
+    def test_case_insensitive_key_access(self):
+        """Tests case insensitive key access and storage."""
+        instance = utils.CaseInsensitiveDict()
+
+        key = 'LEMON'
+        value = 'trees'
+
+        instance[key] = value
+        self.assertIn(key, instance)
+        self.assertEqual(instance.get(key), value)
+        self.assertEqual(instance.get(key.casefold()), value)
+        self.assertEqual(instance.pop(key.casefold()), value)
+        self.assertNotIn(key, instance)
+        self.assertNotIn(key.casefold(), instance)
+
+        instance.setdefault(key, value)
+        del instance[key]
+        self.assertNotIn(key, instance)
+
+    def test_initialization_from_kwargs(self):
+        """Tests creating the dictionary from keyword arguments."""
+        instance = utils.CaseInsensitiveDict({'FOO': 'bar'})
+        self.assertEqual(instance['foo'], 'bar')
+
+    def test_update_from_other_mapping(self):
+        """Tests updating the dictionary from another mapping."""
+        instance = utils.CaseInsensitiveDict()
+        instance.update({'FOO': 'bar'})
+        self.assertEqual(instance['foo'], 'bar')
+
+
+class ChunkTests(unittest.TestCase):
+    """Tests the `chunk` method."""
+
+    def test_empty_chunking(self):
+        """Tests chunking on an empty iterable."""
+        generator = utils.chunks(iterable=[], size=5)
+        self.assertEqual(list(generator), [])
+
+    def test_list_chunking(self):
+        """Tests chunking a non-empty list."""
+        iterable = [1, 2, 3, 4, 5]
+        generator = utils.chunks(iterable=iterable, size=2)
+        self.assertEqual(list(generator), [[1, 2], [3, 4], [5]])
diff --git a/tests/bot/utils/__init__.py b/tests/bot/utils/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/bot/utils/__init__.py
diff --git a/tests/bot/utils/test_checks.py b/tests/bot/utils/test_checks.py
new file mode 100644
index 000000000..9610771e5
--- /dev/null
+++ b/tests/bot/utils/test_checks.py
@@ -0,0 +1,51 @@
+import unittest
+
+from bot.utils import checks
+from tests.helpers import MockContext, MockRole
+
+
+class ChecksTests(unittest.TestCase):
+    """Tests the check functions defined in `bot.checks`."""
+
+    def setUp(self):
+        self.ctx = MockContext()
+
+    def test_with_role_check_without_guild(self):
+        """`with_role_check` returns `False` if `Context.guild` is None."""
+        self.ctx.guild = None
+        self.assertFalse(checks.with_role_check(self.ctx))
+
+    def test_with_role_check_without_required_roles(self):
+        """`with_role_check` returns `False` if `Context.author` lacks the required role."""
+        self.ctx.author.roles = []
+        self.assertFalse(checks.with_role_check(self.ctx))
+
+    def test_with_role_check_with_guild_and_required_role(self):
+        """`with_role_check` returns `True` if `Context.author` has the required role."""
+        self.ctx.author.roles.append(MockRole(id=10))
+        self.assertTrue(checks.with_role_check(self.ctx, 10))
+
+    def test_without_role_check_without_guild(self):
+        """`without_role_check` should return `False` when `Context.guild` is None."""
+        self.ctx.guild = None
+        self.assertFalse(checks.without_role_check(self.ctx))
+
+    def test_without_role_check_returns_false_with_unwanted_role(self):
+        """`without_role_check` returns `False` if `Context.author` has unwanted role."""
+        role_id = 42
+        self.ctx.author.roles.append(MockRole(id=role_id))
+        self.assertFalse(checks.without_role_check(self.ctx, role_id))
+
+    def test_without_role_check_returns_true_without_unwanted_role(self):
+        """`without_role_check` returns `True` if `Context.author` does not have unwanted role."""
+        role_id = 42
+        self.ctx.author.roles.append(MockRole(id=role_id))
+        self.assertTrue(checks.without_role_check(self.ctx, role_id + 10))
+
+    def test_in_channel_check_for_correct_channel(self):
+        self.ctx.channel.id = 42
+        self.assertTrue(checks.in_channel_check(self.ctx, *[42]))
+
+    def test_in_channel_check_for_incorrect_channel(self):
+        self.ctx.channel.id = 42 + 10
+        self.assertFalse(checks.in_channel_check(self.ctx, *[42]))
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
new file mode 100644
index 000000000..69f35f2f5
--- /dev/null
+++ b/tests/bot/utils/test_time.py
@@ -0,0 +1,162 @@
+import asyncio
+import unittest
+from datetime import datetime, timezone
+from unittest.mock import patch
+
+from dateutil.relativedelta import relativedelta
+
+from bot.utils import time
+from tests.helpers import AsyncMock
+
+
+class TimeTests(unittest.TestCase):
+    """Test helper functions in bot.utils.time."""
+
+    def test_humanize_delta_handle_unknown_units(self):
+        """humanize_delta should be able to handle unknown units, and will not abort."""
+        # Does not abort for unknown units, as the unit name is checked
+        # against the attribute of the relativedelta instance.
+        self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'elephants', 2), '2 days and 2 hours')
+
+    def test_humanize_delta_handle_high_units(self):
+        """humanize_delta should be able to handle very high units."""
+        # Very high maximum units, but it only ever iterates over
+        # each value the relativedelta might have.
+        self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'hours', 20), '2 days and 2 hours')
+
+    def test_humanize_delta_should_normal_usage(self):
+        """Testing humanize delta."""
+        test_cases = (
+            (relativedelta(days=2), 'seconds', 1, '2 days'),
+            (relativedelta(days=2, hours=2), 'seconds', 2, '2 days and 2 hours'),
+            (relativedelta(days=2, hours=2), 'seconds', 1, '2 days'),
+            (relativedelta(days=2, hours=2), 'days', 2, '2 days'),
+        )
+
+        for delta, precision, max_units, expected in test_cases:
+            with self.subTest(delta=delta, precision=precision, max_units=max_units, expected=expected):
+                self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+
+    def test_humanize_delta_raises_for_invalid_max_units(self):
+        """humanize_delta should raises ValueError('max_units must be positive') for invalid max_units."""
+        test_cases = (-1, 0)
+
+        for max_units in test_cases:
+            with self.subTest(max_units=max_units), self.assertRaises(ValueError) as error:
+                time.humanize_delta(relativedelta(days=2, hours=2), 'hours', max_units)
+                self.assertEqual(str(error), 'max_units must be positive')
+
+    def test_parse_rfc1123(self):
+        """Testing parse_rfc1123."""
+        self.assertEqual(
+            time.parse_rfc1123('Sun, 15 Sep 2019 12:00:00 GMT'),
+            datetime(2019, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
+        )
+
+    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)
+
+    def test_format_infraction_with_duration_none_expiry(self):
+        """format_infraction_with_duration should work for None expiry."""
+        test_cases = (
+            (None, None, None, None),
+
+            # To make sure that date_from 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, date_from, max_units, expected in test_cases:
+            with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
+                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+
+    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)')
+        )
+
+        for expiry, date_from, max_units, expected in test_cases:
+            with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
+                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+
+    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-11-23T23:59:00Z', datetime(2019, 11, 23, 23, 49, 5), 2,
+             '2019-11-23 23:59 (9 minutes and 55 seconds)'),
+            (None, datetime(2019, 11, 23, 23, 49, 5), 2, None),
+        )
+
+        for expiry, date_from, max_units, expected in test_cases:
+            with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
+                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+
+    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)
+
+    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')
+        )
+
+        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)
+
+    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),
+        )
+
+        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)