aa-intel-tool 2.11.2__py3-none-any.whl → 2.12.1__py3-none-any.whl

aa_intel_tool/tests/test_app_settings.py

@@ -10,12 +10,209 @@ from django.conf import settings
 from django.test import override_settings
 
 # AA Intel Tool
-from aa_intel_tool.app_settings import AppSettings, debug_enabled
+from aa_intel_tool.app_settings import AppSettings, _clean_setting, debug_enabled
 from aa_intel_tool.tests import BaseTestCase
 
 SETTINGS_PATH = "aa_intel_tool.app_settings"
 
 
+class TestHelperCleanSetting(BaseTestCase):
+    """
+    Tests for the _clean_setting helper function
+    """
+
+    def test_returns_default_value_when_setting_is_absent(self):
+        """
+        Test returns default value when setting is absent
+
+        :return:
+        :rtype:
+        """
+
+        if hasattr(settings, "TEST_SETTING"):
+            delattr(settings, "TEST_SETTING")
+
+        result = _clean_setting("TEST_SETTING", default_value=123, required_type=int)
+
+        self.assertEqual(result, 123)
+
+    def test_returns_setting_value_when_valid_and_defined(self):
+        """
+        Test returns setting value when valid and defined
+
+        :return:
+        :rtype:
+        """
+
+        with self.settings(TEST_SETTING=456):
+            result = _clean_setting(
+                "TEST_SETTING", default_value=123, required_type=int
+            )
+
+            self.assertEqual(result, 456)
+
+    def test_raises_value_error_when_default_is_below_minimum(self):
+        """
+        Test raises ValueError when default is below minimum
+
+        :return:
+        :rtype:
+        """
+
+        with self.assertRaises(ValueError):
+            _clean_setting(
+                "TEST_SETTING", default_value=5, min_value=10, required_type=int
+            )
+
+    def test_raises_value_error_when_default_exceeds_maximum(self):
+        """
+        Test raises ValueError when default exceeds maximum
+
+        :return:
+        :rtype:
+        """
+
+        with self.assertRaises(ValueError):
+            _clean_setting(
+                "TEST_SETTING", default_value=15, max_value=10, required_type=int
+            )
+
+    def test_uses_minimum_value_when_setting_is_below_minimum(self):
+        """
+        Test uses minimum value when setting is below minimum
+
+        :return:
+        :rtype:
+        """
+
+        with self.settings(TEST_SETTING=5):
+            result = _clean_setting(
+                "TEST_SETTING", default_value=123, min_value=10, required_type=int
+            )
+
+            self.assertEqual(result, 10)
+
+    def test_uses_maximum_value_when_setting_exceeds_maximum(self):
+        """
+        Test uses maximum value when setting exceeds maximum
+
+        :return:
+        :rtype:
+        """
+
+        with self.settings(TEST_SETTING=15):
+            result = _clean_setting(
+                "TEST_SETTING", default_value=3, max_value=10, required_type=int
+            )
+
+            self.assertEqual(result, 10)
+
+    def test_raises_type_error_when_required_type_is_invalid(self):
+        """
+        Test raises TypeError when required_type is invalid
+
+        :return:
+        :rtype:
+        """
+
+        with self.assertRaises(TypeError):
+            _clean_setting(
+                "TEST_SETTING", default_value=123, required_type="not_a_type"
+            )
+
+    def test_raises_value_error_when_required_type_is_missing_for_none_default(self):
+        """
+        Test raises ValueError when required_type is missing for None default
+
+        :return:
+        :rtype:
+        """
+
+        with self.assertRaises(ValueError):
+            _clean_setting("TEST_SETTING", default_value=None)
+
+    def test_uses_default_value_when_setting_is_not_in_choices(self):
+        """
+        Test uses default value when setting is not in choices
+
+        :return:
+        :rtype:
+        """
+
+        with self.settings(TEST_SETTING=999):
+            result = _clean_setting(
+                "TEST_SETTING", default_value=123, required_type=int, choices=[1, 2, 3]
+            )
+
+            self.assertEqual(result, 123)
+
+    def test_uses_setting_value_when_in_choices(self):
+        """
+        Test uses setting value when in choices
+
+        :return:
+        :rtype:
+        """
+
+        with self.settings(TEST_SETTING=2):
+            result = _clean_setting(
+                "TEST_SETTING", default_value=123, required_type=int, choices=[1, 2, 3]
+            )
+
+            self.assertEqual(result, 2)
+
+    def test_uses_type_of_default_value_when_required_type_is_not_provided(self):
+        """
+        Test uses type of default value when required_type is not provided
+
+        :return:
+        :rtype:
+        """
+
+        result = _clean_setting("TEST_SETTING", default_value=123)
+
+        self.assertEqual(result, 123)
+
+    def test_raises_type_error_when_default_value_is_none_and_required_type_is_not_provided(
+        self,
+    ):
+        """
+        Test raises TypeError when default_value is None and required_type is not provided
+
+        :return:
+        :rtype:
+        """
+
+        with self.assertRaises(ValueError):
+            _clean_setting("TEST_SETTING", default_value=None)
+
+    def test_does_not_raise_error_when_required_type_is_subclass_of_int(self):
+        """
+        Test does not raise error when required_type is subclass of int
+
+        :return:
+        :rtype:
+        """
+
+        result = _clean_setting("TEST_SETTING", default_value=123, required_type=int)
+
+        self.assertEqual(result, 123)
+
+    def test_skips_check_when_default_value_is_none_and_required_type_is_subclass_of_int(
+        self,
+    ):
+        """
+        Test skips check when default_value is None and required_type is subclass of int
+
+        :return:
+        :rtype:
+        """
+
+        result = _clean_setting("TEST_SETTING", default_value=None, required_type=int)
+
+        self.assertIsNone(result)
+
+
 class TestAppSettings(BaseTestCase):
     """
     Tests for App Settings

aa_intel_tool/tests/test_auth_hooks.py

@@ -8,12 +8,9 @@ from http import HTTPStatus
 # Django
 from django.urls import reverse
 
-# Alliance Auth (External Libs)
-from app_utils.testing import create_fake_user
-
 # AA Intel Tool
 from aa_intel_tool.tests import BaseTestCase
-from aa_intel_tool.tests.utils import response_content_to_str
+from aa_intel_tool.tests.utils import create_fake_user, response_content_to_str
 
 
 class TestHooks(BaseTestCase):

aa_intel_tool/tests/test_helper_urls.py

@@ -0,0 +1,70 @@
+"""
+Unit tests for the helper.urls helper.
+"""
+
+# Standard Library
+from unittest.mock import patch
+
+# AA Intel Tool
+from aa_intel_tool.helper.urls import reverse_absolute
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestReverseAbsolute(BaseTestCase):
+    """
+    Test reverse_absolute helper
+    """
+
+    @patch("aa_intel_tool.helper.urls.reverse")
+    def test_returns_absolute_url_for_valid_viewname(self, mock_reverse):
+        """
+        Test returns absolute URL for valid viewname
+
+        :param mock_reverse:
+        :type mock_reverse:
+        :return:
+        :rtype:
+        """
+
+        mock_reverse.return_value = "/mocked-path/"
+
+        with self.settings(SITE_URL="https://example.com"):
+            result = reverse_absolute("mock_view")
+
+        self.assertEqual(result, "https://example.com/mocked-path/")
+
+    @patch("aa_intel_tool.helper.urls.reverse")
+    def test_handles_none_args_correctly(self, mock_reverse):
+        """
+        Test handles None args correctly
+
+        :param mock_reverse:
+        :type mock_reverse:
+        :return:
+        :rtype:
+        """
+
+        mock_reverse.return_value = "/mocked-path/"
+
+        with self.settings(SITE_URL="https://example.com"):
+            result = reverse_absolute("mock_view", args=None)
+
+        self.assertEqual(result, "https://example.com/mocked-path/")
+
+    @patch("aa_intel_tool.helper.urls.reverse")
+    def test_includes_args_in_generated_url(self, mock_reverse):
+        """
+        Test includes args in generated URL
+
+        :param mock_reverse:
+        :type mock_reverse:
+        :return:
+        :rtype:
+        """
+
+        mock_reverse.return_value = "/mocked-path/123/"
+
+        with self.settings(SITE_URL="https://example.com"):
+            result = reverse_absolute("mock_view", args=[123])
+
+        self.assertEqual(result, "https://example.com/mocked-path/123/")

aa_intel_tool/tests/test_providers.py

@@ -0,0 +1,98 @@
+"""
+Test for the providers module.
+"""
+
+# Standard Library
+import logging
+
+# AA Intel Tool
+from aa_intel_tool.providers import AppLogger
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestAppLogger(BaseTestCase):
+    """
+    Test the AppLogger provider.
+    """
+
+    def test_adds_prefix_to_log_message(self):
+        """
+        Tests that the AppLogger correctly adds a prefix to log messages.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "PREFIX")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("This is a test message")
+
+        self.assertIn("[PREFIX] This is a test message", log.output[0])
+
+    def test_handles_empty_prefix(self):
+        """
+        Tests that the AppLogger handles an empty prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message without prefix")
+
+        self.assertIn("Message without prefix", log.output[0])
+
+    def test_handles_non_string_prefix(self):
+        """
+        Tests that the AppLogger handles a non-string prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, 123)
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message with numeric prefix")
+
+        self.assertIn("[123] Message with numeric prefix", log.output[0])
+
+    def test_handles_special_characters_in_prefix(self):
+        """
+        Tests that the AppLogger handles special characters in the prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "!@#$%^&*()")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message with special characters in prefix")
+
+        self.assertIn(
+            "[!@#$%^&*()] Message with special characters in prefix", log.output[0]
+        )
+
+    def test_handles_empty_message(self):
+        """
+        Tests that the AppLogger handles an empty log message correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "PREFIX")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("")
+
+        self.assertIn("[PREFIX] ", log.output[0])

