py10x-universe 0.1.3__py3-none-any.whl

ui_10x/rio/widgets/unit_tests/test_group_box.py

@@ -0,0 +1,158 @@
+import asyncio
+
+import rio.testing
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import CheckBox, GroupBox, Label, PushButton
+
+
+async def test_group_box() -> None:
+    """Test basic GroupBox widget functionality."""
+    widget = GroupBox(title='Test Group')
+
+    async with rio.testing.DummyClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert widget['title'] == 'Test Group'
+
+        # Test title change
+        widget.set_title('Updated Group')
+        await test_client.wait_for_refresh()
+        assert widget['title'] == 'Updated Group'
+
+
+async def test_group_box_with_children() -> None:
+    """Test GroupBox widget with child widgets."""
+    label = Label('Label inside group')
+    checkbox = CheckBox('Checkbox inside group')
+    button = PushButton('Button inside group')
+
+    widget = GroupBox(None, 'Group with children', label, checkbox, button)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test title
+        assert widget['title'] == 'Group with children'
+
+        # Test children
+        children = widget.get_children()
+        assert len(children) == 3
+        assert label in children
+        assert checkbox in children
+        assert button in children
+        assert 4 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 1 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+
+async def test_group_box_add_remove_children() -> None:
+    """Test GroupBox widget adding and removing children."""
+    widget = GroupBox(title='Dynamic Group')
+    label = Label('Dynamic Label')
+    button = PushButton('Dynamic Button')
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial empty state
+        assert len(widget.get_children()) == 0
+        assert 1 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 0 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+        # Test adding children
+        widget.add_children(label)
+        await test_client.wait_for_refresh()
+        assert len(widget.get_children()) == 1
+        assert label in widget.get_children()
+        assert 2 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 0 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+        widget.add_children(button)
+        await test_client.wait_for_refresh()
+        assert len(widget.get_children()) == 2
+        assert button in widget.get_children()
+        assert 3 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 1 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+        # Test removing children
+        widget._kwargs['children'] = [child for child in widget._kwargs['children'] if child is not label]
+        widget.force_update()
+        await test_client.wait_for_refresh()
+        assert len(widget.get_children()) == 1
+        assert label not in widget.get_children()
+        assert button in widget.get_children()
+        assert 2 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 1 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+        widget._kwargs['children'] = [child for child in widget._kwargs['children'] if child is not button]
+        widget.force_update()
+        await test_client.wait_for_refresh()
+        assert len(widget.get_children()) == 0
+        assert 1 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+        assert 0 == await test_client.execute_js('document.querySelectorAll(".rio-button").length')
+
+
+# async def test_group_box_enabled_disabled() -> None:
+#     """Test GroupBox enabled/disabled state."""
+#     widget = GroupBox(title = 'Enabled Group')
+#     label = Label('Child Label')
+#     widget.add_widget(label)
+#
+#     async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+#         await asyncio.sleep(0.5)
+#
+#         # Test initial enabled state
+#         assert widget['is_sensitive']
+#         assert label.is_enabled()
+#
+#         # Test disabling group (should disable children)
+#         widget.set_enabled(False)
+#         await test_client.wait_for_refresh()
+#         assert not widget['is_sensitive']
+#         assert not label.is_enabled()
+#
+#         # Test re-enabling
+#         widget.set_enabled(True)
+#         await test_client.wait_for_refresh()
+#         assert widget['is_sensitive']
+#         assert label.is_enabled()
+
+
+async def test_group_box_client_interaction() -> None:
+    """Test GroupBox widget client interaction with timeout protection."""
+    widget = GroupBox(title='Client Test')
+    label = Label('Content')
+    widget.add_children(label)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert widget['title'] == 'Client Test'
+        assert len(widget.get_children()) == 1
+        await check_title(widget, test_client)
+        await check_label(label, test_client)
+
+        # Test widget property changes
+        widget.set_title('Updated Title')
+        await test_client.wait_for_refresh()
+        assert widget['title'] == 'Updated Title'
+
+        # Verify client state reflects widget changes
+        await check_title(widget, test_client)
+        await check_label(label, test_client)
+
+        # Test empty title
+        widget.set_title('')
+        await test_client.wait_for_refresh()
+        assert widget['title'] == ''
+        await check_title(widget, test_client)
+
+
+async def check_label(label, test_client):
+    assert 2 == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text").length')
+    assert label['text'] == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text")[1].innerText')
+
+
+async def check_title(widget, test_client):
+    assert widget['title'] == await test_client.execute_js('document.querySelectorAll(".rio-column .rio-text")[0].innerText')

ui_10x/rio/widgets/unit_tests/test_label.py

