aa-killtracker 0.11.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

killtracker/tests/models/test_trackers_1.py

@@ -19,6 +19,7 @@ from allianceauth.tests.auth_utils import AuthUtils
 from app_utils.esi_testing import BravadoOperationStub
 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.models import Tracker
 
@@ -30,7 +31,7 @@ from ..testdata.factories import (
 )
 from ..testdata.helpers import LoadTestDataMixin, load_killmail
 
-MODULE_PATH = "killtracker.models.trackers"
+MODELS_PATH = "killtracker.models"
 
 
 def esi_get_route_origin_destination(origin, destination, **kwargs) -> list:
@@ -80,7 +81,7 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
         expected = {10000001, 10000002, 10000003, 10000004, 10000005}
         self.assertSetEqual(results, expected)
 
-    @patch(MODULE_PATH + ".KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER", 60)
+    @patch(MODELS_PATH + ".trackers.KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER", 60)
     def test_excludes_older_killmails(self):
         tracker = TrackerFactory(
             name="Test",
@@ -143,7 +144,7 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
         expected = {10000002, 10000003, 10000004}
         self.assertSetEqual(results, expected)
 
-    @patch("eveuniverse.models.esi")
+    @patch("eveuniverse.models.universe_2.esi")
     def test_can_filter_max_jumps(self, mock_esi):
         mock_esi.client.Routes.get_route_origin_destination.side_effect = (
             esi_get_route_origin_destination
@@ -159,7 +160,7 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
         expected = {10000102, 10000103}
         self.assertSetEqual(results, expected)
 
-    @patch("eveuniverse.models.esi")
+    @patch("eveuniverse.models.universe_2.esi")
     def test_can_filter_max_distance(self, mock_esi):
         mock_esi.client.Routes.get_route_origin_destination.side_effect = (
             esi_get_route_origin_destination
@@ -271,8 +272,8 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
     def test_can_require_attackers_ship_groups(self):
         killmail_ids = {10000101, 10000201}
         tracker = TrackerFactory(webhook=self.webhook_1)
-        frigate = EveGroup.objects.get(id=25)
-        td3s = EveGroup.objects.get(id=1305)
+        frigate = EveGroup.objects.get(id=EveGroupId.FRIGATE)
+        td3s = EveGroup.objects.get(id=EveGroupId.TACTICAL_DESTROYER)
         tracker.require_attackers_ship_groups.add(frigate)
         tracker.require_attackers_ship_groups.add(td3s)
         results = self._matching_killmails(tracker, killmail_ids)
@@ -284,7 +285,7 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
     def test_can_require_victim_ship_group(self):
         killmail_ids = {10000101, 10000201}
         tracker = TrackerFactory(webhook=self.webhook_1)
-        td3s = EveGroup.objects.get(id=1305)
+        td3s = EveGroup.objects.get(id=EveGroupId.TACTICAL_DESTROYER)
         tracker.require_victim_ship_groups.add(td3s)
         results = self._matching_killmails(tracker, killmail_ids)
         self.assertEqual(len(results), 1)
@@ -526,8 +527,52 @@ class TestTrackerCalculate2(LoadTestDataMixin, NoSocketsTestCase):
         # then
         self.assertIsNone(result)
 
+    def test_should_accept_with_require_attacker_weapon_group(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2977)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook_1)
+        tracker.require_attackers_weapon_groups.add(
+            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
+        )
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertEqual(killmail.id, result.id)
+
+    def test_should_deny_with_require_attacker_weapon_group(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2488)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook_1)
+        tracker.require_attackers_weapon_groups.add(
+            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
+        )
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_with_require_attacker_weapon_type(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2977)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook_1)
+        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertEqual(killmail.id, result.id)
+
+    def test_should_deny_with_require_attacker_weapon_type(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2488)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook_1)
+        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
 
-@patch(MODULE_PATH + ".EveSolarSystem.jumps_to")
+@patch(MODELS_PATH + ".trackers.EveSolarSystem.jumps_to")
 class TestTrackerCalculateTrackerInfo(LoadTestDataMixin, NoSocketsTestCase):
     def setUp(self) -> None:
         self.tracker = TrackerFactory(webhook=self.webhook_1)
@@ -622,8 +667,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
         self.tracker = TrackerFactory(name="My Tracker", webhook=self.webhook_1)
         self.webhook_1.main_queue.clear()
 
