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

ledger/tests/test_models/test_general.py

@@ -3,16 +3,16 @@ from datetime import timedelta
 from unittest.mock import patch
 
 # Django
-from django.test import TestCase
 from django.utils import timezone
 
 # AA Ledger
 from ledger.models.general import EveEntity
+from ledger.tests import LedgerTestCase
 
 MODULE_PATH = "ledger.models.general"
 
 
-class TestGeneralModel(TestCase):
+class TestGeneralModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
@@ -24,54 +24,87 @@ class TestGeneralModel(TestCase):
         )
 
     def test_str(self):
+        """Test the string representation of EveEntity."""
+        # Expected Result
         self.assertEqual(str(self.eveentity), "Test")
 
     def test_repr(self):
+        """Test the repr representation of EveEntity."""
+        self.eveentity.category = "corporation"
+        # Expected Result
         self.assertEqual(
             repr(self.eveentity),
             "EveEntity(id=123, category='corporation', name='Test')",
         )
 
     def test_is_alliance(self):
+        """Test is_alliance property"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_ALLIANCE
         self.assertTrue(self.eveentity.is_alliance)
 
+        # Expected Result
+        self.eveentity.category = "Invalid Category"
+        self.assertFalse(self.eveentity.is_alliance)
+
     def test_is_corporation(self):
+        """Test is_corporation property"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_CORPORATION
         self.assertTrue(self.eveentity.is_corporation)
 
+        # Expected Result
+        self.eveentity.category = "Invalid Category"
+        self.assertFalse(self.eveentity.is_corporation)
+
     def test_is_character(self):
+        """Test is_character property"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_CHARACTER
         self.assertTrue(self.eveentity.is_character)
 
-    @patch(
-        MODULE_PATH + ".EveAllianceInfo.generic_logo_url"
-    )  # replace with your actual module path
+        # Expected Result
+        self.eveentity.category = "Invalid Category"
+        self.assertFalse(self.eveentity.is_character)
+
+    @patch(MODULE_PATH + ".EveAllianceInfo.generic_logo_url")
     def test_icon_url_alliance(self, mock_generic_logo_url):
+        """Test icon_url for alliance category"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_ALLIANCE
         mock_generic_logo_url.return_value = "Test URL"
+
+        # Expected Result
         self.assertEqual(self.eveentity.icon_url(), "Test URL")
 
-    @patch(
-        MODULE_PATH + ".EveCorporationInfo.generic_logo_url"
-    )  # replace with your actual module path
+    @patch(MODULE_PATH + ".EveCorporationInfo.generic_logo_url")
     def test_icon_url_corporation(self, mock_generic_logo_url):
