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

killtracker/tests/core/test_discord.py

@@ -0,0 +1,184 @@
+import datetime as dt
+from unittest.mock import patch
+
+import dhooks_lite
+import requests_mock
+
+from django.utils.timezone import now
+
+from app_utils.testing import NoSocketsTestCase
+
+from killtracker.core.discord import (
+    DiscordMessage,
+    HTTPError,
+    WebhookRateLimitExhausted,
+    _make_key_last_request,
+    _make_key_retry_at,
+    send_message_to_webhook,
+)
+from killtracker.tests.utils import CacheFake
+
+MODULE_PATH = "killtracker.core.discord"
+
+
+class TestDiscordMessage(NoSocketsTestCase):
+    def test_can_create(self):
+        o = DiscordMessage(content="content")
+        self.assertEqual(o.content, "content")
+
+    def test_should_raise_exception_when_invalid(self):
+        with self.assertRaises(ValueError):
+            DiscordMessage(username="user")
+
+    def test_can_convert_to_and_from_json_1(self):
+        o1 = DiscordMessage(
+            content="content",
+        )
+        s = o1.to_json()
+        o2 = DiscordMessage.from_json(s)
+        self.assertEqual(o1, o2)
+
+    def test_can_convert_to_and_from_json_2(self):
+        o1 = DiscordMessage(
+            avatar_url="avatar_url",
+            content="content",
+            embeds=[dhooks_lite.Embed(description="description")],
+            killmail_id=42,
+            username="username",
+        )
+        s = o1.to_json()
+        o2 = DiscordMessage.from_json(s)
+        self.assertEqual(o1, o2)
+
+
+@requests_mock.Mocker()
+@patch(MODULE_PATH + ".cache", new_callable=CacheFake)
+class TestWebhookSendMessage(NoSocketsTestCase):
+    def setUp(self) -> None:
+        self.name = "webhook"
+        self.message = DiscordMessage(content="Test message")
+        self.url = "https://webhook.example.com/1234"
+        self.message_api = {
+            "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,
+            },
+        }
+
+    def test_when_send_ok_returns_true(self, requests_mocker, mock_cache):
+        # given
+        requests_mocker.register_uri(
+            "POST", self.url, status_code=200, json=self.message_api
+        )
+        # when
+        got = send_message_to_webhook(
+            name=self.name, url=self.url, message=self.message
+        )
+        # then
+        self.assertEqual(got, 223704706495545344)
+        self.assertTrue(requests_mocker.called)
+
+    def test_should_ignore_invalid_key_for_last_request(
+        self, requests_mocker, mock_cache
+    ):
+        # given
+        mock_cache.set(_make_key_last_request(self.url), "invalid")
+        requests_mocker.register_uri(
+            "POST", self.url, status_code=200, json=self.message_api
+        )
+        # when
+        got = send_message_to_webhook(
+            name=self.name, url=self.url, message=self.message
+        )
+        # then
+        self.assertEqual(got, 223704706495545344)
+        self.assertTrue(requests_mocker.called)
+
+    def test_should_ignore_invalid_key_for_retry_at(self, requests_mocker, mock_cache):
+        # given
+        mock_cache.set(_make_key_retry_at(self.url), "invalid")
+        requests_mocker.register_uri(
+            "POST", self.url, status_code=200, json=self.message_api
+        )
+        # when
+        got = send_message_to_webhook(
+            name=self.name, url=self.url, message=self.message
+        )
+        # then
+        self.assertEqual(got, 223704706495545344)
+        self.assertTrue(requests_mocker.called)
+
+    def test_when_send_not_ok_raise_error(self, requests_mocker, mock_cache):
+        # given
+        requests_mocker.register_uri("POST", self.url, status_code=404)
+        # when
+        with self.assertRaises(HTTPError) as ctx:
+            send_message_to_webhook(name=self.name, url=self.url, message=self.message)
+        # then
+        self.assertEqual(ctx.exception.status_code, 404)
+        self.assertTrue(requests_mocker.called)
+
+    def test_raise_too_many_requests_when_received_from_api(
+        self, requests_mocker, mock_cache
+    ):
+        # given
+        requests_mocker.register_uri(
+            "POST",
+            self.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
+        with self.assertRaises(WebhookRateLimitExhausted) as ctx:
+            send_message_to_webhook(name=self.name, url=self.url, message=self.message)
+
+        self.assertTrue(ctx.exception.retry_at)
+
+    def test_too_many_requests_no_retry_value(self, requests_mocker, mock_cache):
+        # given
+        requests_mocker.register_uri(
+            "POST",
+            self.url,
+            status_code=429,
+            headers={
+                "x-ratelimit-remaining": "5",
+                "x-ratelimit-reset-after": "60",
+            },
+        )
+        # when/then
+        with self.assertRaises(WebhookRateLimitExhausted) as ctx:
+            send_message_to_webhook(name=self.name, url=self.url, message=self.message)
+
+        self.assertTrue(ctx.exception.retry_at)
+
+    def test_should_reraise_exception_when_not_expired(
+        self, requests_mocker, mock_cache
+    ):
+        # given
+        key = _make_key_retry_at(self.url)
+        mock_cache.set(key, now() + dt.timedelta(hours=1))
+        # when
+        with self.assertRaises(WebhookRateLimitExhausted) as ctx:
+            send_message_to_webhook(name=self.name, url=self.url, message=self.message)
+        # then
+        self.assertTrue(ctx.exception.retry_at)

killtracker/tests/core/test_helpers.py

@@ -0,0 +1,23 @@
+import datetime as dt
+from typing import Any, NamedTuple, Optional
+from unittest import TestCase
+
+from killtracker.core.helpers import datetime_or_none
+
+
+class TestDatetimeOrNone(TestCase):
+    def test_should_return_value(self):
+        class Case(NamedTuple):
+            value: Any
+            want: Optional[dt.datetime]
+
+        now = dt.datetime.now()
+        cases = [
+            Case(now, now),
+            Case("abc", None),
+            Case(42, None),
+            Case(None, None),
+        ]
+        for tc in cases:
+            got = datetime_or_none(tc.value)
+            self.assertIs(got, tc.want)

killtracker/tests/core/{test_discord_messages_1.py → test_tracker_1.py}

@@ -2,7 +2,10 @@ import dhooks_lite
 
 from app_utils.testing import NoSocketsTestCase
 
-from killtracker.core import discord_messages
+from killtracker.core.trackers import (
+    _create_embed,
+    create_discord_message_from_killmail,
+)
 from killtracker.tests.testdata.factories import (
     EveEntityVariant,
     KillmailFactory,
@@ -25,7 +28,7 @@ class TestCreateEmbed(NoSocketsTestCase):
         tracker = TrackerFactory()
         killmail = KillmailFactory()
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -34,7 +37,7 @@ class TestCreateEmbed(NoSocketsTestCase):
         tracker = TrackerFactory()
         killmail = KillmailFactory(zkb__total_value=None)
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -43,7 +46,7 @@ class TestCreateEmbed(NoSocketsTestCase):
         tracker = TrackerFactory()
         killmail = KillmailFactory(victim__alliance_id=None)
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -54,7 +57,7 @@ class TestCreateEmbed(NoSocketsTestCase):
             victim__alliance_id=None, victim__corporation_id=None
         )
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -64,7 +67,7 @@ class TestCreateEmbed(NoSocketsTestCase):
         killmail = KillmailFactory()
         killmail.attackers.remove(killmail.attacker_final_blow())
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -73,7 +76,7 @@ class TestCreateEmbed(NoSocketsTestCase):
         tracker = TrackerFactory()
         killmail = KillmailFactory().clone_with_tracker_info(tracker.pk)
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
 
@@ -85,6 +88,23 @@ class TestCreateEmbed(NoSocketsTestCase):
             tracker.pk, jumps=3, distance=3.5, matching_ship_type_ids=[ship_type.id]
         )
         # when
