aa-ledger 1.0.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

ledger/tests/test_admin.py

@@ -1,20 +1,14 @@
 # Standard Library
-from unittest.mock import Mock, patch
+from unittest.mock import patch
 
 # Django
 from django.contrib.admin.sites import AdminSite
-from django.contrib.messages.middleware import MessageMiddleware
-from django.contrib.sessions.middleware import SessionMiddleware
-from django.test import RequestFactory, override_settings
+from django.test import override_settings
 from django.utils import timezone
-from django.utils.safestring import mark_safe
 
 # Alliance Auth
 from allianceauth.eveonline.evelinks import eveimageserver
 
-# Alliance Auth (External Libs)
-from app_utils.testing import NoSocketsTestCase
-
 # AA Ledger
 from ledger.admin import (
     CharacterAuditAdmin,
@@ -22,18 +16,13 @@ from ledger.admin import (
     CorporationAuditAdmin,
     CorporationUpdateStatusAdminInline,
 )
-from ledger.models.characteraudit import CharacterAudit, CharacterUpdateStatus
-from ledger.models.corporationaudit import CorporationAudit, CorporationUpdateStatus
-from ledger.tests.testdata.generate_characteraudit import (
-    add_characteraudit_character_to_user,
+from ledger.models.characteraudit import CharacterOwner, CharacterUpdateStatus
+from ledger.models.corporationaudit import CorporationOwner, CorporationUpdateStatus
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    add_owner_to_user,
     create_update_status,
 )
-from ledger.tests.testdata.generate_corporationaudit import (
-    add_corporationaudit_corporation_to_user,
-    create_corporation_update_status,
-    create_user_from_evecharacter,
-)
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
 
 ADMIN_PATH = "ledger.admin"
 
@@ -43,29 +32,26 @@ class MockRequest:
 
 
 @override_settings(CELERY_ALWAYS_EAGER=True, CELERY_EAGER_PROPAGATES_EXCEPTIONS=True)
-class TestCorporationAuditAdmin(NoSocketsTestCase):
+class TestCorporationAuditAdmin(LedgerTestCase):
+    """Test Backend AA Administration for Ledger."""
+
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
-        load_allianceauth()
 
-        cls.factory = RequestFactory()
         cls.site = AdminSite()
 
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001,
-            ["ledger.basic_access"],
-        )
-        cls.corporation_audit_admin = CorporationAuditAdmin(CorporationAudit, cls.site)
-        cls.corporation_audit = add_corporationaudit_corporation_to_user(
+        cls.corporation_audit_admin = CorporationAuditAdmin(CorporationOwner, cls.site)
+        cls.corporation_audit = add_owner_to_user(
             cls.user,
-            cls.character_ownership.character.character_id,
+            cls.user_character.character.character_id,
+            owner_type="corporation",
         )
-        cls.user.is_superuser = True
 
-        cls.update_status = create_corporation_update_status(
-            cls.corporation_audit,
+        cls.update_status = create_update_status(
+            owner=cls.corporation_audit,
             section="wallet_journal",
+            owner_type="corporation",
             last_update_at=timezone.now() - timezone.timedelta(minutes=5),
             last_update_finished_at=timezone.now() - timezone.timedelta(minutes=3),
             last_run_at=timezone.now() - timezone.timedelta(minutes=4),
@@ -73,42 +59,75 @@ class TestCorporationAuditAdmin(NoSocketsTestCase):
         )
 
     def test_get_queryset(self):
-        qs = self.corporation_audit_admin.get_queryset(CorporationAudit.objects.all())
+        """
+        Test get_queryset method.
+
+        This test ensures that the get_queryset method of the CorporationAuditAdmin
+        class returns a valid queryset without errors.
+        """
+        # Test Action
+        qs = self.corporation_audit_admin.get_queryset(CorporationOwner.objects.all())
+        # Expected Result
         self.assertIsNotNone(qs)
 
     def test_run_update_duration(self):
+        """
+        Test run and update duration calculations in inline admin.
+
+        This test verifies that the duration calculations for run and update times
+        in the CorporationUpdateStatusAdminInline class are functioning correctly.
+        """
+        # Test Data
         inline = CorporationUpdateStatusAdminInline(CorporationUpdateStatus, self.site)
 
+        # Test Action
         run_duration = inline._run_duration(self.update_status)
         update_duration = inline._update_duration(self.update_status).replace(
             "\xa0", " "
         )
+
+        # Expected Results
         self.assertIn("minute", run_duration)
         self.assertIn("2 minutes", update_duration)
         self.assertEqual(inline._calc_duration(None, None), "-")
 
     @patch(ADMIN_PATH + ".update_corporation.delay")
     def test_force_update(self, mock_update_character_delay):
+        """
+        Test force_update admin action.
+
+        This test checks that the force_update method in the CorporationAuditAdmin
+        class correctly triggers the update_corporation task when invoked.
+        """
+        # Test Data
         request = self.factory.get("/")
-        request.user = self.user
+        request.user = self.superuser
 
-        # Add session middleware to process the request
-        middleware = SessionMiddleware(Mock())
-        middleware.process_request(request)
-        message_middleware = MessageMiddleware(Mock())
-        message_middleware.process_request(request)
+        self._middleware_process_request(request)
+        queryset = CorporationOwner.objects.filter(pk=self.corporation_audit.pk)
 
-        queryset = CorporationAudit.objects.filter(pk=self.corporation_audit.pk)
+        # Test Action
         self.corporation_audit_admin.force_update(request, queryset)
+
+        # Expected Result
         mock_update_character_delay.assert_called_once()
 
     def test_entity_pic(self):
-        self.client.force_login(self.user)
+        """
+        Test entity picture display in admin.
+
+        This test verifies that the _entity_pic method in the CorporationAuditAdmin
+        class returns the correct HTML for displaying the corporation's image.
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
         request = self.factory.get("/")
-        request.user = self.user
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         expected_html = '<img src="{}" class="img-circle">'.format(
             eveimageserver._eve_entity_image_url(
-                "corporation", self.corporation_audit.corporation.corporation_id, 32
+                "corporation", self.corporation_audit.eve_corporation.corporation_id, 32
             )
         )
         self.assertEqual(
@@ -117,9 +136,19 @@ class TestCorporationAuditAdmin(NoSocketsTestCase):
         )
 
     def test_corporation_corporation_id(self):
-        self.client.force_login(self.user)
+        """
+        Test corporation ID display in admin.
+
+        This test checks that the _corporation__corporation_id method in the
+        CorporationAuditAdmin class returns the correct corporation ID.
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
+
         request = self.factory.get("/")
-        request.user = self.user
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         self.assertEqual(
             self.corporation_audit_admin._corporation__corporation_id(
                 self.corporation_audit
@@ -128,16 +157,33 @@ class TestCorporationAuditAdmin(NoSocketsTestCase):
         )
 
     def test_has_add_permission(self):
-        self.client.force_login(self.user)
+        """
+        Test has_add_permission method.
+
+        This test ensures that the has_add_permission method of the CorporationAuditAdmin
+        class always returns False, preventing addition of new corporation audits
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
         request = self.factory.get("/")
-        request.user = self.user
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         self.assertFalse(self.corporation_audit_admin.has_add_permission(request))
 
     def test_has_change_permission(self):
-        self.client.force_login(self.user)
+        """
+        Test has_change_permission method.
+
+        This test ensures that the has_change_permission method of the CorporationAuditAdmin
+        class always returns False, preventing changes to existing corporation audits.
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
         request = self.factory.get("/")
-        request.user = self.user
-        request = MockRequest()
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         self.assertFalse(self.corporation_audit_admin.has_change_permission(request))
         self.assertFalse(
             self.corporation_audit_admin.has_change_permission(
@@ -146,24 +192,18 @@ class TestCorporationAuditAdmin(NoSocketsTestCase):
         )
 
 
-class TestCharacterAuditAdmin(NoSocketsTestCase):
+class TestCharacterAuditAdmin(LedgerTestCase):
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
-        load_allianceauth()
-        cls.factory = RequestFactory()
         cls.site = AdminSite()
 
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001,
-            ["ledger.basic_access"],
-        )
-        cls.character_audit_admin = CharacterAuditAdmin(CharacterAudit, cls.site)
-        cls.character_audit = add_characteraudit_character_to_user(
+        cls.character_audit_admin = CharacterAuditAdmin(CharacterOwner, cls.site)
+        cls.character_audit = add_owner_to_user(
             cls.user,
-            cls.character_ownership.character.character_id,
+            cls.user_character.character.character_id,
+            owner_type="character",
         )
-        cls.user.is_superuser = True
         cls.update_status = create_update_status(
             cls.character_audit,
             section="wallet_journal",
@@ -174,36 +214,62 @@ class TestCharacterAuditAdmin(NoSocketsTestCase):
         )
 
     def test_get_queryset(self):
-        qs = self.character_audit_admin.get_queryset(CharacterAudit.objects.all())
+        qs = self.character_audit_admin.get_queryset(CharacterOwner.objects.all())
         self.assertIsNotNone(qs)
 
     @patch(ADMIN_PATH + ".update_character.delay")
     def test_force_update(self, mock_update_character_delay):
-        queryset = CharacterAudit.objects.filter(pk=self.character_audit.pk)
+        """
+        Test force_update admin action.
+
+        This test checks that the force_update method in the CharacterAuditAdmin
+        class correctly triggers the update_character task when invoked.
+        """
+        # Test Data
+        queryset = CharacterOwner.objects.filter(pk=self.character_audit.pk)
         request = self.factory.get("/")
+        request.user = self.superuser
 
-        # Add session middleware to process the request
-        middleware = SessionMiddleware(Mock())
-        middleware.process_request(request)
-        message_middleware = MessageMiddleware(Mock())
-        message_middleware.process_request(request)
+        self._middleware_process_request(request)
 
+        # Test Action
         self.character_audit_admin.force_update(request, queryset)
+
+        # Expected Result
         mock_update_character_delay.assert_called_once()
 
     def test_run_update_duration(self):
+        """
+        Test run and update duration calculations in inline admin.
+
+        This test verifies that the duration calculations for run and update times
+        in the CharacterUpdateStatusAdminInline class are functioning correctly.
+        """
+        # Test Data
         inline = CharacterUpdateStatusAdminInline(CharacterUpdateStatus, self.site)
 
+        # Test Action
         run_duration = inline._run_duration(self.update_status)
         update_duration = inline._update_duration(self.update_status).replace(
             "\xa0", " "
         )
+
+        # Expected Results
         self.assertIn("minute", run_duration)
         self.assertIn("2 minutes", update_duration)
         self.assertEqual(inline._calc_duration(None, None), "-")
 
     def test_entity_pic(self):
-        self.client.force_login(self.user)
+        """
+        Test entity picture rendering in admin.
+
+        This test verifies that the _entity_pic method in the CharacterAuditAdmin
+        class returns the correct HTML for displaying the character's image.
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
+
+        # Test Action/Expected Result
         expected_html = '<img src="{}" class="img-circle">'.format(
             eveimageserver._eve_entity_image_url(
                 "character", self.character_audit.eve_character.character_id, 32
@@ -214,6 +280,16 @@ class TestCharacterAuditAdmin(NoSocketsTestCase):
         )
 
     def test_character_character_name(self):
+        """
+        Test character name display in admin.
+
+        This test checks that the _eve_character__character_name method in the
+        CharacterAuditAdmin class returns the correct character name.
+        """
+        # Test Data
+        self.client.force_login(self.superuser)
+
+        # Test Action/Expected Result
         self.assertEqual(
             self.character_audit_admin._eve_character__character_name(
                 self.character_audit
@@ -222,11 +298,31 @@ class TestCharacterAuditAdmin(NoSocketsTestCase):
         )
 
     def test_has_add_permission(self):
+        """
+        Test has_add_permission method.
+
+        This test ensures that the has_add_permission method of the CharacterAuditAdmin
+        class always returns False, preventing addition of new character audits.
+        """
+        # Test Data
         request = self.factory.get("/")
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         self.assertFalse(self.character_audit_admin.has_add_permission(request))
 
     def test_has_change_permission(self):
+        """
+        Test has_change_permission method.
+
+        This test ensures that the has_change_permission method of the CharacterAuditAdmin
+        class always returns False, preventing changes to existing character audits.
+        """
+        # Test Data
         request = self.factory.get("/")
+        request.user = self.superuser
+
+        # Test Action/Expected Result
         self.assertFalse(self.character_audit_admin.has_change_permission(request))
         self.assertFalse(
             self.character_audit_admin.has_change_permission(

ledger/tests/test_auth_hook.py

@@ -2,22 +2,19 @@
 from unittest.mock import MagicMock
 
 # Django
-from django.test import TestCase
 from django.urls import reverse
 
-# Alliance Auth (External Libs)
-from app_utils.testdata_factories import UserMainFactory
-
 # AA Ledger
 from ledger.auth_hooks import LedgerMenuItem, register_charlink_hook
+from ledger.tests import LedgerTestCase
 
 
-class TestAuthHooks(TestCase):
+class TestAuthHooks(LedgerTestCase):
+    """Test Alliance Auth Menu Hooks for Ledger"""
 
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
-        cls.user = UserMainFactory(permissions=["ledger.basic_access"])
         cls.html_menu = f"""
             <li class="d-flex flex-wrap m-2 p-2 pt-0 pb-0 mt-0 mb-0 me-0 pe-0">
                 <i class="nav-link fas fa-book fa-fw fa-fw align-self-center me-3 active"></i>
@@ -28,27 +25,40 @@ class TestAuthHooks(TestCase):
         """
 
     def test_menu_hook(self):
+        """
+        Test that the menu hook renders correctly for a user with permission.
+
+        This test logs in a user with the 'ledger.basic_access' permission
+        and verifies that the Ledger menu item is present in the rendered HTML.
+        """
+        # Test Data
         self.client.force_login(self.user)
 
+        # Test Action
         response = self.client.get(
             reverse("ledger:index"), follow=True
         )  # Follow redirects
 
-        # Überprüfen, ob der Benutzer korrekt weitergeleitet wurde
+        # Expected Results
         self.assertEqual(response.status_code, 200)
-
-        # Überprüfen, ob das HTML-Menü enthalten ist
         self.assertContains(response, self.html_menu, html=True)
 
     def test_render_returns_empty_string_for_user_without_permission(self):
-        # given
+        """
+        Test that the render method returns an empty string for a user without permission.
+
+        This test creates a mock request for a user who lacks the 'ledger.basic_access' permission
+        and verifies that the render method of LedgerMenuItem returns an empty string.
+        """
+        # Test Data
         ledger_menu_item = LedgerMenuItem()
         mock_request = MagicMock()
         mock_request.user.has_perm.return_value = False
 
-        # when
+        # Test Action
         result = ledger_menu_item.render(mock_request)
-        # then
+
+        # Expected Result
         self.assertEqual(
             result,
             "",
@@ -56,6 +66,14 @@ class TestAuthHooks(TestCase):
         )
 
     def test_register_charlink_hook(self):
-        # Verify that the hook returns the expected value
+        """
+        Test that the register_charlink_hook function returns the expected value.
+
+        This test calls the register_charlink_hook function and verifies that it returns
+        the correct string indicating the charlink hook location.
+        """
+        # Test Action
         result = register_charlink_hook()
+
+        # Expected Result
         self.assertEqual(result, "ledger.thirdparty.charlink_hook")

ledger/tests/test_decarators.py

@@ -1,99 +1,34 @@
-# Standard Library
-from unittest.mock import patch
-
 # Alliance Auth
 from allianceauth.services.hooks import get_extension_logger
 
-# Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
-from app_utils.testing import NoSocketsTestCase
-
 # AA Ledger
 from ledger import __title__
 from ledger.decorators import (
     log_timing,
-    when_esi_is_available,
 )
+from ledger.providers import AppLogger
+from ledger.tests import LedgerTestCase
 
 DECORATOR_PATH = "ledger.decorators."
 
 
-@patch(DECORATOR_PATH + "ESI_STATUS_ROUTE_RATE_LIMIT", new=1)
-class TestDecorators(NoSocketsTestCase):
-    @patch(DECORATOR_PATH + "fetch_esi_status")
-    @patch(DECORATOR_PATH + "IS_TESTING", new=True)
-    def test_when_esi_is_available_is_test(self, mock_fetch_esi_status):
-        """Test when ESI is available in testing mode."""
-
-        @when_esi_is_available
-        def trigger_esi_deco():
-            return "Testing Mode."
-
-        # when
-        result = trigger_esi_deco()
-        # then
-        self.assertEqual(result, "Testing Mode.")
-
-    @patch(DECORATOR_PATH + "fetch_esi_status")
-    @patch(DECORATOR_PATH + "IS_TESTING", new=False)
-    def test_when_esi_is_ok(self, mock_fetch_esi_status):
-        """Test when ESI is available in non-testing mode."""
-
-        # ensure the fetch_esi_status call reports ESI as up
-        mock_fetch_esi_status.return_value.is_ok = True
-
-        @when_esi_is_available
-        def trigger_esi_deco():
-            return "Esi is Available"
-
-        # when
-        result = trigger_esi_deco()
-        # then
-        mock_fetch_esi_status.assert_called_once()
-        self.assertEqual(result, "Esi is Available")
-
-    @patch(DECORATOR_PATH + "fetch_esi_status")
-    @patch(DECORATOR_PATH + "IS_TESTING", new=False)
-    def test_when_esi_is_not_ok(self, mock_fetch_esi_status):
-        """Test when ESI is not available in non-testing mode."""
-        # ensure the fetch_esi_status call reports ESI as down
-        mock_fetch_esi_status.return_value.is_ok = False
-
-        @when_esi_is_available
-        def trigger_esi_deco():
-            return None
-
-        # when
-        result = trigger_esi_deco()
-        # then
-        self.assertIsNone(result)
-
-    @patch(DECORATOR_PATH + "fetch_esi_status")
-    @patch(DECORATOR_PATH + "IS_TESTING", new=False)
-    def test_when_esi_is_ok_and_cached(self, mock_fetch_esi_status):
-        """Test when ESI is available in non-testing mode and cached."""
-        # Make a Exception to ensure fetch_esi_status is not called
-        mock_fetch_esi_status.side_effect = Exception("Should not be called")
-
-        @when_esi_is_available
-        def trigger_esi_deco():
-            return "Esi is Available"
-
-        # when
-        result = trigger_esi_deco()
-        # then
-        mock_fetch_esi_status.assert_not_called()
-        self.assertEqual(result, "Esi is Available")
-
+class TestDecorators(LedgerTestCase):
     def test_log_timing(self):
-        # given
-        logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+        """
+        Test log_timing decorator functionality.
+
+        This test defines a simple function decorated with log_timing and
+        verifies that it returns the expected result.
+        """
+        # Test Data
+        logger = AppLogger(get_extension_logger(__name__), __title__)
 
         @log_timing(logger)
         def trigger_log_timing():
             return "Log Timing"
 
-        # when
+        # Test Action
         result = trigger_log_timing()
-        # then
+
+        # Expected Result
         self.assertEqual(result, "Log Timing")

ledger/tests/test_discord_installed.py

@@ -2,7 +2,6 @@
 from django.test import TestCase, modify_settings
 
 # AA Ledger
-# AA Skillfarm
 from ledger.helpers.discord import (
     allianceauth_discordbot_installed,
     discordnotify_installed,

ledger/tests/test_helpers/test_ledger_data.py

@@ -0,0 +1,19 @@
+# AA Ledger
+from ledger.tests import LedgerTestCase
+
+MODULE_PATH = "ledger.helpers.ledger_data"
+
+
+class TestCharacterWalletJournalModel(LedgerTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+    def test_get_footer_text_class(self):
+        # AA Ledger
+        from ledger.helpers.ledger_data import get_footer_text_class
+
+        self.assertEqual(get_footer_text_class(10), "text-success")
+        self.assertEqual(get_footer_text_class(-10), "text-danger")
+        self.assertEqual(get_footer_text_class(0), "")
+        self.assertEqual(get_footer_text_class(10, mining=True), "text-info")