From 1e0c0cfe37eb9a868454508fcb813d7cf19e12cc Mon Sep 17 00:00:00 2001
From: Izan <tizzysaurus@gmail.com>
Date: Wed, 29 Dec 2021 15:09:22 +0000
Subject: Fix tests

---
 tests/bot/exts/moderation/test_incidents.py | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/test_incidents.py b/tests/bot/exts/moderation/test_incidents.py
index cfe0c4b03..ef33aa62b 100644
--- a/tests/bot/exts/moderation/test_incidents.py
+++ b/tests/bot/exts/moderation/test_incidents.py
@@ -1,4 +1,5 @@
 import asyncio
+import datetime
 import enum
 import logging
 import typing as t
@@ -13,6 +14,7 @@ from async_rediscache import RedisSession
 from bot.constants import Colours
 from bot.exts.moderation import incidents
 from bot.utils.messages import format_user
+from bot.utils.time import TimestampFormats, discord_timestamp
 from tests.helpers import (
     MockAsyncWebhook, MockAttachment, MockBot, MockMember, MockMessage, MockReaction, MockRole, MockTextChannel,
     MockUser
@@ -114,10 +116,19 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
 
     async def test_make_embed_content(self):
         """Incident content appears as embed description."""
-        incident = MockMessage(content="this is an incident")
+        current_time = datetime.datetime(2022, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
+        incident = MockMessage(content="this is an incident", created_at=current_time)
+
+        day_timestamp = discord_timestamp(current_time, TimestampFormats.DATE)
+        time_timestamp = discord_timestamp(current_time, TimestampFormats.TIME)
+        relative_timestamp = discord_timestamp(current_time, TimestampFormats.RELATIVE)
+
         embed, file = await incidents.make_embed(incident, incidents.Signal.ACTIONED, MockMember())
 
-        self.assertEqual(incident.content, embed.description)
+        self.assertEqual(
+            f"{incident.content}\n\n__*Reported {day_timestamp} at {time_timestamp} ({relative_timestamp}).*__",
+            embed.description
+        )
 
     async def test_make_embed_with_attachment_succeeds(self):
         """Incident's attachment is downloaded and displayed in the embed's image field."""
@@ -391,7 +402,7 @@ class TestArchive(TestIncidents):
         # Define our own `incident` to be archived
         incident = MockMessage(
             content="this is an incident",
-            author=MockUser(name="author_name", display_avatar=Mock(url="author_avatar")),
+            author=MockUser(display_name="author_name", display_avatar=Mock(url="author_avatar")),
             id=123,
         )
         built_embed = MagicMock(discord.Embed, id=123)  # We patch `make_embed` to return this
@@ -422,7 +433,7 @@ class TestArchive(TestIncidents):
         webhook = MockAsyncWebhook()
         self.cog_instance.bot.fetch_webhook = AsyncMock(return_value=webhook)
 
-        message_from_clyde = MockMessage(author=MockUser(name="clyde the great"))
+        message_from_clyde = MockMessage(author=MockUser(display_name="clyde the great"))
         await self.cog_instance.archive(message_from_clyde, MagicMock(incidents.Signal), MockMember())
 
         self.assertNotIn("clyde", webhook.send.call_args.kwargs["username"])
@@ -521,12 +532,13 @@ class TestProcessEvent(TestIncidents):
     async def test_process_event_confirmation_task_is_awaited(self):
         """Task given by `Incidents.make_confirmation_task` is awaited before method exits."""
         mock_task = AsyncMock()
+        mock_member = MockMember(display_name="Bobby Johnson", roles=[MockRole(id=1)])
 
         with patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", mock_task):
             await self.cog_instance.process_event(
                 reaction=incidents.Signal.ACTIONED.value,
-                incident=MockMessage(id=123),
-                member=MockMember(roles=[MockRole(id=1)])
+                incident=MockMessage(author=mock_member, id=123),
+                member=mock_member
             )
 
         mock_task.assert_awaited()
-- 
cgit v1.2.3


From b7e03616ac3fc0b5e8a5a77a352df593983d187a Mon Sep 17 00:00:00 2001
From: Izan <tizzysaurus@gmail.com>
Date: Thu, 14 Jul 2022 22:21:34 +0100
Subject: Address Reviews

- Use the more concise DATETIME timestamp instead of both a DATE and a TIME timestamp.

- Remove underline from the "Reported ..." section at the bottom of the embed.

- Re-add time of action/rejection timestamp to footer of embed.
---
 bot/exts/moderation/incidents.py            | 7 ++++---
 tests/bot/exts/moderation/test_incidents.py | 5 ++---
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/moderation/incidents.py b/bot/exts/moderation/incidents.py
index bd9e5b88e..f29cfcdd6 100644
--- a/bot/exts/moderation/incidents.py
+++ b/bot/exts/moderation/incidents.py
@@ -1,5 +1,6 @@
 import asyncio
 import re
+from datetime import datetime, timezone
 from enum import Enum
 from typing import Optional
 
@@ -97,10 +98,9 @@ async def make_embed(incident: discord.Message, outcome: Signal, actioned_by: di
         colour = Colours.soft_red
         footer = f"Rejected by {actioned_by}"
 
-    day_timestamp = discord_timestamp(incident.created_at, TimestampFormats.DATE)
-    time_timestamp = discord_timestamp(incident.created_at, TimestampFormats.TIME)
+    reported_timestamp = discord_timestamp(incident.created_at)
     relative_timestamp = discord_timestamp(incident.created_at, TimestampFormats.RELATIVE)
-    reported_on_msg = f"__*Reported {day_timestamp} at {time_timestamp} ({relative_timestamp}).*__"
+    reported_on_msg = f"*Reported {reported_timestamp} ({relative_timestamp}).*"
 
     # If the description will be too long (>4096 total characters), truncate the incident content
     if len(incident.content) > (allowed_content_chars := 4096-len(reported_on_msg)-2):  # -2 for the newlines
@@ -111,6 +111,7 @@ async def make_embed(incident: discord.Message, outcome: Signal, actioned_by: di
     embed = discord.Embed(
         description=description,
         colour=colour,
+        timestamp=datetime.now(timezone.utc)
     )
     embed.set_footer(text=footer, icon_url=actioned_by.display_avatar.url)
 
diff --git a/tests/bot/exts/moderation/test_incidents.py b/tests/bot/exts/moderation/test_incidents.py
index ef33aa62b..da0a79ce8 100644
--- a/tests/bot/exts/moderation/test_incidents.py
+++ b/tests/bot/exts/moderation/test_incidents.py
@@ -119,14 +119,13 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
         current_time = datetime.datetime(2022, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
         incident = MockMessage(content="this is an incident", created_at=current_time)
 
-        day_timestamp = discord_timestamp(current_time, TimestampFormats.DATE)
-        time_timestamp = discord_timestamp(current_time, TimestampFormats.TIME)
+        reported_timestamp = discord_timestamp(current_time)
         relative_timestamp = discord_timestamp(current_time, TimestampFormats.RELATIVE)
 
         embed, file = await incidents.make_embed(incident, incidents.Signal.ACTIONED, MockMember())
 
         self.assertEqual(
-            f"{incident.content}\n\n__*Reported {day_timestamp} at {time_timestamp} ({relative_timestamp}).*__",
+            f"{incident.content}\n\n*Reported {reported_timestamp} ({relative_timestamp}).*",
             embed.description
         )
 
-- 
cgit v1.2.3


From fb419bc8f0525e8296abc5017a0d316adb22d4c4 Mon Sep 17 00:00:00 2001
From: wookie184 <wookie1840@gmail.com>
Date: Thu, 4 Aug 2022 17:32:12 +0100
Subject: Fix tests

---
 .../exts/moderation/infraction/test_infractions.py | 30 +++++++++++++---------
 1 file changed, 18 insertions(+), 12 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 052048053..9636f0146 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -35,17 +35,20 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
         self.cog.apply_infraction = AsyncMock()
         self.bot.get_cog.return_value = AsyncMock()
         self.cog.mod_log.ignore = Mock()
-        self.ctx.guild.ban = Mock()
+        self.ctx.guild.ban = AsyncMock()
 
         await self.cog.apply_ban(self.ctx, self.target, "foo bar" * 3000)
-        self.ctx.guild.ban.assert_called_once_with(
+        self.cog.apply_infraction.assert_awaited_once_with(
+            self.ctx, {"foo": "bar", "purge": ""}, self.target, ANY
+        )
+
+        action = self.cog.apply_infraction.call_args.args[-1]
+        await action()
+        self.ctx.guild.ban.assert_awaited_once_with(
             self.target,
             reason=textwrap.shorten("foo bar" * 3000, 512, placeholder="..."),
             delete_message_days=0
         )
-        self.cog.apply_infraction.assert_awaited_once_with(
-            self.ctx, {"foo": "bar", "purge": ""}, self.target, self.ctx.guild.ban.return_value
-        )
 
     @patch("bot.exts.moderation.infraction._utils.post_infraction")
     async def test_apply_kick_reason_truncation(self, post_infraction_mock):
@@ -54,14 +57,17 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
 
         self.cog.apply_infraction = AsyncMock()
         self.cog.mod_log.ignore = Mock()
-        self.target.kick = Mock()
+        self.target.kick = AsyncMock()
 
         await self.cog.apply_kick(self.ctx, self.target, "foo bar" * 3000)
-        self.target.kick.assert_called_once_with(reason=textwrap.shorten("foo bar" * 3000, 512, placeholder="..."))
         self.cog.apply_infraction.assert_awaited_once_with(
-            self.ctx, {"foo": "bar"}, self.target, self.target.kick.return_value
+            self.ctx, {"foo": "bar"}, self.target, ANY
         )
 
+        action = self.cog.apply_infraction.call_args.args[-1]
+        await action()
+        self.target.kick.assert_awaited_once_with(reason=textwrap.shorten("foo bar" * 3000, 512, placeholder="..."))
+
 
 @patch("bot.exts.moderation.infraction.infractions.constants.Roles.voice_verified", new=123456)
 class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
@@ -141,8 +147,8 @@ class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
 
     async def action_tester(self, action, reason: str) -> None:
         """Helper method to test voice mute action."""
-        self.assertTrue(inspect.iscoroutine(action))
-        await action
+        self.assertTrue(inspect.iscoroutinefunction(action))
+        await action()
 
         self.user.move_to.assert_called_once_with(None, reason=ANY)
         self.user.remove_roles.assert_called_once_with(self.cog._voice_verified_role, reason=reason)
@@ -194,8 +200,8 @@ class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
 
         # Test action
         action = self.cog.apply_infraction.call_args[0][-1]
-        self.assertTrue(inspect.iscoroutine(action))
-        await action
+        self.assertTrue(inspect.iscoroutinefunction(action))
+        await action()
 
     async def test_voice_unmute_user_not_found(self):
         """Should include info to return dict when user was not found from guild."""
-- 
cgit v1.2.3


From 1df6034a1723fd3ff1bd88047ca6a62f920767e6 Mon Sep 17 00:00:00 2001
From: Izan <tizzysaurus@gmail.com>
Date: Mon, 15 Aug 2022 12:04:33 +0100
Subject: Fix incident tests.

---
 tests/bot/exts/moderation/test_incidents.py | 38 +++++++++++++++++++----------
 1 file changed, 25 insertions(+), 13 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/test_incidents.py b/tests/bot/exts/moderation/test_incidents.py
index 11fe565fc..53d98360c 100644
--- a/tests/bot/exts/moderation/test_incidents.py
+++ b/tests/bot/exts/moderation/test_incidents.py
@@ -20,6 +20,8 @@ from tests.helpers import (
     MockUser
 )
 
+CURRENT_TIME = datetime.datetime(2022, 1, 1, tzinfo=datetime.timezone.utc)
+
 
 class MockAsyncIterable:
     """
@@ -102,25 +104,32 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
 
     async def test_make_embed_actioned(self):
         """Embed is coloured green and footer contains 'Actioned' when `outcome=Signal.ACTIONED`."""
-        embed, file = await incidents.make_embed(MockMessage(), incidents.Signal.ACTIONED, MockMember())
+        embed, file = await incidents.make_embed(
+            incident=MockMessage(created_at=CURRENT_TIME),
+            outcome=incidents.Signal.ACTIONED,
+            actioned_by=MockMember()
+        )
 
         self.assertEqual(embed.colour.value, Colours.soft_green)
         self.assertIn("Actioned", embed.footer.text)
 
     async def test_make_embed_not_actioned(self):
         """Embed is coloured red and footer contains 'Rejected' when `outcome=Signal.NOT_ACTIONED`."""
-        embed, file = await incidents.make_embed(MockMessage(), incidents.Signal.NOT_ACTIONED, MockMember())
+        embed, file = await incidents.make_embed(
+            incident=MockMessage(created_at=CURRENT_TIME),
+            outcome=incidents.Signal.NOT_ACTIONED,
+            actioned_by=MockMember()
+        )
 
         self.assertEqual(embed.colour.value, Colours.soft_red)
         self.assertIn("Rejected", embed.footer.text)
 
     async def test_make_embed_content(self):
         """Incident content appears as embed description."""
-        current_time = datetime.datetime(2022, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
-        incident = MockMessage(content="this is an incident", created_at=current_time)
+        incident = MockMessage(content="this is an incident", created_at=CURRENT_TIME)
 
-        reported_timestamp = discord_timestamp(current_time)
-        relative_timestamp = discord_timestamp(current_time, TimestampFormats.RELATIVE)
+        reported_timestamp = discord_timestamp(CURRENT_TIME)
+        relative_timestamp = discord_timestamp(CURRENT_TIME, TimestampFormats.RELATIVE)
 
         embed, file = await incidents.make_embed(incident, incidents.Signal.ACTIONED, MockMember())
 
@@ -133,7 +142,7 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
         """Incident's attachment is downloaded and displayed in the embed's image field."""
         file = MagicMock(discord.File, filename="bigbadjoe.jpg")
         attachment = MockAttachment(filename="bigbadjoe.jpg")
-        incident = MockMessage(content="this is an incident", attachments=[attachment])
+        incident = MockMessage(content="this is an incident", attachments=[attachment], created_at=CURRENT_TIME)
 
         # Patch `download_file` to return our `file`
         with patch("bot.exts.moderation.incidents.download_file", AsyncMock(return_value=file)):
@@ -145,7 +154,7 @@ class TestMakeEmbed(unittest.IsolatedAsyncioTestCase):
     async def test_make_embed_with_attachment_fails(self):
         """Incident's attachment fails to download, proxy url is linked instead."""
         attachment = MockAttachment(proxy_url="discord.com/bigbadjoe.jpg")
-        incident = MockMessage(content="this is an incident", attachments=[attachment])
+        incident = MockMessage(content="this is an incident", attachments=[attachment], created_at=CURRENT_TIME)
 
         # Patch `download_file` to return None as if the download failed
         with patch("bot.exts.moderation.incidents.download_file", AsyncMock(return_value=None)):
@@ -359,7 +368,6 @@ class TestCrawlIncidents(TestIncidents):
 
 class TestArchive(TestIncidents):
     """Tests for the `Incidents.archive` coroutine."""
-
     async def test_archive_webhook_not_found(self):
         """
         Method recovers and returns False when the webhook is not found.
@@ -369,7 +377,11 @@ class TestArchive(TestIncidents):
         """
         self.cog_instance.bot.fetch_webhook = AsyncMock(side_effect=mock_404)
         self.assertFalse(
-            await self.cog_instance.archive(incident=MockMessage(), outcome=MagicMock(), actioned_by=MockMember())
+            await self.cog_instance.archive(
+                incident=MockMessage(created_at=CURRENT_TIME),
+                outcome=MagicMock(),
+                actioned_by=MockMember()
+            )
         )
 
     async def test_archive_relays_incident(self):
@@ -416,7 +428,7 @@ class TestArchive(TestIncidents):
         webhook = MockAsyncWebhook()
         self.cog_instance.bot.fetch_webhook = AsyncMock(return_value=webhook)
 
-        message_from_clyde = MockMessage(author=MockUser(display_name="clyde the great"))
+        message_from_clyde = MockMessage(author=MockUser(display_name="clyde the great"), created_at=CURRENT_TIME)
         await self.cog_instance.archive(message_from_clyde, MagicMock(incidents.Signal), MockMember())
 
         self.assertNotIn("clyde", webhook.send.call_args.kwargs["username"])
@@ -520,7 +532,7 @@ class TestProcessEvent(TestIncidents):
         with patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", mock_task):
             await self.cog_instance.process_event(
                 reaction=incidents.Signal.ACTIONED.value,
-                incident=MockMessage(author=mock_member, id=123),
+                incident=MockMessage(author=mock_member, id=123, created_at=CURRENT_TIME),
                 member=mock_member
             )
 
@@ -540,7 +552,7 @@ class TestProcessEvent(TestIncidents):
             with patch("bot.exts.moderation.incidents.Incidents.make_confirmation_task", mock_task):
                 await self.cog_instance.process_event(
                     reaction=incidents.Signal.ACTIONED.value,
-                    incident=MockMessage(id=123),
+                    incident=MockMessage(id=123, created_at=CURRENT_TIME),
                     member=MockMember(roles=[MockRole(id=1)])
                 )
         except asyncio.TimeoutError:
-- 
cgit v1.2.3


From 0e6242f7f4c41329e9270724a9780511f7165240 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Thu, 28 Jul 2022 04:54:26 -0400
Subject: Updated tests

- Refactored tests for new time duration arguments
---
 .../exts/moderation/infraction/test_infractions.py | 11 ++++----
 tests/bot/exts/moderation/infraction/test_utils.py | 29 +++++++++++++---------
 2 files changed, 23 insertions(+), 17 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 052048053..a18a4d23b 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -79,13 +79,13 @@ class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
         """Should call voice mute applying function without expiry."""
         self.cog.apply_voice_mute = AsyncMock()
         self.assertIsNone(await self.cog.voicemute(self.cog, self.ctx, self.user, reason="foobar"))
-        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", duration_or_expiry=None)
 
     async def test_temporary_voice_mute(self):
         """Should call voice mute applying function with expiry."""
         self.cog.apply_voice_mute = AsyncMock()
         self.assertIsNone(await self.cog.tempvoicemute(self.cog, self.ctx, self.user, "baz", reason="foobar"))
-        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at="baz")
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", duration_or_expiry="baz")
 
     async def test_voice_unmute(self):
         """Should call infraction pardoning function."""
@@ -189,7 +189,8 @@ class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
 
         user = MockUser()
         await self.cog.voicemute(self.cog, self.ctx, user, reason=None)
-        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_mute", None, active=True, expires_at=None)
+        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_mute", None, active=True,
+                                                     duration_or_expiry=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
         # Test action
@@ -273,7 +274,7 @@ class CleanBanTests(unittest.IsolatedAsyncioTestCase):
             self.user,
             "FooBar",
             purge_days=1,
-            expires_at=None,
+            duration_or_expiry=None,
         )
 
     async def test_cleanban_doesnt_purge_messages_if_clean_cog_available(self):
@@ -285,7 +286,7 @@ class CleanBanTests(unittest.IsolatedAsyncioTestCase):
             self.ctx,
             self.user,
             "FooBar",
-            expires_at=None,
+            duration_or_expiry=None,
         )
 
     @patch("bot.exts.moderation.infraction.infractions.Age")
diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index 5cf02033d..4c78c0bd8 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -318,14 +318,17 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "user": self.member.id,
             "active": False,
             "expires_at": now.isoformat(),
-            "dm_sent": False
+            "dm_sent": False,
+            "last_applied": datetime(2020, 1, 1).isoformat(),
         }
 
-        self.ctx.bot.api_client.post.return_value = "foo"
-        actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
+        # Patch the time.now(tz=timezone.utc) function to return a specific time
+        with patch("bot.exts.moderation.infraction._utils.datetime.now", return_value=datetime(2020, 1, 1)):
+            self.ctx.bot.api_client.post.return_value = "foo"
+            actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
 
-        self.assertEqual(actual, "foo")
-        self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
+            self.assertEqual(actual, "foo")
+            self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
 
     async def test_unknown_error_post_infraction(self):
         """Should send an error message to chat when a non-400 error occurs."""
@@ -356,12 +359,14 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "type": "mute",
             "user": self.user.id,
             "active": True,
-            "dm_sent": False
+            "dm_sent": False,
+            "last_applied": datetime(2020, 1, 1),
         }
 
-        self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
-
-        actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
-        self.assertEqual(actual, "foo")
-        self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
-        post_user_mock.assert_awaited_once_with(self.ctx, self.user)
+        # Patch the time.now(tz=timezone.utc) function to return a specific time
+        with patch("bot.exts.moderation.infraction._utils.datetime.now", return_value=datetime(2020, 1, 1)):
+            self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
+            actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
+            self.assertEqual(actual, "foo")
+            self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
+            post_user_mock.assert_awaited_once_with(self.ctx, self.user)
-- 
cgit v1.2.3


From 035b5accf78f8623b40e0612e3c057f0ef2b93a7 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Thu, 28 Jul 2022 05:04:38 -0400
Subject: Fixed test patches

---
 tests/bot/exts/moderation/infraction/test_utils.py | 32 ++++++++++++----------
 1 file changed, 17 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index 4c78c0bd8..def06932b 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -307,7 +307,8 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
         self.user = MockUser(id=1234)
         self.ctx = MockContext(bot=self.bot, author=self.member)
 
-    async def test_normal_post_infraction(self):
+    @patch("bot.exts.moderation.infraction._utils.datetime", wraps=datetime)
+    async def test_normal_post_infraction(self, mock_datetime):
         """Should return response from POST request if there are no errors."""
         now = datetime.now()
         payload = {
@@ -322,13 +323,13 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "last_applied": datetime(2020, 1, 1).isoformat(),
         }
 
-        # Patch the time.now(tz=timezone.utc) function to return a specific time
-        with patch("bot.exts.moderation.infraction._utils.datetime.now", return_value=datetime(2020, 1, 1)):
-            self.ctx.bot.api_client.post.return_value = "foo"
-            actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
+        # Patch the datetime.now function to return a specific time
+        mock_datetime.now.return_value = datetime(2020, 1, 1)
+        self.ctx.bot.api_client.post.return_value = "foo"
+        actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
 
-            self.assertEqual(actual, "foo")
-            self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
+        self.assertEqual(actual, "foo")
+        self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
 
     async def test_unknown_error_post_infraction(self):
         """Should send an error message to chat when a non-400 error occurs."""
@@ -349,8 +350,9 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(actual)
         post_user_mock.assert_awaited_once_with(self.ctx, self.user)
 
+    @patch("bot.exts.moderation.infraction._utils.datetime", wraps=datetime)
     @patch("bot.exts.moderation.infraction._utils.post_user", return_value="bar")
-    async def test_first_fail_second_success_user_post_infraction(self, post_user_mock):
+    async def test_first_fail_second_success_user_post_infraction(self, post_user_mock, mock_datetime):
         """Should post the user if they don't exist, POST infraction again, and return the response if successful."""
         payload = {
             "actor": self.ctx.author.id,
@@ -363,10 +365,10 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "last_applied": datetime(2020, 1, 1),
         }
 
-        # Patch the time.now(tz=timezone.utc) function to return a specific time
-        with patch("bot.exts.moderation.infraction._utils.datetime.now", return_value=datetime(2020, 1, 1)):
-            self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
-            actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
-            self.assertEqual(actual, "foo")
-            self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
-            post_user_mock.assert_awaited_once_with(self.ctx, self.user)
+        # Patch the datetime.now function to return a specific time
+        mock_datetime.now.return_value = datetime(2020, 1, 1)
+        self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
+        actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
+        self.assertEqual(actual, "foo")
+        self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
+        post_user_mock.assert_awaited_once_with(self.ctx, self.user)
-- 
cgit v1.2.3


From 8db7ef5df087e43804d07dabe2037af18adcb0d6 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Thu, 28 Jul 2022 05:19:30 -0400
Subject: Added isoformat for test payload

---
 tests/bot/exts/moderation/infraction/test_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index def06932b..d3a908b28 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -362,7 +362,7 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "user": self.user.id,
             "active": True,
             "dm_sent": False,
-            "last_applied": datetime(2020, 1, 1),
+            "last_applied": datetime(2020, 1, 1).isoformat(),
         }
 
         # Patch the datetime.now function to return a specific time
