aa-fleetfinder 2.3.1__py3-none-any.whl → 2.3.3__py3-none-any.whl

fleetfinder/templatetags/fleetfinder.py

@@ -18,18 +18,22 @@ from app_utils.logging import LoggerAddTag
 
 # AA Fleet Finder
 from fleetfinder import __title__, __version__
+from fleetfinder.app_settings import debug_enabled
+from fleetfinder.constants import PACKAGE_NAME
 from fleetfinder.helper.static_files import calculate_integrity_hash
 
 logger = LoggerAddTag(my_logger=get_extension_logger(__name__), prefix=__title__)
 
 
 @register.simple_tag
-def fleetfinder_static(relative_file_path: str) -> str | None:
+def fleetfinder_static(relative_file_path: str, script_type: str = None) -> str | None:
     """
     Versioned static URL
 
-    :param relative_file_path: The file path relative to the `aa-fleetfinder/fleetfinder/static/fleetfinder` folder
+    :param relative_file_path: The file path relative to the `{APP_NAME}/{PACKAGE_NAME}/static/{PACKAGE_NAME}` folder
     :type relative_file_path: str
+    :param script_type: The script type
+    :type script_type: str
     :return: Versioned static URL
     :rtype: str
     """
@@ -44,10 +48,16 @@ def fleetfinder_static(relative_file_path: str) -> str | None:
     if file_type not in ["css", "js"]:
         raise ValueError(f"Unsupported file type: {file_type}")
 
-    integrity_hash = calculate_integrity_hash(relative_file_path)
-    static_file_path = os.path.join("fleetfinder", relative_file_path)
+    static_file_path = os.path.join(PACKAGE_NAME, relative_file_path)
     static_url = static(static_file_path)
 
+    # Integrity hash calculation only for non-debug mode
+    sri_string = (
+        f' integrity="{calculate_integrity_hash(relative_file_path)}" crossorigin="anonymous"'
+        if not debug_enabled()
+        else ""
+    )
+
     # Versioned URL for CSS and JS files
     # Add version query parameter to break browser caches when changing the app version
     # Do not add version query parameter for libs as they are already versioned through their file path
@@ -57,18 +67,36 @@ def fleetfinder_static(relative_file_path: str) -> str | None:
         else static_url + "?v=" + __version__
     )
 
+    return_value = None
+
     # Return the versioned URL with integrity hash for CSS
     if file_type == "css":
-        logger.debug(f"Integrity hash for {relative_file_path}: {integrity_hash}")
-
-        return mark_safe(
-            f'<link rel="stylesheet" href="{versioned_url}" integrity="{integrity_hash}" crossorigin="anonymous">'
+        return_value = mark_safe(
+            f'<link rel="stylesheet" href="{versioned_url}"{sri_string}>'
         )
 
     # Return the versioned URL with integrity hash for JS files
     if file_type == "js":
-        return mark_safe(
-            f'<script src="{versioned_url}" integrity="{integrity_hash}" crossorigin="anonymous"></script>'
+        js_type = f' type="{script_type}"' if script_type else ""
+
+        return_value = mark_safe(
+            f'<script{js_type} src="{versioned_url}"{sri_string}></script>'
         )
 
-    return None
+    return return_value
+
+
+@register.filter
+def get_item(dictionary: dict | None, key: str) -> str | None:
+    """
+    Little helper: get a key from a dictionary
+
+    :param dictionary:
+    :param key:
+    :return:
+    """
+
+    if dictionary is None:
+        return None
+
+    return dictionary.get(key, None)

fleetfinder/tests/test_settings.py

@@ -0,0 +1,37 @@
+"""
+Test the settings
+"""
+
+# Django
+from django.test import TestCase, override_settings
+
+# AA Fleet Finder
+from fleetfinder.app_settings import debug_enabled
+
+
+class TestSettings(TestCase):
+    """
+    Test the settings
+    """
+
+    @override_settings(DEBUG=True)
+    def test_debug_enabled_with_debug_true(self) -> None:
+        """
+        Test debug_enabled with DEBUG = True
+
+        :return:
+        :rtype:
+        """
+
+        self.assertTrue(debug_enabled())
+
+    @override_settings(DEBUG=False)
+    def test_debug_enabled_with_debug_false(self) -> None:
+        """
+        Test debug_enabled with DEBUG = False
+
+        :return:
+        :rtype:
+        """
+
+        self.assertFalse(debug_enabled())

fleetfinder/tests/test_templatetags.py

@@ -4,11 +4,13 @@ Test the apps' template tags
 
 # Django
 from django.template import Context, Template
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 # AA Fleet Finder
 from fleetfinder import __version__
+from fleetfinder.constants import PACKAGE_NAME
 from fleetfinder.helper.static_files import calculate_integrity_hash
+from fleetfinder.templatetags.fleetfinder import get_item
 
 
 class TestVersionedStatic(TestCase):
@@ -16,6 +18,7 @@ class TestVersionedStatic(TestCase):
     Test the `fleetfinder_static` template tag
     """
 
+    @override_settings(DEBUG=False)
     def test_versioned_static(self):
         """
         Test should return the versioned static
@@ -32,14 +35,120 @@ class TestVersionedStatic(TestCase):
             )
         )
 
-        rendered_template = template_to_render.render(context)
+        rendered_template = template_to_render.render(context=context)
 
