aa-killtracker 0.17.0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

killtracker/tests/core/{test_killmails.py → test_zkb.py}

@@ -1,11 +1,9 @@
+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
 from django.test import TestCase
 from django.utils.dateparse import parse_datetime
@@ -14,31 +12,35 @@ from django.utils.timezone import now
 from app_utils.esi_testing import BravadoOperationStub
 from app_utils.testing import NoSocketsTestCase
 
-from killtracker.core.killmails import (
-    ZKB_API_URL,
-    ZKB_REDISQ_URL,
+from killtracker.core.zkb import (
+    _KEY_LAST_REQUEST,
+    _KEY_RETRY_AT,
+    _ZKB_API_URL,
+    _ZKB_REDISQ_URL,
     Killmail,
+    KillmailDoesNotExist,
+    ZKBTooManyRequestsError,
     _EntityCount,
 )
-from killtracker.exceptions import KillmailDoesNotExist
 from killtracker.tests import CacheStub
 from killtracker.tests.testdata.factories import KillmailFactory
 from killtracker.tests.testdata.helpers import killmails_data, load_killmail
+from killtracker.tests.utils import CacheFake
 
-MODULE_PATH = "killtracker.core.killmails"
+MODULE_PATH = "killtracker.core.zkb"
 unittest.util._MAX_LENGTH = 1000
 requests_mock.mock.case_sensitive = True
 
 
 @requests_mock.Mocker()
-@patch(MODULE_PATH + ".get_redis_client")
+@patch(MODULE_PATH + ".cache", new_callable=CacheFake)
 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
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             status_code=200,
             json={"package": killmails_data()[10000001]},
         )