+        """Test icon_url for corporation category"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_CORPORATION
         mock_generic_logo_url.return_value = "Test URL"
+
+        # Expected Result
         self.assertEqual(self.eveentity.icon_url(), "Test URL")
 
-    @patch(
-        MODULE_PATH + ".EveCharacter.generic_portrait_url"
-    )  # replace with your actual module path
+    @patch(MODULE_PATH + ".EveCharacter.generic_portrait_url")
     def test_icon_url_character(self, mock_generic_portrait_url):
+        """Test icon_url for character category"""
+        # Test Data
         self.eveentity.category = self.eveentity.CATEGORY_CHARACTER
         mock_generic_portrait_url.return_value = "Test URL"
+
+        # Expected Result
         self.assertEqual(self.eveentity.icon_url(), "Test URL")
 
     def test_icon_url_not_implemented(self):
+        """Test icon_url raises NotImplementedError for invalid category"""
+        # Expected Result
         self.eveentity.category = "Invalid Category"
         with self.assertRaises(NotImplementedError):
             self.eveentity.icon_url()
 
     def test_needs_update(self):
+        """Test needs_update method"""
+        # Expected Result
         self.assertTrue(self.eveentity.needs_update())

ledger/tests/test_models/test_planetary.py

@@ -6,34 +6,31 @@ from django.test import TestCase
 from django.utils import timezone
 
 # AA Ledger
-from ledger.tests.testdata.generate_characteraudit import (
-    create_characteraudit_from_evecharacter,
-)
-from ledger.tests.testdata.generate_planets import (
-    _planetary_data,
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.integrations.planetary import _planetary_data
+from ledger.tests.testdata.utils import (
     create_character_planet,
     create_character_planet_details,
+    create_owner_from_user,
 )
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 
 MODULE_PATH = "ledger.models.planetary"
 
 
-class TestPlanetModel(TestCase):
+class TestPlanetModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
 
         cls.planet_params = {
             "upgrade_level": 5,
             "num_pins": 5,
         }
 
-        cls.audit = create_characteraudit_from_evecharacter(1001)
-        cls.planetary = create_character_planet(cls.audit, 4001, **cls.planet_params)
+        cls.owner = create_owner_from_user(user=cls.user, owner_type="character")
+        cls.planetary = create_character_planet(
+            owner=cls.owner, planet_id=4001, **cls.planet_params
+        )
 
     def test_str(self):
         self.assertEqual(str(self.planetary), "Planet Data: Gneuten - Test Planet I")
@@ -44,20 +41,20 @@ class TestPlanetModel(TestCase):
         )
 
 
-class TestPlanetaryDetailsModel(TestCase):
+class TestPlanetaryDetailsModel(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
 
         cls.planet_params = {
             "upgrade_level": 5,
             "num_pins": 5,
         }
 
-        cls.audit = create_characteraudit_from_evecharacter(1001)
-        cls.planetary = create_character_planet(cls.audit, 4001, **cls.planet_params)
+        cls.owner = create_owner_from_user(user=cls.user, owner_type="character")
+        cls.planetary = create_character_planet(
+            owner=cls.owner, planet_id=4001, **cls.planet_params
+        )
         cls.planetarydetails = create_character_planet_details(
             cls.planetary, **_planetary_data
         )
@@ -67,68 +64,5 @@ class TestPlanetaryDetailsModel(TestCase):
             str(self.planetarydetails), "Planet Details Data: Gneuten - Test Planet I"
         )
 
-    def test_count_extractors(self):
-        extractors_count = self.planetarydetails.count_extractors()
-
-        self.assertEqual(extractors_count, 2)
-
-    def test_get_planet_install_date(self):
-        install_time = self.planetarydetails.get_planet_install_date()
-
-        expected_install_date = timezone.datetime(
-            2024, 8, 12, 17, 17, 2, tzinfo=timezone.utc
-        )
-        self.assertEqual(install_time, expected_install_date)
-
-    def test_get_planet_expiry_date(self):
-        expected_expiry_date = timezone.datetime(
-            2024, 8, 26, 17, 17, 2, tzinfo=timezone.utc
-        )
-        self.assertEqual(
-            self.planetarydetails.get_planet_expiry_date(), expected_expiry_date
-        )
-
     def test_is_expired(self):
         self.assertEqual(self.planetarydetails.is_expired, True)
-
-    def test_get_types(self):
-        self.assertEqual(
-            self.planetarydetails.get_types(), [9832, 3645, 2390, 2268, 2309]
-        )
-
-    @patch(MODULE_PATH + ".timezone.now")
-    def test_is_percent_correct(self, mock_now):
-        fixed_date = timezone.make_aware(timezone.datetime(2024, 8, 20, 17, 17, 2))
-        mock_now.return_value = fixed_date
-
-        extractor_info = self.planetarydetails.get_extractors_info()
-        expected_percent = 57.14
-        for _, value in extractor_info.items():
-            self.assertIn(
-                "progress_percentage", value
-            )  # Check if the key exists in the nested dictionary
-            self.assertEqual(value["progress_percentage"], expected_percent)
-
-    def test_get_planet_install_date_none(self):
-        planetary_details = create_character_planet_details(self.planetary)
-        planetary_details.pins = []
-        self.assertIsNone(planetary_details.get_planet_install_date())
-
-    def test_get_planet_expiry_date_none(self):
-        planetary_details = create_character_planet_details(self.planetary)
-        planetary_details.pins = []
-        self.assertIsNone(planetary_details.get_planet_expiry_date())
-
-    @patch("django.utils.timezone.now")
-    def test_is_expired_false(self, mock_now):
-        mock_now.return_value = timezone.datetime(2023, 10, 1, tzinfo=timezone.utc)
-        future_date = mock_now.return_value + timezone.timedelta(days=10)
-
-        planetary_details = create_character_planet_details(self.planetary)
-        planetary_details.pins = [{"expiry_time": future_date.isoformat()}]
-        self.assertFalse(planetary_details.is_expired)
-
-    def test_is_expired_empty(self):
-        planetary_details = create_character_planet_details(self.planetary)
-        planetary_details.pins = [{"expiry_time": None}]
-        self.assertFalse(planetary_details.is_expired)

ledger/tests/test_templatetags.py

@@ -1,14 +1,9 @@
-# Standard Library
-from unittest.mock import MagicMock
-
-# Django
-from django.test import TestCase
-
 # AA Ledger
 from ledger.templatetags.ledger import get_item, month_days, month_name, range_filter
+from ledger.tests import LedgerTestCase
 
 
-class TestTemplateTags(TestCase):
+class TestTemplateTags(LedgerTestCase):
 
     @classmethod
     def setUpClass(cls) -> None:

ledger/tests/test_views/corporation/test_add_corp.py

@@ -2,21 +2,16 @@
 
 # Standard Library
 from http import HTTPStatus
-from unittest.mock import Mock, patch
+from unittest.mock import patch
 
 # Django
-from django.contrib.sessions.middleware import SessionMiddleware
-from django.test import RequestFactory, TestCase, override_settings
+from django.test import override_settings
 from django.urls import reverse
 
 # AA Ledger
-from ledger.models.corporationaudit import CorporationAudit
-from ledger.tests.testdata.generate_corporationaudit import (
-    create_user_from_evecharacter,
-)
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
-from ledger.views.corporation.add_corp import add_corp
+from ledger.models.corporationaudit import CorporationOwner
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import add_new_permission_to_user
 
 MODULE_PATH = "ledger.views.corporation.add_corp"
 
@@ -24,38 +19,22 @@ MODULE_PATH = "ledger.views.corporation.add_corp"
 @patch(MODULE_PATH + ".messages")
 @patch(MODULE_PATH + ".tasks")
 @override_settings(CELERY_ALWAYS_EAGER=True, CELERY_EAGER_PROPAGATES_EXCEPTIONS=True)
-class TestAddCorpView(TestCase):
+class TestAddCorpView(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-
-        cls.factory = RequestFactory()
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001,
-            permissions=[
-                "ledger.basic_access",
-                "ledger.advanced_access",
-            ],
-        )
-
-    def _add_corporation(self, user, token):
-        request = self.factory.get(reverse("ledger:add_corp"))
-        request.user = user
-        request.token = token
-        middleware = SessionMiddleware(Mock())
-        middleware.process_request(request)
-        orig_view = add_corp.__wrapped__.__wrapped__.__wrapped__
-        return orig_view(request, token)
 
     def test_add_corp(self, mock_tasks, mock_messages):
-        # given
+        """Test adding a corporation via the add_corp view."""
+        # Test Data
+        self.user = add_new_permission_to_user(self.user, "ledger.advanced_access")
         user = self.user
         token = user.token_set.get(character_id=1001)
-        # when
+
+        # Test Action
         response = self._add_corporation(user, token)
-        # then
+
+        # Expected Results
         self.assertEqual(response.status_code, HTTPStatus.FOUND)
         self.assertEqual(
             response.url, reverse("ledger:corporation_ledger", args=[2001])
@@ -63,5 +42,7 @@ class TestAddCorpView(TestCase):
         self.assertTrue(mock_tasks.update_corporation.apply_async.called)
         self.assertTrue(mock_messages.info.called)
         self.assertTrue(
-            CorporationAudit.objects.filter(corporation__corporation_id=2001).exists()
+            CorporationOwner.objects.filter(
+                eve_corporation__corporation_id=2001
+            ).exists()
         )

ledger/tests/test_views/corporation/test_delete_corporation.py

@@ -9,83 +9,107 @@ from django.test import RequestFactory, TestCase
 from django.urls import reverse
 
 # AA Ledger
-from ledger.tests.testdata.generate_corporationaudit import (
-    add_corporationaudit_corporation_to_user,
-    create_user_from_evecharacter,
+from ledger.tests import LedgerTestCase
+from ledger.tests.testdata.utils import (
+    add_new_permission_to_user,
+    create_owner_from_user,
 )
-
-# AA Skillfarm
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
 from ledger.views.corporation.corporation_ledger import corporation_delete
 
 MODULE_PATH = "ledger.views.corporation.corporation_ledger"
 
 
-class TestDeleteCorporationView(TestCase):
+class TestDeleteCorporationView(LedgerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-
-        cls.factory = RequestFactory()
-        cls.user, cls.character_ownership = create_user_from_evecharacter(
-            1001,
-            permissions=[
-                "ledger.basic_access",
-                "ledger.advanced_access",
-                "ledger.corp_audit_manager",
-                "ledger.manage_access",
-            ],
-        )
-        cls.audit = add_corporationaudit_corporation_to_user(cls.user, 1001)
-        cls.no_audit_user, cls.character_ownership = create_user_from_evecharacter(
-            1002,
-            permissions=[
-                "ledger.basic_access",
-                "ledger.advanced_access",
-                "ledger.manage_access",
-            ],
+        cls.audit = create_owner_from_user(
+            user=cls.user,
+            owner_type="corporation",
         )
 
     def test_delete_corporation(self):
-        corporation_id = self.audit.corporation.corporation_id
+        """
+        Test deleting a corporation successfully.
 
