django-spire 0.22.4__py3-none-any.whl → 0.23.2__py3-none-any.whl

django_spire/testing/playwright/components/dropdown.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator
+
+
+class Dropdown:
+    """Playwright component for django_spire/dropdown/dropdown.html"""
+
+    menu_selector: str = '.position-absolute.shadow-lg.card'
+    trigger_selector: str = '[x-bind="trigger"]'
+
+    def __init__(self, parent_locator: Locator) -> None:
+        self.parent = parent_locator
+
+    @property
+    def menu(self) -> Locator:
+        return self.parent.page.locator(self.menu_selector).filter(
+            has=self.parent.page.locator(':visible')
+        ).first
+
+    @property
+    def trigger(self) -> Locator:
+        return self.parent.locator(self.trigger_selector)
+
+    def click_option(self, text: str) -> None:
+        self.menu.locator(f'text={text}').click()
+
+    def close(self) -> None:
+        if self.is_open():
+            self.trigger.click()
+
+    def get_option(self, text: str) -> Locator:
+        return self.menu.locator(f'text={text}')
+
+    def has_option(self, text: str) -> bool:
+        return self.get_option(text).is_visible()
+
+    def is_open(self) -> bool:
+        return self.menu.is_visible()
+
+    def open(self) -> None:
+        if not self.is_open():
+            self.trigger.click()
+
+
+class EllipsisDropdown(Dropdown):
+    """Playwright component for django_spire/dropdown/ellipsis_dropdown.html"""
+
+    trigger_selector: str = '.bi-three-dots-vertical'
+
+    def click_delete(self) -> None:
+        self.click_option('Delete')
+
+    def click_edit(self) -> None:
+        self.click_option('Edit')
+
+    def click_view(self) -> None:
+        self.click_option('View')
+
+    def has_delete_option(self) -> bool:
+        return self.has_option('Delete')
+
+    def has_edit_option(self) -> bool:
+        return self.has_option('Edit')
+
+    def has_view_option(self) -> bool:
+        return self.has_option('View')
+
+
+class EllipsisModalDropdown(EllipsisDropdown):
+    """
+    Playwright component for django_spire/dropdown/ellipsis_modal_dropdown.html
+    Dropdown options trigger modals via dispatch_modal_view()
+    """
+
+    pass
+
+
+class EllipsisTableDropdown(EllipsisDropdown):
+    """
+    Playwright component for django_spire/dropdown/ellipsis_table_dropdown.html
+    Used in table rows, positioned start-0 instead of end-0
+    """
+    trigger_selector: str = 'td .bi-three-dots-vertical'

