From 0eade4697bd76b9cc99e74777531ba00df558ff5 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 10:45:24 +0100
Subject: Add unit test for mentions antispam rule

---
 tests/bot/rules/test_mentions.py | 98 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 tests/bot/rules/test_mentions.py

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
new file mode 100644
index 000000000..520184c2f
--- /dev/null
+++ b/tests/bot/rules/test_mentions.py
@@ -0,0 +1,98 @@
+import unittest
+from typing import List, NamedTuple, Tuple
+
+from bot.rules import mentions
+from tests.helpers import async_test
+
+
+class FakeMessage(NamedTuple):
+    author: str
+    mentions: List[None]
+
+
+class Case(NamedTuple):
+    recent_messages: List[FakeMessage]
+    relevant_messages: Tuple[FakeMessage]
+    culprit: str
+    total_mentions: int
+
+
+def msg(author: str, total_mentions: int) -> FakeMessage:
+    return FakeMessage(author=author, mentions=[None] * total_mentions)
+
+
+class TestMentions(unittest.TestCase):
+    """Tests applying the `mentions` antispam rule."""
+
+    def setUp(self):
+        self.config = {
+            "max": 2,
+            "interval": 10
+        }
+
+    @async_test
+    async def test_mentions_within_limit(self):
+        """Messages with an allowed amount of mentions."""
+        cases = (
+            [msg("bob", 0)],
+            [msg("bob", 2)],
+            [msg("bob", 1), msg("bob", 1)],
+            [msg("bob", 1), msg("alice", 2)]
+        )
+
+        for recent_messages in cases:
+            last_message = recent_messages[0]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                config=self.config
+            ):
+                self.assertIsNone(
+                    await mentions.apply(last_message, recent_messages, self.config)
+                )
+
+    @async_test
+    async def test_mentions_exceeding_limit(self):
+        """Messages with a higher than allowed amount of mentions."""
+        cases = (
+            Case(
+                [msg("bob", 3)],
+                (msg("bob", 3),),
+                ("bob",),
+                3
+            ),
+            Case(
+                [msg("alice", 2), msg("alice", 0), msg("alice", 1)],
+                (msg("alice", 2), msg("alice", 0), msg("alice", 1)),
+                ("alice",),
+                3
+            ),
+            Case(
+                [msg("bob", 2), msg("alice", 3), msg("bob", 2)],
+                (msg("bob", 2), msg("bob", 2)),
+                ("bob",),
+                4
+            )
+        )
+
+        for recent_messages, relevant_messages, culprit, total_mentions in cases:
+            last_message = recent_messages[0]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                relevant_messages=relevant_messages,
+                culprit=culprit,
+                total_mentions=total_mentions,
+                cofig=self.config
+            ):
+                desired_output = (
+                    f"sent {total_mentions} mentions in {self.config['interval']}s",
+                    culprit,
+                    relevant_messages
+                )
+                self.assertTupleEqual(
+                    await mentions.apply(last_message, recent_messages, self.config),
+                    desired_output
+                )
-- 
cgit v1.2.3


From 187d419810759992e19a792fd746f26960f3831a Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 10:46:34 +0100
Subject: Add missing docstring

---
 tests/bot/rules/test_mentions.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index 520184c2f..987a42c0a 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -18,6 +18,7 @@ class Case(NamedTuple):
 
 
 def msg(author: str, total_mentions: int) -> FakeMessage:
+    """Makes a message with `total_mentions` mentions."""
     return FakeMessage(author=author, mentions=[None] * total_mentions)
 
 
-- 
cgit v1.2.3


From 32caead77e4bad04689892a29005faa3ffde2e83 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 10:50:54 +0100
Subject: Adjust docstring asterisk to backtick for consistency

---
 tests/bot/rules/test_links.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_links.py b/tests/bot/rules/test_links.py
index be832843b..40336beb0 100644
--- a/tests/bot/rules/test_links.py
+++ b/tests/bot/rules/test_links.py
@@ -18,7 +18,7 @@ class Case(NamedTuple):
 
 
 def msg(author: str, total_links: int) -> FakeMessage:
-    """Makes a message with *total_links* links."""
+    """Makes a message with `total_links` links."""
     content = " ".join(["https://pydis.com"] * total_links)
     return FakeMessage(author=author, content=content)
 
-- 
cgit v1.2.3


From b87a98c7749edfeb9fbc368f2bf9a7ecb9434662 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 10:54:26 +0100
Subject: Use range to build mock mentions list

---
 tests/bot/rules/test_mentions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index 987a42c0a..e1a971dbb 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -19,7 +19,7 @@ class Case(NamedTuple):
 
 def msg(author: str, total_mentions: int) -> FakeMessage:
     """Makes a message with `total_mentions` mentions."""
-    return FakeMessage(author=author, mentions=[None] * total_mentions)
+    return FakeMessage(author=author, mentions=list(range(total_mentions)))
 
 
 class TestMentions(unittest.TestCase):
-- 
cgit v1.2.3


