django-spire 0.23.4__py3-none-any.whl

django_spire/testing/playwright/components/modal.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class Modal:
+    """Playwright component for django_spire/modal/modal.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def close_button(self) -> Locator:
+        return self.modal.locator('[\\@click*="close_modal"]').first
+
+    @property
+    def content(self) -> Locator:
+        return self.modal.locator('.bg-app-layer-one.card')
+
+    @property
+    def modal(self) -> Locator:
+        return self.page.locator('[x-show="show_modal"]').last
+
+    @property
+    def overlay(self) -> Locator:
+        return self.page.locator('[\\@click="close_modal"]').first
+
+    def close(self) -> None:
+        self.close_button.click()
+
+    def close_by_overlay(self) -> None:
+        self.overlay.click()
+
+    def is_open(self) -> bool:
+        return self.modal.is_visible()
+
+    def wait_for_close(self, timeout: int = 5000) -> None:
+        self.modal.wait_for(state='hidden', timeout=timeout)
+
+    def wait_for_open(self, timeout: int = 5000) -> None:
+        self.modal.wait_for(state='visible', timeout=timeout)
+
+
+class TitleModal(Modal):
+    """Playwright component for django_spire/modal/title_modal.html"""
+
+    @property
+    def title(self) -> Locator:
+        return self.modal.locator('.text-uppercase.text-app-secondary-dark.h6').first
+
+    def get_title_text(self) -> str:
+        return self.title.inner_text()
+
+
+class FormModal(TitleModal):
+    """Playwright component for modals containing forms"""
+
+    @property
+    def cancel_button(self) -> Locator:
+        return self.modal.locator('button:has-text("Cancel"), [type="button"]:has-text("Cancel")').first
+
+    @property
+    def form(self) -> Locator:
+        return self.modal.locator('form')
+
+    @property
+    def submit_button(self) -> Locator:
+        return self.modal.locator('button[type="submit"], input[type="submit"]').first
+
+    def cancel(self) -> None:
+        self.cancel_button.click()
+
+    def fill_field(self, name: str, value: str) -> None:
+        self.form.locator(f'[name="{name}"]').fill(value)
+
+    def get_field_value(self, name: str) -> str:
+        return self.form.locator(f'[name="{name}"]').input_value()
+
+    def submit(self) -> None:
+        self.submit_button.click()
+
+
+class DeleteModal(TitleModal):
+    """Playwright component for delete confirmation modals"""
+
+    @property
+    def cancel_button(self) -> Locator:
+        return self.modal.locator('button:has-text("Cancel")').first
+
+    @property
+    def confirm_button(self) -> Locator:
+        return self.modal.locator('button:has-text("Delete"), button:has-text("Confirm")').first
+
+    def cancel(self) -> None:
+        self.cancel_button.click()
+
+    def confirm(self) -> None:
+        self.confirm_button.click()

django_spire/testing/playwright/components/navigation.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class SideNavigation:
+    """Playwright component for django_spire/navigation/side_navigation.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def container(self) -> Locator:
+        return self.page.locator('.side-navigation')
+
+    @property
+    def links(self) -> Locator:
+        return self.container.locator('a.nav-link')
+
+    @property
+    def scroll_container(self) -> Locator:
+        return self.container.locator('[x-ref="scroll_container"]')
+
+    def click_link(self, text: str) -> None:
+        self.get_link_by_text(text).click()
+
+    def get_link_by_text(self, text: str) -> Locator:
+        return self.container.locator(f'a.nav-link:has-text("{text}")')
+
+    def get_link_count(self) -> int:
+        return self.links.count()
+
+    def get_link_texts(self) -> list[str]:
+        return [self.links.nth(i).inner_text() for i in range(self.get_link_count())]
+
+    def has_link(self, text: str) -> bool:
+        return self.get_link_by_text(text).count() > 0
+
+    def is_visible(self) -> bool:
+        return self.container.is_visible()
+
+
+class TopNavigation:
+    """Playwright component for django_spire/navigation/top_navigation.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def container(self) -> Locator:
+        return self.page.locator('.top-navigation')
+
+    @property
+    def notification_bell(self) -> Locator:
+        return self.container.locator('.bi-bell')
+
+    @property
+    def theme_selector(self) -> Locator:
+        return self.container.locator('.bi-sun-fill, .bi-moon-fill')
+
+    @property
+    def title(self) -> Locator:
+        return self.container.locator('.fs-5.fw-bold, .fs-md-1.fw-bold').first
+
+    @property
+    def user_menu(self) -> Locator:
+        return self.container.locator('.bi-person-circle')
+
+    def click_notification_bell(self) -> None:
+        self.notification_bell.click()
+
+    def click_theme_selector(self) -> None:
+        self.theme_selector.click()
+
+    def click_user_menu(self) -> None:
+        self.user_menu.click()
+
+    def get_title_text(self) -> str:
+        return self.title.inner_text()
+
+    def is_visible(self) -> bool:
+        return self.container.is_visible()
+
+
+class UserMenu:
+    """Playwright component for user dropdown menu in top navigation"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def menu(self) -> Locator:
+        return self.page.locator('.dropdown-menu[aria-labelledby="dropdownMenuButton1"]')
+
+    @property
+    def trigger(self) -> Locator:
+        return self.page.locator('#dropdownMenuButton1')
+
+    def click_admin_panel(self) -> None:
+        self.menu.locator('a:has-text("Admin Panel")').click()
+
+    def click_change_password(self) -> None:
+        self.menu.locator('a:has-text("Change Password")').click()
+
+    def click_logout(self) -> None:
+        self.menu.locator('a:has-text("Logout")').click()
+
+    def click_theme_dashboard(self) -> None:
+        self.menu.locator('a:has-text("Theme Dashboard")').click()
+
+    def is_open(self) -> bool:
+        return self.menu.is_visible()
+
+    def open(self) -> None:
+        if not self.is_open():
+            self.trigger.click()

