aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/bot/cogs/sync/test_cog.py84
-rw-r--r--tests/bot/cogs/test_logging.py32
-rw-r--r--tests/bot/cogs/test_slowmode.py111
-rw-r--r--tests/bot/test_pagination.py39
4 files changed, 242 insertions, 24 deletions
diff --git a/tests/bot/cogs/sync/test_cog.py b/tests/bot/cogs/sync/test_cog.py
index 14fd909c4..120bc991d 100644
--- a/tests/bot/cogs/sync/test_cog.py
+++ b/tests/bot/cogs/sync/test_cog.py
@@ -131,6 +131,15 @@ class SyncCogListenerTests(SyncCogTestCase):
super().setUp()
self.cog.patch_user = mock.AsyncMock(spec_set=self.cog.patch_user)
+ self.guild_id_patcher = mock.patch("bot.cogs.sync.cog.constants.Guild.id", 5)
+ self.guild_id = self.guild_id_patcher.start()
+
+ self.guild = helpers.MockGuild(id=self.guild_id)
+ self.other_guild = helpers.MockGuild(id=0)
+
+ def tearDown(self):
+ self.guild_id_patcher.stop()
+
async def test_sync_cog_on_guild_role_create(self):
"""A POST request should be sent with the new role's data."""
self.assertTrue(self.cog.on_guild_role_create.__cog_listener__)
@@ -142,20 +151,32 @@ class SyncCogListenerTests(SyncCogTestCase):
"permissions": 8,
"position": 23,
}
- role = helpers.MockRole(**role_data)
+ role = helpers.MockRole(**role_data, guild=self.guild)
await self.cog.on_guild_role_create(role)
self.bot.api_client.post.assert_called_once_with("bot/roles", json=role_data)
+ async def test_sync_cog_on_guild_role_create_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ role = helpers.MockRole(guild=self.other_guild)
+ await self.cog.on_guild_role_create(role)
+ self.bot.api_client.post.assert_not_awaited()
+
async def test_sync_cog_on_guild_role_delete(self):
"""A DELETE request should be sent."""
self.assertTrue(self.cog.on_guild_role_delete.__cog_listener__)
- role = helpers.MockRole(id=99)
+ role = helpers.MockRole(id=99, guild=self.guild)
await self.cog.on_guild_role_delete(role)
self.bot.api_client.delete.assert_called_once_with("bot/roles/99")
+ async def test_sync_cog_on_guild_role_delete_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ role = helpers.MockRole(guild=self.other_guild)
+ await self.cog.on_guild_role_delete(role)
+ self.bot.api_client.delete.assert_not_awaited()
+
async def test_sync_cog_on_guild_role_update(self):
"""A PUT request should be sent if the colour, name, permissions, or position changes."""
self.assertTrue(self.cog.on_guild_role_update.__cog_listener__)
@@ -180,8 +201,8 @@ class SyncCogListenerTests(SyncCogTestCase):
after_role_data = role_data.copy()
after_role_data[attribute] = 876
- before_role = helpers.MockRole(**role_data)
- after_role = helpers.MockRole(**after_role_data)
+ before_role = helpers.MockRole(**role_data, guild=self.guild)
+ after_role = helpers.MockRole(**after_role_data, guild=self.guild)
await self.cog.on_guild_role_update(before_role, after_role)
@@ -193,31 +214,43 @@ class SyncCogListenerTests(SyncCogTestCase):
else:
self.bot.api_client.put.assert_not_called()
+ async def test_sync_cog_on_guild_role_update_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ role = helpers.MockRole(guild=self.other_guild)
+ await self.cog.on_guild_role_update(role, role)
+ self.bot.api_client.put.assert_not_awaited()
+
async def test_sync_cog_on_member_remove(self):
- """Member should patched to set in_guild as False."""
+ """Member should be patched to set in_guild as False."""
self.assertTrue(self.cog.on_member_remove.__cog_listener__)
- member = helpers.MockMember()
+ member = helpers.MockMember(guild=self.guild)
await self.cog.on_member_remove(member)
self.cog.patch_user.assert_called_once_with(
member.id,
- updated_information={"in_guild": False}
+ json={"in_guild": False}
)
+ async def test_sync_cog_on_member_remove_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ member = helpers.MockMember(guild=self.other_guild)
+ await self.cog.on_member_remove(member)
+ self.cog.patch_user.assert_not_awaited()
+
async def test_sync_cog_on_member_update_roles(self):
"""Members should be patched if their roles have changed."""
self.assertTrue(self.cog.on_member_update.__cog_listener__)
# Roles are intentionally unsorted.
before_roles = [helpers.MockRole(id=12), helpers.MockRole(id=30), helpers.MockRole(id=20)]
- before_member = helpers.MockMember(roles=before_roles)
- after_member = helpers.MockMember(roles=before_roles[1:])
+ before_member = helpers.MockMember(roles=before_roles, guild=self.guild)
+ after_member = helpers.MockMember(roles=before_roles[1:], guild=self.guild)
await self.cog.on_member_update(before_member, after_member)
data = {"roles": sorted(role.id for role in after_member.roles)}
- self.cog.patch_user.assert_called_once_with(after_member.id, updated_information=data)
+ self.cog.patch_user.assert_called_once_with(after_member.id, json=data)
async def test_sync_cog_on_member_update_other(self):
"""Members should not be patched if other attributes have changed."""
@@ -233,13 +266,19 @@ class SyncCogListenerTests(SyncCogTestCase):
with self.subTest(attribute=attribute):
self.cog.patch_user.reset_mock()
- before_member = helpers.MockMember(**{attribute: old_value})
- after_member = helpers.MockMember(**{attribute: new_value})
+ before_member = helpers.MockMember(**{attribute: old_value}, guild=self.guild)
+ after_member = helpers.MockMember(**{attribute: new_value}, guild=self.guild)
await self.cog.on_member_update(before_member, after_member)
self.cog.patch_user.assert_not_called()
+ async def test_sync_cog_on_member_update_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ member = helpers.MockMember(guild=self.other_guild)
+ await self.cog.on_member_update(member, member)
+ self.cog.patch_user.assert_not_awaited()
+
async def test_sync_cog_on_user_update(self):
"""A user should be patched only if the name, discriminator, or avatar changes."""
self.assertTrue(self.cog.on_user_update.__cog_listener__)
@@ -272,12 +311,15 @@ class SyncCogListenerTests(SyncCogTestCase):
# Don't care if *all* keys are present; only the changed one is required
call_args = self.cog.patch_user.call_args
- self.assertEqual(call_args[0][0], after_user.id)
- self.assertIn("updated_information", call_args[1])
+ self.assertEqual(call_args.args[0], after_user.id)
+ self.assertIn("json", call_args.kwargs)
+
+ self.assertIn("ignore_404", call_args.kwargs)
+ self.assertTrue(call_args.kwargs["ignore_404"])
- updated_information = call_args[1]["updated_information"]
- self.assertIn(api_field, updated_information)
- self.assertEqual(updated_information[api_field], api_value)
+ json = call_args.kwargs["json"]
+ self.assertIn(api_field, json)
+ self.assertEqual(json[api_field], api_value)
else:
self.cog.patch_user.assert_not_called()
@@ -290,6 +332,7 @@ class SyncCogListenerTests(SyncCogTestCase):
member = helpers.MockMember(
discriminator="1234",
roles=[helpers.MockRole(id=22), helpers.MockRole(id=12)],
+ guild=self.guild,
)
data = {
@@ -334,6 +377,13 @@ class SyncCogListenerTests(SyncCogTestCase):
self.bot.api_client.post.assert_not_called()
+ async def test_sync_cog_on_member_join_ignores_guilds(self):
+ """Events from other guilds should be ignored."""
+ member = helpers.MockMember(guild=self.other_guild)
+ await self.cog.on_member_join(member)
+ self.bot.api_client.post.assert_not_awaited()
+ self.bot.api_client.put.assert_not_awaited()
+
class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
"""Tests for the commands in the Sync cog."""
diff --git a/tests/bot/cogs/test_logging.py b/tests/bot/cogs/test_logging.py
new file mode 100644
index 000000000..8a18fdcd6
--- /dev/null
+++ b/tests/bot/cogs/test_logging.py
@@ -0,0 +1,32 @@
+import unittest
+from unittest.mock import patch
+
+from bot import constants
+from bot.cogs.logging import Logging
+from tests.helpers import MockBot, MockTextChannel
+
+
+class LoggingTests(unittest.IsolatedAsyncioTestCase):
+ """Test cases for connected login."""
+
+ def setUp(self):
+ self.bot = MockBot()
+ self.cog = Logging(self.bot)
+ self.dev_log = MockTextChannel(id=1234, name="dev-log")
+
+ @patch("bot.cogs.logging.DEBUG_MODE", False)
+ async def test_debug_mode_false(self):
+ """Should send connected message to dev-log."""
+ self.bot.get_channel.return_value = self.dev_log
+
+ await self.cog.startup_greeting()
+ self.bot.wait_until_guild_available.assert_awaited_once_with()
+ self.bot.get_channel.assert_called_once_with(constants.Channels.dev_log)
+ self.dev_log.send.assert_awaited_once()
+
+ @patch("bot.cogs.logging.DEBUG_MODE", True)
+ async def test_debug_mode_true(self):
+ """Should not send anything to dev-log."""
+ await self.cog.startup_greeting()
+ self.bot.wait_until_guild_available.assert_awaited_once_with()
+ self.bot.get_channel.assert_not_called()
diff --git a/tests/bot/cogs/test_slowmode.py b/tests/bot/cogs/test_slowmode.py
new file mode 100644
index 000000000..f442814c8
--- /dev/null
+++ b/tests/bot/cogs/test_slowmode.py
@@ -0,0 +1,111 @@
+import unittest
+from unittest import mock
+
+from dateutil.relativedelta import relativedelta
+
+from bot.cogs.moderation.slowmode import Slowmode
+from bot.constants import Emojis
+from tests.helpers import MockBot, MockContext, MockTextChannel
+
+
+class SlowmodeTests(unittest.IsolatedAsyncioTestCase):
+
+ def setUp(self) -> None:
+ self.bot = MockBot()
+ self.cog = Slowmode(self.bot)
+ self.ctx = MockContext()
+
+ async def test_get_slowmode_no_channel(self) -> None:
+ """Get slowmode without a given channel."""
+ self.ctx.channel = MockTextChannel(name='python-general', slowmode_delay=5)
+
+ await self.cog.get_slowmode(self.cog, self.ctx, None)
+ self.ctx.send.assert_called_once_with("The slowmode delay for #python-general is 5 seconds.")
+
+ async def test_get_slowmode_with_channel(self) -> None:
+ """Get slowmode with a given channel."""
+ text_channel = MockTextChannel(name='python-language', slowmode_delay=2)
+
+ await self.cog.get_slowmode(self.cog, self.ctx, text_channel)
+ self.ctx.send.assert_called_once_with('The slowmode delay for #python-language is 2 seconds.')
+
+ async def test_set_slowmode_no_channel(self) -> None:
+ """Set slowmode without a given channel."""
+ test_cases = (
+ ('helpers', 23, True, f'{Emojis.check_mark} The slowmode delay for #helpers is now 23 seconds.'),
+ ('mods', 76526, False, f'{Emojis.cross_mark} The slowmode delay must be between 0 and 6 hours.'),
+ ('admins', 97, True, f'{Emojis.check_mark} The slowmode delay for #admins is now 1 minute and 37 seconds.')
+ )
+
+ for channel_name, seconds, edited, result_msg in test_cases:
+ with self.subTest(
+ channel_mention=channel_name,
+ seconds=seconds,
+ edited=edited,
+ result_msg=result_msg
+ ):
+ self.ctx.channel = MockTextChannel(name=channel_name)
+
+ await self.cog.set_slowmode(self.cog, self.ctx, None, relativedelta(seconds=seconds))
+
+ if edited:
+ self.ctx.channel.edit.assert_awaited_once_with(slowmode_delay=float(seconds))
+ else:
+ self.ctx.channel.edit.assert_not_called()
+
+ self.ctx.send.assert_called_once_with(result_msg)
+
+ self.ctx.reset_mock()
+
+ async def test_set_slowmode_with_channel(self) -> None:
+ """Set slowmode with a given channel."""
+ test_cases = (
+ ('bot-commands', 12, True, f'{Emojis.check_mark} The slowmode delay for #bot-commands is now 12 seconds.'),
+ ('mod-spam', 21, True, f'{Emojis.check_mark} The slowmode delay for #mod-spam is now 21 seconds.'),
+ ('admin-spam', 4323598, False, f'{Emojis.cross_mark} The slowmode delay must be between 0 and 6 hours.')
+ )
+
+ for channel_name, seconds, edited, result_msg in test_cases:
+ with self.subTest(
+ channel_mention=channel_name,
+ seconds=seconds,
+ edited=edited,
+ result_msg=result_msg
+ ):
+ text_channel = MockTextChannel(name=channel_name)
+
+ await self.cog.set_slowmode(self.cog, self.ctx, text_channel, relativedelta(seconds=seconds))
+
+ if edited:
+ text_channel.edit.assert_awaited_once_with(slowmode_delay=float(seconds))
+ else:
+ text_channel.edit.assert_not_called()
+
+ self.ctx.send.assert_called_once_with(result_msg)
+
+ self.ctx.reset_mock()
+
+ async def test_reset_slowmode_no_channel(self) -> None:
+ """Reset slowmode without a given channel."""
+ self.ctx.channel = MockTextChannel(name='careers', slowmode_delay=6)
+
+ await self.cog.reset_slowmode(self.cog, self.ctx, None)
+ self.ctx.send.assert_called_once_with(
+ f'{Emojis.check_mark} The slowmode delay for #careers has been reset to 0 seconds.'
+ )
+
+ async def test_reset_slowmode_with_channel(self) -> None:
+ """Reset slowmode with a given channel."""
+ text_channel = MockTextChannel(name='meta', slowmode_delay=1)
+
+ await self.cog.reset_slowmode(self.cog, self.ctx, text_channel)
+ self.ctx.send.assert_called_once_with(
+ f'{Emojis.check_mark} The slowmode delay for #meta has been reset to 0 seconds.'
+ )
+
+ @mock.patch("bot.cogs.moderation.slowmode.with_role_check")
+ @mock.patch("bot.cogs.moderation.slowmode.MODERATION_ROLES", new=(1, 2, 3))
+ def test_cog_check(self, role_check):
+ """Role check is called with `MODERATION_ROLES`"""
+ self.cog.cog_check(self.ctx)
+ role_check.assert_called_once_with(self.ctx, *(1, 2, 3))
diff --git a/tests/bot/test_pagination.py b/tests/bot/test_pagination.py
index 0a734b505..ce880d457 100644
--- a/tests/bot/test_pagination.py
+++ b/tests/bot/test_pagination.py
@@ -8,17 +8,42 @@ class LinePaginatorTests(TestCase):
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)
+ self.paginator = pagination.LinePaginator(prefix='', suffix='', max_size=30,
+ scale_to_size=50)
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))
+ # Note that the page isn't added to _pages until it's full.
+ self.assertEqual(len(self.paginator._pages), 0)
+
+ def test_add_line_works_on_long_lines(self):
+ """After additional lines after `max_size` is exceeded should go on the next page."""
+ self.paginator.add_line('x' * self.paginator.max_size)
+ self.assertEqual(len(self.paginator._pages), 0)
+
+ # Any additional lines should start a new page after `max_size` is exceeded.
+ self.paginator.add_line('x')
+ self.assertEqual(len(self.paginator._pages), 1)
+
+ def test_add_line_continuation(self):
+ """When `scale_to_size` is exceeded, remaining words should be split onto the next page."""
+ self.paginator.add_line('zyz ' * (self.paginator.scale_to_size//4 + 1))
+ self.assertEqual(len(self.paginator._pages), 1)
+
+ def test_add_line_no_continuation(self):
+ """If adding a new line to an existing page would exceed `max_size`, it should start a new
+ page rather than using continuation.
+ """
+ self.paginator.add_line('z' * (self.paginator.max_size - 3))
+ self.paginator.add_line('z')
+ self.assertEqual(len(self.paginator._pages), 1)
+
+ def test_add_line_truncates_very_long_words(self):
+ """`add_line` should truncate if a single long word exceeds `scale_to_size`."""
+ self.paginator.add_line('x' * (self.paginator.scale_to_size + 1))
+ # Note: item at index 1 is the truncated line, index 0 is prefix
+ self.assertEqual(self.paginator._current_page[1], 'x' * self.paginator.scale_to_size)
class ImagePaginatorTests(TestCase):