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

ledger/tests/test_models/test_characteraudit.py

@@ -1,46 +1,36 @@
-# Standard Library
-from unittest.mock import PropertyMock, patch
-
 # Django
-from django.test import RequestFactory, TestCase
+from django.test import TestCase
 from django.utils import timezone
 
 # AA Ledger
-from ledger.models.characteraudit import CharacterAudit, CharacterUpdateStatus
-from ledger.models.general import _NeedsUpdate
-from ledger.tests.testdata.generate_characteraudit import (
-    add_characteraudit_character_to_user,
+from ledger.models.characteraudit import (
+    CharacterOwner,
+    CharacterUpdateSection,
+    CharacterUpdateStatus,
+)
+from ledger.models.helpers.update_manager import UpdateStatus
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    create_owner_from_user,
     create_update_status,
-    create_user_from_evecharacter_with_access,
 )
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveentity import load_eveentity
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 
 MODULE_PATH = "ledger.models.characteraudit"
 
 
-class TestCharacterWalletJournalModel(TestCase):
+class TestCharacterWalletJournalModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-        load_eveentity()
 
-        cls.user, cls.character_ownership = create_user_from_evecharacter_with_access(
-            1001,
-        )
-        cls.audit = add_characteraudit_character_to_user(
-            cls.user, cls.character_ownership.character.character_id
-        )
-        sections = CharacterAudit.UpdateSection.get_sections()
+        cls.owner = create_owner_from_user(cls.user, owner_type="character")
+        sections = CharacterUpdateSection.get_sections()
         for section in sections:
             create_update_status(
-                cls.audit,
+                owner=cls.owner,
                 section=section,
-                is_success=True,
                 error_message="",
+                is_success=True,
                 has_token_error=False,
                 last_run_at=timezone.now(),
                 last_run_finished_at=timezone.now(),
@@ -48,21 +38,27 @@ class TestCharacterWalletJournalModel(TestCase):
                 last_update_finished_at=timezone.now(),
             )
         cls.update_status_wallet = CharacterUpdateStatus.objects.get(
-            character=cls.audit,
-            section=CharacterAudit.UpdateSection.WALLET_JOURNAL,
+            owner=cls.owner,
+            section=CharacterUpdateSection.WALLET_JOURNAL,
         )
         cls.update_status_mining_ledger = CharacterUpdateStatus.objects.get(
-            character=cls.audit,
-            section=CharacterAudit.UpdateSection.MINING_LEDGER,
+            owner=cls.owner,
+            section=CharacterUpdateSection.MINING_LEDGER,
         )
 
     def test_str(self):
-        excepted_str = CharacterAudit.objects.get(id=self.audit.id)
-        self.assertEqual(self.audit, excepted_str)
+        excepted_str = CharacterOwner.objects.get(id=self.owner.id)
+        self.assertEqual(self.owner, excepted_str)
 
     def test_get_esi_scopes(self):