From b1c6b4e20578395a5766ac116fd4def1df777de7 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 13:49:55 +0100
Subject: Adjust type hint to correctly represent internal type

---
 tests/bot/rules/test_mentions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index e1a971dbb..08dd1d6d5 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -7,7 +7,7 @@ from tests.helpers import async_test
 
 class FakeMessage(NamedTuple):
     author: str
-    mentions: List[None]
+    mentions: List[int]
 
 
 class Case(NamedTuple):
-- 
cgit v1.2.3


From f915782192fd7b631b23fa31e524cacdc8e72614 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 16:25:23 +0100
Subject: Use MockMessage instead of custom FakeMessage

---
 tests/bot/rules/test_mentions.py | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index 08dd1d6d5..e377f2164 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -2,24 +2,18 @@ import unittest
 from typing import List, NamedTuple, Tuple
 
 from bot.rules import mentions
-from tests.helpers import async_test
-
-
-class FakeMessage(NamedTuple):
-    author: str
-    mentions: List[int]
+from tests.helpers import MockMessage, async_test
 
 
 class Case(NamedTuple):
-    recent_messages: List[FakeMessage]
-    relevant_messages: Tuple[FakeMessage]
-    culprit: str
+    recent_messages: List[MockMessage, ...]
+    culprit: Tuple[str]
     total_mentions: int
 
 
-def msg(author: str, total_mentions: int) -> FakeMessage:
+def msg(author: str, total_mentions: int) -> MockMessage:
     """Makes a message with `total_mentions` mentions."""
-    return FakeMessage(author=author, mentions=list(range(total_mentions)))
+    return MockMessage(author=author, mentions=list(range(total_mentions)))
 
 
 class TestMentions(unittest.TestCase):
@@ -59,26 +53,28 @@ class TestMentions(unittest.TestCase):
         cases = (
             Case(
                 [msg("bob", 3)],
-                (msg("bob", 3),),
                 ("bob",),
                 3
             ),
             Case(
                 [msg("alice", 2), msg("alice", 0), msg("alice", 1)],
-                (msg("alice", 2), msg("alice", 0), msg("alice", 1)),
                 ("alice",),
                 3
             ),
             Case(
                 [msg("bob", 2), msg("alice", 3), msg("bob", 2)],
-                (msg("bob", 2), msg("bob", 2)),
                 ("bob",),
                 4
             )
         )
 
-        for recent_messages, relevant_messages, culprit, total_mentions in cases:
+        for recent_messages, culprit, total_mentions in cases:
             last_message = recent_messages[0]
