gui_e2e: wait for rendering before reading element snapshots

count(), inner_text() and all_inner_texts() return an immediate snapshot
without waiting. Replace or supplement their usage with waited checks.

CMK-34806

Change-Id: I8831870bac22b2699a0a6541b55adc4994a44248

Author: asyash26

tests/system/gui/testlib/playwright/pom/email.py

@@ -8,7 +8,7 @@
 import logging
 from pathlib import Path
 
-from playwright.sync_api import Locator, Page
+from playwright.sync_api import expect, Locator, Page
 
 logger = logging.getLogger(__name__)
 
@@ -32,8 +32,9 @@ def _get_row(self, row_name: str) -> Locator:
 
     def get_field_value(self, field_name: str) -> str:
         """Get the value of the specified field from the rendered HTML email."""
-        value = self._get_row(field_name).inner_text()
-        value = value.replace("\n", "").replace("\t", "")
+        row = self._get_row(field_name)
+        expect(row, f"Field '{field_name}' is not shown in the email").to_be_visible()
+        value = row.inner_text().replace("\n", "").replace("\t", "")
         return value.split(field_name, 1)[1]
 
     def check_table_content(self, expected_content: dict) -> None:

tests/system/gui/testlib/playwright/pom/monitor/dashboard.py

@@ -220,7 +220,11 @@ def get_chart_widget_hexagon(
 
     def get_chart_widget_total_value(self, widget_title: str) -> int:
         widget = self.get_widget(widget_title)
-        return int(widget.get_by_role("row", name="Total").locator("a.count").inner_text())
+        total_count = widget.get_by_role("row", name="Total").locator("a.count")
+        expect(
+            total_count, message=f"Total count of chart widget '{widget_title}' is not shown"
+        ).to_have_text(re.compile(r"\d+"))
+        return int(total_count.inner_text())
 
 
 class MainDashboard(BaseDashboard):

tests/system/gui/testlib/playwright/pom/monitor/host_search.py

@@ -78,11 +78,12 @@ def check_label_filter_applied(
         Check that label name and logical operator are correct at the expected position.
         """
         # example of returned result - ['is', 'test_label:foo', 'and', '(Select label)']
-        labels_text = self._labels_table.get_by_role("textbox").all_inner_texts()
-
-        assert labels_text[expected_position * 2] == logical_operator, (
-            "Logical operator used to filter hosts using labels is incorrect."
-        )
-        assert labels_text[expected_position * 2 + 1] == label, (
-            "Label used to filter hosts is incorrect."
-        )
+        label_textboxes = self._labels_table.get_by_role("textbox")
+        expect(
+            label_textboxes.nth(expected_position * 2),
+            "Logical operator used to filter hosts using labels is incorrect.",
+        ).to_have_text(logical_operator)
+        expect(
+            label_textboxes.nth(expected_position * 2 + 1),
+            "Label used to filter hosts is incorrect.",
+        ).to_have_accessible_name(label)

tests/system/gui/testlib/playwright/pom/page.py

@@ -9,7 +9,7 @@
 from typing import Literal, override
 from urllib.parse import quote_plus, urljoin
 
-from playwright.sync_api import expect, Locator, Page, Response
+from playwright.sync_api import expect, FrameLocator, Locator, Page, Response
 from playwright.sync_api import TimeoutError as PWTimeoutError
 
 from tests.system.gui.testlib.playwright.helpers import DropdownListNameToID, Keys, LocatorHelper
@@ -238,18 +238,75 @@ def _sub_menu(
         _loc = self.locator().get_by_role(role="link", name=menu)
         if sub_menu:
             _loc.click()
-
-            if show_more:
-                show_more_locator = self.locator().get_by_role(
-                    role="link", name="show more", exact=True
-                )
-                # only try to press if it hasn't already been pressed before
-                if show_more_locator.count():
-                    show_more_locator.click()
-            _loc = self.locator().get_by_role(role="link", name=sub_menu, exact=exact)
+            # After the click, the popup renders either the sub menu entry directly, or --
+            # if the menu has too many entries -- a "show more" link instead. Guards the
+            # one-shot .count() calls below against racing the popup's render.
+            sub_menu_entry = self.locator().get_by_role(role="link", name=sub_menu, exact=exact)
+            show_more_locator = self.locator().get_by_role(
+                role="link", name="show more", exact=True
+            )
+            expect(
+                sub_menu_entry.or_(show_more_locator),
+                message=f"The '{menu}' menu popup did not open",
+            ).not_to_have_count(0)
+
+            # only try to press if it hasn't already been pressed before
+            if show_more and show_more_locator.count():
+                show_more_locator.click()
+                # Clicking "show more" either reveals the sub menu entry directly, or --
+                # if it's still hidden inside an individual topic -- that topic's own
+                # "show all" overflow link. Guards the one-shot .count() call below
+                # against racing the expansion's render.
+                topic_overflow_locator = self.locator().locator(".mm-nav-item-topic__show-all")
+                expect(
+                    sub_menu_entry.or_(topic_overflow_locator),
+                    message="Clicking 'show more' did not expand the categories",
+                ).not_to_have_count(0)
+            _loc = sub_menu_entry
+            if not _loc.count():
+                _loc = self._reveal_overflowing_entry(sub_menu, exact)
         self._unique_web_element(_loc)
         return _loc
 
+    def _reveal_overflowing_entry(self, sub_menu: str, exact: bool) -> Locator:
+        """Locate a sub menu entry hidden behind a topic's "Show all" overflow.
+
+        Each topic renders only a limited number of entries; any surplus is
+        collapsed behind a "Show all" link and is therefore absent from the DOM.
+        Which entries are displayed depends on their configured sort order, so
+        adding a new entry can push an existing one out of the rendered set.
+        To stay independent of ordering and entry count, expand each
+        overflowing topic in turn until the requested entry shows up.
+        """
+        back_button = (
+            self.locator().locator(".mm-nav-item-topic__show-all-back").get_by_role("button")
+        )
+        show_all_links = self.locator().locator(".mm-nav-item-topic__show-all")
+        entry = self.locator().get_by_role(role="link", name=sub_menu, exact=exact)
+        # The requested entry is either already rendered, or hidden behind at least one
+        # topic's "show all" overflow link. Guards the one-shot .count() calls below
+        # against racing the render.
+        expect(
+            show_all_links.first.or_(entry),
+            message=f"Neither '{sub_menu}' nor any overflowing topic is shown",
+        ).not_to_have_count(0)
+
+        for index in range(show_all_links.count()):
+            show_all_links.nth(index).click()
+            expect(
+                back_button, message=f"'Show all' for topic {index} did not expand"
+            ).to_be_visible()
+            # Safe one-shot count: the back button and this topic's full entry
+            # list are driven by the same reactive flag and render in the same
+            # Vue update, so waiting on the button also covers the entries.
+            if entry.count():
+                return entry
+            back_button.click()
+            expect(
+                back_button, message=f"Collapsing topic {index} via its 'back' button did not work"
+            ).not_to_be_visible()
+        return entry
+
     @property
     def main_page(self) -> Locator:
         return self._sub_menu("Go to main page", sub_menu=None)
@@ -476,7 +533,18 @@ def locator(
     ) -> Locator:
         if not selector:
             selector = ":scope"
-        _loc = self._iframe_locator.locator(selector)
+
+        # Mixed-version tests drive older remote sites where the page content
+        # still renders inside the main iframe. Current sites render it in the
+        # shared document; popups, dialogs and slide-ins teleport to <body>,
+        # so no narrower container than the document itself covers them all.
+        _base: FrameLocator | Page
+        self.page.wait_for_load_state("load")
+        if self.page.locator("iframe[name='main']").count():
+            _base = self.page.frame_locator("iframe[name='main']")
+        else:
+            _base = self.page
+        _loc = _base.locator(selector)
         kwargs = self._build_locator_kwargs(
             has_text=has_text,
             has_not_text=has_not_text,
@@ -710,14 +778,20 @@ def filter_combobox(self, filter_name: str, check: bool = True) -> Locator:
             "combobox"
         )
 
+    def _add_filter(self, filter_name: str, exact: bool = False) -> None:
+        """Open `filter_name` in the sidebar's filter list, unless it's already applied."""
+        self.add_filter_button.click()
+        filter_link = self.filter_button(filter_name, exact=exact)
+        expect(
+            filter_link, message=f"The '{filter_name}' filter link did not render"
+        ).to_be_visible()
+        if "disabled" not in (filter_link.get_attribute("class") or ""):
+            filter_link.click()
+
     def apply_last_service_state_change_filter(
         self, from_units: str, from_value: str, until_units: str, until_value: str
     ) -> None:
-        try:
-            expect(self.last_service_state_change_filter).to_be_visible(timeout=3000)
-        except AssertionError:
-            self.add_filter_button.click()
-            self.filter_button("Last service state change").click()
+        self._add_filter("Last service state change")
 
         self.last_service_state_change_from_dropdown.click()
         self.dropdown_option(from_units).click()
@@ -743,12 +817,9 @@ def apply_host_filter(self, host_filter: str) -> None:
     def apply_filter_by_name(
         self, filter_name: str, filter_value: str, exact: bool = False
     ) -> None:
-        filter_combobox = self.filter_combobox(filter_name, check=False)
-
-        if filter_combobox.count() == 0:
-            self.add_filter_button.click()
-            self.filter_button(filter_name, exact=exact).click()
+        self._add_filter(filter_name, exact=exact)
 
+        filter_combobox = self.filter_combobox(filter_name)
         filter_combobox.click()
         self.search_text_field.fill(filter_value)
         # TODO: remove 'first' after fixing CMK-19975

tests/system/gui/testlib/playwright/pom/setup/analyze_configuration.py

@@ -49,35 +49,26 @@ def _dropdown_list_name_to_id(self) -> DropdownListNameToID:
     def analyse_config_table(self) -> Locator:
         return self.main_area.locator("table[class*='analyze_config']")
 
-    @property
-    def status_column_values(self) -> Locator:
-        return self.main_area.locator("span[class*='state']")
-
     @property
     def title_column_values(self) -> Locator:
         return self.main_area.locator("td[class*='buttons'] + td")
 
     def verify_all_expected_checks_are_present(self, expected_checks: list[str]) -> None:
         """Verify that all expected checks are present in the analyze configuration table."""
+        expect(
+            self.title_column_values,
+            f"Expected {len(expected_checks)} checks in the analyze configuration table.",
+        ).to_have_count(len(expected_checks))
         titles = self.title_column_values.all_inner_texts()
-        assert len(expected_checks) == len(titles), (
-            f"Expected {len(expected_checks)} checks, but got {len(titles)} checks."
-        )
         for expected_check in expected_checks:
             assert expected_check in titles, (
                 f"Expected check '{expected_check}' not found in the analyze configuration table."
             )
 
     def verify_checks_statuses(self, expected_statues: dict[str, str]) -> None:
-        titles = self.title_column_values.all_inner_texts()
-        statuses = self.status_column_values.all_inner_texts()
-        actual_statuses = dict(zip(titles, statuses))
-        assert len(titles) == len(actual_statuses), (
-            f"Expected {len(expected_statues)} checks, but got {len(actual_statuses)} checks."
-        )
         for title, expected_status in expected_statues.items():
-            actual_status = actual_statuses.get(title)
-            assert actual_status == expected_status, (
-                f"Expected status '{expected_status}' for check '{title}', "
-                f"but got '{actual_status}'."
-            )
+            check_row = self.main_area.locator(f"tr:has(td:text-is('{title}'))")
+            expect(
+                check_row.locator("span[class*='state']"),
+                f"Unexpected status of the check '{title}'.",
+            ).to_have_text(expected_status)

tests/system/gui/testlib/playwright/pom/setup/background_jobs.py

@@ -52,11 +52,6 @@ def result_retrieve_created_dump_file_icon(self) -> Locator:
     def progress_info_retrieve_created_dump_icon(self) -> Locator:
         return self._detail_row("Progress info").get_by_role("link", name="Download")
 
-    @property
-    def job_state(self) -> str:
-        """Return the state of the job as text."""
-        return self.job_state_locator.inner_text()
-
     @property
     def job_state_locator(self) -> Locator:
         return self._detail_row("State", exact=True).locator("td")

tests/system/gui/testlib/playwright/pom/setup/distributed_monitoring.py

@@ -127,6 +127,7 @@ def clean_all_site_connections(self) -> int:
         """
         logger.info("Delete all site connections")
 
+        expect(self.data_table, message="Site connections table is not shown").to_be_visible()
         delete_buttons = self.data_table.get_by_role("link", name="Delete")
 
         number_of_deleted_sites = delete_buttons.count()

tests/system/gui/testlib/playwright/pom/setup/hosts.py

@@ -130,6 +130,10 @@ def delete_folder(self, folder_id: str) -> None:
         buttons.hover()
         buttons.get_by_role("link", name="Delete this folder").click()
         self.main_area.locator().get_by_role("button", name="Delete").click()
+        expect(
+            self.folder_icon(folder_id),
+            message=f"Folder '{folder_id}' is still present after deletion",
+        ).to_have_count(0)
 
     def check_host_not_present(self, host_name: str) -> None:
         """Check that a host is not present in the list of hosts."""

tests/system/gui/testlib/playwright/pom/setup/notification_configuration.py

@@ -138,14 +138,22 @@ def _get_notification_stat_count(self, title: str) -> Locator:
         )
 
     def get_total_sent_notifications_count(self) -> int:
-        return int(self._get_notification_stat_count("Total sent notifications").inner_text())
+        stat_count = self._get_notification_stat_count("Total sent notifications")
+        expect(stat_count, message="'Total sent notifications' count is not shown").to_have_text(
+            re.compile(r"\d+")
+        )
+        return int(stat_count.inner_text())
 
     def check_total_sent_notifications_has_changed(self, previous_count: int) -> None:
         locator = self._get_notification_stat_count("Total sent notifications")
         expect(locator).not_to_have_text(re.compile(rf"^{previous_count}$"))
 
     def get_failed_notifications_count(self) -> int:
-        return int(self._get_notification_stat_count("Failed notifications").inner_text())
+        stat_count = self._get_notification_stat_count("Failed notifications")
+        expect(stat_count, message="'Failed notifications' count is not shown").to_have_text(
+            re.compile(r"\d+")
+        )
+        return int(stat_count.inner_text())
 
     def check_failed_notifications_has_not_changed(self, previous_count: int) -> None:
         locator = self._get_notification_stat_count("Failed notifications")