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

killtracker/tests/test_tasks.py

@@ -1,16 +1,17 @@
 import datetime as dt
 from unittest.mock import patch
 
-import celery
-import dhooks_lite
+from celery.exceptions import Retry
 
 from django.core.cache import cache
 from django.test import TestCase
-from django.test.utils import override_settings
 from django.utils.timezone import now
 
-from killtracker.core.discord_messages import DiscordMessage
-from killtracker.exceptions import WebhookTooManyRequests
+from killtracker.core.discord import (
+    DiscordMessage,
+    HTTPError,
+    WebhookRateLimitExhausted,
+)
 from killtracker.models import EveKillmail
 from killtracker.tasks import (
     ZKBTooManyRequestsError,
@@ -19,7 +20,6 @@ from killtracker.tasks import (
     run_killtracker,
     run_tracker,
     send_messages_to_webhook,
-    send_test_message_to_webhook,
     store_killmail,
 )
 
@@ -53,7 +53,7 @@ class TestTrackerBase(LoadTestDataMixin, TestCase):
         )
 
 
-@patch(MODULE_PATH + ".worker_shutdown.is_shutting_down", spec=True)
+@patch(MODULE_PATH + ".workers.is_shutting_down", spec=True)
 @patch(MODULE_PATH + ".is_esi_online", spec=True)
 @patch(MODULE_PATH + ".delete_stale_killmails", spec=True)
 @patch(MODULE_PATH + ".store_killmail", spec=True)
@@ -177,7 +177,7 @@ class TestRunKilltracker(TestTrackerBase):
         )
         mock_is_esi_online.return_value = True
         # when/then
-        with self.assertRaises(celery.exceptions.Retry):
+        with self.assertRaises(Retry):
             run_killtracker()
         # then
         self.assertEqual(mock_run_tracker.delay.call_count, 0)
@@ -302,79 +302,107 @@ class TestGenerateKillmailMessage(TestTrackerBase):
         self.assertEqual(mock_retry.call_count, 4)
 
 
-@patch("celery.app.task.Context.called_directly", False)  # make retry work with eager
-@override_settings(CELERY_ALWAYS_EAGER=True)
+# @patch("celery.app.task.Context.called_directly", False)  # make retry work with eager
+# @override_settings(CELERY_ALWAYS_EAGER=True)
+
+
+@patch(MODULE_PATH + ".workers.is_shutting_down", spec=True)
 @patch(MODULE_PATH + ".Webhook.send_message", spec=True)
 class TestSendMessagesToWebhook(TestTrackerBase):
     def setUp(self) -> None:
         cache.clear()
 
-    def test_should_send_one_message(self, mock_send_message):
+    def test_should_send_one_message(self, mock_send_message, mock_is_shutting_down):
         # given
-        mock_send_message.return_value = dhooks_lite.WebhookResponse(
-            {}, status_code=200
-        )
+        mock_is_shutting_down.return_value = False
+        mock_send_message.return_value = 42
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         # when
-        send_messages_to_webhook.delay(self.webhook_1.pk)
+        send_messages_to_webhook(self.webhook_1.pk)
         # then
         self.assertEqual(mock_send_message.call_count, 1)
         self.assertEqual(self.webhook_1._main_queue.size(), 0)
         self.assertEqual(self.webhook_1._error_queue.size(), 0)
 
-    def test_three_message(self, mock_send_message):
-        """when three messages in queue, then sends them and returns 3"""
+    def test_should_send_three_messages(self, mock_send_message, mock_is_shutting_down):
         # given
-        mock_send_message.return_value = dhooks_lite.WebhookResponse(
-            {}, status_code=200
-        )
+        mock_is_shutting_down.return_value = False
+        mock_send_message.return_value = [1, 2, 3]
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         # when
-        send_messages_to_webhook.delay(self.webhook_1.pk)
+        send_messages_to_webhook(self.webhook_1.pk)
         # then
         self.assertEqual(mock_send_message.call_count, 3)
         self.assertEqual(self.webhook_1._main_queue.size(), 0)
         self.assertEqual(self.webhook_1._error_queue.size(), 0)
 