-        embed = discord_messages.create_embed(tracker, killmail)
+        embed = _create_embed(tracker, killmail)
         # then
         self.assertIsInstance(embed, dhooks_lite.Embed)
+
+
+class TestDiscordMessageFromKillmail(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+        load_eve_entities()
+
+    def test_should_create_from_killmail(self):
+        # given
+        tracker = TrackerFactory()
+        killmail = KillmailFactory()
+        # when
+        m = create_discord_message_from_killmail(tracker, killmail)
+        # then
+        self.assertIsInstance(m.embeds[0], dhooks_lite.Embed)

killtracker/tests/core/{test_discord_messages_2.py → test_tracker_2.py}

@@ -8,16 +8,16 @@ from django.test import TestCase
 
 from app_utils.django import app_labels
 
-from killtracker.core.killmails import Killmail
+from killtracker.core.zkb import Killmail
 from killtracker.models import Tracker
 from killtracker.tests.testdata.factories import TrackerFactory
 from killtracker.tests.testdata.helpers import LoadTestDataMixin, load_killmail
 
-DISCORD_MESSAGES_PATH = "killtracker.core.discord_messages"
+MODULE_PATH = "killtracker.core.trackers"
 
 if "discord" in app_labels():
 
-    @patch(DISCORD_MESSAGES_PATH + "._import_discord_user")
+    @patch(MODULE_PATH + "._import_discord_user")
     class TestGroupPings(LoadTestDataMixin, TestCase):
         @classmethod
         def setUpClass(cls):
@@ -51,8 +51,8 @@ if "discord" in app_labels():
             self.assertTrue(
                 mock_import_discord_user.return_value.objects.group_to_role.called
             )
-            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(f"<@&{self.group_1.pk}>", message["content"])
 
         def test_can_ping_multiple_groups(self, mock_import_discord_user):
@@ -70,8 +70,8 @@ if "discord" in app_labels():
             self.assertTrue(
                 mock_import_discord_user.return_value.objects.group_to_role.called
             )
-            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(f"<@&{self.group_1.pk}>", message["content"])
             self.assertIn(f"<@&{self.group_2.pk}>", message["content"])
 
@@ -91,8 +91,8 @@ if "discord" in app_labels():
             self.assertTrue(
                 mock_import_discord_user.return_value.objects.group_to_role.called
             )
-            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(f"<@&{self.group_1.pk}>", message["content"])
             self.assertIn("@here", message["content"])
 
@@ -110,6 +110,6 @@ if "discord" in app_labels():
             self.assertTrue(
                 mock_import_discord_user.return_value.objects.group_to_role.called
             )
-            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(f"<@&{self.group_1.pk}>", message["content"])

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)