django_spire/testing/playwright/components/infinite_scroll.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class InfiniteScroll:
+    """
+    Playwright component for django_spire/infinite_scroll/base.html
+    and django_spire/infinite_scroll/scroll.html
+    """
+
+    def __init__(self, page: Page, container_selector: str = '[x-ref="scroll_container"]') -> None:
+        self.container_selector = container_selector
+        self.page = page
+
+    @property
+    def content_container(self) -> Locator:
+        return self.page.locator('[x-ref="content_container"]')
+
+    @property
+    def loaded_count_text(self) -> Locator:
+        return self.page.locator('[x-text="loaded_count"]')
+
+    @property
+    def scroll_container(self) -> Locator:
+        return self.page.locator(self.container_selector)
+
+    @property
+    def spinner(self) -> Locator:
+        return self.page.locator('.spinner-border')
+
+    @property
+    def total_count_text(self) -> Locator:
+        return self.page.locator('[x-text="total_count"]')
+
+    def get_loaded_count(self) -> int:
+        return int(self.loaded_count_text.inner_text())
+
+    def get_total_count(self) -> int:
+        return int(self.total_count_text.inner_text())
+
+    def is_loading(self) -> bool:
+        return self.spinner.is_visible()
+
+    def scroll_to_bottom(self) -> None:
+        self.scroll_container.evaluate('el => el.scrollTop = el.scrollHeight')
+
+    def scroll_to_top(self) -> None:
+        self.scroll_container.evaluate('el => el.scrollTop = 0')
+
+    def wait_for_count_to_increase(self, initial_count: int, timeout: int = 5000) -> None:
+        self.page.wait_for_function(
+            f'() => parseInt(document.querySelector("[x-text=\\"loaded_count\\"]").textContent) > {initial_count}',
+            timeout=timeout
+        )
+
+    def wait_for_items_to_load(self) -> None:
+        self.loaded_count_text.wait_for()
+
+
+class InfiniteScrollList(InfiniteScroll):
+    """Playwright component for infinite scroll with list items"""
+
+    item_selector: str = '[data-row-id]'
+
+    @property
+    def items(self) -> Locator:
+        return self.page.locator(self.item_selector)
+
+    def get_item(self, index: int) -> Locator:
+        return self.items.nth(index)
+
+    def get_item_count(self) -> int:
+        return self.items.count()
+
+    def get_item_ids(self) -> list[str]:
+        items = self.items
+        return [items.nth(i).get_attribute('data-row-id') for i in range(items.count())]
+
+
+class InfiniteScrollTable(InfiniteScroll):
+    """Playwright component for django_spire/table/base.html"""
+
+    row_selector: str = 'tbody tr[data-row-id]'
+    skeleton_selector: str = '.skeleton-box'
+
+    def __init__(self, page: Page, container_selector: str = '.table-container[x-ref="scroll_container"]') -> None:
+        super().__init__(page, container_selector)
+
+    @property
+    def rows(self) -> Locator:
+        return self.page.locator(self.row_selector)
+
+    @property
+    def select_all_checkbox(self) -> Locator:
+        return self.page.locator('thead input[type="checkbox"]')
+
+    @property
+    def selected_count_text(self) -> Locator:
+        return self.page.locator('[x-text="selected_rows.size"]')
+
+    @property
+    def skeleton_rows(self) -> Locator:
+        return self.page.locator(self.skeleton_selector)
+
+    @property
+    def table(self) -> Locator:
+        return self.page.locator('table')
+
+    def click_header(self, header_text: str) -> None:
+        self.get_header(header_text).click()
+
+    def deselect_all_rows(self) -> None:
+        self.select_all_checkbox.click()
+
+    def deselect_row(self, index: int) -> None:
+        self.get_row(index).locator('input[type="checkbox"]').click()
+
+    def get_first_row_text(self) -> str:
+        return self.rows.first.inner_text()
+
+    def get_header(self, header_text: str) -> Locator:
+        return self.page.locator(f'th:has-text("{header_text}")')
+
+    def get_row(self, index: int) -> Locator:
+        return self.rows.nth(index)
+
+    def get_row_count(self) -> int:
+        return self.rows.count()
+
+    def get_selected_count(self) -> int:
+        return int(self.selected_count_text.inner_text())
+
+    def get_sort_icon(self, header_text: str) -> Locator:
+        return self.get_header(header_text).locator('i.bi')
+
+    def is_sorted_ascending(self, header_text: str) -> bool:
+        icon = self.get_sort_icon(header_text)
+        return 'bi-chevron-up' in (icon.get_attribute('class') or '')
+
+    def is_sorted_descending(self, header_text: str) -> bool:
+        icon = self.get_sort_icon(header_text)
+        return 'bi-chevron-down' in (icon.get_attribute('class') or '')
+
+    def select_all_rows(self) -> None:
+        self.select_all_checkbox.click()
+
+    def select_row(self, index: int) -> None:
+        self.get_row(index).locator('input[type="checkbox"]').click()
+
+    def wait_for_rows_to_load(self) -> None:
+        self.rows.first.wait_for()
+
+    def wait_for_table(self) -> None:
+        self.table.wait_for()

django_spire/testing/playwright/components/lazy_tab.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import re
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Locator, Page
+
+
+class LazyTab:
+    """Playwright component for django_spire/lazy_tab/lazy_tab.html"""
+
+    selected_class: str = 'tab-item'
+
+    def __init__(self, page: Page, container_selector: str, tab_id: str | None = None) -> None:
+        self.container_selector = container_selector
+        self.page = page
+        self.tab_id = tab_id
+
+    @property
+    def container(self) -> Locator:
+        return self.page.locator(self.container_selector)
+
+    @property
+    def sections(self) -> Locator:
+        return self.container.locator('[role="tabpanel"]')
+
+    @property
+    def triggers(self) -> Locator:
+        return self.container.locator('[role="tab"]')
+
+    def click_tab(self, index: int) -> None:
+        self.get_trigger(index).click()
+
+    def get_section(self, index: int) -> Locator:
+        return self.sections.nth(index)
+
+    def get_section_count(self) -> int:
+        return self.sections.count()
+
+    def get_trigger(self, index: int) -> Locator:
+        return self.triggers.nth(index)
+
+    def get_trigger_count(self) -> int:
+        return self.triggers.count()
+
+    def get_url_param(self) -> str | None:
+        if not self.tab_id:
+            return None
+
+        url = self.page.url
+        match = re.search(f'{self.tab_id}=([^&]+)', url)
+
+        if match:
+            return match.group(1)
+
+        return None
+
+    def get_visible_section(self) -> Locator | None:
+        for i in range(self.sections.count()):
+            section = self.sections.nth(i)
+
+            if section.is_visible():
+                return section
+
+        return None
+
+    def get_visible_section_text(self) -> str:
+        section = self.get_visible_section()
+
+        if section:
+            return section.inner_text()
+
+        return ''
+
+    def is_loading(self, index: int) -> bool:
+        section = self.get_section(index)
+        spinner = section.locator('.spinner-border')
+        return spinner.is_visible()
+
+    def is_tab_selected(self, index: int) -> bool:
+        trigger = self.get_trigger(index)
+        classes = trigger.get_attribute('class') or ''
+        return self.selected_class in classes
+
+    def wait_for_section_content(self, index: int, timeout: int = 5000) -> None:
+        section = self.get_section(index)
+        section.locator('.spinner-border').wait_for(state='hidden', timeout=timeout)
+
+    def wait_for_tabs_to_load(self) -> None:
+        self.triggers.first.wait_for()

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
+        )