django_spire/testing/playwright/components/notification_bell.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class NotificationBell:
+    """Playwright component for django_spire/notification/app/element/notification_bell.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def badge(self) -> Locator:
+        return self.bell.locator('.badge, .position-absolute')
+
+    @property
+    def bell(self) -> Locator:
+        return self.page.locator('.bi-bell').first
+
+    @property
+    def dropdown(self) -> Locator:
+        return self.page.locator('.notification-dropdown, [x-show*="notification"]')
+
+    def click(self) -> None:
+        self.bell.click()
+
+    def get_badge_count(self) -> int:
+        if not self.has_badge():
+            return 0
+
+        text = self.badge.inner_text()
+
+        if text.isdigit():
+            return int(text)
+
+        return 0
+
+    def has_badge(self) -> bool:
+        return self.badge.count() > 0 and self.badge.is_visible()
+
+    def has_notifications(self) -> bool:
+        return self.has_badge() and self.get_badge_count() > 0
+
+    def is_dropdown_open(self) -> bool:
+        return self.dropdown.is_visible()
+
+    def is_visible(self) -> bool:
+        return self.bell.is_visible()
+
+    def open_dropdown(self) -> None:
+        if not self.is_dropdown_open():
+            self.click()
+
+    def close_dropdown(self) -> None:
+        if self.is_dropdown_open():
+            self.click()

django_spire/testing/playwright/components/theme_selector.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class ThemeSelector:
+    """Playwright component for django_spire/theme/element/theme_selector.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def icon(self) -> Locator:
+        return self.page.locator('.bi-sun-fill, .bi-moon-fill').first
+
+    def click(self) -> None:
+        self.icon.click()
+
+    def get_current_mode(self) -> str:
+        html = self.page.locator('html')
+        return html.get_attribute('data-theme') or 'light'
+
+    def get_current_theme_family(self) -> str:
+        html = self.page.locator('html')
+        return html.get_attribute('data-theme-family') or ''
+
+    def is_dark_mode(self) -> bool:
+        return self.get_current_mode() == 'dark'
+
+    def is_light_mode(self) -> bool:
+        return self.get_current_mode() == 'light'
+
+    def is_visible(self) -> bool:
+        return self.icon.is_visible()
+
+    def toggle(self) -> None:
+        self.click()
+
+    def wait_for_theme_change(self, expected_mode: str, timeout: int = 5000) -> None:
+        self.page.wait_for_function(
+            f'() => document.documentElement.getAttribute("data-theme") === "{expected_mode}"',
+            timeout=timeout
+        )