@@ -0,0 +1,43 @@
+import asyncio
+
+import rio.testing.browser_client
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import Label
+
+
+async def check_text(widget, test_client, text):
+    assert widget['text'] == text
+    client_text = await test_client.execute_js('document.querySelector(".rio-text")?.children[0]?.innerText || ""')
+    assert client_text == text
+
+
+async def test_label() -> None:
+    """Test basic Label widget functionality with client interaction verification."""
+    widget = Label('Hello World')
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial text - verify widget state
+        assert widget['text'] == 'Hello World'
+
+        # Test text change - verify widget update
+        widget.set_text('Updated Text')
+        await test_client.wait_for_refresh()
+        await check_text(widget, test_client, 'Updated Text')
+
+
+async def test_label_empty() -> None:
+    """Test Label widget with empty text and client validation."""
+    widget = Label()
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test empty text
+        await check_text(widget, test_client, '')
+
+        # Test setting text
+        widget.set_text('New Text')
+        await test_client.wait_for_refresh()
+        await check_text(widget, test_client, 'New Text')

ui_10x/rio/widgets/unit_tests/test_line_edit.py

@@ -0,0 +1,140 @@
+import asyncio
+
+import pytest
+import rio.testing
+from ui_10x import platform_interface as i
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import LineEdit
+
+
+@pytest.mark.async_timeout(10)
+async def test_line_edit_comprehensive() -> None:
+    """Test LineEdit with comprehensive client-widget interaction verification."""
+    widget = LineEdit('Initial Text')
+    find_input = 'document.querySelector(".rio-input-box").querySelector("input")'
+    find_tool_tip = 'document.querySelector(".rio-tooltip-popup").querySelector(".rio-text").children[0].innerText'
+
+    edited_calls = []
+    finished_calls = []
+
+    def edited_handler(text):
+        edited_calls.append(text)
+
+    def finished_handler():
+        finished_calls.append(True)
+
+    widget.text_edited_connect(edited_handler)
+    widget.editing_finished_connect(finished_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # 1) Verify client shows widget value
+        assert widget.text() == 'Initial Text'
+        assert widget.text() == await test_client.execute_js(find_input + '.value')
+
+        # 2) Modify client value (user typing)
+        await test_client.execute_js(find_input + '.focus();')
+        await test_client.execute_js(find_input + '.value = "User Typed Text";')
+        await test_client.execute_js(find_input + '.dispatchEvent(new Event("input"));')
+        await asyncio.sleep(1)  # wait for change delay
+
+        # 3) Verify widget reflects client value
+        assert widget.text() == 'User Typed Text'
+        assert widget.text() == await test_client.execute_js(find_input + '.value')
+        assert len(edited_calls) == 1
+        assert widget.text() == edited_calls[0]
+
+        # Test editing finished
+        await test_client.execute_js(find_input + '.blur();')
+        assert len(finished_calls) == 1
+        assert widget.text() == await test_client.execute_js(find_input + '.value')
+
+        # Test widget changes propagate to client with timeout protection
+        widget.set_text('Widget Updated')
+        await test_client.wait_for_refresh()
+        client_value = await test_client.execute_js(find_input + '.value')
+        assert client_value == 'Widget Updated'
+        assert widget.text() == 'Widget Updated'
+
+        # Test tooltip functionality
+        widget.set_tool_tip('Helpful tip')
+        await test_client.wait_for_refresh()
+        await test_client._page.mouse.move(1, 1)
+        tooltip_text = await test_client.execute_js(find_tool_tip)
+        assert tooltip_text == 'Helpful tip'
+
+        # Test password mode with timeout protection
+        assert 'password' != await test_client.execute_js(find_input + '.type')
+        widget.set_password_mode()
+        await test_client.wait_for_refresh()
+        assert 'password' == await test_client.execute_js(find_input + '.type')
+
+
+async def test_line_edit_disabled_interaction() -> None:
+    """Test LineEdit disabled state blocks user interaction."""
+
+    right_button_presses = []
+    left_button_presses = []
+
+    class MyLineEdit(LineEdit):
+        def mouse_press_event(self, event: i.MouseEvent):
+            if event.is_right_button():
+                right_button_presses.append(event)
+            else:
+                left_button_presses.append(event)
+
+    widget = MyLineEdit('Initial Text')
+    find_input = 'document.querySelector(".rio-input-box input")'
+
+    edited_calls = []
+
+    def edited_handler(text):
+        edited_calls.append(text)
+
+    widget.text_edited_connect(edited_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial enabled state - typing should work
+        async def test_interaction(old_content, new_content, enabled=True):
+            initial_left = len(left_button_presses)
+            initial_right = len(right_button_presses)
+            initial_edited = len(edited_calls)
+            await test_client.click(10, 20, button='right')  # handler
+            await test_client._page.click('.rio-input-box input', click_count=3, force=True)  # select all
+            await test_client._page.keyboard.press(new_content)
+            await asyncio.sleep(1)
+
+            right, left, edited, content = (1, 3, 1, new_content) if enabled else (1, 3, 0, old_content)
+
+            assert len(right_button_presses) == right + initial_right
+            assert len(left_button_presses) == left + initial_left
+            assert len(edited_calls) == edited + initial_edited
+            assert edited_calls[-1] == content
+            assert widget.text() == content
+
+        await test_interaction(widget.text(), 'A')
+
+        # Disable widget
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+
+        # Verify client shows disabled state
+        client_disabled = await test_client.execute_js(find_input + '.disabled')
+        assert client_disabled is True
+
+        # Test that typing is blocked when disabled
+        await test_interaction(widget.text(), 'B', enabled=False)
+
+        # Re-enable widget
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+
+        # Verify client shows enabled state
+        client_disabled = await test_client.execute_js(find_input + '.disabled')
+        assert client_disabled is False
+
+        # Test that typing works again
+        await test_interaction(widget.text(), 'C')

ui_10x/rio/widgets/unit_tests/test_list.py

@@ -0,0 +1,146 @@
+import asyncio
+
+import rio.testing.browser_client
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import ListWidget
+
+
+async def test_list_comprehensive() -> None:
+    """Test ListWidget with comprehensive client-widget interaction verification."""
+    widget = ListWidget()
+    widget.add_items(['Item 1', 'Item 2', 'Item 3'])
+
+    find_list_items = 'document.querySelectorAll(".rio-selectable-item")'
+    find_selected_text = 'document.querySelector(".selected").querySelector(".rio-text").children[0].innerText'
+
+    clicked_calls = []
+
+    def clicked_handler(item):
+        clicked_calls.append(item)
+
+    widget.clicked_connect(clicked_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # 1) Verify client shows widget value (list items)
+        assert widget.child_count() == 3
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 3
+
+        # 2) Modify client value (user clicking first item)
+        await test_client.click(10, 1)
+        await asyncio.sleep(0.5)
+
+        # 3) Verify widget reflects client value
+        assert len(clicked_calls) == 1
+        assert clicked_calls[0]['text'] == 'Item 1'
+        assert widget['selected_items'] == [clicked_calls[0]['key']]
+
+        # Verify client shows selection
+        selected_text = await test_client.execute_js(find_selected_text)
+        assert selected_text == 'Item 1'
+
+        # Test clicking second item
+        await test_client.click(10, test_client.window_height_in_pixels - 1)
+        await asyncio.sleep(0.5)
+        assert len(clicked_calls) == 2
+        assert clicked_calls[1]['text'] == 'Item 3'  # Last item
+        assert widget['selected_items'] == [clicked_calls[1]['key']]
+
+        # Test widget changes propagate to client (clearing list)
+        widget.clear()
+        assert not widget.get_children()
+        await test_client.wait_for_refresh()
+        assert not widget.subcomponent.selected_items
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 0
+
+        # Test adding item
+        widget.add_item('New Item')
+        await test_client.wait_for_refresh()
+        assert widget.child_count() == 1
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 1
+
+        # Test clicking new item
+        await test_client.click(10, 1)
+        await asyncio.sleep(0.5)
+        assert len(clicked_calls) == 3
+        assert clicked_calls[2]['text'] == 'New Item'
+
+
+async def test_list_item_management() -> None:
+    """Test ListWidget item management operations."""
+    widget = ListWidget()
+    widget.add_items(['A', 'B', 'C'])
+
+    find_list_items = 'document.querySelectorAll(".rio-selectable-item")'
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert widget.child_count() == 3
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 3
+
+        # Test removing item
+        removed_item = widget.take_item(1)  # Remove 'B'
+        await test_client.wait_for_refresh()
+        assert widget.child_count() == 2
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 2
+        assert removed_item['text'] == 'B'
+
+        # Test adding another item with timeout protection
+        widget.add_item('Inserted')
+        await test_client.wait_for_refresh()
+        assert widget.child_count() == 3
+        client_items = await test_client.execute_js(f'{find_list_items}.length')
+        assert client_items == 3
+
+
+async def test_list_disabled_interaction() -> None:
+    """Test ListWidget disabled state blocks user interaction."""
+    widget = ListWidget()
+    widget.add_items(['Item 1', 'Item 2', 'Item 3'])
+
+    clicked_calls = []
+
+    def clicked_handler(item):
+        clicked_calls.append(item)
+
+    widget.clicked_connect(clicked_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial enabled state - clicks should work
+        await test_client.click(10, 1)
+        await asyncio.sleep(0.5)
+        assert len(clicked_calls) == 1
+        assert clicked_calls[0]['text'] == 'Item 1'
+        assert widget['selected_items'] == [id(widget.get_children()[0])]
+
+        # Disable widget
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+
+        # Test that clicks are blocked when disabled
+        initial_calls = len(clicked_calls)
+        await test_client.click(10, 1)
+        await asyncio.sleep(0.5)
+        assert len(clicked_calls) == initial_calls  # No additional calls
+        assert widget['selected_items'] == [id(widget.get_children()[0])]
+
+        # Re-enable widget
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+
+        # Test that clicks work again
+        await test_client.click(10, 1)
+        await asyncio.sleep(0.5)
+        assert len(clicked_calls) == initial_calls + 1
+        assert clicked_calls[-1]['text'] == 'Item 1'
+        assert widget['selected_items'] == []