+        """
+        Test retrieval of ESI scopes for CharacterOwner.
+
+        ### Expected Result
+        - Correct list of ESI scopes is returned.
+        """
         self.assertEqual(
-            self.audit.get_esi_scopes(),
+            self.owner.get_esi_scopes(),
             [
                 # Mining Ledger
                 "esi-industry.read_character_mining.v1",
@@ -75,77 +71,65 @@ class TestCharacterWalletJournalModel(TestCase):
         )
 
     def test_get_status_states(self):
+        """
+        Test various states of get_status property.
+
+        ### Expected Results:
+        - OK
+        - DISABLED
+        - TOKEN_ERROR
+        - ERROR
+        - INCOMPLETE
+        """
+        # Test Data - OK
         update_status = self.update_status_wallet
-        audit = self.audit
+        audit = self.owner
 
+        # Expected Result
         self.assertEqual(
-            self.audit.get_status,
-            CharacterAudit.UpdateStatus.OK,
+            self.owner.get_status,
+            UpdateStatus.OK,
         )
 
+        # Test Data - DISABLED
         audit.active = False
         audit.save()
 
+        # Expected Result
         self.assertEqual(
-            self.audit.get_status,
-            CharacterAudit.UpdateStatus.DISABLED,
+            self.owner.get_status,
+            UpdateStatus.DISABLED,
         )
 
+        # Test Data - TOKEN_ERROR
         audit.active = True
         audit.save()
         update_status.is_success = False
         update_status.has_token_error = True
         update_status.save()
 
+        # Expected Result
         self.assertEqual(
-            self.audit.get_status,
-            CharacterAudit.UpdateStatus.TOKEN_ERROR,
+            self.owner.get_status,
+            UpdateStatus.TOKEN_ERROR,
         )
 
+        # Test Data - ERROR
         audit.active = True
         audit.save()
         update_status.is_success = False
         update_status.has_token_error = False
         update_status.save()
 
+        # Expected Result
         self.assertEqual(
-            self.audit.get_status,
-            CharacterAudit.UpdateStatus.ERROR,
+            self.owner.get_status,
+            UpdateStatus.ERROR,
         )
-
         update_status.delete()
 
+        # Test Data - INCOMPLETE
         self.assertEqual(
-            self.audit.get_status,
-            CharacterAudit.UpdateStatus.INCOMPLETE,
-        )
-
-    def test_reset_has_token_error(self):
-        audit = self.audit
-
-        self.assertEqual(
-            audit.reset_has_token_error(),
-            False,
-        )
-
-        self.update_status_mining_ledger.has_token_error = True
-        self.update_status_mining_ledger.save()
-
-        self.assertEqual(
-            audit.reset_has_token_error(),
-            True,
-        )
-
-    def test_reset_update_status(self):
-        # given
-        audit = self.audit
-        # when
-        update_status = audit.reset_update_status("mining_ledger")
-        # then
-        self.assertEqual(
-            update_status,
-            CharacterUpdateStatus.objects.get(
-                character=audit,
-                section="mining_ledger",
-            ),
+            self.owner.get_status,
+            UpdateStatus.INCOMPLETE,
         )

ledger/tests/test_models/test_characterminingledger.py

@@ -3,7 +3,6 @@ from types import SimpleNamespace
 from unittest.mock import patch
 
 # Django
-from django.test import TestCase
 from django.utils import timezone
 
 # Alliance Auth (External Libs)
@@ -11,32 +10,20 @@ from eveuniverse.models import EveMarketPrice, EveSolarSystem, EveType
 
 # AA Ledger
 from ledger.models.characteraudit import CharacterMiningLedger
-from ledger.tests.testdata.generate_characteraudit import (
-    add_characteraudit_character_to_user,
-    create_user_from_evecharacter_with_access,
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    create_miningledger,
+    create_owner_from_user,
 )
-from ledger.tests.testdata.generate_miningledger import create_miningledger
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveentity import load_eveentity
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 
 MODULE_PATH = "ledger.models.characteraudit"
 
 
-class TestCharacterMiningLedgerModel(TestCase):
+class TestCharacterMiningLedgerModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-        load_eveentity()
-
-        cls.user, cls.character_ownership = create_user_from_evecharacter_with_access(
-            1001,
-        )
-        cls.audit = add_characteraudit_character_to_user(
-            cls.user, cls.character_ownership.character.character_id
-        )
+        cls.audit = create_owner_from_user(cls.user, owner_type="character")
         cls.eve_type = EveType.objects.get(id=17425)
         cls.eve_system = EveSolarSystem.objects.get(id=30004783)
 
@@ -79,30 +66,37 @@ class TestCharacterMiningLedgerModel(TestCase):
         )
 
     def test_str(self):
+        """Test string representation of CharacterMiningLedger."""
         self.assertEqual(str(self.miningentry), f"{self.audit} 1")
 
     def test_create_primary_key(self):
-        # when
+        """Test creation of primary key for CharacterMiningLedger."""
+        # Test Data
         primary_key = CharacterMiningLedger.create_primary_key(
             self.audit.eve_character.character_id, self.miningrecord
         )
-        # then
+        # Expected Result
         self.assertEqual(primary_key, "20240101-1-1001-1")
 
     def test_get_npc_price(self):
-        # when
+        """Test retrieval of NPC price for CharacterMiningLedger."""
+        # Test Data
         npc_price = self.miningentry2.get_npc_price()
-        # then
+
+        # Expected Result
         self.assertIsNotNone(npc_price)
         self.assertEqual(npc_price, 100)
 
     @patch(MODULE_PATH + ".cache.get", return_value=False)
     @patch(MODULE_PATH + ".EveMarketPrice.objects.update_from_esi")
     def test_update_evemarket_price(self, mock_market_price, mock_cache_get):
-        # given
+        """Test updating Eve market price for CharacterMiningLedger."""
+        # Test Data
         mock_market_price.return_value = 1337
-        # when
+
+        # Test Action
         updated = self.miningentry.update_evemarket_price()
-        # then
+
+        # Expected Result
         self.assertTrue(mock_market_price.called)
         self.assertEqual(updated, 1337)

ledger/tests/test_models/test_characterwalletjournal.py

