Merge branch 'master' into revert-695-revert-510-reddit-api-oauth

7 files changed, 233 insertions, 27 deletions

diff --git a/bot/cogs/clean.py b/bot/cogs/clean.py
index c7168122d..2104efe57 100644
--- a/bot/cogs/clean.py
+++ b/bot/cogs/clean.py
@@ -3,7 +3,7 @@ import random
 import re
 from typing import Optional
 
-from discord import Colour, Embed, Message, User
+from discord import Colour, Embed, Message, TextChannel, User
 from discord.ext.commands import Cog, Context, group
 
 from bot.bot import Bot
@@ -38,9 +38,13 @@ class Clean(Cog):
         return self.bot.get_cog("ModLog")
 
     async def _clean_messages(
-            self, amount: int, ctx: Context,
-            bots_only: bool = False, user: User = None,
-            regex: Optional[str] = None
+        self,
+        amount: int,
+        ctx: Context,
+        bots_only: bool = False,
+        user: User = None,
+        regex: Optional[str] = None,
+        channel: Optional[TextChannel] = None
     ) -> None:
         """A helper function that does the actual message cleaning."""
         def predicate_bots_only(message: Message) -> bool:
@@ -105,6 +109,10 @@ class Clean(Cog):
         else:
             predicate = None                     # Delete all messages
 
+        # Default to using the invoking context's channel
+        if not channel:
+            channel = ctx.channel
+
         # Look through the history and retrieve message data
         messages = []
         message_ids = []
@@ -112,7 +120,7 @@ class Clean(Cog):
         invocation_deleted = False
 
         # To account for the invocation message, we index `amount + 1` messages.
-        async for message in ctx.channel.history(limit=amount + 1):
+        async for message in channel.history(limit=amount + 1):
 
             # If at any point the cancel command is invoked, we should stop.
             if not self.cleaning:
@@ -136,7 +144,7 @@ class Clean(Cog):
         self.mod_log.ignore(Event.message_delete, *message_ids)
 
         # Use bulk delete to actually do the cleaning. It's far faster.
-        await ctx.channel.purge(
+        await channel.purge(
             limit=amount,
             check=predicate
         )
@@ -156,7 +164,7 @@ class Clean(Cog):
 
         # Build the embed and send it
         message = (
-            f"**{len(message_ids)}** messages deleted in <#{ctx.channel.id}> by **{ctx.author.name}**\n\n"
+            f"**{len(message_ids)}** messages deleted in <#{channel.id}> by **{ctx.author.name}**\n\n"
             f"A log of the deleted messages can be found [here]({log_url})."
         )
 
@@ -168,7 +176,7 @@ class Clean(Cog):
             channel_id=Channels.modlog,
         )
 
-    @group(invoke_without_command=True, name="clean", hidden=True)
+    @group(invoke_without_command=True, name="clean", aliases=["purge"])
     @with_role(*MODERATION_ROLES)
     async def clean_group(self, ctx: Context) -> None:
         """Commands for cleaning messages in channels."""
@@ -176,27 +184,49 @@ class Clean(Cog):
 
     @clean_group.command(name="user", aliases=["users"])
     @with_role(*MODERATION_ROLES)
-    async def clean_user(self, ctx: Context, user: User, amount: int = 10) -> None:
+    async def clean_user(
+        self,
+        ctx: Context,
+        user: User,
+        amount: Optional[int] = 10,
+        channel: TextChannel = None
+    ) -> None:
         """Delete messages posted by the provided user, stop cleaning after traversing `amount` messages."""
-        await self._clean_messages(amount, ctx, user=user)
+        await self._clean_messages(amount, ctx, user=user, channel=channel)
 
     @clean_group.command(name="all", aliases=["everything"])
     @with_role(*MODERATION_ROLES)
-    async def clean_all(self, ctx: Context, amount: int = 10) -> None:
+    async def clean_all(
+        self,
+        ctx: Context,
+        amount: Optional[int] = 10,
+        channel: TextChannel = None
+    ) -> None:
         """Delete all messages, regardless of poster, stop cleaning after traversing `amount` messages."""
-        await self._clean_messages(amount, ctx)
+        await self._clean_messages(amount, ctx, channel=channel)
 
     @clean_group.command(name="bots", aliases=["bot"])
     @with_role(*MODERATION_ROLES)
-    async def clean_bots(self, ctx: Context, amount: int = 10) -> None:
+    async def clean_bots(
+        self,
+        ctx: Context,
+        amount: Optional[int] = 10,
+        channel: TextChannel = None
+    ) -> None:
         """Delete all messages posted by a bot, stop cleaning after traversing `amount` messages."""
-        await self._clean_messages(amount, ctx, bots_only=True)
+        await self._clean_messages(amount, ctx, bots_only=True, channel=channel)
 
     @clean_group.command(name="regex", aliases=["word", "expression"])
     @with_role(*MODERATION_ROLES)
-    async def clean_regex(self, ctx: Context, regex: str, amount: int = 10) -> None:
+    async def clean_regex(
+        self,
+        ctx: Context,
+        regex: str,
+        amount: Optional[int] = 10,
+        channel: TextChannel = None
+    ) -> None:
         """Delete all messages that match a certain regex, stop cleaning after traversing `amount` messages."""
-        await self._clean_messages(amount, ctx, regex=regex)
+        await self._clean_messages(amount, ctx, regex=regex, channel=channel)
 
     @clean_group.command(name="stop", aliases=["cancel", "abort"])
     @with_role(*MODERATION_ROLES)
