Merge pull request #1021 from python-discord/feat/util/1019/slowmode

Implement the Slowmode cog

5 files changed, 232 insertions, 6 deletions

diff --git a/bot/cogs/moderation/__init__.py b/bot/cogs/moderation/__init__.py
index 6880ca1bd..a5c1ef362 100644
--- a/bot/cogs/moderation/__init__.py
+++ b/bot/cogs/moderation/__init__.py
@@ -3,13 +3,15 @@ from .infractions import Infractions
 from .management import ModManagement
 from .modlog import ModLog
 from .silence import Silence
+from .slowmode import Slowmode
 from .superstarify import Superstarify
 
 
 def setup(bot: Bot) -> None:
-    """Load the Infractions, ModManagement, ModLog, Silence, and Superstarify cogs."""
+    """Load the Infractions, ModManagement, ModLog, Silence, Slowmode, and Superstarify cogs."""
     bot.add_cog(Infractions(bot))
     bot.add_cog(ModLog(bot))
     bot.add_cog(ModManagement(bot))
     bot.add_cog(Silence(bot))
+    bot.add_cog(Slowmode(bot))
     bot.add_cog(Superstarify(bot))
diff --git a/bot/cogs/moderation/slowmode.py b/bot/cogs/moderation/slowmode.py
new file mode 100644
index 000000000..1d055afac
--- /dev/null
+++ b/bot/cogs/moderation/slowmode.py
@@ -0,0 +1,97 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from dateutil.relativedelta import relativedelta
+from discord import TextChannel
+from discord.ext.commands import Cog, Context, group
+
+from bot.bot import Bot
+from bot.constants import Emojis, MODERATION_ROLES
+from bot.converters import DurationDelta
+from bot.decorators import with_role_check
+from bot.utils import time
+
+log = logging.getLogger(__name__)
+
+SLOWMODE_MAX_DELAY = 21600  # seconds
+
+
+class Slowmode(Cog):
+    """Commands for getting and setting slowmode delays of text channels."""
+
+    def __init__(self, bot: Bot) -> None:
+        self.bot = bot
+
+    @group(name='slowmode', aliases=['sm'], invoke_without_command=True)
+    async def slowmode_group(self, ctx: Context) -> None:
+        """Get or set the slowmode delay for the text channel this was invoked in or a given text channel."""
+        await ctx.send_help(ctx.command)
+
+    @slowmode_group.command(name='get', aliases=['g'])
+    async def get_slowmode(self, ctx: Context, channel: Optional[TextChannel]) -> None:
+        """Get the slowmode delay for a text channel."""
+        # Use the channel this command was invoked in if one was not given
+        if channel is None:
+            channel = ctx.channel
+
+        delay = relativedelta(seconds=channel.slowmode_delay)
+        humanized_delay = time.humanize_delta(delay)
+
+        await ctx.send(f'The slowmode delay for {channel.mention} is {humanized_delay}.')
+
+    @slowmode_group.command(name='set', aliases=['s'])
+    async def set_slowmode(self, ctx: Context, channel: Optional[TextChannel], delay: DurationDelta) -> None:
+        """Set the slowmode delay for a text channel."""
+        # Use the channel this command was invoked in if one was not given
+        if channel is None:
+            channel = ctx.channel
+
+        # Convert `dateutil.relativedelta.relativedelta` to `datetime.timedelta`
+        # Must do this to get the delta in a particular unit of time
+        utcnow = datetime.utcnow()
+        slowmode_delay = (utcnow + delay - utcnow).total_seconds()
+
+        humanized_delay = time.humanize_delta(delay)
+
+        # Ensure the delay is within discord's limits
+        if slowmode_delay <= SLOWMODE_MAX_DELAY:
+            log.info(f'{ctx.author} set the slowmode delay for #{channel} to {humanized_delay}.')
+
+            await channel.edit(slowmode_delay=slowmode_delay)
+            await ctx.send(
+                f'{Emojis.check_mark} The slowmode delay for {channel.mention} is now {humanized_delay}.'
+            )
+
+        else:
+            log.info(
+                f'{ctx.author} tried to set the slowmode delay of #{channel} to {humanized_delay}, '
+                'which is not between 0 and 6 hours.'
+            )
+
+            await ctx.send(
+                f'{Emojis.cross_mark} The slowmode delay must be between 0 and 6 hours.'
+            )
+
+    @slowmode_group.command(name='reset', aliases=['r'])
+    async def reset_slowmode(self, ctx: Context, channel: Optional[TextChannel]) -> None:
+        """Reset the slowmode delay for a text channel to 0 seconds."""
+        # Use the channel this command was invoked in if one was not given
+        if channel is None:
+            channel = ctx.channel
+
+        log.info(f'{ctx.author} reset the slowmode delay for #{channel} to 0 seconds.')
+
+        await channel.edit(slowmode_delay=0)
+        await ctx.send(
+            f'{Emojis.check_mark} The slowmode delay for {channel.mention} has been reset to 0 seconds.'
+        )
+
+    def cog_check(self, ctx: Context) -> bool:
+        """Only allow moderators to invoke the commands in this cog."""
+        return with_role_check(ctx, *MODERATION_ROLES)
+
+
+def setup(bot: Bot) -> None:
+    """Load the Slowmode cog."""
+    bot.add_cog(Slowmode(bot))
diff --git a/bot/converters.py b/bot/converters.py
index 4deb59f87..898822165 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -181,8 +181,8 @@ class TagContentConverter(Converter):
         return tag_content
 
 
-class Duration(Converter):
-    """Convert duration strings into UTC datetime.datetime objects."""
+class DurationDelta(Converter):
+    """Convert duration strings into dateutil.relativedelta.relativedelta objects."""
 
     duration_parser = re.compile(
         r"((?P<years>\d+?) ?(years|year|Y|y) ?)?"
@@ -194,9 +194,9 @@ class Duration(Converter):
         r"((?P<seconds>\d+?) ?(seconds|second|S|s))?"
     )
 
-    async def convert(self, ctx: Context, duration: str) -> datetime:
+    async def convert(self, ctx: Context, duration: str) -> relativedelta:
         """
-        Converts a `duration` string to a datetime object that's `duration` in the future.
+        Converts a `duration` string to a relativedelta object.
 
         The converter supports the following symbols for each unit of time:
         - years: `Y`, `y`, `year`, `years`
@@ -215,6 +215,20 @@ class Duration(Converter):
 
         duration_dict = {unit: int(amount) for unit, amount in match.groupdict(default=0).items()}
         delta = relativedelta(**duration_dict)
+
+        return delta
+
+
+class Duration(DurationDelta):
+    """Convert duration strings into UTC datetime.datetime objects."""
+
+    async def convert(self, ctx: Context, duration: str) -> datetime:
+        """
+        Converts a `duration` string to a datetime object that's `duration` in the future.
+
+        The converter supports the same symbols for each unit of time as its parent class.
+        """
+        delta = await super().convert(ctx, duration)
         now = datetime.utcnow()
 
         try:
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 77060143c..47e49904b 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -20,7 +20,9 @@ def _stringify_time_unit(value: int, unit: str) -> str:
     >>> _stringify_time_unit(0, "minutes")
     "less than a minute"
     """
-    if value == 1:
+    if unit == "seconds" and value == 0:
+        return "0 seconds"
+    elif value == 1:
         return f"{value} {unit[:-1]}"
     elif value == 0:
         return f"less than a {unit[:-1]}"
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))