@@ -1,51 +1,26 @@
-# Standard Library
-from unittest.mock import PropertyMock, patch
-
 # Django
-from django.contrib.auth.models import Permission
-from django.test import TestCase
 from django.utils import timezone
 
-# Alliance Auth
-from allianceauth.eveonline.models import EveCharacter
-
 # AA Ledger
-from ledger.models.corporationaudit import (
-    CorporationAudit,
-)
 from ledger.models.general import EveEntity
-from ledger.tests.testdata.generate_characteraudit import (
-    add_characteraudit_character_to_user,
-    create_user_from_evecharacter_with_access,
-)
-from ledger.tests.testdata.generate_walletjournal import (
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    create_owner_from_user,
     create_wallet_journal_entry,
 )
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveentity import load_eveentity
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 
-MODULE_PATH = "ledger.models.corporationaudit"
+MODULE_PATH = "ledger.models.characteraudit"
 
 
-class TestCharacterWalletJournalModel(TestCase):
+class TestCharacterWalletJournalModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-        load_eveentity()
-
-        cls.user, cls.character_ownership = create_user_from_evecharacter_with_access(
-            1001,
-        )
-        cls.audit = add_characteraudit_character_to_user(
-            cls.user, cls.character_ownership.character.character_id
-        )
+        cls.audit = create_owner_from_user(cls.user, owner_type="character")
         cls.eve_character_first_party = EveEntity.objects.get(eve_id=1001)
         cls.eve_character_second_party = EveEntity.objects.get(eve_id=1002)
         cls.journal_entry = create_wallet_journal_entry(
-            journal_type="character",
+            owner_type="character",
             character=cls.audit,
             entry_id=1,
             amount=1000,
@@ -67,12 +42,14 @@ class TestCharacterWalletJournalModel(TestCase):
         )
 
     def test_str(self):
+        """Test the string representation of CharacterWalletJournalEntry."""
         self.assertEqual(
             str(self.journal_entry),
             f"Character Wallet Journal: RefType: test - {self.eve_character_first_party.name} -> {self.eve_character_second_party.name}: 1000 ISK",
         )
 
-    def test_get_visible_should_get_empty_list(self):
+    def test_get_visible_should_get_list_with_entries(self):
+        """Test get_visible method with entries."""
         self.assertEqual(
             list(self.journal_entry.get_visible(self.user)), [self.journal_entry]
         )

ledger/tests/test_models/test_corporationaudit.py

@@ -1,43 +1,36 @@
-# Django
-from django.contrib.auth.models import Permission
-from django.test import TestCase
-
-# Alliance Auth
-from allianceauth.tests.auth_utils import AuthUtils
-
 # AA Ledger
-from ledger.models.corporationaudit import CorporationAudit
-from ledger.tests.testdata.generate_corporationaudit import (
-    create_corporationaudit_from_user,
-    create_user_from_evecharacter,
+from ledger.models.corporationaudit import CorporationOwner
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    add_new_permission_to_user,
+    create_owner_from_user,
 )
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
 
 MODULE_PATH = "ledger.models.corporationaudit"
 
 
-class TestCorporationAuditModel(TestCase):
+class TestCorporationAuditModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
 
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001, permissions=["ledger.basic_access"]
-        )
-        cls.user2, cls.character_ownership2 = create_user_from_evecharacter(
-            1002, permissions=["ledger.basic_access"]
-        )
-        cls.audit = create_corporationaudit_from_user(cls.user)
-        cls.audit2 = create_corporationaudit_from_user(cls.user2)
+        cls.owner = create_owner_from_user(user=cls.user, owner_type="corporation")
+        cls.owner2 = create_owner_from_user(user=cls.user2, owner_type="corporation")
 
     def test_str(self):
-        expected_str = CorporationAudit.objects.get(id=self.audit.pk)
-        self.assertEqual(self.audit, expected_str)
+        """Test the string representation of CorporationOwner."""
+        expected_str = CorporationOwner.objects.get(id=self.owner.pk)
+        self.assertEqual(self.owner, expected_str)
 
     def test_get_esi_scopes(self):
+        """
+        Test the ESI scopes for CorporationOwner.
+
+        ### Expected Result
+        - Correct list of ESI scopes is returned.
+        """
         self.assertEqual(
-            self.audit.get_esi_scopes(),
+            self.owner.get_esi_scopes(),
             [
                 # General
                 "esi-search.search_structures.v1",
@@ -53,16 +46,29 @@ class TestCorporationAuditModel(TestCase):
             ],
         )
 
