aa-killtracker 0.17.0__py3-none-any.whl → 0.18.0a2__py3-none-any.whl

killtracker/tests/core/test_killmails.py

@@ -1,9 +1,8 @@
+import datetime as dt
 import unittest
-from datetime import timedelta
 from unittest.mock import patch
 
 import requests_mock
-from redis.exceptions import LockError
 
 from django.core.cache import cache
 from django.core.exceptions import ImproperlyConfigured
@@ -18,6 +17,7 @@ from killtracker.core.killmails import (
     ZKB_API_URL,
     ZKB_REDISQ_URL,
     Killmail,
+    ZKBTooManyRequestsError,
     _EntityCount,
 )
 from killtracker.exceptions import KillmailDoesNotExist
@@ -31,11 +31,12 @@ requests_mock.mock.case_sensitive = True
 
 
 @requests_mock.Mocker()
-@patch(MODULE_PATH + ".get_redis_client")
+@patch(MODULE_PATH + ".cache")
 class TestCreateFromZkbRedisq(NoSocketsTestCase):
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_return_killmail(self, requests_mocker, mock_redis):
+    def test_should_return_killmail(self, requests_mocker, mock_cache):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
             ZKB_REDISQ_URL,
@@ -48,7 +49,7 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self.assertIsNotNone(killmail)
         self.assertEqual(killmail.id, 10000001)
         self.assertEqual(killmail.solar_system_id, 30004984)
-        self.assertAlmostEqual(killmail.time, now(), delta=timedelta(seconds=120))
+        self.assertAlmostEqual(killmail.time, now(), delta=dt.timedelta(seconds=120))
         self.assertEqual(killmail.victim.alliance_id, 3011)
         self.assertEqual(killmail.victim.character_id, 1011)
         self.assertEqual(killmail.victim.corporation_id, 2011)
@@ -75,9 +76,10 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
     def test_should_return_none_when_zkb_returns_empty_package(
-        self, requests_mocker, mock_redis
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
@@ -88,9 +90,10 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
     def test_should_handle_zkb_data_has_no_solar_system(
-        self, requests_mocker, mock_redis
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
             ZKB_REDISQ_URL,
@@ -103,23 +106,48 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self.assertIsNotNone(killmail)
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_return_none_when_zkb_returns_429_error(
-        self, requests_mocker, mock_redis
-    ):
+    def test_should_return_none_when_http_error(self, requests_mocker, mock_cache):
         # given
-        requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=429, text="429 too many requests"
-        )
+        mock_cache.get.return_value = None
+        requests_mocker.register_uri("GET", ZKB_REDISQ_URL, status_code=500)
         # when
         killmail = Killmail.create_from_zkb_redisq()
         # then
         self.assertIsNone(killmail)
 
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    def test_should_return_raise_too_many_requests_error(
+        self, requests_mocker, mock_cache
+    ):
+        # given
+        mock_cache.get.return_value = None
+        requests_mocker.register_uri(
+            "GET", ZKB_REDISQ_URL, status_code=429, text="429 too many requests"
+        )
+        # when/then
+        with self.assertRaises(ZKBTooManyRequestsError):
+            Killmail.create_from_zkb_redisq()
+
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    def test_should_reraise_too_many_requests_error_when_ongoing(
+        self, requests_mocker, mock_cache
+    ):
+        # given
+        retry_at = now() + dt.timedelta(hours=3)
+        mock_cache.get.return_value = retry_at.isoformat()
+        requests_mocker.register_uri("GET", ZKB_REDISQ_URL, status_code=500)
+        # when/then
+        self.assertEqual(requests_mocker.call_count, 0)
+        with self.assertRaises(ZKBTooManyRequestsError) as ex:
+            Killmail.create_from_zkb_redisq()
+        self.assertEqual(retry_at, ex.exception.retry_at)
+
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
     def test_should_return_none_when_zkb_returns_general_error(
-        self, requests_mocker, mock_redis
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
             ZKB_REDISQ_URL,
@@ -135,9 +163,10 @@ You can only have one request to listen.php in flight at any time, otherwise you
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
     def test_should_return_none_when_zkb_does_not_return_json(
-        self, requests_mocker, mock_redis
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, text="this is not JSON"
         )
@@ -146,18 +175,10 @@ You can only have one request to listen.php in flight at any time, otherwise you
         # then
         self.assertIsNone(killmail)
 
-    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_return_none_if_lock_not_acquired(self, requests_mocker, mock_redis):
-        # given
-        mock_redis.return_value.lock.side_effect = LockError
-        # when
-        killmail = Killmail.create_from_zkb_redisq()
-        # then
-        self.assertIsNone(killmail)
-
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "Voltron9000")
-    def test_should_have_queue_id_in_request(self, requests_mocker, mock_redis):
+    def test_should_have_queue_id_in_request(self, requests_mocker, mock_cache):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
@@ -171,8 +192,9 @@ You can only have one request to listen.php in flight at any time, otherwise you
         self.assertEqual(queue_id[0], "Voltron9000")
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "")
-    def test_should_abort_when_no_queue_id_defined(self, requests_mocker, mock_redis):
+    def test_should_abort_when_no_queue_id_defined(self, requests_mocker, mock_cache):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
@@ -181,8 +203,9 @@ You can only have one request to listen.php in flight at any time, otherwise you
             Killmail.create_from_zkb_redisq()
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "Möchtegern")
-    def test_should_urlize_queue_ids(self, requests_mocker, mock_redis):
+    def test_should_urlize_queue_ids(self, requests_mocker, mock_cache):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
@@ -196,8 +219,9 @@ You can only have one request to listen.php in flight at any time, otherwise you
         self.assertEqual(queue_id[0], "M%C3%B6chtegern")
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "alpha,bravo")
-    def test_should_not_accept_list_for_queue_id(self, requests_mocker, mock_redis):
+    def test_should_not_accept_list_for_queue_id(self, requests_mocker, mock_cache):
         # given