-    @patch(MODULE_PATH + ".KILLTRACKER_WEBHOOK_SET_AVATAR", True)
-    @patch("eveuniverse.models.esi")
+    @patch(MODELS_PATH + ".webhooks.KILLTRACKER_WEBHOOK_SET_AVATAR", True)
+    @patch("eveuniverse.models.universe_2.esi")
     def test_normal(self, mock_esi):
         mock_esi.client.Routes.get_route_origin_destination.side_effect = (
             esi_get_route_origin_destination
@@ -649,8 +694,8 @@ class TestTrackerEnqueueKillmail(LoadTestDataMixin, TestCase):
         self.assertIn("Combat Battlecruiser", embed["description"])
         self.assertIn("Tracked ship types", embed["description"])
 
-    @patch(MODULE_PATH + ".KILLTRACKER_WEBHOOK_SET_AVATAR", False)
-    @patch("eveuniverse.models.esi")
+    @patch(MODELS_PATH + ".webhooks.KILLTRACKER_WEBHOOK_SET_AVATAR", False)
+    @patch("eveuniverse.models.universe_2.esi")
     def test_disabled_avatar(self, mock_esi):
         mock_esi.client.Routes.get_route_origin_destination.side_effect = (
             esi_get_route_origin_destination

killtracker/tests/models/test_trackers_2.py

@@ -1,21 +1,14 @@
-import json
 from unittest.mock import patch
 
-import dhooks_lite
-import requests_mock
 from bs4 import BeautifulSoup
 from markdown import markdown
 
-from django.core.cache import cache
 from django.test import TestCase
 from eveuniverse.models import EveConstellation, EveRegion, EveSolarSystem, EveType
 
-from app_utils.json import JSONDateTimeDecoder
 from app_utils.testing import NoSocketsTestCase
 
 from killtracker.core.killmails import Killmail
-from killtracker.exceptions import WebhookTooManyRequests
-from killtracker.models import Webhook
 
 from ..testdata.factories import TrackerFactory
 from ..testdata.helpers import LoadTestDataMixin, load_killmail
@@ -23,47 +16,6 @@ from ..testdata.helpers import LoadTestDataMixin, load_killmail
 MODELS_PATH = "killtracker.models.trackers"
 
 
-class TestWebhookQueue(LoadTestDataMixin, TestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-    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_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("")
-
-
 class TestHasLocalizationClause(LoadTestDataMixin, NoSocketsTestCase):
     def test_has_localization_filter_1(self):
         tracker = TrackerFactory.build(webhook=self.webhook_1, exclude_high_sec=True)
@@ -137,102 +89,6 @@ class TestSaveMethod(LoadTestDataMixin, NoSocketsTestCase):
         self.assertFalse(tracker.color)
 
 
-@requests_mock.Mocker()
-class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
-    def setUp(self) -> None:
-        self.message = Webhook._discord_message_asjson(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_to_webhook(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_to_webhook(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_to_webhook(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_to_webhook(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")
-
-
 @patch(MODELS_PATH + ".Webhook.enqueue_message")
 class TestTrackerGenerateKillmailMessage(LoadTestDataMixin, TestCase):
     def setUp(self) -> None:

killtracker/tests/models/test_webhook.py

@@ -0,0 +1,150 @@
+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.exceptions import WebhookTooManyRequests
+from killtracker.models import Webhook
+from killtracker.tests.testdata.helpers import LoadTestDataMixin
+
+
+class TestWebhookQueue(LoadTestDataMixin, TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+    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_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("")
+
+
+@requests_mock.Mocker()
+class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
+    def setUp(self) -> None:
+        self.message = Webhook._discord_message_asjson(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_to_webhook(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_to_webhook(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_to_webhook(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_to_webhook(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_admin.py

@@ -1,16 +1,15 @@
 from django.contrib.auth.models import User
+from django.test import TestCase
 from django.urls import reverse
 from django_webtest import WebTest
-from eveuniverse.models import EveType
 
 from allianceauth.eveonline.models import EveCorporationInfo
-from app_utils.testing import create_fake_user
+from app_utils.testdata_factories import UserFactory
 
 from killtracker.models import Tracker, Webhook
 
-from .testdata.factories import TrackerFactory
+from .testdata.factories import TrackerFactory, WebhookFactory
 from .testdata.helpers import LoadTestDataMixin
-from .testdata.load_eveuniverse import load_eveuniverse
 
 
 class TestTrackerChangeList(LoadTestDataMixin, WebTest):
@@ -97,34 +96,6 @@ class TestTrackerValidations(LoadTestDataMixin, WebTest):
         self.assertIn("Please correct the error below", response.text)
         self.assertEqual(Tracker.objects.count(), 0)
 
-    def test_can_not_have_same_options_attacker_alliances(self):
-        form = self._open_page()
-        form["exclude_attacker_alliances"] = [
-            self.alliance_3001.pk,
-            self.alliance_3011.pk,
-        ]
-        form["require_attacker_alliances"] = [self.alliance_3001.pk]
-        response = form.submit()
-
-        # assert results
-        self.assertEqual(response.status_code, 200)
-        self.assertIn("Please correct the error below", response.text)
-        self.assertEqual(Tracker.objects.count(), 0)
-
-    def test_can_not_have_same_options_attacker_corporations(self):
-        form = self._open_page()
-        form["exclude_attacker_corporations"] = [
-            self.corporation_2001.pk,
-            self.corporation_2011.pk,
-        ]
-        form["require_attacker_corporations"] = [self.corporation_2011.pk]
-        response = form.submit()
-
-        # assert results
-        self.assertEqual(response.status_code, 200)
-        self.assertIn("Please correct the error below", response.text)
-        self.assertEqual(Tracker.objects.count(), 0)
-
     def test_min_attackers_must_be_less_than_max_attackers(self):
         form = self._open_page()
         form["require_min_attackers"] = 10
@@ -161,142 +132,32 @@ class TestTrackerValidations(LoadTestDataMixin, WebTest):
         self.assertEqual(Tracker.objects.count(), 0)
 
 
-class TestTrackerChangeForm(WebTest):
+class TestTrackerValidations2(TestCase):
     @classmethod
-    def setUpClass(cls) -> None:
+    def setUpClass(cls):
         super().setUpClass()
-        cls.user = create_fake_user(1001, "Bruce Wayne")
-        cls.user.is_staff = True
-        cls.user.is_superuser = True
-        cls.user.save()
-        load_eveuniverse()
-        cls.npc_type = EveType.objects.get(id=23320)
-
-    def test_do_not_show_npcs_when_not_used_and_not_enabled(self):
-        # given
-        tracker = TrackerFactory()
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertNotIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertNotIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-    def test_show_npcs_when_in_use(self):
-        # given
-        tracker = TrackerFactory()
-        tracker.require_attackers_ship_types.add(self.npc_type)
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
+        cls.user = UserFactory(is_staff=True, is_superuser=True)
+        cls.webhook = WebhookFactory()
+        cls.url_add = reverse("admin:killtracker_tracker_add")
+        cls.url_changelist = reverse("admin:killtracker_tracker_changelist")
 
-    def test_show_npcs_when_enabled(self):
+    def test_should_add_new_tracker(self):
         # given
-        tracker = TrackerFactory()
-        tracker.require_attackers_ship_types.add(self.npc_type)
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        self.app.session["killtracker_toogle_npc"] = True
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
+        self.client.force_login(self.user)
+        data = {
+            "name": "Dummy",
+            "webhook": self.webhook.pk,
+            "_save": "Save",
+            "is_enabled": "on",
+            "color": "#000000",
+            "ping_type": "PN",
+            "is_posting_name": "on",
         }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
 
-    def test_can_enable_npcs(self):
-        # given
-        tracker = TrackerFactory()
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        initial_page = self.app.get(url)
         # when
-        response = initial_page.click(linkid="toogle-npc").follow()
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-
-class TestTrackerAddForm(WebTest):
-    @classmethod
-    def setUpClass(cls) -> None:
-        super().setUpClass()
-        cls.user = create_fake_user(1001, "Bruce Wayne")
-        cls.user.is_staff = True
-        cls.user.is_superuser = True
-        cls.user.save()
-        load_eveuniverse()
-        cls.npc_type = EveType.objects.get(id=23320)
+        response = self.client.post(self.url_add, data=data)
 
-    def test_do_not_show_npcs_when_not_enabled(self):
-        # given
-        url = reverse("admin:killtracker_tracker_add")
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertNotIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertNotIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-    def test_can_enable_npcs(self):
-        # given
-        url = reverse("admin:killtracker_tracker_add")
-        self.app.set_user(self.user)
-        initial_page = self.app.get(url)
-        # when
-        response = initial_page.click(linkid="toogle-npc").follow()
         # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response.url, self.url_changelist)
+        self.assertTrue(Tracker.objects.filter(name="Dummy").exists())

killtracker/tests/test_integration.py

@@ -19,7 +19,7 @@ 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 + ".tasks.is_esi_online", lambda: True)
-@patch(PACKAGE_PATH + ".models.trackers.dhooks_lite.Webhook.execute", spec=True)
+@patch(PACKAGE_PATH + ".models.webhooks.dhooks_lite.Webhook.execute", spec=True)
 @requests_mock.Mocker()
 class TestTasksEnd2End(LoadTestDataMixin, TestCase):
     @classmethod