+            relevant_messages = tuple(
+                msg
+                for msg in recent_messages
+                if msg.author == last_message.author
+            )
 
             with self.subTest(
                 last_message=last_message,
-- 
cgit v1.2.3


From 16e6c36c6b370300ef7507d2e01421ad0d83f407 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Sat, 9 Nov 2019 16:27:02 +0100
Subject: Adjust incorrect type hint

---
 tests/bot/rules/test_mentions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_mentions.py b/tests/bot/rules/test_mentions.py
index e377f2164..ad49ead32 100644
--- a/tests/bot/rules/test_mentions.py
+++ b/tests/bot/rules/test_mentions.py
@@ -6,7 +6,7 @@ from tests.helpers import MockMessage, async_test
 
 
 class Case(NamedTuple):
-    recent_messages: List[MockMessage, ...]
+    recent_messages: List[MockMessage]
     culprit: Tuple[str]
     total_mentions: int
 
-- 
cgit v1.2.3


From 2a9b1fc24ffe9679a565c0f9f4678357e9c80e44 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Wed, 13 Nov 2019 22:17:18 +0100
Subject: Adjust links rule to use proper MockMessage

---
 tests/bot/rules/test_links.py | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_links.py b/tests/bot/rules/test_links.py
index 40336beb0..02a5d5501 100644
--- a/tests/bot/rules/test_links.py
+++ b/tests/bot/rules/test_links.py
@@ -2,25 +2,19 @@ import unittest
 from typing import List, NamedTuple, Tuple
 
 from bot.rules import links
-from tests.helpers import async_test
-
-
-class FakeMessage(NamedTuple):
-    author: str
-    content: str
+from tests.helpers import MockMessage, async_test
 
 
 class Case(NamedTuple):
-    recent_messages: List[FakeMessage]
-    relevant_messages: Tuple[FakeMessage]
+    recent_messages: List[MockMessage]
     culprit: Tuple[str]
     total_links: int
 
 
-def msg(author: str, total_links: int) -> FakeMessage:
+def msg(author: str, total_links: int) -> MockMessage:
     """Makes a message with `total_links` links."""
     content = " ".join(["https://pydis.com"] * total_links)
-    return FakeMessage(author=author, content=content)
+    return MockMessage(author=author, content=content)
 
 
 class LinksTests(unittest.TestCase):
@@ -61,26 +55,28 @@ class LinksTests(unittest.TestCase):
         cases = (
             Case(
                 [msg("bob", 1), msg("bob", 2)],
-                (msg("bob", 1), msg("bob", 2)),
                 ("bob",),
                 3
             ),
             Case(
                 [msg("alice", 1), msg("alice", 1), msg("alice", 1)],
-                (msg("alice", 1), msg("alice", 1), msg("alice", 1)),
                 ("alice",),
                 3
             ),
             Case(
                 [msg("alice", 2), msg("bob", 3), msg("alice", 1)],
-                (msg("alice", 2), msg("alice", 1)),
                 ("alice",),
                 3
             )
         )
 
-        for recent_messages, relevant_messages, culprit, total_links in cases:
+        for recent_messages, culprit, total_links in cases:
             last_message = recent_messages[0]
+            relevant_messages = tuple(
+                msg
+                for msg in recent_messages
+                if msg.author == last_message.author
+            )
 
             with self.subTest(
                 last_message=last_message,
-- 
cgit v1.2.3


From a2617d197f4863123caa33076d89b7612a902d60 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Wed, 13 Nov 2019 22:42:25 +0100
Subject: Adjust attachments rule to use MockMessage, restructure test cases

---
 tests/bot/rules/test_attachments.py | 43 ++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 20 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index 4bb0acf7c..2f8294922 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -1,26 +1,17 @@
 import asyncio
 import unittest
-from dataclasses import dataclass
-from typing import Any, List
 
 from bot.rules import attachments
+from tests.helpers import MockMessage
 
 
-# Using `MagicMock` sadly doesn't work for this usecase
-# since it's __eq__ compares the MagicMock's ID. We just
-# want to compare the actual attributes we set.
-@dataclass
-class FakeMessage:
-    author: str
-    attachments: List[Any]
-
-
-def msg(total_attachments: int) -> FakeMessage:
-    return FakeMessage(author='lemon', attachments=list(range(total_attachments)))
+def msg(total_attachments: int) -> MockMessage:
+    """Builds a message with `total_attachments` attachments."""
+    return MockMessage(author='lemon', attachments=list(range(total_attachments)))
 
 
 class AttachmentRuleTests(unittest.TestCase):
-    """Tests applying the `attachment` antispam rule."""
+    """Tests applying the `attachments` antispam rule."""
 
     def test_allows_messages_without_too_many_attachments(self):
         """Messages without too many attachments are allowed as-is."""
@@ -38,13 +29,25 @@ class AttachmentRuleTests(unittest.TestCase):
     def test_disallows_messages_with_too_many_attachments(self):
         """Messages with too many attachments trigger the rule."""
         cases = (
-            ((msg(4), msg(0), msg(6)), [msg(4), msg(6)], 10),
-            ((msg(6),), [msg(6)], 6),
-            ((msg(1),) * 6, [msg(1)] * 6, 6),
+            ([msg(4), msg(0), msg(6)], 10),
+            ([msg(6)], 6),
+            ([msg(1)] * 6, 6),
         )
-        for messages, relevant_messages, total in cases:
-            with self.subTest(messages=messages, relevant_messages=relevant_messages, total=total):
-                last_message, *recent_messages = messages
+        for messages, total in cases:
+            last_message, *recent_messages = messages
+            relevant_messages = [last_message] + [
+                msg
+                for msg in recent_messages
+                if msg.author == last_message.author
+                and len(msg.attachments) > 0
+            ]
+
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages,
+                relevant_messages=relevant_messages,
+                total=total
+            ):
                 coro = attachments.apply(last_message, recent_messages, {'max': 5})
                 self.assertEqual(
                     asyncio.run(coro),
-- 
cgit v1.2.3


From dd098d91e35c2e333af14919d7405fe47f298ac2 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Wed, 13 Nov 2019 22:48:59 +0100
Subject: Use async_test helper to simplify coro testing

---
 tests/bot/rules/test_attachments.py | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index 2f8294922..770dd3201 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -1,8 +1,7 @@
-import asyncio
 import unittest
 
 from bot.rules import attachments
-from tests.helpers import MockMessage
+from tests.helpers import MockMessage, async_test
 
 
 def msg(total_attachments: int) -> MockMessage:
@@ -13,7 +12,8 @@ def msg(total_attachments: int) -> MockMessage:
 class AttachmentRuleTests(unittest.TestCase):
     """Tests applying the `attachments` antispam rule."""
 
-    def test_allows_messages_without_too_many_attachments(self):
+    @async_test
+    async def test_allows_messages_without_too_many_attachments(self):
         """Messages without too many attachments are allowed as-is."""
         cases = (
             (msg(0), msg(0), msg(0)),
@@ -22,17 +22,23 @@ class AttachmentRuleTests(unittest.TestCase):
         )
 
         for last_message, *recent_messages in cases:
-            with self.subTest(last_message=last_message, recent_messages=recent_messages):
-                coro = attachments.apply(last_message, recent_messages, {'max': 5})
-                self.assertIsNone(asyncio.run(coro))
+            with self.subTest(
+                last_message=last_message,
+                recent_messages=recent_messages
+            ):
+                self.assertIsNone(
+                    await attachments.apply(last_message, recent_messages, {'max': 5})
+                )
 
-    def test_disallows_messages_with_too_many_attachments(self):
+    @async_test
+    async def test_disallows_messages_with_too_many_attachments(self):
         """Messages with too many attachments trigger the rule."""
         cases = (
             ([msg(4), msg(0), msg(6)], 10),
             ([msg(6)], 6),
             ([msg(1)] * 6, 6),
         )
+
         for messages, total in cases:
             last_message, *recent_messages = messages
             relevant_messages = [last_message] + [
@@ -48,8 +54,7 @@ class AttachmentRuleTests(unittest.TestCase):
                 relevant_messages=relevant_messages,
                 total=total
             ):
-                coro = attachments.apply(last_message, recent_messages, {'max': 5})
                 self.assertEqual(
-                    asyncio.run(coro),
+                    await attachments.apply(last_message, recent_messages, {'max': 5}),
                     (f"sent {total} attachments in 5s", ('lemon',), relevant_messages)
                 )
-- 
cgit v1.2.3


From eef447a2c4e237a56b8f3cb72ee3e4bc54e7961c Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Thu, 14 Nov 2019 20:16:23 +0100
Subject: Adjust attachments rule unit test to correcty build the arguments for
 the tested rule

---
 tests/bot/rules/test_attachments.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index 770dd3201..a43741fcc 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -21,7 +21,9 @@ class AttachmentRuleTests(unittest.TestCase):
             (msg(0),),
         )
 
-        for last_message, *recent_messages in cases:
+        for recent_messages in cases:
+            last_message = recent_messages[0]
+
             with self.subTest(
                 last_message=last_message,
                 recent_messages=recent_messages
@@ -39,14 +41,16 @@ class AttachmentRuleTests(unittest.TestCase):
             ([msg(1)] * 6, 6),
         )
 
-        for messages, total in cases:
-            last_message, *recent_messages = messages
-            relevant_messages = [last_message] + [
+        for recent_messages, total in cases:
+            last_message = recent_messages[0]
+            relevant_messages = tuple(
                 msg
                 for msg in recent_messages
-                if msg.author == last_message.author
-                and len(msg.attachments) > 0
-            ]
+                if (
+                    msg.author == last_message.author
+                    and len(msg.attachments) > 0
+                )
+            )
 
             with self.subTest(
                 last_message=last_message,
-- 
cgit v1.2.3


From 37b526f372ebc981f5691c5aca1ca8c721da77f6 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Thu, 14 Nov 2019 20:18:57 +0100
Subject: Hold recent_messages in a list to respect type hint, set config in
 setUp

---
 tests/bot/rules/test_attachments.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index a43741fcc..fa6b63654 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -12,13 +12,16 @@ def msg(total_attachments: int) -> MockMessage:
 class AttachmentRuleTests(unittest.TestCase):
     """Tests applying the `attachments` antispam rule."""
 
+    def setUp(self):
+        self.config = {"max": 5}
+
     @async_test
     async def test_allows_messages_without_too_many_attachments(self):
         """Messages without too many attachments are allowed as-is."""
         cases = (
-            (msg(0), msg(0), msg(0)),
-            (msg(2), msg(2)),
-            (msg(0),),
+            [msg(0), msg(0), msg(0)],
+            [msg(2), msg(2)],
+            [msg(0)],
         )
 
         for recent_messages in cases:
@@ -29,7 +32,7 @@ class AttachmentRuleTests(unittest.TestCase):
                 recent_messages=recent_messages
             ):
                 self.assertIsNone(
-                    await attachments.apply(last_message, recent_messages, {'max': 5})
+                    await attachments.apply(last_message, recent_messages, self.config)
                 )
 
     @async_test
@@ -59,6 +62,6 @@ class AttachmentRuleTests(unittest.TestCase):
                 total=total
             ):
                 self.assertEqual(
-                    await attachments.apply(last_message, recent_messages, {'max': 5}),
+                    await attachments.apply(last_message, recent_messages, self.config),
                     (f"sent {total} attachments in 5s", ('lemon',), relevant_messages)
                 )
