aa-structures 2.2.0__py3-none-any.whl → 2.3.1b1__py3-none-any.whl

structures/tests/test_admin.py

@@ -11,15 +11,16 @@ from eveuniverse.models import EveEntity
 
 from allianceauth.eveonline.models import EveCorporationInfo
 
-from ..admin import (
+from structures.admin import (
     NotificationAdmin,
     OwnerAdmin,
     OwnerAllianceFilter,
     OwnerCorporationsFilter,
     StructureAdmin,
+    StructureFuelAlertConfigAdmin,
     WebhookAdmin,
 )
-from ..models import (
+from structures.models import (
     FuelAlertConfig,
     Notification,
     Owner,
@@ -27,6 +28,13 @@ from ..models import (
     StructureTag,
     Webhook,
 )
+
+from .testdata.factories_2 import (
+    FuelAlertConfigFactory,
+    NotificationFactory,
+    OwnerFactory,
+    StructureFactory,
+)
 from .testdata.helpers import (
     create_structures,
     create_user,
@@ -44,7 +52,7 @@ class MockRequest(object):
         self.user = user
 
 
-class TestFuelNotificationConfigAdmin(TestCase):
+class TestFuelNotificationConfigAdminView(TestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
@@ -55,7 +63,6 @@ class TestFuelNotificationConfigAdmin(TestCase):
         }
         cls.user = User.objects.create_superuser("Clark Kent")
         load_eveuniverse()
-        create_structures()
 
     def test_should_create_new_config(self):
         # given
@@ -74,7 +81,7 @@ class TestFuelNotificationConfigAdmin(TestCase):
     def test_should_update_existing_config(self):
         # given
         self.client.force_login(self.user)
-        config = FuelAlertConfig.objects.create(start=48, end=24, repeat=12)
+        config = FuelAlertConfigFactory(start=48, end=24, repeat=12)
         # when
         response = self.client.post(
             reverse("admin:structures_fuelalertconfig_change", args=[config.pk]),
@@ -89,8 +96,8 @@ class TestFuelNotificationConfigAdmin(TestCase):
     def test_should_remove_existing_fuel_notifications_when_timing_changed(self):
         # given
         self.client.force_login(self.user)
-        config = FuelAlertConfig.objects.create(start=48, end=24, repeat=12)
-        structure = Structure.objects.get(id=1000000000001)
+        config = FuelAlertConfigFactory(start=48, end=24, repeat=12)
+        structure = StructureFactory()
         structure.structure_fuel_alerts.create(
             config=config, structure=structure, hours=5
         )
@@ -108,8 +115,8 @@ class TestFuelNotificationConfigAdmin(TestCase):
     def test_should_not_remove_existing_fuel_notifications_on_other_changes(self):
         # given
         self.client.force_login(self.user)
-        config = FuelAlertConfig.objects.create(start=48, end=24, repeat=12)
-        structure = Structure.objects.get(id=1000000000001)
+        config = FuelAlertConfigFactory(start=48, end=24, repeat=12)
+        structure = StructureFactory()
         structure.structure_fuel_alerts.create(
             config=config, structure=structure, hours=5
         )
@@ -156,7 +163,7 @@ class TestFuelNotificationConfigAdmin(TestCase):
     def test_should_not_allow_creating_overlapping(self):
         # given
         self.client.force_login(self.user)
-        FuelAlertConfig.objects.create(start=48, end=24, repeat=12)
+        FuelAlertConfigFactory(start=48, end=24, repeat=12)
         # when
         response = self.client.post(
             reverse("admin:structures_fuelalertconfig_add"),
@@ -207,6 +214,29 @@ class TestFuelNotificationConfigAdmin(TestCase):
         self.assertEqual(FuelAlertConfig.objects.count(), 0)
 
 
+class TestStructureFuelAlertAdmin(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.modeladmin = StructureFuelAlertConfigAdmin(
+            model=FuelAlertConfig, admin_site=AdminSite()
+        )
+        load_eveuniverse()
+
+    @patch(MODULE_PATH + ".StructureFuelAlertConfigAdmin.message_user", spec=True)
+    @patch(MODULE_PATH + ".tasks", spec=True)
+    def test_should_send_fuel_notifications(self, mock_tasks, mock_message_user):
+        # given
+        config = FuelAlertConfigFactory()
+        request = MockRequest()
+        queryset = FuelAlertConfig.objects.filter(pk=config.pk)
+        # when
+        self.modeladmin.send_fuel_notifications(request, queryset)
+        # then
+        self.assertTrue(mock_tasks.send_queued_messages_for_webhooks.called)
+        self.assertTrue(mock_message_user.called)
+
+
 class TestNotificationAdmin(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -337,10 +367,10 @@ class TestOwnerAdmin(TestCase):
     )
     def test_should_return_correct_turnaround_times(self):
         # given
-        my_owner = Owner.objects.get(corporation__corporation_id=2001)
+        my_owner = OwnerFactory()
         my_sender = EveEntity.objects.get(id=1001)
         my_now = now()
-        Notification.objects.create(
+        NotificationFactory(
             owner=my_owner,
             notification_id=1,
             sender=my_sender,
@@ -350,7 +380,7 @@ class TestOwnerAdmin(TestCase):
         )
         for i in range(50):
             timestamp = my_now + dt.timedelta(minutes=i)
-            Notification.objects.create(
+            NotificationFactory(
                 owner=my_owner,
                 notification_id=2 + i,
                 sender=my_sender,
@@ -422,12 +452,10 @@ class TestStructureAdmin(TestCase):
             list_filter = (OwnerCorporationsFilter,)
 
         Owner.objects.all().delete()
-        owner_2001 = Owner.objects.create(
+        owner_2001 = OwnerFactory(
             corporation=EveCorporationInfo.objects.get(corporation_id=2001)
         )
-        Owner.objects.create(
-            corporation=EveCorporationInfo.objects.get(corporation_id=2002)
-        )
+        OwnerFactory(corporation=EveCorporationInfo.objects.get(corporation_id=2002))
         my_modeladmin = StructureAdminTest(Structure, AdminSite())
 
         # Make sure the lookups are correct
@@ -451,15 +479,13 @@ class TestStructureAdmin(TestCase):
             list_filter = (OwnerAllianceFilter,)
 
         Owner.objects.all().delete()
-        owner_2001 = Owner.objects.create(
+        owner_2001 = OwnerFactory(
             corporation=EveCorporationInfo.objects.get(corporation_id=2001)
         )
-        owner_2002 = Owner.objects.create(
+        owner_2002 = OwnerFactory(
             corporation=EveCorporationInfo.objects.get(corporation_id=2002)
         )
-        Owner.objects.create(
-            corporation=EveCorporationInfo.objects.get(corporation_id=2102)
-        )
+        OwnerFactory(corporation=EveCorporationInfo.objects.get(corporation_id=2102))
         modeladmin = StructureAdminTest(Structure, AdminSite())
 
         # Make sure the lookups are correct

structures/tests/test_integration.py

@@ -16,9 +16,11 @@ from app_utils.esi_testing import EsiClientStub, EsiEndpoint
 from .. import tasks
 from ..models import NotificationType, Structure
 from .testdata.factories_2 import (
+    EveEntityAllianceFactory,
     EveEntityCorporationFactory,
     NotificationFactory,
     OwnerFactory,
+    RawNotificationFactory,
     StarbaseFactory,
     StructureFactory,
     WebhookFactory,
@@ -431,6 +433,91 @@ class TestTasks(TestCase):
         if AuthTimer:
             self.assertTrue(AuthTimer.objects.exists())
 
+    def test_should_fetch_and_send_notification_when_enabled_for_webhook(
+        self, mock_esi_2, mock_esi, mock_execute
+    ):
+        # given
+        webhook = WebhookFactory(
+            notification_types=[NotificationType.WAR_CORPORATION_BECAME_ELIGIBLE]
+        )
+        owner = OwnerFactory(webhooks=[webhook], is_alliance_main=True)
+        eve_character = owner.characters.first().character_ownership.character
+        # corporation_id = owner.corporation.corporation_id
+        notif = RawNotificationFactory()
+        endpoints = [
+            EsiEndpoint(
+                "Character",
+                "get_characters_character_id_notifications",
+                "character_id",
+                needs_token=True,
+                data={
+                    str(eve_character.character_id): [notif],
+                },
+            ),
+        ]
+        mock_esi.client = mock_esi_2.client = EsiClientStub.create_from_endpoints(
+            endpoints
+        )
+        # when
+        tasks.fetch_all_notifications.delay()
+        # then
+        self.assertTrue(mock_execute.called)
+        embed = mock_execute.call_args[1]["embeds"][0]
+        self.assertIn("now eligible", embed.description)
+
+    def test_should_fetch_and_send_notification_when_enabled_for_webhook_all_anchoring(
+        self, mock_esi_2, mock_esi, mock_execute
+    ):
+        # given
+        webhook = WebhookFactory(
+            notification_types=[NotificationType.SOV_ALL_ANCHORING_MSG]
+        )
+        owner = OwnerFactory(webhooks=[webhook], is_alliance_main=False)
+        eve_character = owner.characters.first().character_ownership.character
+        alliance = EveEntityAllianceFactory(
+            id=owner.corporation.alliance_id,
+            name=owner.corporation.alliance.alliance_name,
+        )
+        corporation = EveEntityCorporationFactory(
+            id=owner.corporation.corporation_id, name=owner.corporation.corporation_name
+        )
+        starbase = StarbaseFactory(owner=owner)
+        notif = RawNotificationFactory(
+            type="AllAnchoringMsg",
+            sender=corporation,
+            data={
+                "allianceID": alliance.id,
+                "corpID": corporation.id,
+                "corpsPresent": [{"allianceID": alliance.id, "corpID": corporation.id}],
+                "moonID": starbase.eve_moon.id,
+                "solarSystemID": starbase.eve_solar_system.id,
+                "towers": [
+                    {"moonID": starbase.eve_moon.id, "typeID": starbase.eve_type.id}
+                ],
+                "typeID": starbase.eve_type.id,
+            },
+        )
+        endpoints = [
+            EsiEndpoint(
+                "Character",
+                "get_characters_character_id_notifications",
+                "character_id",
+                needs_token=True,
+                data={
+                    str(eve_character.character_id): [notif],
+                },
+            ),
+        ]
+        mock_esi.client = mock_esi_2.client = EsiClientStub.create_from_endpoints(
+            endpoints
+        )
+        # when
+        tasks.fetch_all_notifications.delay()
+        # then
+        self.assertTrue(mock_execute.called)
+        embed = mock_execute.call_args[1]["embeds"][0]
+        self.assertIn("has anchored in", embed.description)
+
     @patch(NOTIFICATIONS_PATH + ".STRUCTURES_ADD_TIMERS", True)
     def test_should_fetch_new_notification_from_esi_and_send_to_webhook_and_create_timers(
         self, mock_esi_2, mock_esi, mock_execute
@@ -508,7 +595,7 @@ class TestTasks(TestCase):
                 NotificationType.SOV_ALL_CLAIM_LOST_MSG,
             ]
         )
-        owner = OwnerFactory(webhooks=[webhook])
+        owner = OwnerFactory(webhooks=[webhook], is_alliance_main=True)
         NotificationFactory(
             owner=owner, notif_type=NotificationType.STRUCTURE_DESTROYED
         )

structures/tests/testdata/factories_2.py

@@ -142,7 +142,7 @@ class OwnerFactory(factory.django.DjangoModelFactory):
     assets_last_update_at = factory.LazyFunction(now)
     character_ownership = None  # no longer used
     forwarding_last_update_at = factory.LazyFunction(now)
-    is_alliance_main = True
+    is_alliance_main = False
     is_up = True
     notifications_last_update_at = factory.LazyFunction(now)
     structures_last_update_at = factory.LazyFunction(now)
@@ -330,3 +330,36 @@ class GeneratedNotificationFactory(factory.django.DjangoModelFactory):
             state_timer_end=reinforced_until,
         )
         obj.structures.add(starbase)
+
+
+class RawNotificationFactory(factory.DictFactory):
+    """Create a raw notification as received from ESI."""
+
+    class Meta:
+        exclude = ("data", "timestamp_dt", "sender")
+
+    # excluded
+    data = None
+    timestamp_dt = None
+    sender = factory.SubFactory(EveEntityCorporationFactory, id=2902, name="CONCORD")
+
+    # included
+    notification_id = factory.Sequence(lambda o: 1999000000 + o)
+    type = "CorpBecameWarEligible"
+    sender_id = factory.LazyAttribute(lambda o: o.sender.id)
+    sender_type = factory.LazyAttribute(lambda o: o.sender.category)
+    is_read = True
+
+    @factory.lazy_attribute
+    def timestamp(self):
+        if not self.timestamp_dt:
+            timestamp_dt = now()
+        else:
+            timestamp_dt = self.timestamp_dt
+        return datetime_to_esi(timestamp_dt)
+
+    @factory.lazy_attribute
+    def text(self):
+        if not self.data:
+            return ""
+        return yaml.dump(self.data)

structures/views.py

@@ -1,6 +1,7 @@
 import functools
 from collections import defaultdict
 from enum import IntEnum
+from typing import Dict
 from urllib.parse import urlencode
 
 from django.contrib.auth.decorators import login_required, permission_required
@@ -354,7 +355,7 @@ def starbase_detail(request, structure_id):
     assets = defaultdict(int)
     for item in structure.items.select_related("eve_type"):
         assets[item.eve_type_id] += item.quantity
-    eve_types = EveType.objects.in_bulk(id_list=assets.keys())
+    eve_types: Dict[int, EveType] = EveType.objects.in_bulk(id_list=assets.keys())
     modules = sorted(
         [
             {"eve_type": eve_types.get(eve_type_id), "quantity": quantity}
@@ -432,7 +433,7 @@ def add_structure_owner(request, token):
             owner.save()
 
     if owner.characters.count() == 1:
-        tasks.update_all_for_owner.delay(owner_pk=owner.pk, user_pk=request.user.pk)
+        tasks.update_all_for_owner.delay(owner_pk=owner.pk, user_pk=request.user.pk)  # type: ignore
         messages_plus.info(
             request,
             format_html(

structures/tests/core/test_notification_embeds_2.py

@@ -1,78 +0,0 @@
-import dhooks_lite
-
-from app_utils.testing import NoSocketsTestCase
-
-from ...core.notification_embeds import (
-    NotificationBaseEmbed,
-    NotificationTowerReinforcedExtra,
-)
-from ...models import NotificationType
-from ..testdata.factories_2 import (
-    EveEntityAllianceFactory,
-    GeneratedNotificationFactory,
-    NotificationFactory,
-    OwnerFactory,
-)
-from ..testdata.load_eveuniverse import load_eveuniverse
-
-
-class TestGeneratedNotification(NoSocketsTestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        load_eveuniverse()
-
-    def test_should_create_tower_reinforced_embed(self):
-        # given
-        notif = GeneratedNotificationFactory()
-        # when
-        obj = NotificationBaseEmbed.create(notif)
-        # then
-        self.assertIsInstance(obj, NotificationTowerReinforcedExtra)
-
-    def test_should_generate_embed(self):
-        # given
-        notif = GeneratedNotificationFactory()
-        embed = NotificationBaseEmbed.create(notif)
-        # when
-        obj = embed.generate_embed()
-        # then
-        self.assertIsInstance(obj, dhooks_lite.Embed)
-        starbase = notif.structures.first()
-        self.assertIn(starbase.name, obj.description)
-
-
-class TestEveNotificationEmbeds(NoSocketsTestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        load_eveuniverse()
-        cls.owner = OwnerFactory()
-
-    def test_should_create_sov_embed(self):
-        # given
-        notif = NotificationFactory(
-            owner=self.owner,
-            sender=EveEntityAllianceFactory(),
-            notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED,
-            text_from_dict={"solarSystemID": 30000474, "structureTypeID": 32226},
-        )
-        embed = NotificationBaseEmbed.create(notif)
-        # when
-        obj = embed.generate_embed()
-        # then
-        self.assertIsInstance(obj, dhooks_lite.Embed)
-
-    def test_should_create_sov_embed_without_sender(self):
-        # given
-        notif = NotificationFactory(
-            owner=self.owner,
-            sender=None,
-            notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED,
-            text_from_dict={"solarSystemID": 30000474, "structureTypeID": 32226},
-        )
-        embed = NotificationBaseEmbed.create(notif)
-        # when
-        obj = embed.generate_embed()
-        # then
-        self.assertIsInstance(obj, dhooks_lite.Embed)