+        This test verifies that a user with the appropriate permissions can successfully
+        delete a corporation from the system. It checks that the response indicates success
+        and that the correct success message is returned.
+
+        ## Results: Corporation is deleted successfully.
+        """
+        # Test Data
         request = self.factory.post(
-            reverse("ledger:delete_corp", args=[corporation_id])
+            reverse(
+                "ledger:delete_corp",
+                kwargs={"corporation_id": self.audit.eve_corporation.corporation_id},
+            )
         )
-        request.user = self.user
+        request.user = self.manage_own_user
 
-        response = corporation_delete(request, corporation_id=corporation_id)
+        # Test Action
+        response = corporation_delete(
+            request, corporation_id=self.audit.eve_corporation.corporation_id
+        )
 
+        # Expected Results
         response_data = json.loads(response.content)
-
         self.assertEqual(response.status_code, HTTPStatus.OK)
         self.assertTrue(response_data["success"])
         self.assertEqual(response_data["message"], "Hell RiderZ successfully deleted")
 
     def test_delete_corporation_no_audit(self):
-        request = self.factory.post(reverse("ledger:delete_corp", args=[2002]))
-        request.user = self.user
+        """
+        Test deleting a corporation that does not exist.
+
+        This test verifies that when a user attempts to delete a corporation that does not
+        exist in the system, the appropriate error response is returned.
+
+        ## Results: Corporation not found message is returned.
+        """
+        # Test Data
+        request = self.factory.post(
+            reverse("ledger:delete_corp", kwargs={"corporation_id": 2002})
+        )
+        request.user = self.manage_user
 
+        # Test Action
         response = corporation_delete(request, corporation_id=2002)
 
+        # Expected Results
         response_data = json.loads(response.content)
-
         self.assertEqual(response.status_code, HTTPStatus.NOT_FOUND)
         self.assertFalse(response_data["success"])
         self.assertEqual(response_data["message"], "Corporation not found")
 
     def test_delete_corporation_no_permission(self):
-        """Test deleting a corporation without being in the corporation."""
-        request = self.factory.post(reverse("ledger:delete_corp", args=[2001]))
-        request.user = self.no_audit_user
+        """
+        Test deleting a corporation without being in the corporation.
 
-        response = corporation_delete(request, corporation_id=2001)
+        This test verifies that when a user without the necessary permissions
+        attempts to delete a corporation, the system prevents the deletion and
+        provides an appropriate error message.
 
-        response_data = json.loads(response.content)
+        ## Results: Permission Denied message is returned.
+        """
+        # Test Data
+        request = self.factory.post(
+            reverse(
+                "ledger:delete_corp",
+                kwargs={"corporation_id": self.audit.eve_corporation.corporation_id},
+            )
+        )
+        add_new_permission_to_user(
+            user=self.user2, permission_name="ledger.manage_access"
+        )
+        request.user = self.user2
 
+        # Test Action
+        response = corporation_delete(
+            request, corporation_id=self.audit.eve_corporation.corporation_id
+        )
+        # Expected Results
+        response_data = json.loads(response.content)
         self.assertEqual(response.status_code, HTTPStatus.FORBIDDEN)
         self.assertFalse(response_data["success"])
         self.assertEqual(response_data["message"], "Permission Denied")