aa-structures 2.3.0__tar.gz → 2.3.1b1__tar.gz

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aa-structures
-Version: 2.3.0
+Version: 2.3.1b1
 Summary: App for managing Eve Online structures with Alliance Auth
 Project-URL: Homepage, https://gitlab.com/ErikKalkoken/aa-structures
 Project-URL: Documentation, https://aa-structures.readthedocs.io/en/latest/

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/structures/__init__.py

@@ -1,4 +1,4 @@
 default_app_config = "structures.apps.StructuresConfig"
 
-__version__ = "2.3.0"
+__version__ = "2.3.1b1"
 __title__ = "Structures"

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/structures/models/notifications.py

@@ -239,7 +239,7 @@ class NotificationType(models.TextChoices):
             cls.SOV_STRUCTURE_REINFORCED,
             cls.SOV_STRUCTURE_DESTROYED,
             cls.SOV_ALL_CLAIM_LOST_MSG,
-            cls.SOV_ALL_ANCHORING_MSG,
+            # cls.SOV_ALL_ANCHORING_MSG, # This notif is not broadcasted to all corporations
             # wars
             cls.WAR_ALLY_JOINED_WAR_AGGRESSOR_MSG,
             cls.WAR_ALLY_JOINED_WAR_AllY_MSG,

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/structures/tests/models/test_notifications_1.py

@@ -121,47 +121,73 @@ class TestNotificationFilterForAllianceLevel(NoSocketsTestCase):
         # given
         self.owner.is_alliance_main = False
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000509)
+        notifs = self.owner.notification_set.exclude(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_non_alliance_notifications_2(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000509)
+        notifs = self.owner.notification_set.exclude(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_filter_alliance_notifications(self):
         # given
         self.owner.is_alliance_main = False
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000803)
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertTrue(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertTrue(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_1(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        notif = self.owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_2(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
+        # when/then
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_3(self):
         # given
         _, owner = set_owner_character(character_id=1102)  # corp with no alliance
         load_notification_entities(owner)
-        notif = owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
+        # when/then
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
 
 class TestNotificationCreateFromStructure(NoSocketsTestCase):

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/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
         )

{aa_structures-2.3.0 → aa_structures-2.3.1b1}/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)