from operator import attrgetter import pytest from textual import events from textual._node_list import DuplicateIds from textual.app import App, ComposeResult from textual.containers import Container from textual.content import Content from textual.css.errors import StyleValueError from textual.css.query import NoMatches from textual.geometry import Offset, Size from textual.message import Message from textual.widget import BadWidgetName, MountError, PseudoClasses, Widget from textual.widgets import ( Button, DataTable, Footer, Header, Input, Label, LoadingIndicator, Log, OptionList, RichLog, Switch, TextArea, ) async def test_widget_construct(): """Regression test for https://github.com/Textualize/textual/issues/5042""" # Check that constructing the widget outside of the app, doesn't invoke code that # expects an active app. class MyApp(App): def __init__(self) -> None: super().__init__() self.button = Button() self.data_table = DataTable() self.footer = Footer() self.header = Header() self.input = Input() self.label = Label() self.loading_indicator = LoadingIndicator() self.log_ = Log() self.option_list = OptionList() self.rich_log = RichLog() self.switch = Switch() self.text_area = TextArea(language="python") app = MyApp() async with app.run_test(): pass @pytest.mark.parametrize( "set_val, get_val, style_str", [ [True, True, "visible"], [False, False, "hidden"], ["hidden", False, "hidden"], ["visible", True, "visible"], ], ) async def test_widget_set_visible_true(set_val, get_val, style_str): widget = Widget() widget.visible = set_val assert widget.visible is get_val assert widget.styles.visibility == style_str async def test_widget_set_visible_invalid_string(): widget = Widget() with pytest.raises(StyleValueError): widget.visible = "nope! no widget for me!" assert widget.visible async def test_widget_content_width(): class TextWidget(Widget): def __init__(self, text: str, id: str) -> None: self.text = text super().__init__(id=id) self.expand = False self.shrink = True def render(self) -> str: return self.text widget1 = TextWidget("foo", id="widget1") widget2 = TextWidget("foo\nbar", id="widget2") widget3 = TextWidget("foo\nbar\nbaz", id="widget3") app = App() with app._context(): width = widget1.get_content_width(Size(20, 20), Size(80, 24)) height = widget1.get_content_height(Size(20, 20), Size(80, 24), width) assert width == 3 assert height == 1 width = widget2.get_content_width(Size(20, 20), Size(80, 24)) height = widget2.get_content_height(Size(20, 20), Size(80, 24), width) assert width == 3 assert height == 2 width = widget3.get_content_width(Size(20, 20), Size(80, 24)) height = widget3.get_content_height(Size(20, 20), Size(80, 24), width) assert width == 3 assert height == 3 class GetByIdApp(App): def compose(self) -> ComposeResult: grandchild1 = Widget(id="grandchild1") child1 = Widget(grandchild1, id="child1") child2 = Widget(id="child2") yield Widget( child1, child2, id="parent", ) @property def parent(self) -> Widget: return self.query_one("#parent") @pytest.fixture async def hierarchy_app(): app = GetByIdApp() yield app async def test_get_child_by_id_gets_first_child(hierarchy_app): async with hierarchy_app.run_test(): parent = hierarchy_app.parent child = parent.get_child_by_id(id="child1") assert child.id == "child1" assert child.get_child_by_id(id="grandchild1").id == "grandchild1" assert parent.get_child_by_id(id="child2").id == "child2" async def test_get_child_by_id_no_matching_child(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent with pytest.raises(NoMatches): parent.get_child_by_id(id="doesnt-exist") async def test_get_child_by_id_only_immediate_descendents(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent with pytest.raises(NoMatches): parent.get_child_by_id(id="grandchild1") async def test_get_child_by_type(): class GetChildApp(App): def compose(self) -> ComposeResult: yield Widget(id="widget1") yield Container( Label(id="label1"), Widget(id="widget2"), id="container1", ) app = GetChildApp() async with app.run_test(): assert app.get_child_by_type(Widget).id == "widget1" assert app.get_child_by_type(Container).id == "container1" with pytest.raises(NoMatches): app.get_child_by_type(Label) async def test_get_widget_by_id_no_matching_child(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent with pytest.raises(NoMatches): parent.get_widget_by_id(id="i-dont-exist") async def test_get_widget_by_id_non_immediate_descendants(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent result = parent.get_widget_by_id("grandchild1") assert result.id == "grandchild1" async def test_get_widget_by_id_immediate_descendants(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent result = parent.get_widget_by_id("child1") assert result.id == "child1" async def test_get_widget_by_id_doesnt_return_self(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent with pytest.raises(NoMatches): parent.get_widget_by_id("parent") async def test_get_widgets_app_delegated(hierarchy_app): # Check that get_child_by_id finds the parent, which is a child of the default Screen async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent queried_parent = hierarchy_app.get_child_by_id("parent") assert queried_parent is parent # Check that the grandchild (descendant of the default screen) is found grandchild = hierarchy_app.get_widget_by_id("grandchild1") assert grandchild.id == "grandchild1" async def test_widget_mount_ids_must_be_unique_mounting_all_in_one_go(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent widget1 = Widget(id="hello") widget2 = Widget(id="hello") with pytest.raises(MountError): parent.mount(widget1, widget2) async def test_widget_mount_ids_must_be_unique_mounting_multiple_calls(hierarchy_app): async with hierarchy_app.run_test() as pilot: parent = pilot.app.parent widget1 = Widget(id="hello") widget2 = Widget(id="hello") parent.mount(widget1) with pytest.raises(DuplicateIds): parent.mount(widget2) async def test_get_pseudo_class_state(): widget = Widget() pseudo_classes = widget.get_pseudo_class_state() assert pseudo_classes == PseudoClasses(enabled=True, focus=False, hover=False) async def test_get_pseudo_class_state_disabled(): widget = Widget(disabled=True) pseudo_classes = widget.get_pseudo_class_state() assert pseudo_classes == PseudoClasses(enabled=False, focus=False, hover=False) async def test_get_pseudo_class_state_parent_disabled(): child = Widget() _parent = Widget(disabled=True) child._attach(_parent) pseudo_classes = child.get_pseudo_class_state() assert pseudo_classes == PseudoClasses(enabled=False, focus=False, hover=False) async def test_get_pseudo_class_state_hover(): widget = Widget() widget.mouse_hover = True pseudo_classes = widget.get_pseudo_class_state() assert pseudo_classes == PseudoClasses(enabled=True, focus=False, hover=True) async def test_get_pseudo_class_state_focus(): widget = Widget() widget.has_focus = True pseudo_classes = widget.get_pseudo_class_state() assert pseudo_classes == PseudoClasses(enabled=True, focus=True, hover=False) # Regression test for https://github.com/Textualize/textual/issues/1634 async def test_remove(): class RemoveMeLabel(Label): async def on_mount(self) -> None: await self.run_action("app.remove_all") class Container(Widget): async def clear(self) -> None: await self.query("*").remove() class RemoveApp(App): def compose(self) -> ComposeResult: yield Container(RemoveMeLabel()) async def action_remove_all(self) -> None: await self.query_one(Container).clear() self.exit(123) app = RemoveApp() async with app.run_test() as pilot: await pilot.press("r") await pilot.pause() assert app.return_value == 123 # Regression test for https://github.com/Textualize/textual/issues/2079 async def test_remove_unmounted(): mounted = False class RemoveApp(App): def on_mount(self): nonlocal mounted label = Label() label.remove() mounted = True app = RemoveApp() async with app.run_test() as pilot: await pilot.pause() assert mounted async def test_render_str() -> None: widget = Label() assert widget.render_str("foo") == Content("foo") assert widget.render_str("[b]foo") == Content.from_markup("[b]foo") # Text objects are passed unchanged content = Content("bar") assert widget.render_str(content) is content async def test_compose_order() -> None: from textual.containers import Horizontal from textual.screen import Screen from textual.widgets import Select class MyScreen(Screen): def on_mount(self) -> None: self.query_one(Select).value = 1 def compose(self) -> ComposeResult: yield Horizontal( Select(((str(n), n) for n in range(10)), id="select"), id="screen-horizontal", ) class SelectBugApp(App[None]): async def on_mount(self): await self.push_screen(MyScreen(id="my-screen")) self.screen.query_one(Select) app = SelectBugApp() messages: list[Message] = [] async with app.run_test(message_hook=messages.append) as pilot: await pilot.pause() mounts = [ message._sender.id for message in messages if isinstance(message, events.Mount) and message._sender.id is not None ] expected = [ "_default", # default screen "label", # A static in select "select", # The select "screen-horizontal", # The horizontal in MyScreen.compose "my-screen", # THe screen mounted in the app ] assert mounts == expected def test_children_must_be_widgets(): with pytest.raises(TypeError): Widget(1, 2, 3) async def test_orphan_widget_has_no_siblings(): assert Widget().siblings == [] async def test__allow_scroll_default(): assert not Widget()._allow_scroll async def test__allow_scroll(): from textual.containers import ScrollableContainer class AllowScrollApp(App): CSS = "ScrollableContainer { width: 3; height: 3; }" def compose(self): with ScrollableContainer(): yield Label("This is\n\n\n\n\nlarge text.") app = AllowScrollApp() async with app.run_test(): assert app.query_one(ScrollableContainer)._allow_scroll async def test_offset_getter_setter(): class OffsetApp(App): def compose(self): yield Label("hello") app = OffsetApp() async with app.run_test(): label = app.query_one(Label) assert label.offset == Offset(0, 0) label.offset = (7, 3) assert label.offset == Offset(7, 3) async def test_get_set_tooltip(): widget = Widget() assert widget.tooltip is None widget.tooltip = "This is a tooltip." assert widget.tooltip == "This is a tooltip." async def test_loading(): """Test setting the loading reactive.""" class LoadingApp(App): def compose(self) -> ComposeResult: yield Label("Hello, World") async with LoadingApp().run_test() as pilot: app = pilot.app label = app.query_one(Label) assert label.loading == False assert label._cover_widget is None label.loading = True await pilot.pause() assert label._cover_widget is not None label.loading = True # Setting to same value is a null-op await pilot.pause() assert label._cover_widget is not None label.loading = False await pilot.pause() assert label._cover_widget is None label.loading = False # Setting to same value is a null-op await pilot.pause() assert label._cover_widget is None async def test_loading_button(): """Test loading indicator renders buttons unclickable.""" counter = 0 class LoadingApp(App): def compose(self) -> ComposeResult: yield Button("Hello, World", action="app.inc") def action_inc(self) -> None: nonlocal counter counter += 1 async with LoadingApp().run_test() as pilot: # Sanity check assert counter == 0 button = pilot.app.query_one(Button) button.active_effect_duration = 0 # Click the button to advance the counter await pilot.click(button) assert counter == 1 # Set the button to loading state button.loading = True # A click should do nothing await pilot.click(button) assert counter == 1 # Set the button to not loading button.loading = False # Click should advance counter await pilot.click(button) assert counter == 2 async def test_is_mounted_property(): class TestWidgetIsMountedApp(App): pass async with TestWidgetIsMountedApp().run_test() as pilot: widget = Widget() assert widget.is_mounted is False await pilot.app.mount(widget) assert widget.is_mounted is True async def test_mount_error_not_widget(): class NotWidgetApp(App): def compose(self) -> ComposeResult: yield {} app = NotWidgetApp() with pytest.raises(MountError): async with app.run_test(): pass async def test_mount_error_bad_widget(): class DaftWidget(Widget): def __init__(self): # intentionally missing super() pass class NotWidgetApp(App): def compose(self) -> ComposeResult: yield DaftWidget() app = NotWidgetApp() with pytest.raises(MountError): async with app.run_test(): pass async def test_render_returns_text(): """Test that render processes console markup when returning a string.""" # Regression test for https://github.com/Textualize/textual/issues/3918 class SimpleWidget(Widget): def render(self) -> str: return "Hello [b]World[/b]!" widget = SimpleWidget() render_result = widget._render() assert isinstance(render_result, Content) assert render_result.plain == "Hello World!" async def test_sort_children() -> None: """Test the sort_children method.""" class SortApp(App): def compose(self) -> ComposeResult: with Container(id="container"): yield Label("three", id="l3") yield Label("one", id="l1") yield Label("four", id="l4") yield Label("two", id="l2") app = SortApp() async with app.run_test(): container = app.query_one("#container", Container) assert [label.id for label in container.query(Label)] == [ "l3", "l1", "l4", "l2", ] container.sort_children(key=attrgetter("id")) assert [label.id for label in container.query(Label)] == [ "l1", "l2", "l3", "l4", ] container.sort_children(key=attrgetter("id"), reverse=True) assert [label.id for label in container.query(Label)] == [ "l4", "l3", "l2", "l1", ] async def test_sort_children_no_key() -> None: """Test sorting with no key.""" class SortApp(App): def compose(self) -> ComposeResult: with Container(id="container"): yield Label("three", id="l3") yield Label("one", id="l1") yield Label("four", id="l4") yield Label("two", id="l2") app = SortApp() async with app.run_test(): container = app.query_one("#container", Container) assert [label.id for label in container.query(Label)] == [ "l3", "l1", "l4", "l2", ] # Without a key, the sort order is the order children were instantiated container.sort_children() assert [label.id for label in container.query(Label)] == [ "l3", "l1", "l4", "l2", ] container.sort_children(reverse=True) assert [label.id for label in container.query(Label)] == [ "l2", "l4", "l1", "l3", ] def test_bad_widget_name_raised() -> None: """Ensure error is raised when bad class names are used for widgets.""" with pytest.raises(BadWidgetName): class lowercaseWidget(Widget): pass def test_lazy_loading() -> None: """Regression test for https://github.com/Textualize/textual/issues/5077 Check that the lazy loading magic doesn't break attribute access. """ with pytest.raises(ImportError): from textual.widgets import Foo # nopycln: import from textual import widgets from textual.widgets import Label assert not hasattr(widgets, "foo") assert not hasattr(widgets, "bar") assert hasattr(widgets, "Label") async def test_of_type() -> None: class MyApp(App): def compose(self) -> ComposeResult: for ordinal in range(5): yield Label(f"Item {ordinal}") app = MyApp() async with app.run_test(): labels = list(app.query(Label)) assert labels[0].first_of_type assert not labels[0].last_of_type assert labels[0].first_child assert not labels[0].last_child assert labels[0].is_odd assert not labels[0].is_even assert not labels[1].first_of_type assert not labels[1].last_of_type assert not labels[1].first_child assert not labels[1].last_child assert not labels[1].is_odd assert labels[1].is_even assert not labels[2].first_of_type assert not labels[2].last_of_type assert not labels[2].first_child assert not labels[2].last_child assert labels[2].is_odd assert not labels[2].is_even assert not labels[3].first_of_type assert not labels[3].last_of_type assert not labels[3].first_child assert not labels[3].last_child assert not labels[3].is_odd assert labels[3].is_even assert not labels[4].first_of_type assert labels[4].last_of_type assert not labels[4].first_child assert labels[4].last_child assert labels[4].is_odd assert not labels[4].is_even async def test_click_line_api_border(): """Regression test for https://github.com/Textualize/textual/issues/5634""" class MyApp(App): def compose(self) -> ComposeResult: self.my_log = Log() self.my_log.styles.border = ("round", "white") yield self.my_log app = MyApp() async with app.run_test() as pilot: await pilot.pause() await pilot.click("Log", (10, 0))