@@ -48,7 +50,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,11 +77,11 @@ 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
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
@@ -87,28 +89,27 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self.assertIsNone(killmail)
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_handle_zkb_data_has_no_solar_system(
-        self, requests_mocker, mock_redis
+    def test_should_ignore_invalid_value_for_retry_at_key(
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.set(_KEY_RETRY_AT, "abc")
         requests_mocker.register_uri(
-            "GET",
-            ZKB_REDISQ_URL,
-            status_code=200,
-            json={"package": killmails_data()[10000402]},
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
         # then
-        self.assertIsNotNone(killmail)
+        self.assertIsNone(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_ignore_invalid_value_for_last_request_key(
+        self, requests_mocker, mock_cache
     ):
         # given
+        mock_cache.set(_KEY_LAST_REQUEST, "abc")
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=429, text="429 too many requests"
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
@@ -116,30 +117,68 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self.assertIsNone(killmail)
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_return_none_when_zkb_returns_general_error(
-        self, requests_mocker, mock_redis
+    def test_should_handle_zkb_data_has_no_solar_system(
+        self, requests_mocker, mock_cache
     ):
         # given
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             status_code=200,
-            text="""Your IP has been banned because of excessive errors.
-
-You can only have one request to listen.php in flight at any time, otherwise you will generate a too many requests error (429). If you have too many of these errors you will be banned automatically.""",
+            json={"package": killmails_data()[10000402]},
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
         # then
+        self.assertIsNotNone(killmail)
+
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    def test_should_return_none_when_http_error(self, requests_mocker, mock_cache):
+        # given
+        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_none_when_zkb_does_not_return_json(
-        self, requests_mocker, mock_redis
+    def test_should_return_raise_too_many_requests_error(
+        self, requests_mocker, mock_cache
     ):
         # given
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, text="this is not JSON"
+            "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.set(_KEY_RETRY_AT, retry_at)
+        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_cache
+    ):
+        # given
+        requests_mocker.register_uri(
+            "GET",
+            _ZKB_REDISQ_URL,
+            status_code=200,
+            text="""Your IP has been banned because of excessive errors.
+
+You can only have one request to listen.php in flight at any time, otherwise you will generate a too many requests error (429). If you have too many of these errors you will be banned automatically.""",
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
@@ -147,19 +186,23 @@ You can only have one request to listen.php in flight at any time, otherwise you
         self.assertIsNone(killmail)
 
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
-    def test_should_return_none_if_lock_not_acquired(self, requests_mocker, mock_redis):
+    def test_should_return_none_when_zkb_does_not_return_json(
+        self, requests_mocker, mock_cache
+    ):
         # given
-        mock_redis.return_value.lock.side_effect = LockError
+        requests_mocker.register_uri(
+            "GET", _ZKB_REDISQ_URL, status_code=200, text="this is not JSON"
+        )
         # 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
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         Killmail.create_from_zkb_redisq()
@@ -171,20 +214,20 @@ 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
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when/then
         with self.assertRaises(ImproperlyConfigured):
             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
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         Killmail.create_from_zkb_redisq()
@@ -196,15 +239,31 @@ 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
         requests_mocker.register_uri(
-            "GET", ZKB_REDISQ_URL, status_code=200, json={"package": None}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when/then
         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
+    ):
+        # given
+        mock_cache.set(_KEY_LAST_REQUEST, now())
+        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):
@@ -323,7 +382,7 @@ class TestCreateFromZkbApi(NoSocketsTestCase):
         ]
         requests_mocker.register_uri(
             "GET",
-            f"{ZKB_API_URL}killID/{killmail_id}/",
+            f"{_ZKB_API_URL}killID/{killmail_id}/",
             status_code=200,
             json=zkb_api_data,
         )
@@ -337,7 +396,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)
@@ -365,11 +424,9 @@ class TestCreateFromZkbApi(NoSocketsTestCase):
         self.assertFalse(killmail.zkb.is_awox)
 
 
+@patch(MODULE_PATH + ".cache", new_callable=CacheFake)
 class TestKillmailStorage(TestCase):
-    def setUp(self) -> None:
-        cache.clear()
-
-    def test_should_store_and_retrieve_killmail(self):
+    def test_should_store_and_retrieve_killmail(self, mock_cache):
         # given
         killmail_1 = KillmailFactory()
         # when
@@ -378,12 +435,12 @@ class TestKillmailStorage(TestCase):
         # then
         self.assertEqual(killmail_1, killmail_2)
 
-    def test_should_raise_error_when_killmail_does_not_exist(self):
+    def test_should_raise_error_when_killmail_does_not_exist(self, mock_cache):
         # when/then
         with self.assertRaises(KillmailDoesNotExist):
             Killmail.get(id=99)
 
-    def test_should_delete_killmail(self):
+    def test_should_delete_killmail(self, mock_cache):
         # given
         killmail = KillmailFactory()
         killmail.save()
@@ -393,7 +450,7 @@ class TestKillmailStorage(TestCase):
         with self.assertRaises(KillmailDoesNotExist):
             Killmail.get(id=killmail.id)
 
-    def test_should_override_existing_killmail(self):
+    def test_should_override_existing_killmail(self, mock_cache):
         # given
         killmail_1 = KillmailFactory(zkb__points=1)
         killmail_1.save()

killtracker/tests/models/test_killmails.py

@@ -19,8 +19,6 @@ from killtracker.tests.testdata.helpers import (
 )
 from killtracker.tests.testdata.load_eveuniverse import load_eveuniverse
 
-MODELS_PATH = "killtracker.models.killmails"
-
 
 class TestEveKillmailManager(LoadTestDataMixin, NoSocketsTestCase):
     def test_create_from_killmail(self):

killtracker/tests/models/test_trackers_1.py

@@ -24,7 +24,7 @@ from app_utils.testdata_factories import (
 from app_utils.testing import NoSocketsTestCase, add_character_to_user_2
 
 from killtracker.constants import EveGroupId
-from killtracker.core.killmails import Killmail, _EntityCount
+from killtracker.core.zkb import Killmail, _EntityCount
 from killtracker.models import Tracker
 from killtracker.tests.testdata.factories import (
     EveFactionInfoFactory,
@@ -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,7 +8,8 @@ from eveuniverse.models import EveConstellation, EveRegion, EveSolarSystem, EveT
 
 from app_utils.testing import NoSocketsTestCase
 
-from killtracker.core.killmails import Killmail
+from killtracker.core.discord import DiscordMessage
+from killtracker.core.zkb 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_webhooks.py

@@ -0,0 +1,63 @@
+from django.test import TestCase
+
+from killtracker.core.discord import DiscordMessage
+from killtracker.models import Webhook
+
+
+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()
+
+    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.reset_failed_messages()
+        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)

killtracker/tests/test_integration.py

@@ -4,43 +4,56 @@ import dhooks_lite
 import requests_mock
 
 from django.core.cache import cache
-from django.test import TestCase
 from django.test.utils import override_settings
 
+from app_utils.testing import NoSocketsTestCase
+
 from killtracker import tasks
-from killtracker.core.killmails import ZKB_REDISQ_URL
+from killtracker.core.zkb import _ZKB_REDISQ_URL
 
-from .testdata.factories import TrackerFactory
-from .testdata.helpers import LoadTestDataMixin, killmails_data
+from .testdata.factories import TrackerFactory, WebhookFactory
+from .testdata.helpers import (
+    killmails_data,
+    load_eve_corporations,
+    load_eve_entities,
+    load_eveuniverse,
+)
 
 PACKAGE_PATH = "killtracker"
 
 
 @patch("celery.app.task.Context.called_directly", False)  # make retry work with eager
 @override_settings(CELERY_ALWAYS_EAGER=True)
-@patch(PACKAGE_PATH + ".core.killmails.KILLTRACKER_QUEUE_ID", "dummy")
+@patch(PACKAGE_PATH + ".core.zkb.KILLTRACKER_QUEUE_ID", "dummy")
+@patch(PACKAGE_PATH + ".tasks.workers.is_shutting_down", lambda x: False)
 @patch(PACKAGE_PATH + ".tasks.is_esi_online", lambda: True)
-@patch(PACKAGE_PATH + ".models.webhooks.dhooks_lite.Webhook.execute", spec=True)
+@patch(PACKAGE_PATH + ".core.discord.dhooks_lite.Webhook.execute", spec=True)
 @requests_mock.Mocker()
-class TestTasksEnd2End(LoadTestDataMixin, TestCase):
+class TestTasksEnd2End(NoSocketsTestCase):
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
-        cache.clear()
-        cls.tracker_1 = TrackerFactory(
+        load_eveuniverse()
+        load_eve_corporations()
+        load_eve_entities()
+        cls.webhook = WebhookFactory()
+        cls.tracker = TrackerFactory(
             name="My Tracker",
             exclude_null_sec=True,
             exclude_w_space=True,
-            webhook=cls.webhook_1,
+            webhook=cls.webhook,
         )
 
+    def setUp(self):
+        cache.clear()
+
     @patch(PACKAGE_PATH + ".tasks.retry_task_if_esi_is_down", lambda x: None)
     def test_normal_case(self, requests_mocker, mock_execute):
         # given
         mock_execute.return_value = dhooks_lite.WebhookResponse({}, status_code=200)
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             [
                 {"status_code": 200, "json": {"package": killmails_data()[10000001]}},
                 {"status_code": 200, "json": {"package": killmails_data()[10000002]}},
@@ -73,7 +86,7 @@ class TestTasksEnd2End(LoadTestDataMixin, TestCase):
         mock_retry_task_if_esi_is_down.side_effect = my_retry_task_if_esi_is_down
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             [
                 {"status_code": 200, "json": {"package": killmails_data()[10000001]}},
                 {"status_code": 200, "json": {"package": None}},