django_spire/testing/playwright/components/toast.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class Toast:
+    """Playwright component for django_spire/messages/messages.html"""
+
+    def __init__(self, page: Page) -> None:
+        self.page = page
+
+    @property
+    def container(self) -> Locator:
+        return self.page.locator('.fixed-top[\\@notify\\.window]')
+
+    @property
+    def toasts(self) -> Locator:
+        return self.container.locator('[x-data*="show:"]')
+
+    def get_toast(self, index: int = 0) -> Locator:
+        return self.toasts.nth(index)
+
+    def get_toast_count(self) -> int:
+        return self.toasts.count()
+
+    def get_toast_icon(self, index: int = 0) -> Locator:
+        return self.get_toast(index).locator('i.bi').first
+
+    def get_toast_message(self, index: int = 0) -> str:
+        return self.get_toast(index).locator('[x-text="notification.message"]').inner_text()
+
+    def get_toast_type(self, index: int = 0) -> str:
+        toast = self.get_toast(index)
+        classes = toast.get_attribute('class') or ''
+
+        if 'border-app-success' in classes:
+            return 'success'
+
+        if 'border-app-warning' in classes:
+            return 'warning'
+
+        if 'border-app-danger' in classes:
+            return 'error'
+
+        if 'border-app-primary' in classes:
+            return 'info'
+
+        return 'unknown'
+
+    def close_toast(self, index: int = 0) -> None:
+        self.get_toast(index).locator('.bi-x-lg').click()
+
+    def has_success_toast(self) -> bool:
+        return self.page.locator('.border-app-success').count() > 0
+
+    def has_warning_toast(self) -> bool:
+        return self.page.locator('.border-app-warning').count() > 0
+
+    def has_error_toast(self) -> bool:
+        return self.page.locator('.border-app-danger').count() > 0
+
+    def has_info_toast(self) -> bool:
+        return self.page.locator('.border-app-primary').count() > 0
+
+    def wait_for_toast(self, timeout: int = 5000) -> None:
+        self.toasts.first.wait_for(state='visible', timeout=timeout)
+
+    def wait_for_toast_to_disappear(self, timeout: int = 10000) -> None:
+        self.toasts.first.wait_for(state='hidden', timeout=timeout)

django_spire/testing/playwright/fixtures.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import os
+import pytest
+
+from typing import Any, TYPE_CHECKING
+
+from django.contrib.auth import get_user_model
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Page
+    from pytest_django.plugin import _LiveServer
+
+
+User = get_user_model()
+
+
+def pytest_configure(config: Any) -> None:
+    os.environ['DJANGO_ALLOW_ASYNC_UNSAFE'] = 'true'
+
+
+@pytest.fixture(scope='session')
+def browser_context_args(browser_context_args: dict[str, Any]) -> dict[str, Any]:
+    return {
+        **browser_context_args,
+        'no_viewport': True,
+        'viewport': None,
+    }
+
+
+@pytest.fixture(scope='session')
+def browser_type_launch_args(browser_type_launch_args: dict[str, Any]) -> dict[str, Any]:
+    return {
+        **browser_type_launch_args,
+        'args': ['--start-maximized'],
+    }
+
+
+@pytest.fixture
+def authenticated_page(page: Page, live_server: _LiveServer, transactional_db: None) -> Page:
+    User.objects.create_user(
+        username='testuser',
+        password='testpass123',
+        is_staff=True,
+        is_superuser=True
+    )
+
+    page.goto(f'{live_server.url}/admin/login/')
+    page.fill('input[name="username"]', 'testuser')
+    page.fill('input[name="password"]', 'testpass123')
+    page.click('input[type="submit"]')
+    page.wait_for_url(f'{live_server.url}/admin/')
+
+    return page

django_spire/testing/playwright/pages/__init__.py

@@ -0,0 +1,6 @@
+from django_spire.testing.playwright.pages.base import BasePage
+
+
+__all__ = [
+    'BasePage',
+]

django_spire/testing/playwright/pages/base.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Page
+
+
+class BasePage:
+    def __init__(self, page: Page, base_url: str) -> None:
+        self.base_url = base_url
+        self.page = page
+
+    def goto(self, url: str) -> None:
+        self.page.goto(url)
+
+    def has_text(self, text: str) -> bool:
+        return text in self.page.locator('body').inner_text()
+
+    def wait_for_load_state(self, state: str = 'networkidle') -> None:
+        self.page.wait_for_load_state(state)
+
+    def wait_for_timeout(self, timeout: int) -> None:
+        self.page.wait_for_timeout(timeout)

django_spire/theme/apps.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+from django_spire.utils import check_required_apps
+
+
+class ThemeConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    label = 'django_spire_theme'
+    name = 'django_spire.theme'
+
+    REQUIRED_APPS = ('django_spire_core',)
+
+    URLPATTERNS_INCLUDE = 'django_spire.theme.urls'
+    URLPATTERNS_NAMESPACE = 'theme'
+
+    def ready(self) -> None:
+        check_required_apps(self.label)

django_spire/theme/enums.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ThemeFamily(StrEnum):
+    AYU = 'ayu'
+    CATPPUCCIN = 'catppuccin'
+    DEFAULT = 'default'
+    GRUVBOX = 'gruvbox'
+    MATERIAL = 'material'
+    NORD = 'nord'
+    ONE_DARK = 'one-dark'
+    PALENIGHT = 'palenight'
+    ROSE_PINE = 'rose-pine'
+    TOKYO_NIGHT = 'tokyo-night'
+
+
+class ThemeMode(StrEnum):
+    DARK = 'dark'
+    LIGHT = 'light'