-    def test_access_no_perms(self):
-        corporation = CorporationAudit.objects.visible_to(self.user)
-        self.assertNotIn(self.audit, corporation)
-        self.assertNotIn(self.audit2, corporation)
+    def test_visible_to_should_not_include_any_corporations(self):
+        """
+        Test access permissions for CorporationOwner without permissions.
+
+        ### Expected Result
+        - User without permissions cannot access any corporations.
+        """
+        corporation = CorporationOwner.objects.visible_to(self.user)
+        self.assertNotIn(self.owner, corporation)
+        self.assertNotIn(self.owner2, corporation)
+
+    def test_visible_to_should_include_own_corporation_only(self):
+        """
+        Test access permissions for CorporationOwner with own corporation permission.
 
-    def test_access_perms_own_corp(self):
-        self.user = AuthUtils.add_permission_to_user_by_name(
-            "ledger.advanced_access", self.user
+        ### Expected Result
+        - User with own corporation permission can access their own corporation only.
+        - User can not access other corporations.
+        """
+        self.user = add_new_permission_to_user(
+            user=self.user, permission_name="ledger.advanced_access"
         )
         self.user.refresh_from_db()
-        corporation = CorporationAudit.objects.visible_to(self.user)
-        self.assertIn(self.audit, corporation)
-        self.assertNotIn(self.audit2, corporation)
+        corporation = CorporationOwner.objects.visible_to(self.user)
+        self.assertIn(self.owner, corporation)
+        self.assertNotIn(self.owner2, corporation)

ledger/tests/test_models/test_corporationwalletjournal.py

@@ -1,54 +1,33 @@
-# Standard Library
-from unittest.mock import PropertyMock, patch
-
 # Django
-from django.contrib.auth.models import Permission
-from django.test import TestCase
 from django.utils import timezone
 
-# Alliance Auth
-from allianceauth.eveonline.models import EveCharacter
-
 # AA Ledger
-from ledger.models.corporationaudit import (
-    CorporationAudit,
-)
 from ledger.models.general import EveEntity
-from ledger.tests.testdata.generate_characteraudit import create_character
-from ledger.tests.testdata.generate_corporationaudit import (
-    create_corporationaudit_from_user,
-    create_user_from_evecharacter,
-)
-from ledger.tests.testdata.generate_walletjournal import (
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    add_new_permission_to_user,
     create_division,
+    create_owner_from_user,
     create_wallet_journal_entry,
 )
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveentity import load_eveentity
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 
 MODULE_PATH = "ledger.models.corporationaudit"
 
 
-class TestCorporationWalletJournalModel(TestCase):
+class TestCorporationWalletJournalModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-        load_eveentity()
-
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001, permissions=["ledger.basic_access"]
-        )
-        cls.audit = create_corporationaudit_from_user(cls.user)
+        cls.owner = create_owner_from_user(cls.user, owner_type="corporation")
         cls.division = create_division(
-            corporation=cls.audit, name="MEGA KONTO", balance=1000000, division_id=1
+            corporation=cls.owner, name="MEGA KONTO", balance=1000000, division_id=1
         )
+
         cls.eve_character_first_party = EveEntity.objects.get(eve_id=1001)
         cls.eve_character_second_party = EveEntity.objects.get(eve_id=1002)
+
         cls.journal_entry = create_wallet_journal_entry(
-            journal_type="corporation",
+            owner_type="corporation",
             division=cls.division,
             entry_id=1,
             amount=1000,
@@ -70,10 +49,34 @@ class TestCorporationWalletJournalModel(TestCase):
         )
 
     def test_str(self):
+        """Test the string representation of CorporationWalletJournalEntry."""
         self.assertEqual(
             str(self.journal_entry),
             f"Corporation Wallet Journal: RefType: test - {self.eve_character_first_party.name} -> {self.eve_character_second_party.name}: 1000 ISK",
         )
 
-    def test_get_visible_should_get_empty_list(self):
+    def test_get_visible_with_permission(self):
+        """
+        Test get_visible method with permissions.
+
+        ### Expected Result
+        - User with permissions can access journal entries.
+        """
+        # Test Data
+        self.user = add_new_permission_to_user(
+            user=self.user, permission_name="ledger.advanced_access"
+        )
+
+        # Expected Result
+        self.assertEqual(
+            list(self.journal_entry.get_visible(self.user)), [self.journal_entry]
+        )
+
+    def test_get_visible_without_permission(self):
+        """
+        Test get_visible method without permissions.
+
+        ### Expected Result
+        - User without permissions cannot access any journal entries.
+        """
         self.assertEqual(list(self.journal_entry.get_visible(self.user)), [])