aa-structures 2.9.1__py3-none-any.whl → 2.11.0__py3-none-any.whl

structures/tests/models/test_owners_1.py

@@ -318,20 +318,21 @@ class TestOwnerFetchToken(NoSocketsTestCase):
         self.assertTrue(mock_notify.called)
         self.assertEqual(owner.characters.count(), 0)
 
-    def test_raise_error_when_token_not_found_and_delete_character(
+    def test_raise_error_when_no_valid_token_found_and_disable_character(
         self, mock_notify_admins, mock_notify
     ):
         # given
-        character = EveCharacterFactory()
-        user = UserMainDefaultOwnerFactory(main_character__character=character)
-        owner = OwnerFactory(user=user, characters=[character])
-        user.token_set.first().scopes.clear()
+        eve_character = EveCharacterFactory()
+        user = UserMainDefaultOwnerFactory(main_character__character=eve_character)
+        owner = OwnerFactory(user=user, characters=[eve_character])
+        user.token_set.first().scopes.clear()  # token no longer valid
         # when/then
         with self.assertRaises(TokenError):
             owner.fetch_token()
+        character = owner.characters.first()
+        self.assertFalse(character.is_enabled)
         self.assertTrue(mock_notify_admins.called)
         self.assertTrue(mock_notify.called)
-        self.assertEqual(owner.characters.count(), 0)
 
     def test_raise_error_when_character_no_longer_a_corporation_member_and_delete_it(
         self, mock_notify_admins, mock_notify
@@ -351,37 +352,7 @@ class TestOwnerFetchToken(NoSocketsTestCase):
         self.assertTrue(mock_notify.called)
         self.assertEqual(owner.characters.count(), 0)
 
-    def test_should_delete_invalid_characters_and_return_token_from_valid_char(
-        self, mock_notify_admins, mock_notify
-    ):
-        # given
-        character_1 = EveCharacterFactory()
-        user = UserMainDefaultOwnerFactory(main_character__character=character_1)
-        owner = OwnerFactory(
-            user=user,
-            characters=[character_1],
-            characters__notifications_last_used_at=dt.datetime(
-                2021, 1, 1, 1, 2, tzinfo=utc
-            ),
-        )
-        character_2 = EveCharacterFactory()
-        OwnerCharacterFactory(
-            owner=owner,
-            eve_character=character_2,
-            notifications_last_used_at=dt.datetime(2021, 1, 1, 1, 1, tzinfo=utc),
-        )
-
-        # when
-        token = owner.fetch_token()
-
-        # then
-        self.assertIsInstance(token, Token)
-        self.assertEqual(token.user, user)
-        self.assertTrue(mock_notify_admins.called)
-        self.assertTrue(mock_notify.called)
-        self.assertEqual(owner.characters.count(), 1)
-
-    def test_should_rotate_through_characters_for_notification(
+    def test_should_rotate_through_enabled_characters_for_notification(
         self, mock_notify_admins, mock_notify
     ):
         # given
@@ -398,6 +369,9 @@ class TestOwnerFetchToken(NoSocketsTestCase):
             owner=owner,
             notifications_last_used_at=dt.datetime(2021, 1, 1, 3, 0, tzinfo=utc),
         )
+        OwnerCharacterFactory(
+            owner=owner, is_enabled=False
+        )  # this one should be ignore
         tokens_received = []
 
         # when
@@ -493,6 +467,36 @@ class TestOwnerFetchToken(NoSocketsTestCase):
             ],
         )
 
+    def test_should_delete_invalid_characters_and_return_token_from_valid_char(
+        self, mock_notify_admins, mock_notify
+    ):
+        # given
+        character_1 = EveCharacterFactory()
+        user = UserMainDefaultOwnerFactory(main_character__character=character_1)
+        owner = OwnerFactory(
+            user=user,
+            characters=[character_1],
+            characters__notifications_last_used_at=dt.datetime(
+                2021, 1, 1, 1, 2, tzinfo=utc
+            ),
+        )
+        character_2 = EveCharacterFactory()  # invalid, because of different corporation
+        OwnerCharacterFactory(
+            owner=owner,
+            eve_character=character_2,
+            notifications_last_used_at=dt.datetime(2021, 1, 1, 1, 1, tzinfo=utc),
+        )
+
+        # when
+        token = owner.fetch_token()
+
+        # then
+        self.assertIsInstance(token, Token)
+        self.assertEqual(token.user, user)
+        self.assertTrue(mock_notify_admins.called)
+        self.assertTrue(mock_notify.called)
+        self.assertEqual(owner.characters.count(), 1)
+
 
 class TestOwnerCharacters(NoSocketsTestCase):
     @classmethod