-    def test_no_messages(self, mock_send_message):
-        """when no messages in queue, then do nothing"""
+    def test_should_do_nothing_when_queue_is_empty(
+        self, mock_send_message, mock_is_shutting_down
+    ):
         # given
-        mock_send_message.return_value = dhooks_lite.WebhookResponse(
-            {}, status_code=200
-        )
+        mock_is_shutting_down.return_value = False
         # when
-        send_messages_to_webhook.delay(self.webhook_1.pk)
+        send_messages_to_webhook(self.webhook_1.pk)
         # then
         self.assertEqual(mock_send_message.call_count, 0)
         self.assertEqual(self.webhook_1._main_queue.size(), 0)
         self.assertEqual(self.webhook_1._error_queue.size(), 0)
 
-    def test_failed_message(self, mock_send_message):
-        """when message sending failed, then put message in error queue"""
+    def test_should_put_failed_message_in_error_queue(
+        self, mock_send_message, mock_is_shutting_down
+    ):
         # given
-        mock_send_message.return_value = dhooks_lite.WebhookResponse(
-            {}, status_code=404
-        )
+        mock_is_shutting_down.return_value = False
+        mock_send_message.side_effect = HTTPError(404)
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         # when
-        send_messages_to_webhook.delay(self.webhook_1.pk)
+        send_messages_to_webhook(self.webhook_1.pk)
         # then
         self.assertEqual(mock_send_message.call_count, 1)
         self.assertEqual(self.webhook_1._main_queue.size(), 0)
         self.assertEqual(self.webhook_1._error_queue.size(), 1)
 
-    def test_abort_on_too_many_requests(self, mock_send_message):
-        """
-        when WebhookTooManyRequests exception is raised
-        then message is re-queued and retry once
-        """
+    def test_should_retry_on_too_many_requests_error(
+        self, mock_send_message, mock_is_shutting_down
+    ):
+        # given
+        mock_is_shutting_down.return_value = False
+        mock_send_message.side_effect = WebhookRateLimitExhausted(10)
+        self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
+        # when
+        with self.assertRaises(Retry):
+            send_messages_to_webhook(self.webhook_1.pk)
+        # then
+        self.assertEqual(mock_send_message.call_count, 1)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+
+    def test_should_abort_when_worker_is_shutting_down(
+        self, mock_send_message, mock_is_shutting_down
+    ):
+        # given
+        mock_is_shutting_down.return_value = True
+        mock_send_message.return_value = 42
+        self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
+        # when
+        send_messages_to_webhook(self.webhook_1.pk)
+        # then
+        self.assertEqual(mock_send_message.call_count, 0)
+        self.assertEqual(self.webhook_1._main_queue.size(), 1)
+
+    @patch(MODULE_PATH + ".KILLTRACKER_MAX_MESSAGES_SENT_PER_RUN", 1)
+    def test_retry_when_limit_is_reached(
+        self, mock_send_message, mock_is_shutting_down
+    ):
         # given
-        mock_send_message.side_effect = WebhookTooManyRequests(10)
+        mock_is_shutting_down.return_value = False
+        mock_send_message.return_value = [1, 2]
+        self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         self.webhook_1.enqueue_message(DiscordMessage(content="Test message"))
         # when
-        send_messages_to_webhook.delay(self.webhook_1.pk)
+        with self.assertRaises(Retry):
+            send_messages_to_webhook(self.webhook_1.pk)
         # then
         self.assertEqual(mock_send_message.call_count, 1)
         self.assertEqual(self.webhook_1._main_queue.size(), 1)
@@ -406,24 +434,6 @@ class TestStoreKillmail(TestTrackerBase):
         self.assertTrue(mock_logger.warning.called)
 
 
