django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/core/tests/test_context_processors.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from django.test import RequestFactory, TestCase, override_settings
+
+from django_spire.core.context_processors import django_spire, theme_context
+
+
+class TestDjangoSpireContextProcessor(TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+
+    @override_settings(DJANGO_SPIRE_AUTH_CONTROLLERS=[])
+    def test_empty_auth_controllers(self) -> None:
+        request = self.factory.get('/')
+        result = django_spire(request)
+
+        assert 'DJANGO_SPIRE_VERSION' in result
+        assert 'AuthController' in result
+        assert result['AuthController'] == {}
+
+    @override_settings(DJANGO_SPIRE_AUTH_CONTROLLERS=['test_app'])
+    @patch('django_spire.core.context_processors.AppAuthController')
+    def test_with_auth_controllers(self, mock_controller: MagicMock) -> None:
+        mock_instance = MagicMock()
+        mock_controller.return_value = mock_instance
+
+        request = self.factory.get('/')
+        result = django_spire(request)
+
+        assert 'AuthController' in result
+        assert 'test_app' in result['AuthController']
+        mock_controller.assert_called_once_with('test_app', request=request)
+
+
+class TestThemeContextProcessor(TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+
+    def test_default_theme_applied(self) -> None:
+        request = self.factory.get('/')
+        request.COOKIES = {}
+        result = theme_context(request)
+
+        assert 'DJANGO_SPIRE_DEFAULT_THEME' in result
+        assert 'DJANGO_SPIRE_THEME_COOKIE_NAME' in result
+        assert 'DJANGO_SPIRE_THEME_PATH' in result
+        assert 'theme' in result
+
+    @override_settings(DJANGO_SPIRE_DEFAULT_THEME='default-dark')
+    def test_custom_default_theme(self) -> None:
+        request = self.factory.get('/')
+        request.COOKIES = {}
+        result = theme_context(request)
+
+        assert result['DJANGO_SPIRE_DEFAULT_THEME'] == 'default-dark'
+
+    @override_settings(DJANGO_SPIRE_THEME_PATH='/custom/path/{family}/app-{mode}.css')
+    def test_custom_theme_path(self) -> None:
+        request = self.factory.get('/')
+        request.COOKIES = {}
+        result = theme_context(request)
+
+        assert result['DJANGO_SPIRE_THEME_PATH'] == '/custom/path/{family}/app-{mode}.css'
+
+    @patch('django_spire.core.context_processors.get_theme_cookie_name')
+    @patch('django_spire.core.context_processors.Theme')
+    def test_theme_from_cookie(self, mock_theme: MagicMock, mock_cookie_name: MagicMock) -> None:
+        mock_cookie_name.return_value = 'theme_cookie'
+        mock_theme_instance = MagicMock()
+        mock_theme_instance.value = 'custom-dark'
+        mock_theme_instance.to_dict.return_value = {'family': 'custom', 'mode': 'dark'}
+        mock_theme.from_string.return_value = mock_theme_instance
+        mock_theme.get_default.return_value = mock_theme_instance
+
+        request = self.factory.get('/')
+        request.COOKIES = {'theme_cookie': 'custom-dark'}
+        result = theme_context(request)
+
+        assert result['theme'] == {'family': 'custom', 'mode': 'dark'}
+
+    def test_theme_result_contains_required_keys(self) -> None:
+        request = self.factory.get('/')
+        request.COOKIES = {}
+        result = theme_context(request)
+
+        assert 'theme' in result
+        assert isinstance(result['theme'], dict)

django_spire/core/tests/test_decorators.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import MagicMock, patch
+
+from django.http import HttpRequest, JsonResponse
+from django.test import RequestFactory, TestCase
+
+from django_spire.core.decorators import close_db_connections, valid_ajax_request_required
+
+
+class TestCloseDbConnections(TestCase):
+    @patch('django_spire.core.decorators.connections')
+    def test_closes_connections_after_exception(self, mock_connections: MagicMock) -> None:
+        @close_db_connections
+        def sample_func():
+            raise ValueError
+
+        with pytest.raises(ValueError):
+            sample_func()
+
+        mock_connections.close_all.assert_called_once()
+
+    @patch('django_spire.core.decorators.connections')
+    def test_closes_connections_after_success(self, mock_connections: MagicMock) -> None:
+        @close_db_connections
+        def sample_func():
+            return 'result'
+
+        result = sample_func()
+
+        assert result == 'result'
+        mock_connections.close_all.assert_called_once()
+
+    @patch('django_spire.core.decorators.connections')
+    def test_preserves_function_metadata(self, _mock_connections: MagicMock) -> None:
+        @close_db_connections
+        def sample_func():
+            """Sample docstring"""
+
+        assert sample_func.__name__ == 'sample_func'
+        assert sample_func.__doc__ == 'Sample docstring'
+
+
+class TestValidAjaxRequestRequired(TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+
+    def test_get_request_returns_error(self) -> None:
+        @valid_ajax_request_required
+        def sample_view(_request: HttpRequest) -> dict:
+            return {'success': True}
+
+        request = self.factory.get('/test/')
+        response = sample_view(request)
+
+        assert response.status_code == 200
+        assert b'error' in response.content
+
+    def test_post_request_with_json_content_type_succeeds(self) -> None:
+        @valid_ajax_request_required
+        def sample_view(_request: HttpRequest) -> JsonResponse:
+            return JsonResponse({'success': True})
+
+        request = self.factory.post(
+            '/test/',
+            data='{}',
+            content_type='application/json'
+        )
+        response = sample_view(request)
+
+        assert response.status_code == 200
+        assert b'success' in response.content
+
+    def test_post_request_without_json_content_type_passes(self) -> None:
+        @valid_ajax_request_required
+        def sample_view(_request: HttpRequest) -> JsonResponse:
+            return JsonResponse({'success': True})
+
+        request = self.factory.post('/test/', data={})
+        response = sample_view(request)
+
+        assert response.status_code == 200
+        assert b'success' in response.content
+
+    def test_preserves_function_metadata(self) -> None:
+        @valid_ajax_request_required
+        def sample_view(_request: HttpRequest) -> None:
+            """Sample docstring"""
+
+        assert sample_view.__name__ == 'sample_view'
+        assert sample_view.__doc__ == 'Sample docstring'

django_spire/core/tests/test_django_spire_utils.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+
+from django.test import TestCase
+
+from django_spire.utils import (
+    app_is_installed,
+    get_class_from_string,
+    get_class_name_from_class,
+)
+
+
+class TestAppIsInstalled(TestCase):
+    def test_installed_app_returns_true(self) -> None:
+        result = app_is_installed('auth')
+
+        assert result is True
+
+    def test_not_installed_app_returns_false(self) -> None:
+        result = app_is_installed('nonexistent_app')
+
+        assert result is False
+
+
+class TestGetClassFromString(TestCase):
+    def test_imports_class(self) -> None:
+        result = get_class_from_string('django.test.TestCase')
+
+        assert result is TestCase
+
+    def test_invalid_class_string_raises_exception(self) -> None:
+        with pytest.raises(Exception, match='not a valid class string'):
+            get_class_from_string('InvalidString')
+
+    def test_nonexistent_module_raises_exception(self) -> None:
+        with pytest.raises(ModuleNotFoundError):
+            get_class_from_string('nonexistent.module.ClassName')
+
+
+class TestGetClassNameFromClass(TestCase):
+    def test_returns_full_class_path(self) -> None:
+        result = get_class_name_from_class(TestCase)
+
+        assert result == 'django.test.testcases.TestCase'
+
+    def test_returns_string(self) -> None:
+        result = get_class_name_from_class(TestCase)
+
+        assert isinstance(result, str)
+
+    def test_contains_module_and_class_name(self) -> None:
+        result = get_class_name_from_class(TestCase)
+
+        assert 'TestCase' in result
+        assert 'django' in result

django_spire/core/tests/test_exceptions.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import pytest
+
+from django.test import TestCase
+
+from django_spire.exceptions import DjangoSpireConfigurationError, DjangoSpireError
+
+
+class TestDjangoSpireError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(DjangoSpireError):
+            message = 'Test error'
+            raise DjangoSpireError(message)
+
+    def test_is_exception_subclass(self) -> None:
+        assert issubclass(DjangoSpireError, Exception)
+
+    def test_message(self) -> None:
+        error = DjangoSpireError('Test error message')
+
+        assert str(error) == 'Test error message'
+
+
+class TestDjangoSpireConfigurationError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(DjangoSpireConfigurationError):
+            message = 'Test error'
+            raise DjangoSpireConfigurationError(message)
+
+    def test_is_django_spire_error_subclass(self) -> None:
+        assert issubclass(DjangoSpireConfigurationError, DjangoSpireError)
+
+    def test_message(self) -> None:
+        error = DjangoSpireConfigurationError('Configuration error message')
+
+        assert str(error) == 'Configuration error message'

django_spire/core/tests/test_models.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from django.db import connection, models
+
+
+class DummyModel(models.Model):
+    name = models.CharField(max_length=255, default='')
+
+    class Meta:
+        app_label = 'django_spire_core'
+        db_table = 'django_spire_core_dummymodel'
+
+    def __str__(self) -> str:
+        return 'dummy'
+
+    @classmethod
+    def create_table(cls) -> None:
+        vendor = connection.vendor
+
+        with connection.cursor() as cursor:
+            if vendor == 'sqlite':
+                query = '''
+                    CREATE TABLE IF NOT EXISTS django_spire_core_dummymodel (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        name VARCHAR(255) DEFAULT ''
+                    )
+                '''
+            else:
+                query = '''
+                    CREATE TABLE IF NOT EXISTS django_spire_core_dummymodel (
+                        id SERIAL PRIMARY KEY,
+                        name VARCHAR(255) DEFAULT ''
+                    )
+                '''
+
+            cursor.execute(query)
+
+    @classmethod
+    def drop_table(cls) -> None:
+        with connection.cursor() as cursor:
+            cursor.execute('DROP TABLE IF EXISTS django_spire_core_dummymodel')
+
+
+class DummyModelMixin:
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+
+        DummyModel.create_table()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        DummyModel.drop_table()
+        super().tearDownClass()

django_spire/core/tests/test_settings.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire import settings
+
+
+class TestDefaultSettings(TestCase):
+    def test_ai_chat_routers_contains_spire(self) -> None:
+        assert 'SPIRE' in settings.DJANGO_SPIRE_AI_CHAT_ROUTERS
+
+    def test_ai_default_chat_router(self) -> None:
+        assert settings.DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER == 'SPIRE'
+
+    def test_ai_intent_chat_routers_contains_knowledge_search(self) -> None:
+        assert 'KNOWLEDGE_SEARCH' in settings.DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS
+
+    def test_ai_intent_chat_routers_structure(self) -> None:
+        knowledge_search = settings.DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS['KNOWLEDGE_SEARCH']
+
+        assert 'INTENT_DESCRIPTION' in knowledge_search
+        assert 'REQUIRED_PERMISSION' in knowledge_search
+        assert 'CHAT_ROUTER' in knowledge_search
+
+    def test_ai_persona_name(self) -> None:
+        assert settings.DJANGO_SPIRE_AI_PERSONA_NAME == 'AI Assistant'
+
+    def test_auth_controllers_contains_ai_chat(self) -> None:
+        assert 'ai_chat' in settings.DJANGO_SPIRE_AUTH_CONTROLLERS
+
+    def test_auth_controllers_contains_help_desk(self) -> None:
+        assert 'help_desk' in settings.DJANGO_SPIRE_AUTH_CONTROLLERS
+
+    def test_auth_controllers_contains_knowledge(self) -> None:
+        assert 'knowledge' in settings.DJANGO_SPIRE_AUTH_CONTROLLERS
+
+    def test_auth_controllers_is_dict(self) -> None:
+        assert isinstance(settings.DJANGO_SPIRE_AUTH_CONTROLLERS, dict)
+
+    def test_default_theme(self) -> None:
+        assert settings.DJANGO_SPIRE_DEFAULT_THEME == 'default-light'
+
+    def test_theme_path_contains_placeholders(self) -> None:
+        assert '{family}' in settings.DJANGO_SPIRE_THEME_PATH
+        assert '{mode}' in settings.DJANGO_SPIRE_THEME_PATH

django_spire/core/tests/test_shortcuts.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+
+from django.contrib.auth.models import User
+from django.test import RequestFactory
+
+from django_spire.core.shortcuts import (
+    get_object_or_none,
+    get_object_or_null_obj,
+    model_object_from_app_label,
+    process_request_body
+)
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.core.tests.test_models import DummyModel, DummyModelMixin
+
+
+class ShortcutsTestCase(DummyModelMixin, BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.dummy = DummyModel.objects.create(name='test')
+        self.user = User.objects.create_user(username='testuser', password='testpass')  # noqa: S106
+        self.request_factory = RequestFactory()
+
+    def test_get_object_or_none_found(self) -> None:
+        obj = get_object_or_none(DummyModel, pk=self.dummy.pk)
+        assert obj == self.dummy
+
+    def test_get_object_or_none_not_found(self) -> None:
+        obj = get_object_or_none(DummyModel, pk=9999)
+        assert obj is None
+
+    def test_get_object_or_null_obj_model_found(self) -> None:
+        obj = get_object_or_null_obj(DummyModel, name='test')
+        assert obj == self.dummy
+
+    def test_get_object_or_null_obj_model_not_found(self) -> None:
+        obj = get_object_or_null_obj(DummyModel, name='nonexistent')
+        assert obj.pk is None
+        assert obj.name == ''
+
+    def test_get_object_or_null_obj_queryset_found(self) -> None:
+        obj = get_object_or_null_obj(DummyModel.objects.all(), name='test')
+        assert obj == self.dummy
+
+    def test_get_object_or_null_obj_queryset_not_found(self) -> None:
+        obj = get_object_or_null_obj(DummyModel.objects.all(), name='nonexistent')
+        assert obj.pk is None
+        assert obj.name == ''
+
+    def test_model_object_from_app_label_contenttype_not_found(self) -> None:
+        obj = model_object_from_app_label('nonexistent', 'nonexistent', 1)
+        assert obj is None
+
+    def test_model_object_from_app_label_found(self) -> None:
+        obj = model_object_from_app_label('auth', 'user', self.user.pk)
+        assert obj == self.user
+
+    def test_model_object_from_app_label_not_found(self) -> None:
+        obj = model_object_from_app_label('auth', 'user', 9999)
+        assert obj is None
+
+    def test_process_request_body(self) -> None:
+        data = {'data': {'key': 'value'}}
+
+        request = self.request_factory.post(
+            '/dummy-url/',
+            data=json.dumps(data),
+            content_type='application/json'
+        )
+
+        result = process_request_body(request)
+        assert result == data['data']

django_spire/core/tests/test_urls.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire import urls
+
+
+class TestUrls(TestCase):
+    def test_app_name_is_django_spire(self) -> None:
+        assert urls.app_name == 'django_spire'
+
+    def test_urlpatterns_is_list(self) -> None:
+        assert isinstance(urls.urlpatterns, list)
+
+    def test_urlpatterns_is_not_empty(self) -> None:
+        assert len(urls.urlpatterns) > 0

django_spire/core/tests/test_utils.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import pytest
+
+from django.test import TestCase
+
+from django_spire.core.utils import (
+    get_callable_from_module_string_and_validate_arguments,
+    get_object_from_module_string
+)
+
+
+class TestGetObjectFromModuleString(TestCase):
+    def test_import_class(self) -> None:
+        obj = get_object_from_module_string('django.test.TestCase')
+        assert obj is TestCase
+
+    def test_import_function(self) -> None:
+        obj = get_object_from_module_string('os.path.join')
+        assert callable(obj)
+
+    def test_import_invalid_module(self) -> None:
+        with pytest.raises(ImportError, match='Could not import module'):
+            get_object_from_module_string('nonexistent.module.Object')
+
+    def test_import_module_constant(self) -> None:
+        obj = get_object_from_module_string('os.sep')
+        assert isinstance(obj, str)
+
+
+class TestGetCallableFromModuleStringAndValidateArguments(TestCase):
+    def test_callable_with_missing_argument(self) -> None:
+        with pytest.raises(TypeError, match='missing required argument'):
+            get_callable_from_module_string_and_validate_arguments(
+                'json.dumps',
+                ['nonexistent_arg']
+            )
+
+    def test_callable_with_valid_arguments(self) -> None:
+        callable_ = get_callable_from_module_string_and_validate_arguments(
+            'json.dumps',
+            ['obj']
+        )
+        assert callable(callable_)
+
+    def test_invalid_module(self) -> None:
+        with pytest.raises(ImportError, match='Could not import module'):
+            get_callable_from_module_string_and_validate_arguments(
+                'nonexistent.module.func',
+                []
+            )
+
+    def test_non_callable_object(self) -> None:
+        with pytest.raises(TypeError, match='is not callable'):
+            get_callable_from_module_string_and_validate_arguments(
+                'os.sep',
+                []
+            )

django_spire/core/urls.py

@@ -1,6 +1,9 @@
-from django.urls import include, path
+from __future__ import annotations
+
+from django.urls import path
 from django.views.generic import TemplateView
 
+
 app_name = 'core'
 
 urlpatterns = [

django_spire/core/utils.py

@@ -1,25 +1,29 @@
+from __future__ import annotations
+
 import inspect
-from inspect import Signature
-from typing import Callable, Any, Sequence
+
+from typing import Any, Callable, Sequence
 
 
 def get_object_from_module_string(module_string: str) -> Any:
     try:
         module_string, object_name = module_string.rsplit('.', 1)
         module = __import__(module_string, fromlist=[object_name])
-    except ImportError:
-        raise ImportError(f'Could not import module: {module_string}')
+    except ImportError as e:
+        message = f'Could not import module: {module_string}'
+        raise ImportError(message) from e
 
     return getattr(module, object_name)
 
 def get_callable_from_module_string_and_validate_arguments(
-        module_string: str,
-        valid_args: Sequence[str],
+    module_string: str,
+    valid_args: Sequence[str]
 ) -> Callable:
     callable_ = get_object_from_module_string(module_string)
 
     if not callable(callable_):
-        raise TypeError(f'Object {module_string} is not callable')
+        message = f'Object {module_string} is not callable'
+        raise TypeError(message)
 
     sig = inspect.signature(callable_)
     params = sig.parameters
@@ -29,4 +33,4 @@ def get_callable_from_module_string_and_validate_arguments(
             message = f'{callable_.__qualname__} is missing required argument: {name}'
             raise TypeError(message)
 
-    return callable_
+    return callable_

django_spire/exceptions.py

@@ -1,2 +1,17 @@
-class DjangoSpireException(Exception):
+from __future__ import annotations
+
+
+class DjangoSpireError(Exception):
+    pass
+
+
+class DjangoSpireConfigurationError(DjangoSpireError):
+    pass
+
+
+class DjangoSpireInvalidClassStringError(DjangoSpireError):
+    pass
+
+
+class DjangoSpireMissingRequiredAppError(DjangoSpireError):
     pass

django_spire/file/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 from django.urls import reverse
 from django.utils.html import format_html
@@ -21,13 +23,13 @@ class FileAdmin(admin.ModelAdmin):
                 args=[file.object_id]
             )
 
-            return format_html(f'<a href="{url}">{file.content_object}</a>')
+            return format_html('<a href="{}">{}</a>', url, file.content_object)
 
         return 'No Related Object'
 
     content_object_link.short_description = 'Content Object'
 
     def file_link(self, file: models.File) -> str:
-        return format_html(f'<a href="{file.file.url}" download>{file.name}</a>')
+        return format_html('<a href="{}" download>{}</a>', file.file.url, file.name)
 
     file_link.short_description = 'File Download Link'

django_spire/file/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 from django.conf import settings
 
@@ -15,15 +17,11 @@ class FileConfig(AppConfig):
 
     def ready(self) -> None:
         if not hasattr(settings, 'BASE_FOLDER_NAME'):
-            raise ValueError(
-                f'"BASE_FOLDER_NAME" must be set in the django settings when '
-                f'using "{self.label}".'
-            )
-
-        elif not isinstance(getattr(settings, 'BASE_FOLDER_NAME'), str):
-            raise ValueError(
-                f'"BASE_FOLDER_NAME" must be a string in the django settings when '
-                f'using "{self.label}".'
-            )
+            message = f'"BASE_FOLDER_NAME" must be set in the django settings when using "{self.label}".'
+            raise ValueError(message)
+
+        if not isinstance(settings.BASE_FOLDER_NAME, str):
+            message = f'"BASE_FOLDER_NAME" must be a string in the django settings when using "{self.label}".'
+            raise TypeError(message)
 
         check_required_apps(self.label)