@@ -500,12 +504,6 @@ class TestOwnerCharacters(NoSocketsTestCase):
         super().setUpClass()
         cls.owner = OwnerFactory()
 
-    def test_should_return_str(self):
-        # given
-        character = OwnerCharacterFactory(owner=self.owner)
-        # when/then
-        self.assertTrue(str(character))
-
     def test_should_add_new_character(self):
         # given
         character = EveCharacterFactory(corporation=self.owner.corporation)
@@ -546,22 +544,35 @@ class TestOwnerCharacters(NoSocketsTestCase):
         with self.assertRaises(ValueError):
             self.owner.add_character(character_ownership)
 
-    def test_should_count_characters(self):
+    def test_should_count_enabled_characters_only(self):
         # given
-        OwnerCharacterFactory(owner=self.owner)
+        OwnerCharacterFactory(owner=self.owner, is_enabled=False)
         # when
-        result = self.owner.characters_count()
+        result = self.owner.valid_characters_count()
         # then
-        self.assertEqual(result, 2)
+        self.assertEqual(result, 1)
 
     def test_should_count_characters_when_empty(self):
         # given
         owner = OwnerFactory(characters=False)
         # when
-        result = owner.characters_count()
+        result = owner.valid_characters_count()
         # then
         self.assertEqual(result, 0)
 
+    def test_should_reset_character_when_re_adding(self):
+        # given
+        character: OwnerCharacter = self.owner.characters.first()
+        character.is_enabled = False
+        character.disabled_reason = "some reason"
+        character.save()
+        # when
+        self.owner.add_character(character.character_ownership)
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertFalse(character.disabled_reason)
+
 
 @patch(MODULE_PATH + ".notify", spec=True)
 @patch(MODULE_PATH + ".notify_admins", spec=True)
@@ -577,7 +588,7 @@ class TestOwnerDeleteCharacter(NoSocketsTestCase):
         user = character.character_ownership.user
 
         # when
-        self.owner.delete_character(character=character, error="dummy error")
+        self.owner.delete_character(character=character, reason="dummy error")
 
         # then
         self.assertEqual(self.owner.characters.count(), 0)
@@ -591,18 +602,50 @@ class TestOwnerDeleteCharacter(NoSocketsTestCase):
         self.assertEqual(kwargs["user"], user)
         self.assertEqual(kwargs["level"], "warning")
 
