django-spire 0.23.4__py3-none-any.whl

django_spire/theme/tests/test_filesystem.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from django.test import TestCase
+
+from django_spire.theme.enums import ThemeFamily, ThemeMode
+from django_spire.theme.models import Theme
+
+
+class ThemeFilesystemValidationTests(TestCase):
+    def setUp(self) -> None:
+        self.base_path = self._get_themes_base_path()
+
+    def _get_themes_base_path(self) -> Path:
+        file = Path(__file__)
+        root = file.parent.parent.parent.parent
+        return root / 'django_spire' / 'core' / 'static' / 'django_spire' / 'css' / 'themes'
+
+    def test_themes_directory_exists(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}. Create it to enable filesystem validation tests.')
+
+        self.assertTrue(self.base_path.is_dir(), f'Themes path is not a directory: {self.base_path}')
+
+    def test_all_theme_families_have_directories(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        existing = {path.name for path in self.base_path.iterdir() if path.is_dir()}
+        expected = {family.value for family in ThemeFamily}
+
+        missing = expected - existing
+        if missing:
+            self.fail(f'Missing theme directories: {sorted(missing)}. Create these directories: {sorted(missing)}')
+
+    def test_no_unexpected_theme_directories(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        existing = {path.name for path in self.base_path.iterdir() if path.is_dir()}
+        expected = {family.value for family in ThemeFamily}
+
+        unexpected = existing - expected
+
+        if unexpected:
+            self.fail(f'Unexpected theme directories: {sorted(unexpected)}. Remove these or update ThemeFamily enum: {sorted(unexpected)}')
+
+    def test_all_theme_mode_files_exist(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        missing = []
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if not directory.exists():
+                missing.extend([f'{family.value}/app-{mode.value}.css' for mode in ThemeMode])
+                continue
+
+            for mode in ThemeMode:
+                file = directory / f'app-{mode.value}.css'
+                if not file.exists():
+                    missing.append(f'{family.value}/app-{mode.value}.css')
+
+        if missing:
+            self.fail(f'Missing CSS files: {sorted(missing)}')
+
+    def test_no_unexpected_css_files(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        expected = {f'app-{mode.value}.css' for mode in ThemeMode}
+        unexpected = {}
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if directory.exists():
+                existing = {f.name for f in directory.iterdir() if f.is_file() and f.suffix == '.css'}
+                files = existing - expected
+
+                if files:
+                    unexpected[family.value] = sorted(files)
+
+        if unexpected:
+            self.fail(f'Unexpected CSS files by family: {unexpected}')
+
+    def test_theme_stylesheet_paths_match_filesystem(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        missing = []
+
+        for theme in Theme.get_available():
+            expected = theme.stylesheet
+
+            file = Path(__file__)
+            root = file.parent.parent.parent.parent
+            path = root / 'django_spire' / 'core' / 'static' / expected
+
+            if not path.exists():
+                missing.append(f'{theme.value}: {expected}')
+
+        if missing:
+            self.fail(f'Missing stylesheet files: {missing}')
+
+    def test_css_files_are_not_empty(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        empty = []
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if directory.exists():
+                for mode in ThemeMode:
+                    file = directory / f'app-{mode.value}.css'
+
+                    if file.exists():
+                        size = file.stat().st_size
+                        if size == 0:
+                            empty.append(f'{family.value}/app-{mode.value}.css')
+
+        if empty:
+            self.fail(f'Empty CSS files: {sorted(empty)}')
+
+    def test_filesystem_structure_completeness(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        total_expected_families = len(ThemeFamily)
+        total_expected_modes = len(ThemeMode)
+        total_expected_files = total_expected_families * total_expected_modes
+
+        actual = 0
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if directory.exists():
+                files = list(directory.glob('app-*.css'))
+                actual += len(files)
+
+        if actual != total_expected_files:
+            self.fail(f'Expected {total_expected_files} CSS files, found {actual}')
+
+    def test_directory_structure_matches_enum_values(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        missing = []
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if not directory.exists():
+                missing.append(family.value)
+
+        if missing:
+            self.fail(f'Missing directories for theme families: {sorted(missing)}')
+
+    def test_css_filenames_match_enum_values(self) -> None:
+        if not self.base_path.exists():
+            self.skipTest(f'Themes directory does not exist: {self.base_path}')
+
+        for family in ThemeFamily:
+            directory = self.base_path / family.value
+
+            if directory.exists():
+                for mode in ThemeMode:
+                    filename = f'app-{mode.value}.css'
+                    file = directory / filename
+
+                    if file.exists():
+                        self.assertEqual(
+                            file.name, filename,
+                            f'Filename {file.name} does not match expected {filename}'
+                        )

django_spire/theme/tests/test_integration.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.theme.enums import ThemeFamily
+from django_spire.theme.models import Theme
+
+
+class ThemeIntegrationTests(BaseTestCase):
+    def test_all_themes_have_stylesheets(self) -> None:
+        for theme in Theme.get_available():
+            stylesheet = theme.stylesheet
+
+            self.assertIn(f'{theme.family.value}/', stylesheet)
+            self.assertIn(f'app-{theme.mode.value}.css', stylesheet)
+
+    def test_roundtrip_conversion(self) -> None:
+        for theme in Theme.get_available():
+            string = theme.value
+            recovered = Theme.from_string(string)
+            self.assertEqual(theme, recovered)
+
+            dictionary = theme.to_dict()
+            recovered2 = Theme.from_string(dictionary['full'])
+            self.assertEqual(theme, recovered2)
+
+    def test_display_names_complete(self) -> None:
+        for family in ThemeFamily:
+            self.assertIn(family, Theme.FAMILY_DISPLAY_NAMES)
+            display_name = Theme.FAMILY_DISPLAY_NAMES[family]
+            self.assertIsInstance(display_name, str)
+            self.assertTrue(len(display_name) > 0)
+
+    def test_theme_integration_with_authenticated_user(self) -> None:
+        available = Theme.get_available()
+        self.assertGreater(len(available), 0)
+
+        for theme in available[:3]:
+            self.client.cookies['app-theme'] = theme.value
+            response = self.client.get('/')
+            self.assertEqual(response.status_code, 200)
+
+    def test_theme_media_integration(self) -> None:
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode='dark')
+        stylesheet = theme.stylesheet
+
+        self.assertIn('django_spire/css/themes/', stylesheet)
+        self.assertIn('gruvbox', stylesheet)
+        self.assertIn('app-dark.css', stylesheet)

django_spire/theme/tests/test_model.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import pytest
+
+from dataclasses import fields
+
+from django.test import TestCase
+
+from django_spire.theme.enums import ThemeFamily, ThemeMode
+from django_spire.theme.models import Theme
+
+
+class ThemeModelTests(TestCase):
+    def test_dataclass_fields(self) -> None:
+        theme_fields = {f.name: f.type for f in fields(Theme)}
+
+        self.assertEqual(set(theme_fields.keys()), {'family', 'mode'})
+        self.assertEqual(theme_fields['family'], 'ThemeFamily')
+        self.assertEqual(theme_fields['mode'], 'ThemeMode')
+
+    def test_class_variables(self) -> None:
+        self.assertEqual(Theme.DEFAULT_FAMILY, ThemeFamily.DEFAULT)
+        self.assertEqual(Theme.DEFAULT_MODE, ThemeMode.LIGHT)
+        self.assertEqual(Theme.SEPARATOR, '-')
+
+        for family in ThemeFamily:
+            self.assertIn(family, Theme.FAMILY_DISPLAY_NAMES)
+
+    def test_theme_initialization_with_enums(self) -> None:
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
+        self.assertEqual(theme.mode, ThemeMode.DARK)
+
+    def test_theme_initialization_with_strings(self) -> None:
+        theme = Theme(family='gruvbox', mode='dark')
+        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
+        self.assertEqual(theme.mode, ThemeMode.DARK)
+
+    def test_theme_initialization_invalid_family(self) -> None:
+        with pytest.raises(ValueError) as ctx:
+            Theme(family='invalid-family', mode='dark')
+        self.assertIn('Invalid theme family', str(ctx.value))
+
+    def test_theme_initialization_invalid_mode(self) -> None:
+        with pytest.raises(ValueError) as ctx:
+            Theme(family='gruvbox', mode='invalid-mode')
+        self.assertIn('Invalid theme mode', str(ctx.value))
+
+    def test_from_string_valid(self) -> None:
+        cases = [
+            ('default-light', ThemeFamily.DEFAULT, ThemeMode.LIGHT),
+            ('gruvbox-dark', ThemeFamily.GRUVBOX, ThemeMode.DARK),
+            ('one-dark-light', ThemeFamily.ONE_DARK, ThemeMode.LIGHT),
+            ('tokyo-night-dark', ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK),
+        ]
+
+        for string, family, mode in cases:
+            with self.subTest(string=string):
+                theme = Theme.from_string(string)
+                self.assertEqual(theme.family, family)
+                self.assertEqual(theme.mode, mode)
+
+    def test_from_string_empty_with_default(self) -> None:
+        default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        theme = Theme.from_string('', default=default)
+        self.assertEqual(theme, default)
+
+    def test_from_string_empty_without_default(self) -> None:
+        theme = Theme.from_string('')
+        self.assertEqual(theme.family, Theme.DEFAULT_FAMILY)
+        self.assertEqual(theme.mode, Theme.DEFAULT_MODE)
+
+    def test_from_string_invalid_with_default(self) -> None:
+        default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        theme = Theme.from_string('invalid', default=default)
+        self.assertEqual(theme, default)
+
+    def test_from_string_invalid_without_default(self) -> None:
+        with pytest.raises(ValueError):
+            Theme.from_string('invalid')
+
+    def test_get_available(self) -> None:
+        available = Theme.get_available()
+
+        count = len(ThemeFamily) * len(ThemeMode)
+        self.assertEqual(len(available), count)
+
+        for family in ThemeFamily:
+            for mode in ThemeMode:
+                theme = Theme(family=family, mode=mode)
+                self.assertIn(theme, available)
+
+    def test_get_default(self) -> None:
+        default = Theme.get_default()
+        self.assertEqual(default.family, Theme.DEFAULT_FAMILY)
+        self.assertEqual(default.mode, Theme.DEFAULT_MODE)
+
+    def test_display_property(self) -> None:
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        self.assertEqual(theme.display, 'Gruvbox - Dark')
+
+        theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.LIGHT)
+        self.assertEqual(theme.display, 'One Dark Pro - Light')
+
+    def test_family_display_property(self) -> None:
+        theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.DARK)
+        self.assertEqual(theme.family_display, 'One Dark Pro')
+
+    def test_is_dark_property(self) -> None:
+        dark = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        self.assertTrue(dark.is_dark)
+
+        light = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.LIGHT)
+        self.assertFalse(light.is_dark)
+
+    def test_stylesheet_property(self) -> None:
+        cases = [
+            (ThemeFamily.DEFAULT, ThemeMode.LIGHT, 'django_spire/css/themes/default/app-light.css'),
+            (ThemeFamily.GRUVBOX, ThemeMode.DARK, 'django_spire/css/themes/gruvbox/app-dark.css'),
+            (ThemeFamily.ONE_DARK, ThemeMode.LIGHT, 'django_spire/css/themes/one-dark/app-light.css'),
+            (ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK, 'django_spire/css/themes/tokyo-night/app-dark.css'),
+        ]
+
+        for family, mode, path in cases:
+            with self.subTest(family=family, mode=mode):
+                theme = Theme(family=family, mode=mode)
+                self.assertEqual(theme.stylesheet, path)
+
+    def test_value_property(self) -> None:
+        cases = [
+            (ThemeFamily.DEFAULT, ThemeMode.LIGHT, 'default-light'),
+            (ThemeFamily.GRUVBOX, ThemeMode.DARK, 'gruvbox-dark'),
+            (ThemeFamily.ONE_DARK, ThemeMode.LIGHT, 'one-dark-light'),
+            (ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK, 'tokyo-night-dark'),
+        ]
+
+        for family, mode, value in cases:
+            with self.subTest(family=family, mode=mode):
+                theme = Theme(family=family, mode=mode)
+                self.assertEqual(theme.value, value)
+
+    def test_to_dict(self) -> None:
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        result = theme.to_dict()
+
+        keys = {
+            'display',
+            'family',
+            'family_display',
+            'full',
+            'is_dark',
+            'mode',
+            'stylesheet'
+        }
+
+        self.assertEqual(set(result.keys()), keys)
+
+        self.assertEqual(result['display'], 'Gruvbox - Dark')
+        self.assertEqual(result['family'], 'gruvbox')
+        self.assertEqual(result['family_display'], 'Gruvbox')
+        self.assertEqual(result['full'], 'gruvbox-dark')
+        self.assertTrue(result['is_dark'])
+        self.assertEqual(result['mode'], 'dark')
+        self.assertEqual(result['stylesheet'], 'django_spire/css/themes/gruvbox/app-dark.css')
+
+    def test_theme_immutability(self) -> None:
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+
+        with pytest.raises(AttributeError):
+            theme.family = ThemeFamily.DEFAULT
+
+        with pytest.raises(AttributeError):
+            theme.mode = ThemeMode.LIGHT

django_spire/theme/tests/test_views/test_json_views.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+
+from http import HTTPStatus
+from unittest.mock import patch
+
+from django.test import TestCase, RequestFactory
+from django.http import JsonResponse
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.theme.enums import ThemeFamily
+from django_spire.theme.utils import get_theme_cookie_name
+from django_spire.theme.views import json_views
+
+
+class ThemeViewTests(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def test_get_config_success(self) -> None:
+        request = self.factory.get('/django_spire/theme/json/get_config/')
+        response = json_views.get_config(request)
+
+        self.assertIsInstance(response, JsonResponse)
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+
+        data = json.loads(response.content)
+        self.assertTrue(data['success'])
+
+        config = data['data']
+        self.assertIn('families', config)
+        self.assertIn('default_family', config)
+        self.assertIn('default_mode', config)
+        self.assertIn('separator', config)
+
+        for family in ThemeFamily:
+            self.assertIn(family.value, config['families'])
+            family_config = config['families'][family.value]
+            self.assertIn('name', family_config)
+            self.assertIn('modes', family_config)
+            self.assertEqual(set(family_config['modes']), {'dark', 'light'})
+
+    def test_get_config_cache_header(self) -> None:
+        _ = self.factory.get('/django_spire/theme/json/get_config/')
+
+        with patch('django_spire.theme.views.json_views.cache_page') as _:
+            self.assertTrue(hasattr(json_views.get_config, '__wrapped__'))
+
+    def test_set_theme_success(self) -> None:
+        request = self.factory.post(
+            '/django_spire/theme/json/set_theme/',
+            data=json.dumps({'theme': 'gruvbox-dark'}),
+            content_type='application/json'
+        )
+        response = json_views.set_theme(request)
+
+        self.assertIsInstance(response, JsonResponse)
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+
+        data = json.loads(response.content)
+        self.assertTrue(data['success'])
+        self.assertIn('theme', data)
+
+        data = data['theme']
+        self.assertEqual(data['family'], 'gruvbox')
+        self.assertEqual(data['mode'], 'dark')
+
+        cookie_name = get_theme_cookie_name()
+        self.assertIn(cookie_name, response.cookies)
+        self.assertEqual(response.cookies[cookie_name].value, 'gruvbox-dark')
+
+    def test_set_theme_missing_theme(self) -> None:
+        request = self.factory.post(
+            '/django_spire/theme/json/set_theme/',
+            data=json.dumps({}),
+            content_type='application/json'
+        )
+        response = json_views.set_theme(request)
+
+        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        data = json.loads(response.content)
+        self.assertFalse(data['success'])
+        self.assertIn('error', data)
+        self.assertEqual(data['error'], 'Theme is required')
+
+    def test_set_theme_invalid_theme(self) -> None:
+        request = self.factory.post(
+            '/django_spire/theme/json/set_theme/',
+            data=json.dumps({'theme': 'invalid-theme'}),
+            content_type='application/json'
+        )
+        response = json_views.set_theme(request)
+
+        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        data = json.loads(response.content)
+        self.assertFalse(data['success'])
+        self.assertIn('error', data)
+        self.assertIn('Invalid theme', data['error'])
+
+
+class ThemeViewIntegrationTests(BaseTestCase):
+    def test_set_theme_with_authenticated_client(self) -> None:
+        response = self.client.post(
+            '/django_spire/theme/json/set_theme/',
+            data=json.dumps({'theme': 'gruvbox-dark'}),
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        data = json.loads(response.content)
+        self.assertTrue(data['success'])
+
+    def test_get_config_with_authenticated_client(self) -> None:
+        response = self.client.get('/django_spire/theme/json/get_config/')
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+
+        data = json.loads(response.content)
+        self.assertTrue(data['success'])
+        self.assertIn('families', data['data'])

django_spire/theme/urls/__init__.py

@@ -0,0 +1,9 @@
+from django.urls.conf import path, include
+
+
+app_name = 'theme'
+
+urlpatterns = [
+    path('json/', include('django_spire.theme.urls.json_urls', namespace='json')),
+    path('page/', include('django_spire.theme.urls.page_urls', namespace='page')),
+]

django_spire/theme/urls/json_urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+
+from django_spire.theme.views import json_views
+
+app_name = 'json'
+
+urlpatterns = [
+    path('get_config/', json_views.get_config, name='get_config'),
+    path('set_theme/', json_views.set_theme, name='set_theme'),
+]

django_spire/theme/urls/page_urls.py

@@ -0,0 +1,16 @@
+from django.urls import path
+
+from django_spire.theme.views import page_views
+
+app_name = 'page'
+
+urlpatterns = [
+    path('dashboard/', page_views.dashboard_view, name='dashboard'),
+    path('colors/', page_views.colors_view, name='colors'),
+    path('django_glue/', page_views.django_glue_view, name='django_glue'),
+    path('example/', page_views.example_view, name='example'),
+    path('typography/', page_views.typography_view, name='typography'),
+    path('buttons/', page_views.buttons_view, name='buttons'),
+    path('badges/', page_views.badges_view, name='badges'),
+    path('borders/', page_views.borders_view, name='borders'),
+]

django_spire/theme/utils.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import hashlib
+
+from django_spire.conf import settings
+
+
+def get_theme_cookie_name() -> str:
+    if not hasattr(settings, 'BASE_DIR'):
+        return 'django-spire-theme'
+
+    encoded = str(settings.BASE_DIR).encode()
+    identifier = hashlib.md5(encoded, usedforsecurity=False).hexdigest()[:8]
+    return f'django-spire-theme-{identifier}'

django_spire/theme/views/json_views.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+
+from django.http import JsonResponse
+from django.views.decorators.cache import cache_page
+from django.views.decorators.http import require_GET, require_POST
+
+from django_spire.theme.enums import ThemeFamily, ThemeMode
+from django_spire.theme.models import Theme
+from django_spire.theme.utils import get_theme_cookie_name
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+@cache_page(60 * 60 * 24)
+@require_GET
+def get_config(request: WSGIRequest) -> JsonResponse:
+    config = {
+        'families': {},
+        'default_family': Theme.DEFAULT_FAMILY.value,
+        'default_mode': Theme.DEFAULT_MODE.value,
+        'separator': Theme.SEPARATOR,
+        'cookie_name': get_theme_cookie_name()
+    }
+
+    for family in ThemeFamily:
+        config['families'][family.value] = {
+            'name': Theme.FAMILY_DISPLAY_NAMES.get(family, family.value),
+            'modes': [mode.value for mode in ThemeMode]
+        }
+
+    return JsonResponse({
+        'success': True,
+        'data': config
+    })
+
+
+@require_POST
+def set_theme(request: WSGIRequest) -> JsonResponse:
+    data = json.loads(request.body)
+    theme = data.get('theme')
+
+    if not theme:
+        return JsonResponse(
+            {'error': 'Theme is required', 'success': False},
+            status=HTTPStatus.BAD_REQUEST
+        )
+
+    try:
+        validated = Theme.from_string(theme)
+    except ValueError:
+        return JsonResponse(
+            {'error': f'Invalid theme: {theme}', 'success': False},
+            status=HTTPStatus.BAD_REQUEST
+        )
+
+    response = JsonResponse({
+        'success': True,
+        'theme': validated.to_dict()
+    })
+
+    response.set_cookie(
+        get_theme_cookie_name(),
+        validated.value,
+        max_age=31536000
+    )
+
+    return response