+        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
@@ -205,6 +229,27 @@ You can only have one request to listen.php in flight at any time, otherwise you
         with self.assertRaises(ImproperlyConfigured):
             Killmail.create_from_zkb_redisq()
 
+    @patch(MODULE_PATH + ".sleep")
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    def test_should_wait_until_next_slot_if_needed(
+        self, requests_mocker, mock_sleep, mock_cache
+    ):
+        def cache_get(v):
+            if v != "killtracker-last-request":
+                return None
+            return now().isoformat()
+
+        # given
+        mock_cache.get = cache_get
+        requests_mocker.register_uri(
+            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+        )
+        # when
+        killmail = Killmail.create_from_zkb_redisq()
+        # then
+        self.assertIsNone(killmail)
+        self.assertTrue(mock_sleep.called)
+
 
 class TestKillmailSerialization(NoSocketsTestCase):
     def test_dict_serialization(self):
@@ -337,7 +382,7 @@ class TestCreateFromZkbApi(NoSocketsTestCase):
         killmail = Killmail.create_from_zkb_api(killmail_id)
         self.assertIsNotNone(killmail)
         self.assertEqual(killmail.id, killmail_id)
-        self.assertAlmostEqual(killmail.time, now(), delta=timedelta(seconds=120))
+        self.assertAlmostEqual(killmail.time, now(), delta=dt.timedelta(seconds=120))
 
         self.assertEqual(killmail.victim.alliance_id, 3011)
         self.assertEqual(killmail.victim.character_id, 1011)

killtracker/tests/core/test_worker_shutdown.py

@@ -0,0 +1,34 @@
+from unittest.mock import patch
+
+from django.test import TestCase
+
+from killtracker.core.worker_shutdown import is_shutting_down
+
+MODULE_PATH = "killtracker.core.worker_shutdown"
+
+
+class FakeTask:
+    class FakeRequest:
+        def __init__(self, hostname: str):
+            self.hostname = hostname
+
+    def __init__(self, hostname: str):
+        self.request = self.FakeRequest(hostname)
+
+
+@patch(MODULE_PATH + ".cache")
+class TestWorkerShutdown(TestCase):
+    def test_should_report_false_when_not_set(self, mock_cache):
+        mock_cache.get.return_value = None
+        got = is_shutting_down("dummy")
+        self.assertFalse(got)
+
+    def test_should_report_true_when_set(self, mock_cache):
+        mock_cache.get.return_value = "value"
+        got = is_shutting_down(FakeTask("dummy"))
+        self.assertTrue(got)
+
+    def test_should_report_false_when_task_not_valid(self, mock_cache):
+        mock_cache.get.return_value = "value"
+        got = is_shutting_down("invalid")
+        self.assertFalse(got)

killtracker/tests/models/test_trackers_1.py

@@ -848,7 +848,7 @@ class TestTrackerCalculateTrackerInfo(LoadTestDataMixin, NoSocketsTestCase):
 class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
     def setUp(self) -> None:
         self.tracker = TrackerFactory(name="My Tracker", webhook=self.webhook_1)
-        self.webhook_1.main_queue.clear()
+        self.webhook_1._main_queue.clear()
 
     @patch(MODELS_PATH + ".webhooks.KILLTRACKER_WEBHOOK_SET_AVATAR", True)
     @patch("eveuniverse.models.universe_2.esi")
@@ -866,8 +866,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
 
         self.assertEqual(message["username"], "Killtracker")
         self.assertIsNotNone(message["avatar_url"])
@@ -893,8 +893,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertNotIn("username", message)
         self.assertNotIn("avatar_url", message)
         self.assertIn("My Tracker", message["content"])