-- 
cgit v1.2.3


From 01731a8873f13cc8a85d08147941ffba7284cf20 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Thu, 14 Nov 2019 20:33:12 +0100
Subject: Make complex test cases namedtuples, recognize between various
 authors, pass config to subTest

---
 tests/bot/rules/test_attachments.py | 55 +++++++++++++++++++++++++++++--------
 1 file changed, 43 insertions(+), 12 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index fa6b63654..d8d1b341f 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -1,12 +1,19 @@
 import unittest
+from typing import List, NamedTuple, Tuple
 
 from bot.rules import attachments
 from tests.helpers import MockMessage, async_test
 
 
-def msg(total_attachments: int) -> MockMessage:
+class Case(NamedTuple):
+    recent_messages: List[MockMessage]
+    culprit: Tuple[str]
+    total_attachments: int
+
+
+def msg(author: str, total_attachments: int) -> MockMessage:
     """Builds a message with `total_attachments` attachments."""
-    return MockMessage(author='lemon', attachments=list(range(total_attachments)))
+    return MockMessage(author=author, attachments=list(range(total_attachments)))
 
 
 class AttachmentRuleTests(unittest.TestCase):
@@ -19,9 +26,9 @@ class AttachmentRuleTests(unittest.TestCase):
     async def test_allows_messages_without_too_many_attachments(self):
         """Messages without too many attachments are allowed as-is."""
         cases = (
-            [msg(0), msg(0), msg(0)],
-            [msg(2), msg(2)],
-            [msg(0)],
+            [msg("bob", 0), msg("bob", 0), msg("bob", 0)],
+            [msg("bob", 2), msg("bob", 2)],
+            [msg("bob", 2), msg("alice", 2), msg("bob", 2)],
         )
 
         for recent_messages in cases:
@@ -29,7 +36,8 @@ class AttachmentRuleTests(unittest.TestCase):
 
             with self.subTest(
                 last_message=last_message,
-                recent_messages=recent_messages
+                recent_messages=recent_messages,
+                config=self.config
             ):
                 self.assertIsNone(
                     await attachments.apply(last_message, recent_messages, self.config)
@@ -39,12 +47,29 @@ class AttachmentRuleTests(unittest.TestCase):
     async def test_disallows_messages_with_too_many_attachments(self):
         """Messages with too many attachments trigger the rule."""
         cases = (
-            ([msg(4), msg(0), msg(6)], 10),
-            ([msg(6)], 6),
-            ([msg(1)] * 6, 6),
+            Case(
+                [msg("bob", 4), msg("bob", 0), msg("bob", 6)],
+                ("bob",),
+                10
+            ),
+            Case(
+                [msg("bob", 4), msg("alice", 6), msg("bob", 2)],
+                ("bob",),
+                6
+            ),
+            Case(
+                [msg("alice", 6)],
+                ("alice",),
+                6
+            ),
+            (
+                [msg("alice", 1) for _ in range(6)],
+                ("alice",),
+                6
+            ),
         )
 
-        for recent_messages, total in cases:
+        for recent_messages, culprit, total_attachments in cases:
             last_message = recent_messages[0]
             relevant_messages = tuple(
                 msg
@@ -59,9 +84,15 @@ class AttachmentRuleTests(unittest.TestCase):
                 last_message=last_message,
                 recent_messages=recent_messages,
                 relevant_messages=relevant_messages,
-                total=total
+                total_attachments=total_attachments,
+                config=self.config
             ):
+                desired_output = (
+                    f"sent {total_attachments} attachments in {self.config['max']}s",
+                    culprit,
+                    relevant_messages
+                )
                 self.assertEqual(
                     await attachments.apply(last_message, recent_messages, self.config),
-                    (f"sent {total} attachments in 5s", ('lemon',), relevant_messages)
+                    desired_output
                 )
-- 
cgit v1.2.3


From c74a6c4fb16052c00041b94c3a3e2ef10efe9827 Mon Sep 17 00:00:00 2001
From: kwzrd <kay.wzrd@gmail.com>
Date: Thu, 14 Nov 2019 20:34:00 +0100
Subject: Specify assertion to be a tuple comparison

---
 tests/bot/rules/test_attachments.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_attachments.py b/tests/bot/rules/test_attachments.py
index d8d1b341f..d7187f315 100644
--- a/tests/bot/rules/test_attachments.py
+++ b/tests/bot/rules/test_attachments.py
@@ -92,7 +92,7 @@ class AttachmentRuleTests(unittest.TestCase):
                     culprit,
                     relevant_messages
                 )