diff --git a/bot/cogs/moderation/scheduler.py b/bot/cogs/moderation/scheduler.py
index 2dd0bf40e..01e4b1fe7 100644
--- a/bot/cogs/moderation/scheduler.py
+++ b/bot/cogs/moderation/scheduler.py
@@ -114,8 +114,8 @@ class InfractionScheduler(Scheduler):
                 dm_result = ":incoming_envelope: "
                 dm_log_text = "\nDM: Sent"
             else:
+                dm_result = f"{constants.Emojis.failmail} "
                 dm_log_text = "\nDM: **Failed**"
-                log_content = ctx.author.mention
 
         if infraction["actor"] == self.bot.user.id:
             log.trace(
@@ -255,8 +255,7 @@ class InfractionScheduler(Scheduler):
         if log_text.get("DM") == "Sent":
             dm_emoji = ":incoming_envelope: "
         elif "DM" in log_text:
-            # Mention the actor because the DM failed to send.
-            log_content = ctx.author.mention
+            dm_emoji = f"{constants.Emojis.failmail} "
 
         # Accordingly display whether the pardon failed.
         if "Failure" in log_text:
diff --git a/bot/cogs/verification.py b/bot/cogs/verification.py
index b32b9a29e..988e0d49a 100644
--- a/bot/cogs/verification.py
+++ b/bot/cogs/verification.py
@@ -10,9 +10,10 @@ from bot.cogs.moderation import ModLog
 from bot.constants import (
     Bot as BotConfig,
     Channels, Colours, Event,
-    Filter, Icons, Roles
+    Filter, Icons, MODERATION_ROLES, Roles
 )
 from bot.decorators import InChannelCheckFailure, in_channel, without_role
+from bot.utils.checks import without_role_check
 
 log = logging.getLogger(__name__)
 
@@ -38,6 +39,7 @@ PERIODIC_PING = (
     f"@everyone To verify that you have read our rules, please type `{BotConfig.prefix}accept`."
     f" If you encounter any problems during the verification process, ping the <@&{Roles.admin}> role in this channel."
 )
+BOT_MESSAGE_DELETE_DELAY = 10
 
 
 class Verification(Cog):
@@ -55,12 +57,16 @@ class Verification(Cog):
     @Cog.listener()
     async def on_message(self, message: Message) -> None:
         """Check new message event for messages to the checkpoint channel & process."""
-        if message.author.bot:
-            return  # They're a bot, ignore
-
         if message.channel.id != Channels.verification:
             return  # Only listen for #checkpoint messages
 
+        if message.author.bot:
+            # They're a bot, delete their message after the delay.
+            # But not the periodic ping; we like that one.
+            if message.content != PERIODIC_PING:
+                await message.delete(delay=BOT_MESSAGE_DELETE_DELAY)
+            return
+
         # if a user mentions a role or guild member
         # alert the mods in mod-alerts channel
         if message.mentions or message.role_mentions:
@@ -190,7 +196,7 @@ class Verification(Cog):
     @staticmethod
     def bot_check(ctx: Context) -> bool:
         """Block any command within the verification channel that is not !accept."""
-        if ctx.channel.id == Channels.verification:
+        if ctx.channel.id == Channels.verification and without_role_check(ctx, *MODERATION_ROLES):
             return ctx.command.name == "accept"
         else:
             return True
diff --git a/bot/constants.py b/bot/constants.py
index ed85adf6a..8815ab983 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -256,6 +256,8 @@ class Emojis(metaclass=YAMLGetter):
     status_idle: str
     status_dnd: str
 
+    failmail: str
+
     bullet: str
     new: str
     pencil: str
diff --git a/bot/utils/time.py b/bot/utils/time.py
index ac64865d6..7416f36e0 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -115,7 +115,7 @@ def format_infraction(timestamp: str) -> str:
 
 def format_infraction_with_duration(
     expiry: Optional[str],
-    date_from: datetime.datetime = None,
+    date_from: Optional[datetime.datetime] = None,
     max_units: int = 2
 ) -> Optional[str]:
     """
@@ -140,10 +140,15 @@ def format_infraction_with_duration(
     return f"{expiry_formatted}{duration_formatted}"
 
 
-def until_expiration(expiry: Optional[str], max_units: int = 2) -> Optional[str]:
+def until_expiration(
+    expiry: Optional[str],
+    now: Optional[datetime.datetime] = None,
+    max_units: int = 2
+) -> Optional[str]:
     """
     Get the remaining time until infraction's expiration, in a human-readable version of the relativedelta.
 
+    Returns a human-readable version of the remaining duration between datetime.utcnow() and an expiry.
     Unlike `humanize_delta`, this function will force the `precision` to be `seconds` by not passing it.
     `max_units` specifies the maximum number of units of time to include (e.g. 1 may include days but not hours).
     By default, max_units is 2.
@@ -151,7 +156,7 @@ def until_expiration(expiry: Optional[str], max_units: int = 2) -> Optional[str]
     if not expiry:
         return None
 
-    now = datetime.datetime.utcnow()
+    now = now or datetime.datetime.utcnow()
     since = dateutil.parser.isoparse(expiry).replace(tzinfo=None, microsecond=0)
 
     if since < now:
diff --git a/config-default.yml b/config-default.yml
index e6f0fda21..6ae07da93 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -27,6 +27,8 @@ style:
         status_dnd:     "<:status_dnd:470326272082313216>"
         status_offline: "<:status_offline:470326266537705472>"
 
+        failmail: "<:failmail:633660039931887616>"
+
         bullet:     "\u2022"
         pencil:     "\u270F"
         new:        "\U0001F195"
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)