django_spire/theme/models.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from django_spire.theme.enums import ThemeFamily, ThemeMode
+
+
+@dataclass(frozen=True)
+class Theme:
+    family: ThemeFamily
+    mode: ThemeMode
+
+    DEFAULT_FAMILY: ClassVar[ThemeFamily] = ThemeFamily.DEFAULT
+    DEFAULT_MODE: ClassVar[ThemeMode] = ThemeMode.LIGHT
+    SEPARATOR: ClassVar[str] = '-'
+
+    FAMILY_DISPLAY_NAMES: ClassVar[dict[ThemeFamily, str]] = {
+        ThemeFamily.AYU: 'Ayu',
+        ThemeFamily.CATPPUCCIN: 'Catppuccin',
+        ThemeFamily.DEFAULT: 'Default',
+        ThemeFamily.GRUVBOX: 'Gruvbox',
+        ThemeFamily.MATERIAL: 'Material',
+        ThemeFamily.NORD: 'Nord',
+        ThemeFamily.ONE_DARK: 'One Dark Pro',
+        ThemeFamily.PALENIGHT: 'Palenight',
+        ThemeFamily.ROSE_PINE: 'Rose Pine',
+        ThemeFamily.TOKYO_NIGHT: 'Tokyo Night',
+    }
+
+    def __post_init__(self):
+        if isinstance(self.family, str):
+            self._validate_family(self.family)
+
+            object.__setattr__(
+                self,
+                'family',
+                ThemeFamily(self.family)
+            )
+
+        if isinstance(self.mode, str):
+            self._validate_mode(self.mode)
+
+            object.__setattr__(
+                self,
+                'mode',
+                ThemeMode(self.mode)
+            )
+
+    @classmethod
+    def _parse(cls, theme: str) -> tuple[str, str]:
+        parts = theme.strip().split(cls.SEPARATOR)
+
+        if len(parts) < 2:
+            message = f'Invalid theme format: {theme}'
+            raise ValueError(message)
+
+        mode = parts[-1]
+        family = cls.SEPARATOR.join(parts[:-1])
+
+        return family, mode
+
+    @classmethod
+    def _validate_family(cls, family: str) -> None:
+        if family not in [family.value for family in ThemeFamily]:
+            message = f'Invalid theme family: {family}'
+            raise ValueError(message)
+
+    @classmethod
+    def _validate_mode(cls, mode: str) -> None:
+        if mode not in [mode.value for mode in ThemeMode]:
+            message = f'Invalid theme mode: {mode}'
+            raise ValueError(message)
+
+    @classmethod
+    def _validate(cls, family: str, mode: str) -> None:
+        cls._validate_family(family)
+        cls._validate_mode(mode)
+
+    @classmethod
+    def from_string(cls, theme: str, default: Theme | None = None) -> Theme:
+        if not theme:
+            if default:
+                return default
+
+            return cls.get_default()
+
+        try:
+            family, mode = cls._parse(theme)
+            cls._validate(family, mode)
+            return cls(family=ThemeFamily(family), mode=ThemeMode(mode))
+        except ValueError:
+            if default:
+                return default
+
+            raise
+
+    @classmethod
+    def get_available(cls) -> list[Theme]:
+        return [
+            cls(family=family, mode=mode)
+            for family in ThemeFamily
+            for mode in ThemeMode
+        ]
+
+    @classmethod
+    def get_default(cls) -> Theme:
+        return cls(family=cls.DEFAULT_FAMILY, mode=cls.DEFAULT_MODE)
+
+    @property
+    def display(self) -> str:
+        family = self.FAMILY_DISPLAY_NAMES.get(self.family, self.family.value)
+        mode = self.mode.value.capitalize()
+        return f'{family} - {mode}'
+
+    @property
+    def family_display(self) -> str:
+        return self.FAMILY_DISPLAY_NAMES.get(self.family, self.family.value)
+
+    @property
+    def is_dark(self) -> bool:
+        return self.mode == ThemeMode.DARK
+
+    @property
+    def stylesheet(self) -> str:
+        return f'django_spire/css/themes/{self.family.value}/app-{self.mode.value}.css'
+
+    @property
+    def value(self) -> str:
+        return f'{self.family.value}{self.SEPARATOR}{self.mode.value}'
+
+    def to_dict(self) -> dict:
+        return {
+            'display': self.display,
+            'family': self.family.value,
+            'family_display': self.family_display,
+            'full': self.value,
+            'is_dark': self.is_dark,
+            'mode': self.mode.value,
+            'stylesheet': self.stylesheet,
+        }