-@override_settings(CELERY_ALWAYS_EAGER=True, CELERY_EAGER_PROPAGATES_EXCEPTIONS=True)
-@patch("killtracker.models.webhooks.dhooks_lite.Webhook.execute", spec=True)
-@patch(MODULE_PATH + ".logger", spec=True)
-class TestSendTestKillmailsToWebhook(TestTrackerBase):
-    def setUp(self) -> None:
-        self.webhook_1._main_queue.clear()
-
-    def test_run_normal(self, mock_logger, mock_execute):
-        # given
-        mock_execute.return_value = dhooks_lite.WebhookResponse({}, status_code=200)
-        # when
-        with self.assertRaises(celery.exceptions.Retry):
-            send_test_message_to_webhook.delay(self.webhook_1.pk)
-        # then
-        self.assertTrue(mock_execute.called)
-        self.assertFalse(mock_logger.error.called)
-
-
 @patch(MODULE_PATH + ".EveKillmail.objects.delete_stale")
 class TestDeleteStaleKillmails(TestTrackerBase):
     def test_normal(self, mock_delete_stale):

killtracker/tests/test_utils.py

@@ -0,0 +1,39 @@
+from unittest import TestCase
+
+from .utils import CacheFake
+
+
+class TestCacheFake(TestCase):
+    def test_get_should_return_value_when_found(self):
+        cache = CacheFake()
+        cache.set("alpha", 5)
+        got = cache.get("alpha")
+        self.assertEqual(got, 5)
+
+    def test_get_should_return_default_when_not_found(self):
+        cache = CacheFake()
+        cache.set("alpha", 5)
+        got = cache.get("bravo", 99)
+        self.assertEqual(got, 99)
+
+    def test_delete_should_remove_key(self):
+        cache = CacheFake()
+        cache.set("alpha", 5)
+        cache.delete("alpha")
+        self.assertIsNone(cache.get("alpha"))
+
+    def test_delete_should_ignore_when_key_does_not_exist(self):
+        cache = CacheFake()
+        cache.delete("alpha")
+
+    def test_clear_should_remove_all_keys(self):
+        cache = CacheFake()
+        cache.set("alpha", 5)
+        cache.clear()
+        self.assertIsNone(cache.get("alpha"))
+
+    def test_set_with_timeout(self):
+        cache = CacheFake()
+        cache.set("alpha", "django", timeout=5)
+        got = cache.get("alpha")
+        self.assertEqual(got, "django")

killtracker/tests/testdata/factories.py

@@ -14,7 +14,7 @@ from allianceauth.eveonline.models import EveFactionInfo
 
 from killtracker.app_settings import KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER
 from killtracker.constants import EveCategoryId
