aa-mumble-quick-connect 0.0.1__py3-none-any.whl

aa_mumble_quick_connect/tests/test_auth_hooks.py

@@ -0,0 +1,113 @@
+"""
+Test auth_hooks
+"""
+
+# Standard Library
+from http import HTTPStatus
+
+# Django
+from django.test import TestCase, modify_settings
+from django.urls import reverse
+
+# Alliance Auth (External Libs)
+from app_utils.testing import create_fake_user
+
+
+class TestHooks(TestCase):
+    """
+    Test the app hook into allianceauth
+    """
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        """
+        Set up groups and users
+
+        :return:
+        :rtype:
+        """
+
+        super().setUpClass()
+
+        # User
+        cls.user_1001 = create_fake_user(
+            character_id=1001,
+            character_name="Jean Luc Picard",
+            permissions=[
+                "aa_mumble_quick_connect.basic_access",
+                "mumble.access_mumble",
+            ],
+        )
+
+        cls.user_1002 = create_fake_user(
+            character_id=1002, character_name="Wesley Crusher"
+        )
+
+        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 fa-solid fa-headphones-simple fa-fw align-self-center me-3 "></i>
+                <a class="nav-link flex-fill align-self-center me-auto" href="{reverse('aa_mumble_quick_connect:index')}">
+                    Mumble Quick Connect
+                </a>
+            </li>
+        """
+
+    def login(self, user):
+        """
+        Login a test user
+
+        :param user:
+        :type user:
+        :return:
+        :rtype:
+        """
+
+        self.client.force_login(user=user)
+
+    @modify_settings(INSTALLED_APPS={"append": "allianceauth.services.modules.mumble"})
+    def test_render_hook_success(self):
+        """
+        Test should show the link to the app for users with the correct permissions
+
+        :return:
+        :rtype:
+        """
+
+        self.login(user=self.user_1001)
+
+        response = self.client.get(path=reverse(viewname="authentication:dashboard"))
+
+        self.assertEqual(first=response.status_code, second=HTTPStatus.OK)
+        self.assertContains(response=response, text=self.html_menu, html=True)
+
+    @modify_settings(INSTALLED_APPS={"append": "allianceauth.services.modules.mumble"})
+    def test_render_hook_fail(self):
+        """
+        Test should not show the link to the app for users without the correct permissions
+
+        :return:
+        :rtype:
+        """
+
+        self.login(user=self.user_1002)
+
+        response = self.client.get(path=reverse(viewname="authentication:dashboard"))
+
+        self.assertEqual(first=response.status_code, second=HTTPStatus.OK)
+        self.assertNotContains(response=response, text=self.html_menu, html=True)
+
+    @modify_settings(INSTALLED_APPS={"remove": "allianceauth.services.modules.mumble"})
+    def test_mumble_service_not_installed(self):
+        """
+        Test should not show the link to the app when the Mumble service is not installed
+
+        :return:
+        :rtype:
+        """
+
+        self.login(user=self.user_1001)
+
+        response = self.client.get(path=reverse(viewname="authentication:dashboard"))
+
+        self.assertEqual(first=response.status_code, second=HTTPStatus.OK)
+        self.assertNotContains(response=response, text=self.html_menu, html=True)

aa_mumble_quick_connect/tests/test_models.py

@@ -0,0 +1,78 @@
+# Django
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.test import TestCase, override_settings
+
+# AA Mumble Quick Connect
+from aa_mumble_quick_connect.models import MumbleLink, Section, validate_mumble_url
+
+
+class TestSection(TestCase):
+    """
+    Tests for the `Section` model
+    """
+
+    def test_model_string_names(self):
+        """
+        Test model string name
+
+        :return:
+        :rtype:
+        """
+
+        section = Section(name="Foobar")
+        section.save()
+        expected_name = section.name
+        self.assertEqual(first=str(section), second=expected_name)
+
+
+class TestMumbleLink(TestCase):
+    """
+    Tests for the `MumbleLink` model
+    """
+
+    def test_model_string_names(self):
+        """
+        Test model string name
+
+        :return:
+        :rtype:
+        """
+
+        section = MumbleLink(name="Foobar")
+        section.save()
+        expected_name = section.name
+        self.assertEqual(first=str(section), second=expected_name)
+
+    @override_settings(MUMBLE_URL="mumble.example.com")
+    def test_validate_mumble_url_with_valid_url(self):
+        """
+        Test validate Mumble URL with valid URL
+
+        :return:
+        :rtype:
+        """
+
+        expected_mumble_base_url = f"mumble://{settings.MUMBLE_URL}"
+
+        self.assertEqual(
+            first=validate_mumble_url(url=f"mumble://{settings.MUMBLE_URL}"),
+            second=expected_mumble_base_url,
+        )
+
+    @override_settings(MUMBLE_URL="mumble.example.com")
+    def test_validate_mumble_url_with_invalid_url(self):
+        """
+        Test validate Mumble URL with invalid URL
+
+        :return:
+        :rtype:
+        """
+
+        expected_mumble_base_url = f"mumble://{settings.MUMBLE_URL}"
+
+        with self.assertRaisesMessage(
+            expected_exception=ValidationError,
+            expected_message=f"The Mumble channel URL must start with '{expected_mumble_base_url}'",
+        ):
+            validate_mumble_url("http://example.com")

aa_mumble_quick_connect/tests/test_templatetags.py

@@ -0,0 +1,35 @@
+"""
+Test the apps' template tags
+"""
+
+# Django
+from django.template import Context, Template
+from django.test import TestCase, override_settings
+
+
+class TestQuickConnectLinkTemplateTag(TestCase):
+    """
+    Test aa_mumble_quick_connect template tag
+    """
+
+    @override_settings(DEBUG=False)
+    def test_aa_mumble_quick_connect(self) -> None:
+        """
+        Test aa_mumble_quick_connect template tag
+
+        :return:
+        :rtype:
+        """
+
+        context = Context({"mumble_link": "mumble://example.com", "username": "foobar"})
+        template_to_render = Template(
+            template_string=(
+                "{% load aa_mumble_quick_connect %}"
+                "{% aa_mumble_quick_connect_link mumble_link username %}"
+            )
+        )
+
+        rendered_template = template_to_render.render(context=context)
+        expected = "mumble://foobar@example.com"
+
+        self.assertEqual(first=rendered_template, second=expected)

aa_mumble_quick_connect/tests/utils.py

@@ -0,0 +1,34 @@
+"""
+Helper for our tests
+"""
+
+# Django
+from django.core.handlers.wsgi import WSGIRequest
+from django.template import Context, Template
+
+
+def render_template(string, context=None):
+    """
+    Helper to render templates
+    :param string:
+    :param context:
+    :return:
+    """
+
+    context = context or {}
+    context = Context(dict_=context)
+
+    return Template(template_string=string).render(context=context)
+
+
+def response_content_to_str(response: WSGIRequest) -> str:
+    """
+    Return the content of a WSGIRequest response as string
+
+    :param response:
+    :type response:
+    :return:
+    :rtype:
+    """
+
+    return response.content.decode(response.charset)

aa_mumble_quick_connect/urls.py

@@ -0,0 +1,13 @@
+"""App URLs"""
+
+# Django
+from django.urls import path
+
+# AA Mumble Quick Connect
+from aa_mumble_quick_connect import views
+
+app_name: str = "aa_mumble_quick_connect"
+
+urlpatterns = [
+    path(route="", view=views.index, name="index"),
+]

aa_mumble_quick_connect/views.py

@@ -0,0 +1,37 @@
+"""App Views"""
+
+# Django
+from django.contrib.auth.decorators import login_required, permission_required
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import HttpResponse
+from django.shortcuts import render
+
+# AA Mumble Quick Connect
+from aa_mumble_quick_connect.dependency_checks import mumble_service_installed
+from aa_mumble_quick_connect.models import MumbleLink, Section
+
+
+@login_required
+@permission_required("aa_mumble_quick_connect.basic_access")
+@permission_required("mumble.access_mumble")
+def index(request: WSGIRequest) -> HttpResponse:
+    """
+    Index view
+    :param request:
+    :return:
+    """
+
+    channels_in_sections = Section.objects.prefetch_related("mumble_links").all()
+    channels_without_sections = MumbleLink.objects.filter(section__isnull=True)
+
+    context = {
+        "mumble_service_installed": mumble_service_installed(),
+        "channels_in_sections": channels_in_sections,
+        "channels_without_sections": channels_without_sections,
+    }
+
+    return render(
+        request=request,
+        template_name="aa_mumble_quick_connect/index.html",
+        context=context,
+    )