@@ -906,8 +906,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertIn("| Fleetkill", message["embeds"][0]["title"])
 
     def test_can_add_intro_text(self):
@@ -915,8 +915,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(killmail, intro_text="Intro Text")
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertIn("Intro Text", message["content"])
 
     def test_without_tracker_info(self):
@@ -924,7 +924,7 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
 
     def test_can_ping_everybody(self):
         tracker = TrackerFactory(
@@ -935,8 +935,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertIn("@everybody", message["content"])
 
     def test_can_ping_here(self):
@@ -947,8 +947,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertIn("@here", message["content"])
 
     def test_can_ping_nobody(self):
@@ -958,8 +958,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertNotIn("@everybody", message["content"])
         self.assertNotIn("@here", message["content"])
 
@@ -970,8 +970,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
-        message = json.loads(self.webhook_1.main_queue.dequeue())
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+        message = json.loads(self.webhook_1._main_queue.dequeue())
         self.assertNotIn("Ping Nobody", message["content"])
 
     def test_can_send_npc_killmail(self):
@@ -979,28 +979,28 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
 
     def test_can_handle_victim_without_character(self):
         killmail = self.tracker.process_killmail(load_killmail(10000501))
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
 
     def test_can_handle_victim_without_corporation(self):
         killmail = self.tracker.process_killmail(load_killmail(10000502))
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
 
     def test_can_handle_final_attacker_with_no_character(self):
         killmail = self.tracker.process_killmail(load_killmail(10000503))
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
 
     def test_can_handle_matching_type_ids(self):
         svipul = EveType.objects.get(id=34562)
@@ -1009,4 +1009,4 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
 
         self.tracker.generate_killmail_message(Killmail.from_json(killmail.asjson()))
 
-        self.assertEqual(self.webhook_1.main_queue.size(), 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)

killtracker/tests/models/test_trackers_2.py

@@ -8,6 +8,7 @@ from eveuniverse.models import EveConstellation, EveRegion, EveSolarSystem, EveT
 
 from app_utils.testing import NoSocketsTestCase
 
+from killtracker.core.discord_messages import DiscordMessage
 from killtracker.core.killmails import Killmail
 from killtracker.tests.testdata.factories import TrackerFactory
 from killtracker.tests.testdata.helpers import LoadTestDataMixin, load_killmail
@@ -107,10 +108,10 @@ class TestTrackerGenerateKillmailMessage(LoadTestDataMixin, TestCase):
         # when
         self.tracker.generate_killmail_message(killmail_json)
         # then
-        _, kwargs = mock_enqueue_message.call_args
-        content = kwargs["content"]
-        self.assertIn("My Tracker", content)
-        embed = kwargs["embeds"][0]
+        arg, _ = mock_enqueue_message.call_args
+        message: DiscordMessage = arg[0]
+        self.assertIn("My Tracker", message.content)
+        embed = message.embeds[0]
         self.assertEqual(embed.title, "Haras | Svipul | Killmail")
         self.assertEqual(embed.thumbnail.url, svipul.icon_url(size=128))
         html = markdown(embed.description)

killtracker/tests/models/test_webhook.py

@@ -1,63 +1,77 @@
-import json
-
-import dhooks_lite
 import requests_mock
 
 from django.core.cache import cache
 from django.test import TestCase
 
-from app_utils.json import JSONDateTimeDecoder
-
+from killtracker.core.discord_messages import DiscordMessage
 from killtracker.exceptions import WebhookTooManyRequests
 from killtracker.models import Webhook
 from killtracker.tests.testdata.helpers import LoadTestDataMixin
 
 
-class TestWebhookQueue(LoadTestDataMixin, TestCase):
+class TestWebhookQueue(TestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
+        cls.webhook_1 = Webhook.objects.create(
+            name="Webhook 1", url="http://www.example.com/webhook_1", is_enabled=True
+        )
 
     def setUp(self) -> None:
-        self.webhook_1.main_queue.clear()
-        self.webhook_1.error_queue.clear()
+        self.webhook_1._main_queue.clear()
+        self.webhook_1._error_queue.clear()
 
     def test_reset_failed_messages(self):
         message = "Test message"
-        self.webhook_1.error_queue.enqueue(message)
-        self.webhook_1.error_queue.enqueue(message)
-        self.assertEqual(self.webhook_1.error_queue.size(), 2)
-        self.assertEqual(self.webhook_1.main_queue.size(), 0)
+        self.webhook_1._error_queue.enqueue(message)
+        self.webhook_1._error_queue.enqueue(message)
+        self.assertEqual(self.webhook_1._error_queue.size(), 2)
+        self.assertEqual(self.webhook_1._main_queue.size(), 0)
         self.webhook_1.reset_failed_messages()
-        self.assertEqual(self.webhook_1.error_queue.size(), 0)
-        self.assertEqual(self.webhook_1.main_queue.size(), 2)
-
-    def test_discord_message_asjson_normal(self):
-        embed = dhooks_lite.Embed(description="my_description")
-        result = Webhook._discord_message_asjson(
-            content="my_content",
-            username="my_username",
-            avatar_url="my_avatar_url",
-            embeds=[embed],
-        )
-        message_python = json.loads(result, cls=JSONDateTimeDecoder)
-        expected = {
-            "content": "my_content",
-            "embeds": [{"description": "my_description", "type": "rich"}],
-            "username": "my_username",
-            "avatar_url": "my_avatar_url",
-        }
-        self.assertDictEqual(message_python, expected)
-
-    def test_discord_message_asjson_empty(self):
-        with self.assertRaises(ValueError):
-            Webhook._discord_message_asjson("")
+        self.assertEqual(self.webhook_1._error_queue.size(), 0)
+        self.assertEqual(self.webhook_1._main_queue.size(), 2)
+
+    def test_should_enqueue_and_dequeue_message_from_main_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1)
+        m2 = self.webhook_1.dequeue_message()
+        self.assertEqual(m1, m2)
+
+    def test_should_enqueue_and_dequeue_message_from_error_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1, is_error=True)
+        m2 = self.webhook_1.dequeue_message(is_error=True)
+        self.assertEqual(m1, m2)
+
+    def test_should_return_size_of_main_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1)
+        self.assertEqual(self.webhook_1.messages_queued(), 1)
+
+    def test_should_return_size_of_error_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1, is_error=True)
+        self.assertEqual(self.webhook_1.messages_queued(is_error=True), 1)
+
+    def test_should_clear_main_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1)
+        self.assertEqual(self.webhook_1.messages_queued(), 1)
+        self.webhook_1.delete_queued_messages()
+        self.assertEqual(self.webhook_1.messages_queued(), 0)
+
+    def test_should_clear_error_queue(self):
+        m1 = DiscordMessage(content="content")
+        self.webhook_1.enqueue_message(m1, is_error=True)
+        self.assertEqual(self.webhook_1.messages_queued(is_error=True), 1)
+        self.webhook_1.delete_queued_messages(is_error=True)
+        self.assertEqual(self.webhook_1.messages_queued(is_error=True), 0)
 
 
 @requests_mock.Mocker()
 class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
     def setUp(self) -> None:
-        self.message = Webhook._discord_message_asjson(content="Test message")
+        self.message = DiscordMessage(content="Test message")
         cache.clear()
 
     def test_when_send_ok_returns_true(self, requests_mocker):
@@ -85,7 +99,7 @@ class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
             },
         )
         # when
-        response = self.webhook_1.send_message_to_webhook(self.message)
+        response = self.webhook_1.send_message(self.message)
         # then
         self.assertTrue(response.status_ok)
         self.assertTrue(requests_mocker.called)
@@ -94,7 +108,7 @@ class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
         # given
         requests_mocker.register_uri("POST", self.webhook_1.url, status_code=404)
         # when
-        response = self.webhook_1.send_message_to_webhook(self.message)
+        response = self.webhook_1.send_message(self.message)
         # then
         self.assertFalse(response.status_ok)
         self.assertTrue(requests_mocker.called)
@@ -118,7 +132,7 @@ class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
         )
         # when/then
         try:
-            self.webhook_1.send_message_to_webhook(self.message)
+            self.webhook_1.send_message(self.message)
         except Exception as ex:
             self.assertIsInstance(ex, WebhookTooManyRequests)
             self.assertEqual(ex.retry_after, 2002)
@@ -142,7 +156,7 @@ class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
         )
         # when/then
         try:
-            self.webhook_1.send_message_to_webhook(self.message)
+            self.webhook_1.send_message(self.message)
         except Exception as ex:
             self.assertIsInstance(ex, WebhookTooManyRequests)
             self.assertEqual(ex.retry_after, WebhookTooManyRequests.DEFAULT_RESET_AFTER)

killtracker/tests/test_integration.py

@@ -3,7 +3,6 @@ from unittest.mock import patch
 import dhooks_lite
 import requests_mock
 
-from django.core.cache import cache
 from django.test import TestCase
 from django.test.utils import override_settings
 
@@ -12,6 +11,7 @@ from killtracker.core.killmails import ZKB_REDISQ_URL
 
 from .testdata.factories import TrackerFactory
 from .testdata.helpers import LoadTestDataMixin, killmails_data
+from .utils import reset_celery_once_locks
 
 PACKAGE_PATH = "killtracker"
 
@@ -26,7 +26,7 @@ class TestTasksEnd2End(LoadTestDataMixin, TestCase):
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
-        cache.clear()
+        reset_celery_once_locks()
         cls.tracker_1 = TrackerFactory(
             name="My Tracker",
             exclude_null_sec=True,