-- 
cgit v1.2.3


From 3280ac48a9031b727bdde69909729093593bd967 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Thu, 28 Jul 2022 06:11:11 -0400
Subject: Fixed tests

- Corrected datetime patching
---
 tests/bot/exts/moderation/infraction/test_utils.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index d3a908b28..b1f23e31c 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -307,8 +307,7 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
         self.user = MockUser(id=1234)
         self.ctx = MockContext(bot=self.bot, author=self.member)
 
-    @patch("bot.exts.moderation.infraction._utils.datetime", wraps=datetime)
-    async def test_normal_post_infraction(self, mock_datetime):
+    async def test_normal_post_infraction(self):
         """Should return response from POST request if there are no errors."""
         now = datetime.now()
         payload = {
@@ -320,16 +319,18 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "active": False,
             "expires_at": now.isoformat(),
             "dm_sent": False,
-            "last_applied": datetime(2020, 1, 1).isoformat(),
         }
 
-        # Patch the datetime.now function to return a specific time
-        mock_datetime.now.return_value = datetime(2020, 1, 1)
         self.ctx.bot.api_client.post.return_value = "foo"
         actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
 
         self.assertEqual(actual, "foo")
-        self.ctx.bot.api_client.post.assert_awaited_once_with("bot/infractions", json=payload)
+        self.ctx.bot.api_client.post.assert_awaited_once()
+        await_args = str(self.ctx.bot.api_client.post.await_args)
+        # Check existing keys present, allow for additional keys (e.g. `last_applied`)
+        for key, value in payload.items():
+            self.assertTrue(key in await_args)
+            self.assertTrue(str(value) in await_args)
 
     async def test_unknown_error_post_infraction(self):
         """Should send an error message to chat when a non-400 error occurs."""