-        expected_static_src = (
-            f'/static/fleetfinder/css/fleetfinder.min.css?v={context["version"]}'
+        expected_static_css_src = (
+            f'/static/{PACKAGE_NAME}/css/fleetfinder.min.css?v={context["version"]}'
         )
-        expected_static_src_integrity = calculate_integrity_hash(
+        expected_static_css_src_integrity = calculate_integrity_hash(
             "css/fleetfinder.min.css"
         )
 
-        self.assertIn(member=expected_static_src, container=rendered_template)
-        self.assertIn(member=expected_static_src_integrity, container=rendered_template)
+        self.assertIn(member=expected_static_css_src, container=rendered_template)
+        self.assertIn(
+            member=expected_static_css_src_integrity, container=rendered_template
+        )
+
+    @override_settings(DEBUG=True)
+    def test_versioned_static_with_debug_enabled(self) -> None:
+        """
+        Test versioned static template tag with DEBUG enabled
+
+        :return:
+        :rtype:
+        """
+
+        context = Context({"version": __version__})
+        template_to_render = Template(
+            template_string=(
+                "{% load fleetfinder %}"
+                "{% fleetfinder_static 'css/fleetfinder.min.css' %}"
+            )
+        )
+
+        rendered_template = template_to_render.render(context=context)
+
+        expected_static_css_src = (
+            f'/static/{PACKAGE_NAME}/css/fleetfinder.min.css?v={context["version"]}'
+        )
+
+        self.assertIn(member=expected_static_css_src, container=rendered_template)
+        self.assertNotIn(member="integrity=", container=rendered_template)
+
+    @override_settings(DEBUG=False)
+    def test_invalid_file_type(self) -> None:
+        """
+        Test should raise a ValueError for an invalid file type
+
+        :return:
+        :rtype:
+        """
+
+        context = Context({"version": __version__})
+        template_to_render = Template(
+            template_string=(
+                "{% load fleetfinder %}"
+                "{% fleetfinder_static 'invalid/invalid.txt' %}"
+            )
+        )
+
+        with self.assertRaises(ValueError):
+            template_to_render.render(context=context)
+
+
+class TestGetItem(TestCase):
+    """
+    Test the `get_item` template tag
+    """
+
+    def test_returns_value_for_existing_key(self):
+        """
+        Test should return the value for an existing key
+
+        :return:
+        :rtype:
+        """
+
+        dictionary = {"key1": "value1", "key2": "value2"}
+        result = get_item(dictionary, "key1")
+
+        self.assertEqual(result, "value1")
+
+    def test_returns_none_for_non_existing_key(self):
+        """
+        Test should return None for a non-existing key
+
+        :return:
+        :rtype:
+        """
+
+        dictionary = {"key1": "value1", "key2": "value2"}
+        result = get_item(dictionary, "key3")
+
+        self.assertIsNone(result)
+
+    def test_returns_none_for_empty_dictionary(self):
+        """
+        Test should return None for an empty dictionary
+
+        :return:
+        :rtype:
+        """
+
+        dictionary = {}
+        result = get_item(dictionary, "key1")
+
+        self.assertIsNone(result)
+
+    def test_returns_none_for_none_dictionary(self):
+        """
+        Test should return None for a None dictionary
+
+        :return:
+        :rtype:
+        """
+
+        dictionary = None
+        result = get_item(dictionary, "key1")
+
+        self.assertIsNone(result)

fleetfinder/views.py

@@ -11,7 +11,6 @@ from django.contrib.auth.decorators import login_required, permission_required
 from django.db.models import Q
 from django.http import JsonResponse
 from django.shortcuts import redirect, render
-from django.template.defaulttags import register
 from django.urls import reverse
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
@@ -341,16 +340,3 @@ def ajax_fleet_details(
         data["fleet_composition"].append({"ship_type_name": ship, "number": number})
 
     return JsonResponse(data=data, safe=False)
-
-
-@register.filter
-def get_item(dictionary, key):
-    """
-    Little helper: get a key from a dictionary
-
-    :param dictionary:
-    :param key:
-    :return:
-    """
-
-    return dictionary.get(key=key, default=None)

fleetfinder/templates/fleetfinder/partials/header/header-navigation.html

@@ -1,35 +0,0 @@
-{% load i18n %}
-
-<nav class="navbar navbar-expand-lg bg-primary navbar-dark mb-3 rounded">
-    <div class="container-fluid">
-        <a class="navbar-brand" href="{% url 'fleetfinder:dashboard' %}">
-            {% translate "Available fleets" as navigation_item %}
-            {{ navigation_item|title }}
-        </a>
-
-        <button
-            class="navbar-toggler collapsed"
-            type="button"
-            data-bs-toggle="collapse"
-            data-bs-target="#fleetfinder-header-navbar"
-            aria-controls="fleetfinder-header-navbar"
-            aria-expanded="false"
-            aria-label="{% translate 'Toggle navigation' %}"
-        >
-            <span class="navbar-toggler-icon"></span>
-        </button>
-
-        <div class="collapse navbar-collapse" id="fleetfinder-header-navbar">
-            <ul class="navbar-nav">
-                {% if perms.fleetfinder.manage_fleets %}
-                    <li class="nav-item">
-                        <a class="nav-link" href="{% url 'fleetfinder:create_fleet' %}">
-                            {% translate "Create fleet" as navigation_item %}
-                            {{ navigation_item|title }}
-                        </a>
-                    </li>
-                {% endif %}
-            </ul>
-        </div>
-    </div>
-</nav>