Use global bot instance in send_to_paste_service

5 files changed, 28 insertions, 27 deletions

diff --git a/bot/exts/utils/internal.py b/bot/exts/utils/internal.py
index 1b4900f42..a6bc60026 100644
--- a/bot/exts/utils/internal.py
+++ b/bot/exts/utils/internal.py
@@ -195,7 +195,7 @@ async def func():  # (None,) -> Any
             truncate_index = newline_truncate_index
 
         if len(out) > truncate_index:
-            paste_link = await send_to_paste_service(self.bot.http_session, out, extension="py")
+            paste_link = await send_to_paste_service(out, extension="py")
             if paste_link is not None:
                 paste_text = f"full contents at {paste_link}"
             else:
diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index 59a27a2be..e727be39e 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -72,7 +72,7 @@ class Snekbox(Cog):
         if len(output) > MAX_PASTE_LEN:
             log.info("Full output is too long to upload")
             return "too long to upload"
-        return await send_to_paste_service(self.bot.http_session, output, extension="txt")
+        return await send_to_paste_service(output, extension="txt")
 
     @staticmethod
     def prepare_input(code: str) -> str:
diff --git a/bot/utils/services.py b/bot/utils/services.py
index 087b9f969..5949c9e48 100644
--- a/bot/utils/services.py
+++ b/bot/utils/services.py
@@ -1,8 +1,9 @@
 import logging
 from typing import Optional
 
-from aiohttp import ClientConnectorError, ClientSession
+from aiohttp import ClientConnectorError
 
+import bot
 from bot.constants import URLs
 
 log = logging.getLogger(__name__)
@@ -10,11 +11,10 @@ log = logging.getLogger(__name__)
 FAILED_REQUEST_ATTEMPTS = 3
 
 
-async def send_to_paste_service(http_session: ClientSession, contents: str, *, extension: str = "") -> Optional[str]:
+async def send_to_paste_service(contents: str, *, extension: str = "") -> Optional[str]:
     """
     Upload `contents` to the paste service.
 
-    `http_session` should be the current running ClientSession from aiohttp
     `extension` is added to the output URL
 
     When an error occurs, `None` is returned, otherwise the generated URL with the suffix.
@@ -24,7 +24,7 @@ async def send_to_paste_service(http_session: ClientSession, contents: str, *, e
     paste_url = URLs.paste_service.format(key="documents")
     for attempt in range(1, FAILED_REQUEST_ATTEMPTS + 1):
         try:
-            async with http_session.post(paste_url, data=contents) as response:
+            async with bot.instance.http_session.post(paste_url, data=contents) as response:
                 response_json = await response.json()
         except ClientConnectorError:
             log.warning(
diff --git a/tests/bot/exts/utils/test_snekbox.py b/tests/bot/exts/utils/test_snekbox.py
index 6601fad2c..9d3e07e7c 100644
--- a/tests/bot/exts/utils/test_snekbox.py
+++ b/tests/bot/exts/utils/test_snekbox.py
@@ -42,9 +42,7 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
     async def test_upload_output(self, mock_paste_util):
         """Upload the eval output to the URLs.paste_service.format(key="documents") endpoint."""
         await self.cog.upload_output("Test output.")
-        mock_paste_util.assert_called_once_with(
-            self.bot.http_session, "Test output.", extension="txt"
-        )
+        mock_paste_util.assert_called_once_with("Test output.", extension="txt")
 
     def test_prepare_input(self):
         cases = (
diff --git a/tests/bot/utils/test_services.py b/tests/bot/utils/test_services.py
index 5e0855704..1b48f6560 100644
--- a/tests/bot/utils/test_services.py
+++ b/tests/bot/utils/test_services.py
@@ -5,11 +5,14 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 from aiohttp import ClientConnectorError
 
 from bot.utils.services import FAILED_REQUEST_ATTEMPTS, send_to_paste_service
+from tests.helpers import MockBot
 
 
 class PasteTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
-        self.http_session = MagicMock()
+        patcher = patch("bot.instance", new=MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_url_and_sent_contents(self):
@@ -17,10 +20,10 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": ""})
         )
-        self.http_session.post().__aenter__.return_value = response
-        self.http_session.post.reset_mock()
-        await send_to_paste_service(self.http_session, "Content")
-        self.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
+        self.bot.http_session.post.reset_mock()
+        await send_to_paste_service("Content")
+        self.bot.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_paste_returns_correct_url_on_success(self):
@@ -34,41 +37,41 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": key})
         )
-        self.http_session.post().__aenter__.return_value = response
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
 
         for expected_output, extension in test_cases:
             with self.subTest(msg=f"Send contents with extension {repr(extension)}"):
                 self.assertEqual(
-                    await send_to_paste_service(self.http_session, "", extension=extension),
+                    await send_to_paste_service("", extension=extension),
                     expected_output
                 )
 
     async def test_request_repeated_on_json_errors(self):
         """Json with error message and invalid json are handled as errors and requests repeated."""
         test_cases = ({"message": "error"}, {"unexpected_key": None}, {})
-        self.http_session.post().__aenter__.return_value = response = MagicMock()
-        self.http_session.post.reset_mock()
+        self.bot.http_session.post.return_value.__aenter__.return_value = response = MagicMock()
+        self.bot.http_session.post.reset_mock()
 
         for error_json in test_cases:
             with self.subTest(error_json=error_json):
                 response.json = AsyncMock(return_value=error_json)
-                result = await send_to_paste_service(self.http_session, "")
-                self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+                result = await send_to_paste_service("")
+                self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
                 self.assertIsNone(result)
 
-            self.http_session.post.reset_mock()
+            self.bot.http_session.post.reset_mock()
 
     async def test_request_repeated_on_connection_errors(self):
         """Requests are repeated in the case of connection errors."""
-        self.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertIsNone(result)
 
     async def test_general_error_handled_and_request_repeated(self):
         """All `Exception`s are handled, logged and request repeated."""
-        self.http_session.post = MagicMock(side_effect=Exception)
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=Exception)
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertLogs("bot.utils", logging.ERROR)
         self.assertIsNone(result)