aa_intel_tool/tests/utils.py

@@ -3,12 +3,17 @@ Helper for our tests
 """
 
 # Standard Library
+import re
 from pathlib import Path
 
 # Django
+from django.contrib.auth.models import User
 from django.core.handlers.wsgi import WSGIRequest
 from django.template import Context, Template
 
+# Alliance Auth
+from allianceauth.tests.auth_utils import AuthUtils
+
 
 def render_template(string, context=None):
     """
@@ -79,3 +84,66 @@ def response_content_to_str(response: WSGIRequest) -> str:
     """
 
     return response.content.decode(response.charset)
+
+
+def create_fake_user(
+    character_id: int,
+    character_name: str,
+    corporation_id: int = None,
+    corporation_name: str = None,
+    corporation_ticker: str = None,
+    permissions: list[str] = None,
+    **kwargs,
+) -> User:
+    """
+    Create a fake user with a given character name and id.
+
+    :param character_id:
+    :type character_id:
+    :param character_name:
+    :type character_name:
+    :param corporation_id:
+    :type corporation_id:
+    :param corporation_name:
+    :type corporation_name:
+    :param corporation_ticker:
+    :type corporation_ticker:
+    :param permissions:
+    :type permissions:
+    :param kwargs:
+    :type kwargs:
+    :return:
+    :rtype:
+    """
+
+    username = re.sub(pattern=r"[^\w\d@\.\+-]", repl="_", string=character_name)
+    user = AuthUtils.create_user(username=username)
+
+    if not corporation_id:
+        corporation_id = 2001
+        corporation_name = "Wayne Technologies Inc."
+        corporation_ticker = "WTE"
+
+    alliance_id = kwargs.get("alliance_id", 3001)
+    alliance_name = (
+        kwargs.get("alliance_name", "Wayne Enterprises")
+        if alliance_id is not None
+        else ""
+    )
+
+    AuthUtils.add_main_character_2(
+        user=user,
+        name=character_name,
+        character_id=character_id,
+        corp_id=corporation_id,
+        corp_name=corporation_name,
+        corp_ticker=corporation_ticker,
+        alliance_id=alliance_id,
+        alliance_name=alliance_name,
+    )
+
+    if permissions:
+        perm_objs = [AuthUtils.get_permission_by_name(perm) for perm in permissions]
+        user = AuthUtils.add_permissions_to_user(perms=perm_objs, user=user)
+
+    return user

aa_intel_tool/views/general.py

@@ -12,9 +12,6 @@ from django.utils.translation import gettext_lazy as _
 # Alliance Auth
 from allianceauth.services.hooks import get_extension_logger
 
-# Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
-
 # AA Intel Tool
 from aa_intel_tool import __title__
 from aa_intel_tool.app_settings import AppSettings
@@ -23,8 +20,9 @@ from aa_intel_tool.exceptions import ParserError
 from aa_intel_tool.form import IntelForm
 from aa_intel_tool.models import Scan, ScanData
 from aa_intel_tool.parser.general import parse_intel
+from aa_intel_tool.providers import AppLogger
 
-logger = LoggerAddTag(my_logger=get_extension_logger(name=__name__), prefix=__title__)
+logger = AppLogger(my_logger=get_extension_logger(name=__name__), prefix=__title__)
 
 
 def index(request: WSGIRequest) -> HttpResponse:

{aa_intel_tool-2.11.2.dist-info → aa_intel_tool-2.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aa-intel-tool
-Version: 2.11.2
+Version: 2.12.1
 Summary: A simple parser for D-Scans and more for Alliance Auth
 Project-URL: Changelog, https://github.com/ppfeufer/aa-intel-tool/blob/master/CHANGELOG.md
 Project-URL: Codecov, https://codecov.io/gh/ppfeufer/aa-intel-tool
@@ -702,7 +702,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Requires-Python: <3.14,>=3.10
-Requires-Dist: allianceauth-app-utils>=1.19.1
 Requires-Dist: allianceauth<5,>=4.10
 Requires-Dist: django-eveuniverse>=1.3
 Provides-Extra: tests-allianceauth-latest