-    def test_should_not_delete_when_errors_are_allowed(
+
+@patch(MODULE_PATH + ".notify", spec=True)
+@patch(MODULE_PATH + ".notify_admins", spec=True)
+class TestOwnerDisableCharacters(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.owner = OwnerFactory(characters=False)
+
+    def test_should_disable_character_and_notify(self, mock_notify_admins, mock_notify):
+        # given
+        character = OwnerCharacterFactory(owner=self.owner)
+        user = character.character_ownership.user
+
+        # when
+        self.owner.disable_character(character=character, reason="dummy error")
+
+        # then
+        character.refresh_from_db()
+        self.assertFalse(character.is_enabled)
+        self.assertTrue(character.disabled_reason)
+        self.assertTrue(mock_notify_admins.called)
+        _, kwargs = mock_notify_admins.call_args
+        self.assertIn("dummy error", kwargs["message"])
+        self.assertEqual(kwargs["level"], "danger")
+        self.assertTrue(mock_notify.called)
+        _, kwargs = mock_notify.call_args
+        self.assertIn("dummy error", kwargs["message"])
+        self.assertEqual(kwargs["user"], user)
+        self.assertEqual(kwargs["level"], "warning")
+
+    def test_should_not_disable_when_error_counter_above_zero(
         self, mock_notify_admins, mock_notify
     ):
         # given
         character = OwnerCharacterFactory(owner=self.owner)
 
         # when
-        self.owner.delete_character(
-            character=character, error="dummy error", max_allowed_errors=1
+        self.owner.disable_character(
+            character=character, reason="dummy error", max_allowed_errors=1
         )
         # then
         character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
         self.assertEqual(character.error_count, 1)
         self.assertFalse(mock_notify_admins.called)
         self.assertFalse(mock_notify.called)

structures/tests/models/test_owners_4.py

@@ -7,7 +7,7 @@ from app_utils.esi_testing import EsiClientStub, EsiEndpoint
 from app_utils.testing import NoSocketsTestCase
 
 from structures.constants import EveCorporationId
-from structures.models import StarbaseDetail, Structure
+from structures.models import OwnerCharacter, StarbaseDetail, Structure
 from structures.tests.testdata.factories import (
     EveEntityCorporationFactory,
     OwnerFactory,
@@ -353,12 +353,13 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         owner.refresh_from_db()
         self.assertFalse(owner.is_structure_sync_fresh)
         self.assertTrue(mock_notify)
-        character = owner.characters.first()
+        character: OwnerCharacter = owner.characters.first()
         self.assertEqual(character.error_count, 1)
+        self.assertTrue(character.is_enabled)
 
     @patch(MODULE_PATH + ".STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES", 3)
     @patch(MODULE_PATH + ".notify", spec=True)
-    def test_should_remove_character_when_not_director_while_updating_starbases(
+    def test_should_disable_character_when_not_director_while_updating_starbases(
         self, mock_notify, mock_esi
     ):
         # given
@@ -369,7 +370,7 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         )
         mock_esi.client = self.esi_client_stub.replace_endpoints([new_endpoint])
         owner = OwnerFactory(user=self.user, structures_last_update_at=None)
-        character = owner.characters.first()
+        character: OwnerCharacter = owner.characters.first()
         character.error_count = 3
         character.save()
         # when
@@ -378,7 +379,22 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         owner.refresh_from_db()
         self.assertFalse(owner.is_structure_sync_fresh)
         self.assertTrue(mock_notify)
-        self.assertNotIn(character, owner.characters.all())
+        character.refresh_from_db()
+        self.assertFalse(character.is_enabled)
+
+    def test_should_reset_error_count_for_character_when_successful(self, mock_esi):
+        # given
+        mock_esi.client = self.esi_client_stub
+        owner = OwnerFactory(user=self.user, structures_last_update_at=None)
+        character: OwnerCharacter = owner.characters.first()
+        character.error_count = 3
+        character.save()
+        # when
+        owner.update_structures_esi()
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertEqual(character.error_count, 0)
 
     def test_should_remove_old_starbases(self, mock_esi):
         # given

structures/tests/models/test_owners_6.py

@@ -0,0 +1,31 @@
+from app_utils.testing import NoSocketsTestCase
+
+from structures.tests.testdata.factories import OwnerCharacterFactory, OwnerFactory
+
+MODULE_PATH = "structures.models.owners"
+
+
+class TestOwnerCharacter(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.owner = OwnerFactory()
+
+    def test_should_return_str(self):
+        # given
+        character = OwnerCharacterFactory(owner=self.owner)
+        # when/then
+        self.assertTrue(str(character))
+
+    def test_can_reset_character(self):
+        # given
+        character = OwnerCharacterFactory(
+            owner=self.owner, is_enabled=False, disabled_reason="reason", error_count=42
+        )
+        # when
+        character.reset()
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertFalse(character.disabled_reason)
+        self.assertFalse(character.error_count)

structures/tests/test_admin.py

@@ -32,6 +32,7 @@ from .testdata.factories import (
     EveCorporationInfoFactory,
     FuelAlertConfigFactory,
     NotificationFactory,
+    OwnerCharacterFactory,
     OwnerFactory,
     PocoFactory,
     StarbaseFactory,
@@ -261,6 +262,7 @@ class TestNotificationAdmin(TestCase):
         )
         # when
         result = self.modeladmin._structures(obj)
+        # then
         self.assertIsNone(result)
 
     # FIXME: Does not seam to work with special prefetch list
@@ -356,6 +358,52 @@ class TestNotificationAdmin(TestCase):
         self.assertSetEqual(set(queryset), set(expected))
 
 
+class TestNotificationAdminWebhooks(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.factory = RequestFactory()
+        load_eveuniverse()
+        cls.modeladmin = NotificationAdmin(model=Notification, admin_site=AdminSite())
+        cls.user = SuperuserFactory()
+
+    def test_should_return_name_of_owner_webhook(self):
+        # given
+        owner = OwnerFactory(webhooks__name="Alpha")
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.STRUCTURE_LOST_SHIELD
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertEqual("Alpha", result)
+
+    def test_should_report_missing_webhook(self):
+        # given
+        owner = OwnerFactory(webhooks=False)
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.STRUCTURE_LOST_SHIELD
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertIn("Not configured", result)
+
+    def test_should_report_when_webhooks_not_configured_for_this_notif_type(self):
+        # given
+        owner = OwnerFactory()
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertIn("Not configured", result)
+
+
 class TestOwnerAdmin(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -420,6 +468,23 @@ class TestOwnerAdmin(TestCase):
         self.assertEqual(mock_task.delay.call_count, 1)
         self.assertTrue(mock_message_user.called)
 
+    @patch(MODULE_PATH + ".OwnerAdmin.message_user", spec=True)
+    def test_action_reset_characters(self, mock_message_user):
+        # given
+        owner_1 = OwnerFactory(characters=False)
+        character_1 = OwnerCharacterFactory(owner=owner_1, is_enabled=False)
+        owner_2 = OwnerFactory(characters=False)
+        character_2 = OwnerCharacterFactory(owner=owner_2, is_enabled=False)
+        # when
+        queryset = Owner.objects.filter(pk=owner_1.pk)
+        self.modeladmin.reset_characters(MockRequest(self.user), queryset)
+        # then
+        self.assertTrue(mock_message_user.called)
+        character_1.refresh_from_db()
+        self.assertTrue(character_1.is_enabled)
+        character_2.refresh_from_db()
+        self.assertFalse(character_2.is_enabled)
+
     def test_should_return_empty_turnaround_times(self):
         # given
         obj = OwnerFactory()

structures/tests/test_managers_2.py

@@ -60,12 +60,13 @@ class TestOwnerManager(NoSocketsTestCase):
     def test_should_annotate_characters_count(self):
         # given
         owner = OwnerFactory()  # 1st character automatically created
-        OwnerCharacterFactory(owner=owner)  # 2nd character added
+        OwnerCharacterFactory(owner=owner, is_enabled=False)  # 2nd character added
         # when
         result = Owner.objects.annotate_characters_count()
         # then
         obj = result.get(pk=owner.pk)
-        self.assertEqual(obj.characters_count_2, 2)
+        self.assertEqual(obj.characters_enabled_count, 1)
+        self.assertEqual(obj.characters_disabled_count, 1)
 
     def test_should_return_when_structures_where_last_updated_for_several_owners(self):
         # given

structures/tests/testdata/factories.py

@@ -203,9 +203,7 @@ class OwnerFactory(factory.django.DjangoModelFactory, metaclass=BaseMetaFactory[
     def characters(
         obj, create: bool, extracted: Optional[List[EveCharacter]], **kwargs
     ):
-        """
-        Set extracted to False to skip creating characters.
-        """
+        # Set characters=False to skip creating characters.
         if not create or extracted is False:
             return
 
@@ -222,7 +220,8 @@ class OwnerFactory(factory.django.DjangoModelFactory, metaclass=BaseMetaFactory[
 
     @factory.post_generation
     def webhooks(obj, create, extracted, **kwargs):
-        if not create:
+        # Set webhooks=False to skip creating characters.
+        if not create or extracted is False:
             return
 
         if extracted:

structures/tests/views/test_service_status.py

@@ -0,0 +1,113 @@
+import datetime as dt
+from unittest.mock import patch
+
+from django.test import TestCase
+from django.urls import reverse
+from django.utils.timezone import now
+
+from app_utils.testing import response_text
+
+from structures.tests.testdata.factories import OwnerFactory
+from structures.views import status
+
+OWNERS_PATH = "structures.models.owners"
+
+
+@patch(OWNERS_PATH + ".STRUCTURES_STRUCTURE_SYNC_GRACE_MINUTES", 30)
+@patch(OWNERS_PATH + ".STRUCTURES_NOTIFICATION_SYNC_GRACE_MINUTES", 30)
+class TestServiceStatus(TestCase):
+    def test_should_report_ok(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now(),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now(),
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response_text(response), "service is up")
+
+    def test_should_report_ok_when_downed_owner_is_inactive(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now(),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now(),
+        )
+        OwnerFactory(
+            structures_last_update_at=now() - dt.timedelta(minutes=31),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now(),
+            is_active=False,
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 200)
+
+    def test_should_report_fail_when_issue_with_structures(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now() - dt.timedelta(minutes=31),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now(),
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 500)
+        self.assertEqual(response_text(response), "service is down")
+
+    def test_should_report_fail_when_issue_with_notifications(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now(),
+            notifications_last_update_at=now() - dt.timedelta(minutes=31),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now(),
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 500)
+        self.assertEqual(response_text(response), "service is down")
+
+    def test_should_report_fail_when_issue_with_forwarding(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now(),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now() - dt.timedelta(minutes=31),
+            assets_last_update_at=now(),
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 500)
+        self.assertEqual(response_text(response), "service is down")
+
+    def test_should_report_fail_when_issue_with_assets(self):
+        # given
+        OwnerFactory(
+            structures_last_update_at=now(),
+            notifications_last_update_at=now(),
+            forwarding_last_update_at=now(),
+            assets_last_update_at=now() - dt.timedelta(minutes=31),
+        )
+        request = self.client.get(reverse("structures:service_status"))
+        # when
+        response = status.service_status(request)
+        # then
+        self.assertEqual(response.status_code, 500)
+        self.assertEqual(response_text(response), "service is down")