aa-killtracker 0.18.0a2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

killtracker/tests/core/test_workers.py

@@ -0,0 +1,49 @@
+from unittest.mock import patch
+
+from django.test import TestCase
+
+from killtracker.core import workers
+from killtracker.tests.utils import CacheFake
+
+MODULE_PATH = "killtracker.core.workers"
+
+
+class TaskFake:
+    class RequestFake:
+        def __init__(self, hostname: str):
+            self.hostname = hostname
+
+    def __init__(self, hostname: str):
+        self.request = self.RequestFake(hostname)
+
+
+class TestWorker(TestCase):
+    def test_should_report_false_when_not_set(self):
+        with patch(MODULE_PATH + ".cache", new_callable=CacheFake):
+            got = workers.is_shutting_down("dummy")
+        self.assertFalse(got)
+
+    def test_should_report_true_when_set(self):
+        with patch(MODULE_PATH + ".cache", new_callable=CacheFake):
+            workers.state_set("alpha")
+            got = workers.is_shutting_down(TaskFake("alpha"))
+        self.assertTrue(got)
+
+    def test_should_report_false_when_other_worker_is_shutting_down(self):
+        with patch(MODULE_PATH + ".cache", new_callable=CacheFake):
+            workers.state_set("alpha")
+            got = workers.is_shutting_down(TaskFake("bravo"))
+        self.assertFalse(got)
+
+    def test_should_report_false_when_task_not_valid(self):
+        with patch(MODULE_PATH + ".cache", new_callable=CacheFake):
+            workers.state_set("alpha")
+            got = workers.is_shutting_down("invalid")
+        self.assertFalse(got)
+
+    def test_should_report_false_when_worker_shutdown_has_reset(self):
+        with patch(MODULE_PATH + ".cache", new_callable=CacheFake):
+            workers.state_set("alpha")
+            workers.state_reset("alpha")
+            got = workers.is_shutting_down(TaskFake("alpha"))
+        self.assertFalse(got)

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

@@ -4,7 +4,6 @@ from unittest.mock import patch
 
 import requests_mock
 
-from django.core.cache import cache
 from django.core.exceptions import ImproperlyConfigured
 from django.test import TestCase
 from django.utils.dateparse import parse_datetime
@@ -13,33 +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 + ".cache")
+@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_cache):
         # given
-        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             status_code=200,
             json={"package": killmails_data()[10000001]},
         )
@@ -79,9 +80,36 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         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}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
+        )
+        # when
+        killmail = Killmail.create_from_zkb_redisq()
+        # then
+        self.assertIsNone(killmail)
+
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    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": None}
+        )
+        # when
+        killmail = Killmail.create_from_zkb_redisq()
+        # then
+        self.assertIsNone(killmail)
+
+    @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
+    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=200, json={"package": None}
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
@@ -93,10 +121,9 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self, requests_mocker, mock_cache
     ):
         # given
-        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             status_code=200,
             json={"package": killmails_data()[10000402]},
         )
@@ -108,8 +135,7 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "dummy")
     def test_should_return_none_when_http_error(self, requests_mocker, mock_cache):
         # given
-        mock_cache.get.return_value = None
-        requests_mocker.register_uri("GET", ZKB_REDISQ_URL, status_code=500)
+        requests_mocker.register_uri("GET", _ZKB_REDISQ_URL, status_code=500)
         # when
         killmail = Killmail.create_from_zkb_redisq()
         # then
@@ -120,9 +146,8 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         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"
+            "GET", _ZKB_REDISQ_URL, status_code=429, text="429 too many requests"
         )
         # when/then
         with self.assertRaises(ZKBTooManyRequestsError):
@@ -134,8 +159,8 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
     ):
         # 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)
+        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:
@@ -147,10 +172,9 @@ class TestCreateFromZkbRedisq(NoSocketsTestCase):
         self, requests_mocker, mock_cache
     ):
         # given
-        mock_cache.get.return_value = None
         requests_mocker.register_uri(
             "GET",
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             status_code=200,
             text="""Your IP has been banned because of excessive errors.
 
@@ -166,9 +190,8 @@ You can only have one request to listen.php in flight at any time, otherwise you
         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"
+            "GET", _ZKB_REDISQ_URL, status_code=200, text="this is not JSON"
         )
         # when
         killmail = Killmail.create_from_zkb_redisq()
@@ -178,9 +201,8 @@ You can only have one request to listen.php in flight at any time, otherwise you
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "Voltron9000")
     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}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         Killmail.create_from_zkb_redisq()
@@ -194,9 +216,8 @@ You can only have one request to listen.php in flight at any time, otherwise you
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "")
     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}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when/then
         with self.assertRaises(ImproperlyConfigured):
@@ -205,9 +226,8 @@ You can only have one request to listen.php in flight at any time, otherwise you
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "Möchtegern")
     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}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when
         Killmail.create_from_zkb_redisq()
@@ -221,9 +241,8 @@ You can only have one request to listen.php in flight at any time, otherwise you
     @patch(MODULE_PATH + ".KILLTRACKER_QUEUE_ID", "alpha,bravo")
     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}
+            "GET", _ZKB_REDISQ_URL, status_code=200, json={"package": None}
         )
         # when/then
         with self.assertRaises(ImproperlyConfigured):
@@ -234,15 +253,10 @@ You can only have one request to listen.php in flight at any time, otherwise you
     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
+        mock_cache.set(_KEY_LAST_REQUEST, now())
         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()
@@ -368,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,
         )
@@ -410,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
@@ -423,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()
@@ -438,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,

killtracker/tests/models/test_trackers_2.py

@@ -8,8 +8,8 @@ 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.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
 

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

@@ -3,44 +3,57 @@ from unittest.mock import patch
 import dhooks_lite
 import requests_mock
 
-from django.test import TestCase
+from django.core.cache import cache
 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 .utils import reset_celery_once_locks
+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()
-        reset_celery_once_locks()
-        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}},