-from killtracker.core.killmails import (
+from killtracker.core.zkb import (
     Killmail,
     KillmailAttacker,
     KillmailPosition,

killtracker/tests/testdata/helpers.py

@@ -8,7 +8,7 @@ from eveuniverse.models import EveEntity, EveType, EveUniverseEntityModel
 from allianceauth.eveonline.models import EveAllianceInfo, EveCorporationInfo
 from allianceauth.tests.auth_utils import AuthUtils
 
-from killtracker.core.killmails import Killmail
+from killtracker.core.zkb import Killmail
 from killtracker.models import EveKillmail, Webhook
 
 from . import _current_dir

killtracker/tests/utils.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Any, Dict
 
 from app_utils.allianceauth import get_redis_client
 
@@ -14,3 +15,30 @@ def reset_celery_once_locks():
         logger.info("Removed %d stuck celery once keys", deleted_count)
     else:
         deleted_count = 0
+
+
+class CacheFake:
+    """A fake for replacing Django's cache in tests."""
+
+    def __init__(self):
+        self._cache: Dict[str, Any] = {}
+
+    def clear(self) -> None:
+        self._cache.clear()
+
+    def delete(self, key: str, version: int = None) -> None:
+        try:
+            del self._cache[key]
+        except KeyError:
+            pass
+
+    def get(self, key: str, default: Any = None, version: int = None) -> Any:
+        try:
+            return self._cache[key]
+        except KeyError:
+            return default
+
+    def set(
+        self, key: str, value: Any, timeout: int = None, version: int = None
+    ) -> None:
+        self._cache[key] = value

killtracker/exceptions.py

@@ -1,32 +0,0 @@
-"""Custom exceptions for killtracker."""
-
-from typing import Optional
-
-
-class KilltrackerException(Exception):
-    """Exception from Killtracker"""
-
-
-class WebhookTooManyRequests(KilltrackerException):
-    """Webhook is temporarily blocked."""
-
-    DEFAULT_RESET_AFTER = 600
-
-    def __init__(self, retry_after: Optional[int] = None) -> None:
-        """
-        Parameters:
-        - retry_after: time in seconds until this blockage will be reset
-        """
-        super().__init__()
-        if retry_after is None:
-            retry_after = self.DEFAULT_RESET_AFTER
-        self._reset_after = int(retry_after)
-
-    @property
-    def retry_after(self) -> int:
-        """Return in how many seconds to retry."""
-        return self._reset_after
-
-
-class KillmailDoesNotExist(KilltrackerException):
-    """Killmail does not exist in storage."""

killtracker/tests/core/test_worker_shutdown.py

@@ -1,34 +0,0 @@
-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_webhook.py

@@ -1,164 +0,0 @@
-import requests_mock
-
-from django.core.cache import cache
-from django.test import TestCase
-
-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(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)
-
-
-@requests_mock.Mocker()
-class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
-    def setUp(self) -> None:
-        self.message = DiscordMessage(content="Test message")
-        cache.clear()
-
-    def test_when_send_ok_returns_true(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=200,
-            json={
-                "name": "test webhook",
-                "type": 1,
-                "channel_id": "199737254929760256",
-                "token": "3d89bb7572e0fb30d8128367b3b1b44fecd1726de135cbe28a41f8b2f777c372ba2939e72279b94526ff5d1bd4358d65cf11",
-                "avatar": None,
-                "guild_id": "199737254929760256",
-                "id": "223704706495545344",
-                "application_id": None,
-                "user": {
-                    "username": "test",
-                    "discriminator": "7479",
-                    "id": "190320984123768832",
-                    "avatar": "b004ec1740a63ca06ae2e14c5cee11f3",
-                    "public_flags": 131328,
-                },
-            },
-        )
-        # when
-        response = self.webhook_1.send_message(self.message)
-        # then
-        self.assertTrue(response.status_ok)
-        self.assertTrue(requests_mocker.called)
-
-    def test_when_send_not_ok_returns_false(self, requests_mocker):
-        # given
-        requests_mocker.register_uri("POST", self.webhook_1.url, status_code=404)
-        # when
-        response = self.webhook_1.send_message(self.message)
-        # then
-        self.assertFalse(response.status_ok)
-        self.assertTrue(requests_mocker.called)
-
-    def test_too_many_requests_normal(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=429,
-            json={
-                "global": False,
-                "message": "You are being rate limited.",
-                "retry_after": 2000,
-            },
-            headers={
-                "x-ratelimit-remaining": "5",
-                "x-ratelimit-reset-after": "60",
-                "Retry-After": "2000",
-            },
-        )
-        # when/then
-        try:
-            self.webhook_1.send_message(self.message)
-        except Exception as ex:
-            self.assertIsInstance(ex, WebhookTooManyRequests)
-            self.assertEqual(ex.retry_after, 2002)
-        else:
-            self.fail("Did not raise excepted exception")
-
-        self.assertAlmostEqual(
-            cache.ttl(self.webhook_1._blocked_cache_key()), 2002, delta=5
-        )
-
-    def test_too_many_requests_no_retry_value(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=429,
-            headers={
-                "x-ratelimit-remaining": "5",
-                "x-ratelimit-reset-after": "60",
-            },
-        )
-        # when/then
-        try:
-            self.webhook_1.send_message(self.message)
-        except Exception as ex:
-            self.assertIsInstance(ex, WebhookTooManyRequests)
-            self.assertEqual(ex.retry_after, WebhookTooManyRequests.DEFAULT_RESET_AFTER)
-        else:
-            self.fail("Did not raise excepted exception")

killtracker/tests/test_exceptions.py

@@ -1,12 +0,0 @@
-from django.test import TestCase
-
-from killtracker.exceptions import WebhookTooManyRequests
-
-
-class TestExceptions(TestCase):
-    def test_exception(self):
-        ex = WebhookTooManyRequests(10)
-        self.assertEqual(ex.retry_after, 10)
-
-        ex = WebhookTooManyRequests()
-        self.assertEqual(ex.retry_after, 600)