-- 
cgit v1.2.3


From e74ff62122935da349d38a8c06eef14d1e3ba9aa Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Sat, 6 Aug 2022 13:47:49 -0400
Subject: Refactored test to not use datetime patch

- Used new method of dict subset comparison instead of datetime patching for better compat. with argument types
---
 tests/bot/exts/moderation/infraction/test_utils.py | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index b1f23e31c..5ba0f4273 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -1,7 +1,7 @@
 import unittest
 from collections import namedtuple
 from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock, call, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from botcore.site_api import ResponseCodeError
 from discord import Embed, Forbidden, HTTPException, NotFound
@@ -351,11 +351,10 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(actual)
         post_user_mock.assert_awaited_once_with(self.ctx, self.user)
 
-    @patch("bot.exts.moderation.infraction._utils.datetime", wraps=datetime)
     @patch("bot.exts.moderation.infraction._utils.post_user", return_value="bar")
-    async def test_first_fail_second_success_user_post_infraction(self, post_user_mock, mock_datetime):
+    async def test_first_fail_second_success_user_post_infraction(self, post_user_mock):
         """Should post the user if they don't exist, POST infraction again, and return the response if successful."""
-        payload = {
+        expected = {
             "actor": self.ctx.author.id,
             "hidden": False,
             "reason": "Test reason",
@@ -363,13 +362,17 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
             "user": self.user.id,
             "active": True,
             "dm_sent": False,
-            "last_applied": datetime(2020, 1, 1).isoformat(),
         }
 
-        # Patch the datetime.now function to return a specific time
-        mock_datetime.now.return_value = datetime(2020, 1, 1)
         self.bot.api_client.post.side_effect = [ResponseCodeError(MagicMock(status=400), {"user": "foo"}), "foo"]
         actual = await utils.post_infraction(self.ctx, self.user, "mute", "Test reason")
         self.assertEqual(actual, "foo")
-        self.bot.api_client.post.assert_has_awaits([call("bot/infractions", json=payload)] * 2)
+        await_args = self.bot.api_client.post.await_args_list
+        self.assertEqual(len(await_args), 2, "Expected 2 awaits")
+
+        # Since `last_applied` is based on current time, just check if expected is a subset of payload
+        for args in await_args:
+            payload: dict = args.kwargs["json"]
+            self.assertEqual(payload, payload | expected)
+
         post_user_mock.assert_awaited_once_with(self.ctx, self.user)
-- 
cgit v1.2.3


From d93afa3dbe16404a60e23acaf394affcda5aff89 Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Sat, 6 Aug 2022 13:57:51 -0400
Subject: Updated previous tests to use subset method

---
 tests/bot/exts/moderation/infraction/test_utils.py | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index 5ba0f4273..6c9af2555 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -310,7 +310,7 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
     async def test_normal_post_infraction(self):
         """Should return response from POST request if there are no errors."""
         now = datetime.now()
-        payload = {
+        expected = {
             "actor": self.ctx.author.id,
             "hidden": True,
             "reason": "Test reason",
@@ -323,14 +323,12 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
 
         self.ctx.bot.api_client.post.return_value = "foo"
         actual = await utils.post_infraction(self.ctx, self.member, "ban", "Test reason", now, True, False)
-
         self.assertEqual(actual, "foo")
         self.ctx.bot.api_client.post.assert_awaited_once()
-        await_args = str(self.ctx.bot.api_client.post.await_args)
-        # Check existing keys present, allow for additional keys (e.g. `last_applied`)
-        for key, value in payload.items():
-            self.assertTrue(key in await_args)
-            self.assertTrue(str(value) in await_args)
+
+        # Since `last_applied` is based on current time, just check if expected is a subset of payload
+        payload: dict = self.ctx.bot.api_client.post.await_args_list[0].kwargs["json"]
+        self.assertEqual(payload, payload | expected)
 
     async def test_unknown_error_post_infraction(self):
         """Should send an error message to chat when a non-400 error occurs."""
-- 
cgit v1.2.3


From 08a6bbc306d1ec54998b690eeeb258548e8e08fa Mon Sep 17 00:00:00 2001
From: ionite34 <dev@ionite.io>
Date: Sat, 13 Aug 2022 15:45:52 -0400
Subject: Corrected test use of utcnow

Corrected test case to use `datetime.utcnow()` to be consistent with target
---
 tests/bot/exts/moderation/infraction/test_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index 6c9af2555..29dadf372 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -309,7 +309,7 @@ class TestPostInfraction(unittest.IsolatedAsyncioTestCase):
 
     async def test_normal_post_infraction(self):
         """Should return response from POST request if there are no errors."""
-        now = datetime.now()
+        now = datetime.utcnow()
         expected = {
             "actor": self.ctx.author.id,
             "hidden": True,
-- 
cgit v1.2.3


From dada405211eac996196cdfb0496f4ff22f9a656a Mon Sep 17 00:00:00 2001
From: arl <genericusername414+git@gmail.com>
Date: Thu, 18 Aug 2022 19:01:22 -0400
Subject: fix: don't include replied mentions in mention filter (#2017)

Co-authored-by: Izan <tizzysaurus@gmail.com>
Co-authored-by: TizzySaurus <47674925+TizzySaurus@users.noreply.github.com>
Co-authored-by: Xithrius <15021300+Xithrius@users.noreply.github.com>
---
 bot/rules/mentions.py            | 56 +++++++++++++++++++++++++++++++++-----
 tests/bot/rules/test_mentions.py | 58 ++++++++++++++++++++++++++++++++++++----
 tests/helpers.py                 | 22 +++++++++++++++
 3 files changed, 124 insertions(+), 12 deletions(-)

(limited to 'tests')

diff --git a/bot/rules/mentions.py b/bot/rules/mentions.py
index 6f5addad1..ca1d0c01c 100644
--- a/bot/rules/mentions.py
+++ b/bot/rules/mentions.py
@@ -1,23 +1,65 @@
 from typing import Dict, Iterable, List, Optional, Tuple
 
-from discord import Member, Message
+from discord import DeletedReferencedMessage, Member, Message, MessageType, NotFound
+
+import bot
+from bot.log import get_logger
+
+log = get_logger(__name__)
 
 
 async def apply(
     last_message: Message, recent_messages: List[Message], config: Dict[str, int]
 ) -> Optional[Tuple[str, Iterable[Member], Iterable[Message]]]:
-    """Detects total mentions exceeding the limit sent by a single user."""
+    """
+    Detects total mentions exceeding the limit sent by a single user.
+
+    Excludes mentions that are bots, themselves, or replied users.
+
+    In very rare cases, may not be able to determine a
+    mention was to a reply, in which case it is not ignored.
+    """
     relevant_messages = tuple(
         msg
         for msg in recent_messages
         if msg.author == last_message.author
     )
+    # We use `msg.mentions` here as that is supplied by the api itself, to determine who was mentioned.
+    # Additionally, `msg.mentions` includes the user replied to, even if the mention doesn't occur in the body.
+    # In order to exclude users who are mentioned as a reply, we check if the msg has a reference
+    #
+    # While we could use regex to parse the message content, and get a list of
+    # the mentions, that solution is very prone to breaking.
+    # We would need to deal with codeblocks, escaping markdown, and any discrepancies between
+    # our implementation and discord's markdown parser which would cause false positives or false negatives.
+    total_recent_mentions = 0
+    for msg in relevant_messages:
+        # We check if the message is a reply, and if it is try to get the author
+        # since we ignore mentions of a user that we're replying to
+        reply_author = None
 
-    total_recent_mentions = sum(
-        not user.bot
-        for msg in relevant_messages
-        for user in msg.mentions
-    )
+        if msg.type == MessageType.reply:
+            ref = msg.reference
+
+            if not (resolved := ref.resolved):
+                # It is possible, in a very unusual situation, for a message to have a reference
+                # that is both not in the cache, and deleted while running this function.
+                # In such a situation, this will throw an error which we catch.
+                try:
+                    resolved = await bot.instance.get_partial_messageable(resolved.channel_id).fetch_message(
+                        resolved.message_id
+                    )
+                except NotFound:
+                    log.info('Could not fetch the reference message as it has been deleted.')
+
+            if resolved and not isinstance(resolved, DeletedReferencedMessage):
+                reply_author = resolved.author
+
+        for user in msg.mentions:
+            # Don't count bot or self mentions, or the user being replied to (if applicable)
+            if user.bot or user in {msg.author, reply_author}:
+                continue
+            total_recent_mentions += 1
 
     if total_recent_mentions > config['max']:
         return (
diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index f8805ac48..e1f904917 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -1,15 +1,32 @@
-from typing import Iterable
+from typing import Iterable, Optional
+
+import discord
 
 from bot.rules import mentions
 from tests.bot.rules import DisallowedCase, RuleTest
-from tests.helpers import MockMember, MockMessage
+from tests.helpers import MockMember, MockMessage, MockMessageReference
 
 
-def make_msg(author: str, total_user_mentions: int, total_bot_mentions: int = 0) -> MockMessage:
-    """Makes a message with `total_mentions` mentions."""
+def make_msg(
+    author: str,
+    total_user_mentions: int,
+    total_bot_mentions: int = 0,
+    *,
+    reference: Optional[MockMessageReference] = None
+) -> MockMessage:
+    """Makes a message from `author` with `total_user_mentions` user mentions and `total_bot_mentions` bot mentions."""
     user_mentions = [MockMember() for _ in range(total_user_mentions)]
     bot_mentions = [MockMember(bot=True) for _ in range(total_bot_mentions)]
-    return MockMessage(author=author, mentions=user_mentions+bot_mentions)
+
+    mentions = user_mentions + bot_mentions
+    if reference is not None:
+        # For the sake of these tests we assume that all references are mentions.
+        mentions.append(reference.resolved.author)
+        msg_type = discord.MessageType.reply
+    else:
+        msg_type = discord.MessageType.default
+
+    return MockMessage(author=author, mentions=mentions, reference=reference, type=msg_type)
 
 
 class TestMentions(RuleTest):
@@ -56,6 +73,16 @@ class TestMentions(RuleTest):
                 ("bob",),
                 3,
             ),
+            DisallowedCase(
+                [make_msg("bob", 3, reference=MockMessageReference())],
+                ("bob",),
+                3,
+            ),
+            DisallowedCase(
+                [make_msg("bob", 3, reference=MockMessageReference(reference_author_is_bot=True))],
+                ("bob",),
+                3
+            )
         )
 
         await self.run_disallowed(cases)
@@ -71,6 +98,27 @@ class TestMentions(RuleTest):
 
         await self.run_allowed(cases)
 
+    async def test_ignore_reply_mentions(self):
+        """Messages with an allowed amount of mentions in the content, also containing reply mentions."""
+        cases = (
+            [
+                make_msg("bob", 2, reference=MockMessageReference())
+            ],
+            [
+                make_msg("bob", 2, reference=MockMessageReference(reference_author_is_bot=True))
+            ],
+            [
+                make_msg("bob", 2, reference=MockMessageReference()),
+                make_msg("bob", 0, reference=MockMessageReference())
+            ],
+            [
+                make_msg("bob", 2, reference=MockMessageReference(reference_author_is_bot=True)),
+                make_msg("bob", 0, reference=MockMessageReference(reference_author_is_bot=True))
+            ]
+        )
+
+        await self.run_allowed(cases)
+
     def relevant_messages(self, case: DisallowedCase) -> Iterable[MockMessage]:
         last_message = case.recent_messages[0]
         return tuple(
diff --git a/tests/helpers.py b/tests/helpers.py
index 17214553c..687e15b96 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -492,6 +492,28 @@ class MockAttachment(CustomMockMixin, unittest.mock.MagicMock):
     spec_set = attachment_instance
 
 
+message_reference_instance = discord.MessageReference(
+    message_id=unittest.mock.MagicMock(id=1),
+    channel_id=unittest.mock.MagicMock(id=2),
+    guild_id=unittest.mock.MagicMock(id=3)
+)
+
+
+class MockMessageReference(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock MessageReference objects.
+
+    Instances of this class will follow the specification of `discord.MessageReference` instances.
+    For more information, see the `MockGuild` docstring.
+    """
+    spec_set = message_reference_instance
+
+    def __init__(self, *, reference_author_is_bot: bool = False, **kwargs):
+        super().__init__(**kwargs)
+        referenced_msg_author = MockMember(name="bob", bot=reference_author_is_bot)
+        self.resolved = MockMessage(author=referenced_msg_author)
+
+
 class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Message objects.
-- 
cgit v1.2.3


From 8028690d4eae27e57dfe1429b8067eabaa94eef9 Mon Sep 17 00:00:00 2001
From: Aleksey Zasorin <zasorin.alek@gmail.com>
Date: Fri, 16 Sep 2022 10:42:16 -0700
Subject: Removed "redis_ready" from additional_spec_asyncs in MockBot (#2275)

The attribute was removed from Bot in fc05849
---
 tests/helpers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 687e15b96..a4b919dcb 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -317,7 +317,7 @@ class MockBot(CustomMockMixin, unittest.mock.MagicMock):
         guild_id=1,
         intents=discord.Intents.all(),
     )
-    additional_spec_asyncs = ("wait_for", "redis_ready")
+    additional_spec_asyncs = ("wait_for",)
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-- 
cgit v1.2.3