-                self.assertEqual(
+                self.assertTupleEqual(
                     await attachments.apply(last_message, recent_messages, self.config),
                     desired_output
                 )
-- 
cgit v1.2.3


From e07cf7342184b769d8c0655bc9b84be02809319a Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Wed, 4 Dec 2019 23:38:46 +0700
Subject: Added `unittest` for `bot.utils.time`

---
 tests/bot/utils/test_time.py | 87 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 tests/bot/utils/test_time.py

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
new file mode 100644
index 000000000..0ef59292e
--- /dev/null
+++ b/tests/bot/utils/test_time.py
@@ -0,0 +1,87 @@
+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 setUp(self):
+        pass
+
+    def test_humanize_delta(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'),
+
+            # Does not abort for unknown units, as the unit name is checked
+            # against the attribute of the relativedelta instance.
+            (relativedelta(days=2, hours=2), 'elephants', 2, '2 days and 2 hours'),
+
+            # Very high maximum units, but it only ever iterates over
+            # each value the relativedelta might have.
+            (relativedelta(days=2, hours=2), 'hours', 20, '2 days and 2 hours'),
+        )
+
+        for delta, precision, max_units, expected in test_cases:
+            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+
+    def test_humanize_delta_raises_for_invalid_max_units(self):
+        test_cases = (-1, 0)
+
+        for max_units in test_cases:
+            with 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."""
+        test_cases = (
+            ('Sun, 15 Sep 2019 12:00:00 GMT', datetime(2019, 9, 15, 12, 0, 0, tzinfo=timezone.utc)),
+        )
+
+        for stamp, expected in test_cases:
+            self.assertEqual(time.parse_rfc1123(stamp), expected)
+
+    @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
+        assert asyncio.run(time.wait_until(then, start)) is None
+
+        mock.assert_called_once_with(10 * 60)
+
+    def test_format_infraction_with_duration(self):
+        """Testing format_infraction_with_duration."""
+        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:01:00Z', datetime(2019, 12, 11, 12, 5, 5), 6,
+             '2019-12-12 00:01 (11 hours, 55 minutes and 55 seconds)'),
+            ('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:09:00Z', datetime(2019, 4, 25, 20, 15), 6,
+             '2019-11-23 20:09 (6 months, 28 days, 23 hours and 54 minutes)'),
+            ('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:
+            self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
-- 
cgit v1.2.3


From b17dbe5e3e0dfa6ae44d660924455f709abefd0d Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 00:34:58 +0700
Subject: Splitting test cases for `humanize_delta` into proper, independent
 tests.

---
 tests/bot/utils/test_time.py | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 0ef59292e..5e5f2bf2f 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -15,18 +15,20 @@ class TimeTests(unittest.TestCase):
     def setUp(self):
         pass
 
-    def test_humanize_delta(self):
-        """Testing humanize delta."""
+    def test_humanize_delta_handle_unknown_units(self):
+        """humanize_delta should be able to handle unknown units, and will not abort."""
         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'),
-
             # Does not abort for unknown units, as the unit name is checked
             # against the attribute of the relativedelta instance.
             (relativedelta(days=2, hours=2), 'elephants', 2, '2 days and 2 hours'),
+        )
 
+        for delta, precision, max_units, expected in test_cases:
+            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+
+    def test_humanize_delta_handle_high_units(self):
+        """humanize_delta should be able to handle very high units."""
+        test_cases = (
             # Very high maximum units, but it only ever iterates over
             # each value the relativedelta might have.
             (relativedelta(days=2, hours=2), 'hours', 20, '2 days and 2 hours'),
@@ -35,6 +37,18 @@ class TimeTests(unittest.TestCase):
         for delta, precision, max_units, expected in test_cases:
             self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
 
+    def test_humanize_delta_should_work_normally(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:
+            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+
     def test_humanize_delta_raises_for_invalid_max_units(self):
         test_cases = (-1, 0)
 
-- 
cgit v1.2.3


From 0aee728d6d23ef24f51834f39016f938f3f1b8a9 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 00:36:29 +0700
Subject: Added missing docstring for
 `test_humanize_delta_raises_for_invalid_max_units`

---
 tests/bot/utils/test_time.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 5e5f2bf2f..a929bee89 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -50,6 +50,7 @@ class TimeTests(unittest.TestCase):
             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:
-- 
cgit v1.2.3


From beed21355e7f0e25b69637768843c53d510b8969 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 00:40:38 +0700
Subject: Changed `assert` to `self.assertIs` for `test_wait_until`

---
 tests/bot/utils/test_time.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index a929bee89..0afabe400 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -74,7 +74,7 @@ class TimeTests(unittest.TestCase):
         then = datetime(2019, 1, 1, 0, 10)
 
         # No return value
-        assert asyncio.run(time.wait_until(then, start)) is None
+        self.assertIs(asyncio.run(time.wait_until(then, start)), None)
 
         mock.assert_called_once_with(10 * 60)
 
-- 
cgit v1.2.3


From ccdd8363d75846f0841791ba54763dae28243c62 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 00:45:36 +0700
Subject: Splitting test cases for `format_infraction_with_duration` into
 proper, independent tests.

---
 tests/bot/utils/test_time.py | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 0afabe400..2a2a707d8 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -37,7 +37,7 @@ class TimeTests(unittest.TestCase):
         for delta, precision, max_units, expected in test_cases:
             self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
 
-    def test_humanize_delta_should_work_normally(self):
+    def test_humanize_delta_should_normal_usage(self):
         """Testing humanize delta."""
         test_cases = (
             (relativedelta(days=2), 'seconds', 1, '2 days'),
@@ -78,18 +78,38 @@ class TimeTests(unittest.TestCase):
 
         mock.assert_called_once_with(10 * 60)
 
-    def test_format_infraction_with_duration(self):
-        """Testing format_infraction_with_duration."""
+    def test_format_infraction_with_duration_none_expiry(self):
+        """format_infraction_with_duration should work for None expiry."""
+        self.assertEqual(time.format_infraction_with_duration(None), None)
+
+        # To make sure that date_from and max_units are not touched
+        self.assertEqual(time.format_infraction_with_duration(None, date_from='Why hello there!'), None)
+        self.assertEqual(time.format_infraction_with_duration(None, max_units=float('inf')), None)
+        self.assertEqual(
+            time.format_infraction_with_duration(None, date_from='Why hello there!', max_units=float('inf')),
+            None
+        )
+
+    def test_format_infraction_with_duration_custom_units(self):
+        """format_infraction_with_duration should work for custom max_units."""
+        self.assertEqual(
+            time.format_infraction_with_duration('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)'
+        )
+
+        self.assertEqual(
+            time.format_infraction_with_duration('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)'
+        )
+
+    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:01:00Z', datetime(2019, 12, 11, 12, 5, 5), 6,
-             '2019-12-12 00:01 (11 hours, 55 minutes and 55 seconds)'),
             ('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:09:00Z', datetime(2019, 4, 25, 20, 15), 6,
-             '2019-11-23 20:09 (6 months, 28 days, 23 hours and 54 minutes)'),
             ('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)'),
-- 
cgit v1.2.3


From fa66195dbb6f79bb7174084835499a61e8cb03a3 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 00:52:15 +0700
Subject: Introduced test for `test_format_infraction`, refactored
 `test_parse_rfc1123`, fixed typo.

---
 tests/bot/utils/test_time.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 2a2a707d8..09fb824e4 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -50,7 +50,7 @@ class TimeTests(unittest.TestCase):
             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."""
+        """humanize_delta should raises ValueError('max_units must be positive') for invalid max_units."""
         test_cases = (-1, 0)
 
         for max_units in test_cases:
@@ -60,12 +60,14 @@ class TimeTests(unittest.TestCase):
 
     def test_parse_rfc1123(self):
         """Testing parse_rfc1123."""
-        test_cases = (
-            ('Sun, 15 Sep 2019 12:00:00 GMT', datetime(2019, 9, 15, 12, 0, 0, tzinfo=timezone.utc)),
+        self.assertEqual(
+            time.parse_rfc1123('Sun, 15 Sep 2019 12:00:00 GMT'),
+            datetime(2019, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
         )
 
-        for stamp, expected in test_cases:
-            self.assertEqual(time.parse_rfc1123(stamp), expected)
+    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):
-- 
cgit v1.2.3


From 5e0b19ae841f3f355931ad331f7aa861fbafc4d9 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 01:05:41 +0700
Subject: Added `self.subTest` for tests with multiple test cases & simplified
 single test case tests.

---
 tests/bot/utils/test_time.py | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 09fb824e4..c47a306f0 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -17,25 +17,15 @@ class TimeTests(unittest.TestCase):
 
     def test_humanize_delta_handle_unknown_units(self):
         """humanize_delta should be able to handle unknown units, and will not abort."""
-        test_cases = (
-            # Does not abort for unknown units, as the unit name is checked
-            # against the attribute of the relativedelta instance.
-            (relativedelta(days=2, hours=2), 'elephants', 2, '2 days and 2 hours'),
-        )
-
-        for delta, precision, max_units, expected in test_cases:
-            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+        # 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."""
-        test_cases = (
-            # Very high maximum units, but it only ever iterates over
-            # each value the relativedelta might have.
-            (relativedelta(days=2, hours=2), 'hours', 20, '2 days and 2 hours'),
-        )
-
-        for delta, precision, max_units, expected in test_cases:
-            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+        # 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."""
@@ -47,14 +37,15 @@ class TimeTests(unittest.TestCase):
         )
 
         for delta, precision, max_units, expected in test_cases:
-            self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+            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.assertRaises(ValueError) as error:
+            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')
 
@@ -121,4 +112,5 @@ class TimeTests(unittest.TestCase):
         )
 
         for expiry, date_from, max_units, expected in test_cases:
-            self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+            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)
-- 
cgit v1.2.3


From db341d927aab42c2e874cb499ab1c2e6c0e7647b Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 01:17:56 +0700
Subject: Moved all individual test cases into iterables and test with
 `self.subTest` context manager.

---
 tests/bot/utils/test_time.py | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index c47a306f0..25cd3f69f 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -73,27 +73,31 @@ class TimeTests(unittest.TestCase):
 
     def test_format_infraction_with_duration_none_expiry(self):
         """format_infraction_with_duration should work for None expiry."""
-        self.assertEqual(time.format_infraction_with_duration(None), None)
+        test_cases = (
+            (None, None, None, None),
 
-        # To make sure that date_from and max_units are not touched
-        self.assertEqual(time.format_infraction_with_duration(None, date_from='Why hello there!'), None)
-        self.assertEqual(time.format_infraction_with_duration(None, max_units=float('inf')), None)
-        self.assertEqual(
-            time.format_infraction_with_duration(None, date_from='Why hello there!', max_units=float('inf')),
-            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."""
-        self.assertEqual(
-            time.format_infraction_with_duration('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)'
+        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)')
         )
 
-        self.assertEqual(
-            time.format_infraction_with_duration('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."""
-- 
cgit v1.2.3


From 323306776b0312e2a32ada213a35159311a93a7f Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Thu, 5 Dec 2019 01:42:23 +0700
Subject: Removed `setUp()` from `TimeTests` since it is not being used for
 anything.

---
 tests/bot/utils/test_time.py | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 25cd3f69f..7f55dc3ec 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -12,9 +12,6 @@ from tests.helpers import AsyncMock
 class TimeTests(unittest.TestCase):
     """Test helper functions in bot.utils.time."""
 
-    def setUp(self):
-        pass
-
     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
-- 
cgit v1.2.3


From 520346d0b472e5cb6c9091a8323b871d2e3821cc Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Fri, 13 Dec 2019 09:18:49 +0700
Subject: Added tests for `until_expiration`

Similar to `format_infraction_with_duration` ( if not outright copying it ), added 3 tests for `until_expiration`:
- None `expiry`.
- Custom `max_units`.
- Normal use cases.
---
 tests/bot/utils/test_time.py | 45 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 7f55dc3ec..bd04de28b 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -115,3 +115,48 @@ class TimeTests(unittest.TestCase):
         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 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, 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)
-- 
cgit v1.2.3


From 66d4b93593b95bfa6999b70aca53328d83710c44 Mon Sep 17 00:00:00 2001
From: Shirayuki Nekomata <lethienphuoc1991@gmail.com>
Date: Fri, 13 Dec 2019 09:29:06 +0700
Subject: Fixed a typo ( due to poor copy pasta and eyeballing skills )

---
 tests/bot/utils/test_time.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index bd04de28b..69f35f2f5 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -121,7 +121,7 @@ class TimeTests(unittest.TestCase):
         test_cases = (
             (None, None, None, None),
 
-            # To make sure that date_from and max_units are not touched
+            # 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),
-- 
cgit v1.2.3


From d169fbf9204b8a35ad09ab0141eedd873f8bdddf Mon Sep 17 00:00:00 2001
From: Matteo Bertucci <matteobertucci2004@gmail.com>
Date: Thu, 30 Jan 2020 18:17:12 +0100
Subject: Add additional resources to the test readme

---
 tests/README.md | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'tests')

diff --git a/tests/README.md b/tests/README.md
index d052de2f6..c3551bd54 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -212,3 +212,9 @@ All in all, it's not only important to consider if all statements or branches we
 Another restriction of unit testing is that it tests, well, in units. Even if we can guarantee that the units work as they should independently, we have no guarantee that they will actually work well together. Even more, while the mocking described above gives us a lot of flexibility in factoring out external code, we are work under the implicit assumption that we fully understand those external parts and utilize it correctly. What if our mocked `Context` object works with a `send` method, but `discord.py` has changed it to a `send_message` method in a recent update? It could mean our tests are passing, but the code it's testing still doesn't work in production.
 
 The answer to this is that we also need to make sure that the individual parts come together into a working application. In addition, we will also need to make sure that the application communicates correctly with external applications. Since we currently have no automated integration tests or functional tests, that means **it's still very important to fire up the bot and test the code you've written manually** in addition to the unit tests you've written.
+
+## Additional resources
+
+* [Corey Schafer video about unittest](https://youtu.be/6tNS--WetLI)
+* [RealPython tutorial on unittest testing](https://realpython.com/python-testing/)
+* [RealPython tutorial on mocking](https://realpython.com/python-mock-library/)
-- 
cgit v1.2.3


From e518dc2193f0f1ed31217e6097c2c6cdbc36e0e1 Mon Sep 17 00:00:00 2001
From: Matteo Bertucci <matteobertucci2004@gmail.com>
Date: Thu, 30 Jan 2020 19:04:21 +0100
Subject: Merge the note with the additional resources section
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Move the link to Ned Batchelder’s talk and link the note to the section
---
 tests/README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/README.md b/tests/README.md
index c3551bd54..be78821bf 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -2,7 +2,7 @@
 
 Our bot is one of the most important tools we have for running our community. As we don't want that tool break, we decided that we wanted to write unit tests for it. We hope that in the future, we'll have a 100% test coverage for the bot. This guide will help you get started with writing the tests needed to achieve that.
 
-_**Note:** This is a practical guide to getting started with writing tests for our bot, not a general introduction to writing unit tests in Python. If you're looking for a more general introduction, you may like Corey Schafer's [Python Tutorial: Unit Testing Your Code with the unittest Module](https://www.youtube.com/watch?v=6tNS--WetLI) or Ned Batchelder's PyCon talk [Getting Started Testing](https://www.youtube.com/watch?v=FxSsnHeWQBY)._
+_**Note:** This is a practical guide to getting started with writing tests for our bot, not a general introduction to writing unit tests in Python. If you're looking for a more general introduction, you can take a look at the [Additional resources](#additional-resources) section at the bottom of this page._
 
 ## Tools
 
@@ -215,6 +215,7 @@ The answer to this is that we also need to make sure that the individual parts c
 
 ## Additional resources
 
+* [Ned Batchelder's PyCon talk: Getting Started Testing](https://www.youtube.com/watch?v=FxSsnHeWQBY)
 * [Corey Schafer video about unittest](https://youtu.be/6tNS--WetLI)
 * [RealPython tutorial on unittest testing](https://realpython.com/python-testing/)
 * [RealPython tutorial on mocking](https://realpython.com/python-mock-library/)
-- 
cgit v1.2.3