Добавлены тесты для вкладок 'Действия', 'События', 'Обслуживание', 'Аудит' панели событий

components/eventbar_component.py

@@ -6,6 +6,10 @@ from locators.event_panel_locators import EventPanelLocators
 from elements.tooltip_button_element import TooltipButton
 from elements.tab_button_element import TabButton
 from elements.button_element import Button
+from components_derived.container_actions_events import ActionsEventsContainer
+from components_derived.container_audit_events import AuditEventsContainer
+from components_derived.container_events import EventsTabContainer
+from components_derived.container_maintenance_events import MaintenanceEventsContainer
 from components_derived.container_system_log_events import SystemLogEventsContainer
 from components_derived.user_card import UserCard
 from components.base_component import BaseComponent
@@ -66,6 +70,42 @@ class EventPanelComponent(BaseComponent):
 
         self.expand_more_button.click()
 
+    def click_actions_tab(self) -> ActionsEventsContainer:
+        """Выполняет нажатие tab-кнопки Действия."""
+
+        self.actions_tab.check_visibility("Actions tab button is missing on event panel")
+        self.actions_tab.click()
+
+        actions_tab = ActionsEventsContainer(self.page, EventPanelLocators.CONTAINER_ACTIONS_TAB)
+        return actions_tab
+
+    def click_audit_tab(self) -> AuditEventsContainer:
+        """Выполняет нажатие tab-кнопки Аудит."""
+
+        self.audit_tab.check_visibility("Audit tab button is missing on event panel")
+        self.audit_tab.click()
+
+        audit_tab = AuditEventsContainer(self.page, EventPanelLocators.CONTAINER_AUDIT_EVENTS)
+        return audit_tab
+
+    def click_events_tab(self) -> EventsTabContainer:
+        """Выполняет нажатие tab-кнопки События."""
+
+        self.events_tab.check_visibility("Events tab button is missing on event panel")
+        self.events_tab.click()
+
+        events_tab = EventsTabContainer(self.page, EventPanelLocators.CONTAINER_EVENTS_TAB)
+        return events_tab
+
+    def click_maintenance_tab(self) -> MaintenanceEventsContainer:
+        """Выполняет нажатие tab-кнопки Обслуживание."""
+
+        self.maintenance_tab.check_visibility("Maintenance tab button is missing on event panel")
+        self.maintenance_tab.click()
+
+        maintenance_tab = MaintenanceEventsContainer(self.page, EventPanelLocators.CONTAINER_MAINTENANCE_EVENTS)
+        return maintenance_tab
+
     def click_system_log_tab(self) -> SystemLogEventsContainer:
         """Выполняет нажатие tab-кнопки Системный журнал."""
 

components/events_container_component.py

@@ -84,7 +84,7 @@ class EventsContainerComponent(BaseComponent):
         self.chevron_right.click()
 
     def click_first_page(self) -> None:
-        """Нажатие кнопки перехода на первую сраницу"""
+        """Нажатие кнопки перехода на первую страницу"""
 
         self.first_page.click()
 
@@ -94,7 +94,7 @@ class EventsContainerComponent(BaseComponent):
         self.last_page.click()
 
     def click_filter_button(self) -> EventsFilterPanel:
-        """Нажатие кнопки перехода на первую сраницу"""
+        """Нажатие кнопки перехода на первую страницу"""
 
         self.toolbar.click_button("filter_button")
         expect(self.page.locator("div.menuable__content__active")).to_be_visible(), "Events filter is missing"
@@ -110,6 +110,15 @@ class EventsContainerComponent(BaseComponent):
         loc = self.container_locator.locator(self.table_locator)
         self.events_table.click_arrow_button(loc, index)
 
+    def get_events_table_row_locator(self, index: int) -> Locator:
+        """ Возвращает локатор строки таблицы по ее индексу
+
+        Args:
+            index: Индекс строки в таблице.
+        """
+        loc = self.container_locator.locator(self.table_locator)
+        return self.events_table.get_row_locator(loc, index)
+
     def get_current_data_set_number(self) -> int:
         """Получение номера текущего набора данных"""
 
@@ -368,7 +377,7 @@ class EventsContainerComponent(BaseComponent):
     def should_be_toolbar(self) -> None:
         """Проверка наличия тулбара"""
 
-        loc = self.container_locator.locator(self.toolbar_locator)
+        loc = self.container_locator.locator(self.toolbar_locator).first
         self.toolbar.check_toolbar_presence_by_locator(loc, "Toolbar is missing")
 
     def should_be_pagination_buttons(self) -> None:

components_derived/container_actions_events.py

@@ -0,0 +1,140 @@
+"""Модуль контейнера для отображения событий вкладки Действия.
+
+Содержит класс для работы с контейнером для отображения событий
+вкладки Действия через Playwright.
+"""
+
+from playwright.sync_api import Page, Locator
+from tools.logger import get_logger
+from locators.event_panel_locators import EventPanelLocators
+from components.events_container_component import EventsContainerComponent
+from components_derived.modal_view_task import ViewTaskModalWindow
+
+logger = get_logger("ACTIONS_EVENTS_CONTAINER")
+
+
+class ActionsEventsContainer(EventsContainerComponent):
+    """Компонент контейнера для отображения событий вкладки Действия.
+
+    Предоставляет методы для взаимодействия с элементами
+    контейнера для отображения событий вкладки Действия.
+    """
+
+    def __init__(self, page: Page, locator: str | Locator):
+        """Инициализирует компонент контейнера для отображения событий вкладки Действия.
+
+        Args:
+            page: Экземпляр страницы Playwright.
+        """
+
+        super().__init__(page, locator)
+
+        toolbar_locator = self.get_locator(locator).locator(EventPanelLocators.TOOLBAR). \
+                          filter(has_text="Фильтр Реальное время Архив")
+
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.FILTER_TOOLBAR_BUTTON), "filter_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.REAL_TIME_TOOLBAR_BUTTON),
+                               "real_time_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.ARCHIVE_TOOLBAR_BUTTON), "archive_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.PDF_TOOLBAR_BUTTON), "export_to_pdf_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.CSV_TOOLBAR_BUTTON), "export_to_csv_button")
+
+        events_filter = self.get_events_filter()
+        events_filter.add_filtering_parameter("filter_status", "Статус")
+        events_filter.add_filtering_parameter("filter_task_name", "НАИМЕНОВАНИЕ ЗАДАЧИ")
+        events_filter.add_filtering_parameter("filter_object", "Объект")
+        events_filter.add_filtering_parameter("filter_user", "Пользователь")
+
+
+    # Действия:
+    def click_archive_button(self) -> None:
+        """Нажимает кнопку Архив на тулбаре."""
+
+        self.toolbar.check_button_visibility("archive_button")
+        self.click_tab_button("archive_button")
+
+    def click_real_time_button(self) -> None:
+        """Нажимает кнопку Реальное время на тулбаре."""
+
+        self.toolbar.check_button_visibility("real_time_button")
+        self.click_tab_button("real_time_button")
+
+    def click_events_table_row(self, index) -> ViewTaskModalWindow:
+        """Выбор и нажатие на строку таблицы по ее индексу."""
+
+        loc = self.get_events_table_row_locator(index)
+        loc.scroll_into_view_if_needed()
+        loc.click()
+
+        return ViewTaskModalWindow(self.page)
+
+    # Проверки:
+    def check_content(self) -> None:
+        """Проверяет содержимое контейнера для отображения событий вкладки Действия."""
+
+        expected_real_time_headers = ['ВРЕМЯ НАЧАЛА', 'ВРЕМЯ ЗАВЕРШЕНИЯ','СТАТУС',
+                            'НАИМЕНОВАНИЕ ЗАДАЧИ', 'ОБЪЕКТ', 'ПОЛЬЗОВАТЕЛЬ', 'ОПИСАНИЕ']
+
+        expected_archive_headers = ['ВРЕМЯ НАЧАЛА', 'ВРЕМЯ ЗАВЕРШЕНИЯ','СТАТУС',
+                            'НАИМЕНОВАНИЕ ЗАДАЧИ', 'ОБЪЕКТ', 'ПОЛЬЗОВАТЕЛЬ', 'ПРОЦЕССИНГ']
+
+        self.should_be_toolbar()
+        self.should_be_toolbar_buttons()
+
+        if not self.is_tab_active("real_time_button"):
+            self.click_tab_button("real_time_button")
+            self.wait_for_timeout(1000)
+
+        self.check_events_table_content(expected_real_time_headers)
+
+        if not self.is_tab_active("archive_button"):
+            self.click_tab_button("archive_button")
+            self.wait_for_timeout(1000)
+
+        self.check_events_table_content(expected_archive_headers)
+
+        events_filter = self.click_filter_button()
+        events_filter.check_content()
+
+        filter_status_bar =  events_filter.get_filtering_parameter("filter_status")
+        filter_status_title = filter_status_bar.get_selection_bar_title()
+        assert filter_status_title == "Статус", "Filtering parameter bar 'Статус' is missing"
+
+        filter_task_name_bar =  events_filter.get_filtering_parameter("filter_task_name")
+        filter_task_name_title = filter_task_name_bar.get_selection_bar_title()
+        assert filter_task_name_title == "НАИМЕНОВАНИЕ ЗАДАЧИ", \
+               "Filtering parameter bar 'НАИМЕНОВАНИЕ ЗАДАЧИ' is missing"
+
+        filter_object_bar =  events_filter.get_filtering_parameter("filter_object")
+        filter_object_title = filter_object_bar.get_selection_bar_title()
+        assert filter_object_title == "Объект", "Filtering parameter bar 'Объект' is missing"
+
+        filter_user_bar =  events_filter.get_filtering_parameter("filter_user")
+        filter_user_title = filter_user_bar.get_selection_bar_title()
+        assert filter_user_title == "Пользователь", "Filtering parameter bar 'Пользователь' is missing"
+
+    def check_events_table_content(self, expected_headers: list[str]) -> None:
+        """Проверка содержимого таблицы"""
+
+        self.should_be_events_table()
+        events_table = self.get_events_table_content()
+
+        if len(events_table) == 0:
+            assert False, "The contents of the events table are missing"
+
+        self.check_events_table_headers(events_table[0], expected_headers)
+
+        if len(events_table) == 1:
+            logger.info("Table body is missing")
+
+        self.should_be_pagination_buttons()
+
+
+    def should_be_toolbar_buttons(self) -> None:
+        """Проверяет наличие и видимость кнопок тулбара."""
+
+        self.toolbar.check_button_visibility("filter_button")
+        self.toolbar.check_button_visibility("real_time_button")
+        self.toolbar.check_button_visibility("archive_button")
+        self.toolbar.check_button_visibility("export_to_pdf_button")
+        self.toolbar.check_button_visibility("export_to_csv_button")

components_derived/container_audit_events.py

@@ -0,0 +1,96 @@
+"""Модуль контейнера для отображения событий аудита.
+
+Содержит класс для работы с контейнером для отображения событий
+аудита через Playwright.
+"""
+
+from playwright.sync_api import Page, Locator
+from tools.logger import get_logger
+from locators.event_panel_locators import EventPanelLocators
+from components.events_container_component import EventsContainerComponent
+
+logger = get_logger("AUDIT_EVENTS_CONTAINER")
+
+
+class AuditEventsContainer(EventsContainerComponent):
+    """Компонент контейнера для отображения событий аудита.
+
+    Предоставляет методы для взаимодействия с элементами
+    контейнера для отображения событий аудита.
+    """
+
+    def __init__(self, page: Page, locator: str | Locator):
+        """Инициализирует компонент контейнера для отображения событий аудита.
+
+        Args:
+            page: Экземпляр страницы Playwright.
+        """
+
+        super().__init__(page, locator)
+
+        toolbar_locator = self.get_locator(locator).locator(EventPanelLocators.TOOLBAR)
+
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.FILTER_TOOLBAR_BUTTON), "filter_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.EVENTS_TOOLBAR_BUTTON), "view_events_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.PDF_TOOLBAR_BUTTON), "export_to_pdf_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.CSV_TOOLBAR_BUTTON), "export_to_csv_button")
+
+        events_filter = self.get_events_filter()
+        events_filter.add_filtering_parameter("filter_type", "Тип")
+        events_filter.add_filtering_parameter("filter_role", "Роль")
+        events_filter.add_filtering_parameter("filter_name", "Имя")
+        events_filter.add_filtering_parameter("filter_ip", "ip")
+
+    # Действия:
+    # Проверки:
+    def check_content(self) -> None:
+        """Проверяет содержимое контейнера для отображения событий системного журнала."""
+
+        expected_headers = [ 'ВРЕМЯ', 'ОПИСАНИЕ', 'ИДЕНТИФИКАТОР']
+
+        self.should_be_toolbar()
+        self.should_be_toolbar_buttons()
+
+        if not self.is_tab_active("view_events_button"):
+            self.click_tab_button("view_events_button")
+            self.wait_for_timeout(1000)
+
+        self.should_be_events_table()
+        events_table = self.get_events_table_content()
+
+        if len(events_table) == 0:
+            assert False, "The contents of the events table are missing"
+
+        self.check_events_table_headers(events_table[0], expected_headers)
+
+        if len(events_table) == 1:
+            logger.info("Table body is missing")
+
+        self.should_be_pagination_buttons()
+
+        events_filter = self.click_filter_button()
+        events_filter.check_content()
+
+        filter_type_bar =  events_filter.get_filtering_parameter("filter_type")
+        filter_type_title = filter_type_bar.get_selection_bar_title()
+        assert filter_type_title == "Тип", "Filtering parameter bar 'Тип' is missing"
+
+        filter_role_bar =  events_filter.get_filtering_parameter("filter_role")
+        filter_role_title = filter_role_bar.get_selection_bar_title()
+        assert filter_role_title == "Роль", "Filtering parameter bar 'Роль' is missing"
+
+        filter_name_bar =  events_filter.get_filtering_parameter("filter_name")
+        filter_name_title = filter_name_bar.get_selection_bar_title()
+        assert filter_name_title == "Имя", "Filtering parameter bar 'Имя' is missing"
+
+        filter_ip_bar =  events_filter.get_filtering_parameter("filter_ip")
+        filter_ip_title = filter_ip_bar.get_selection_bar_title()
+        assert filter_ip_title == "ip", "Filtering parameter bar 'ip' is missing"
+
+    def should_be_toolbar_buttons(self) -> None:
+        """Проверяет наличие и видимость кнопок тулбара."""
+
+        self.toolbar.check_button_visibility("filter_button")
+        self.toolbar.check_button_visibility("view_events_button")
+        self.toolbar.check_button_visibility("export_to_pdf_button")
+        self.toolbar.check_button_visibility("export_to_csv_button")

components_derived/container_events.py

@@ -0,0 +1,91 @@
+"""Модуль контейнера для отображения событий вкладки События панели событий.
+
+Содержит класс для работы с контейнером для отображения событий
+вкладки События панели событий через Playwright.
+"""
+
+from playwright.sync_api import Page, Locator
+from tools.logger import get_logger
+from locators.event_panel_locators import EventPanelLocators
+from components.events_container_component import EventsContainerComponent
+
+logger = get_logger("EVENTS_TAB_CONTAINER")
+
+
+class EventsTabContainer(EventsContainerComponent):
+    """Компонент контейнера для отображения событий вкладки События панели событий.
+
+    Предоставляет методы для взаимодействия с элементами
+    контейнера для отображения событий вкладки События панели событий.
+    """
+
+    def __init__(self, page: Page, locator: str | Locator):
+        """Инициализирует компонент контейнера для отображения событий вкладки События панели событий.
+
+        Args:
+            page: Экземпляр страницы Playwright.
+        """
+
+        super().__init__(page, locator)
+
+        toolbar_locator = self.get_locator(locator).locator(EventPanelLocators.TOOLBAR)
+
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.FILTER_TOOLBAR_BUTTON), "filter_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.EVENTS_TOOLBAR_BUTTON), "view_events_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.PDF_TOOLBAR_BUTTON), "export_to_pdf_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.CSV_TOOLBAR_BUTTON), "export_to_csv_button")
+
+        events_filter = self.get_events_filter()
+        events_filter.add_filtering_parameter("filter_type", "Тип")
+        events_filter.add_filtering_parameter("filter_strictness", "Критичность")
+        events_filter.add_filtering_parameter("filter_object", "Объект")
+
+    # Действия:
+    # Проверки:
+    def check_content(self) -> None:
+        """Проверяет содержимое контейнера для отображения событий системного журнала."""
+
+        expected_headers = [ 'ВРЕМЯ', 'ТИП', 'КРИТИЧНОСТЬ', 'ОБЪЕКТ', 'ОПИСАНИЕ']
+
+        self.should_be_toolbar()
+        self.should_be_toolbar_buttons()
+
+        if not self.is_tab_active("view_events_button"):
+            self.click_tab_button("view_events_button")
+            self.wait_for_timeout(1000)
+
+        self.should_be_events_table()
+        events_table = self.get_events_table_content()
+
+        if len(events_table) == 0:
+            assert False, "The contents of the events table are missing"
+
+        self.check_events_table_headers(events_table[0], expected_headers)
+
+        if len(events_table) == 1:
+            logger.info("Table body is missing")
+
+        self.should_be_pagination_buttons()
+
+        events_filter = self.click_filter_button()
+        events_filter.check_content()
+
+        filter_type_bar =  events_filter.get_filtering_parameter("filter_type")
+        filter_type_title = filter_type_bar.get_selection_bar_title()
+        assert filter_type_title == "Тип", "Filtering parameter bar 'Тип' is missing"
+
+        filter_strictness_bar =  events_filter.get_filtering_parameter("filter_strictness")
+        filter_strictness_title = filter_strictness_bar.get_selection_bar_title()
+        assert filter_strictness_title == "Критичность", "Filtering parameter bar 'Критичность' is missing"
+
+        filter_object_bar =  events_filter.get_filtering_parameter("filter_object")
+        filter_object_title = filter_object_bar.get_selection_bar_title()
+        assert filter_object_title == "Объект", "Filtering parameter bar 'Объект' is missing"
+
+    def should_be_toolbar_buttons(self) -> None:
+        """Проверяет наличие и видимость кнопок тулбара."""
+
+        self.toolbar.check_button_visibility("filter_button")
+        self.toolbar.check_button_visibility("view_events_button")
+        self.toolbar.check_button_visibility("export_to_pdf_button")
+        self.toolbar.check_button_visibility("export_to_csv_button")

components_derived/container_maintenance_events.py

@@ -0,0 +1,114 @@
+"""Модуль контейнера для отображения событий обслуживания.
+
+Содержит класс для работы с контейнером для отображения событий
+обслуживания через Playwright.
+"""
+
+from playwright.sync_api import Page, Locator
+from tools.logger import get_logger
+from locators.event_panel_locators import EventPanelLocators
+from components.events_container_component import EventsContainerComponent
+
+logger = get_logger("MAINTENANCE_EVENTS_CONTAINER")
+
+
+class MaintenanceEventsContainer(EventsContainerComponent):
+    """Компонент контейнера для отображения событий обслуживания.
+
+    Предоставляет методы для взаимодействия с элементами
+    контейнера для отображения событий системного журнала.
+    """
+
+    def __init__(self, page: Page, locator: str | Locator):
+        """Инициализирует компонент контейнера для отображения событий обслуживания.
+
+        Args:
+            page: Экземпляр страницы Playwright.
+        """
+
+        super().__init__(page, locator)
+
+        toolbar_locator = self.get_locator(locator).locator(EventPanelLocators.TOOLBAR)
+
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.FILTER_TOOLBAR_BUTTON), "filter_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.MAINTENANCE_TOOLBAR_BUTTON),
+                                "maintenance_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.PDF_TOOLBAR_BUTTON), "export_to_pdf_button")
+        self.add_tab_to_toolbar(toolbar_locator.locator(EventPanelLocators.CSV_TOOLBAR_BUTTON), "export_to_csv_button")
+
+        events_filter = self.get_events_filter()
+        events_filter.add_filtering_parameter("filter_date", "Дата")
+        events_filter.add_filtering_parameter("filter_event_name", "Наименование события")
+        events_filter.add_filtering_parameter("filter_type", "Тип")
+        events_filter.add_filtering_parameter("filter_status", "Состояние")
+        events_filter.add_filtering_parameter("filter_object", "Объект")
+        events_filter.add_filtering_parameter("filter_author", "Автор")
+        events_filter.add_filtering_parameter("filter_location", "Расположение")
+
+    # Действия:
+    # Проверки:
+    def check_content(self) -> None:
+        """Проверяет содержимое контейнера для отображения событий обслуживания."""
+
+        expected_headers = ['ДАТА', 'НАИМЕНОВАНИЕ СОБЫТИЯ' ,'ТИП',
+                            'СОСТОЯНИЕ', 'ОБЪЕКТ', 'АВТОР', 'РАСПОЛОЖЕНИЕ']
+
+        self.should_be_toolbar()
+        self.should_be_toolbar_buttons()
+
+        if not self.is_tab_active("maintenance_button"):
+            self.click_tab_button("maintenance_button")
+            self.wait_for_timeout(1000)
+
+        self.should_be_events_table()
+        events_table = self.get_events_table_content()
+
+        if len(events_table) == 0:
+            assert False, "The contents of the events table are missing"
+
+        self.check_events_table_headers(events_table[0], expected_headers)
+
+        if len(events_table) == 1:
+            logger.info("Table body is missing")
+
+        self.should_be_pagination_buttons()
+
+        events_filter = self.click_filter_button()
+        events_filter.check_content()
+
+        filter_date_bar =  events_filter.get_filtering_parameter("filter_date")
+        filter_date_title = filter_date_bar.get_selection_bar_title()
+        assert filter_date_title == "Дата", "Filtering parameter bar 'Дата' is missing"
+
+        filter_event_name_bar =  events_filter.get_filtering_parameter("filter_event_name")
+        filter_event_name_title = filter_event_name_bar.get_selection_bar_title()
+        assert filter_event_name_title == "Наименование события", \
+               "Filtering parameter bar 'Наименование события' is missing"
+
+        filter_type_bar =  events_filter.get_filtering_parameter("filter_type")
+        filter_type_title = filter_type_bar.get_selection_bar_title()
+        assert filter_type_title == "Тип", "Filtering parameter bar 'Тип' is missing"
+
+        filter_status_bar =  events_filter.get_filtering_parameter("filter_status")
+        filter_status_title = filter_status_bar.get_selection_bar_title()
+        assert filter_status_title == "Состояние", "Filtering parameter bar 'Состояние' is missing"
+
+        filter_object_bar =  events_filter.get_filtering_parameter("filter_object")
+        filter_object_title = filter_object_bar.get_selection_bar_title()
+        assert filter_object_title == "Объект", "Filtering parameter bar 'Объект' is missing"
+
+        filter_author_bar =  events_filter.get_filtering_parameter("filter_author")
+        filter_author_title = filter_author_bar.get_selection_bar_title()
+        assert filter_author_title == "Автор", "Filtering parameter bar 'Автор' is missing"
+
+        filter_location_bar =  events_filter.get_filtering_parameter("filter_location")
+        filter_location_title = filter_location_bar.get_selection_bar_title()
+        assert filter_location_title == "Расположение", "Filtering parameter bar 'Расположение' is missing"
+
+    def should_be_toolbar_buttons(self) -> None:
+        """Проверяет наличие и видимость кнопок тулбара."""
+
+        self.toolbar.check_button_visibility("filter_button")
+        self.toolbar.check_button_visibility("maintenance_button")
+        self.toolbar.check_button_visibility("export_to_pdf_button")
+        self.toolbar.check_button_visibility("export_to_csv_button")

components_derived/container_system_log_events.py

@@ -45,7 +45,7 @@ class SystemLogEventsContainer(EventsContainerComponent):
     def check_content(self) -> None:
         """Проверяет содержимое контейнера для отображения событий системного журнала."""
 
-        expected_headers = ['ТИП', 'ВРЕМЯ', 'КРИТИЧНОСТЬ', 'ОБЪЕКТ', 'ОПИСАНИЕ']
+        expected_headers = ['ВРЕМЯ', 'ТИП','КРИТИЧНОСТЬ', 'ОБЪЕКТ', 'ОПИСАНИЕ']
 
         self.should_be_toolbar()
         self.should_be_toolbar_buttons()
@@ -63,7 +63,7 @@ class SystemLogEventsContainer(EventsContainerComponent):
         self.check_events_table_headers(events_table[0], expected_headers)
 
         if len(events_table) == 1:
-            assert False, "Table body is missing"
+            logger.info("Table body is missing")
 
         self.should_be_pagination_buttons()
 

components_derived/date_input_component.py

@@ -5,9 +5,8 @@
 
 from playwright.sync_api import Page, Locator, expect
 from tools.logger import get_logger
-# from elements.text_element import Text
 from elements.text_input_element import TextInput
-from elements.button_element import Button
+from elements.tooltip_button_element import TooltipButton
 from components.date_picker_component import DatePickerComponent
 from components.base_component import BaseComponent
 
@@ -32,7 +31,7 @@ class DateInput(BaseComponent):
 
         self.date_input_locator = self.get_locator(locator)
 
-        self.switch_mode_button = Button(page,
+        self.switch_mode_button = TooltipButton(page,
                                    self.date_input_locator.get_by_role("button"),
                                    "switch_mode_button")
 
@@ -88,11 +87,15 @@ class DateInput(BaseComponent):
         except ValueError:
             assert False, f"Incorrect year value {year} for selection"
 
-        if self.is_text_input_mode():
+        # Temporarily due to error in UI
+        if not self.is_text_input_mode():
+        # if self.is_text_input_mode():
+            # print("by keyboard")
             self.date_input_field.check_editable_input("Text field for date input should be editable")
             self.date_input_field.clear()
             self.date_input_field.input_value(date)
         else:
+            # print("by date picker")
             self.date_picker.select_year_and_month(year, month)
             self.date_picker.select_day(day)
 
@@ -123,8 +126,9 @@ class DateInput(BaseComponent):
 
         self.check_switch_mode_button_visibility()
 
-        label_locator = self.date_input_locator.get_by_label(label)
+        # Temporarily: due to error in UI
-        expect(label_locator).to_be_visible()
+        # label_locator = self.date_input_locator.get_by_label(label)
+        # expect(label_locator).to_be_visible()
 
         self.date_input_field.check_visibility("Text field for date input is missing")
         self.date_input_field.check_empty_input("Text field for date input should be empty")
@@ -135,11 +139,14 @@ class DateInput(BaseComponent):
         self.page.wait_for_timeout(300)
 
         self.date_picker.check_content()
+        self.check_switch_mode_button_tooltip()
 
         self.click_switch_mode_button()
+        self.check_switch_mode_button_tooltip()
+
         self.click_switch_mode_button()
 
-        self.page.wait_for_timeout(300)
+        self.page.wait_for_timeout(1000)
         self.input_date("11.11.2011")
 
         label_locator = self.date_input_locator.get_by_label("Время")
@@ -154,6 +161,20 @@ class DateInput(BaseComponent):
 
         self.switch_mode_button.check_visibility("Switch Mode Button is missing")
 
+    def check_switch_mode_button_tooltip(self) -> None:
+        """ Проверка tooltip кнопки переключения режимов ввода."""
+
+        text_mode = self.is_text_input_mode()
+
+        tooltip_text = self.switch_mode_button.get_tooltip_text()
+
+        if text_mode:
+            assert tooltip_text == "Ручной ввод", \
+                "Should be 'Ручной ввод' tooltip for switch mode button"
+        else:
+            assert tooltip_text == "Выбрать в календаре", \
+                "Should be 'Выбрать в календаре' tooltip for switch mode button"
+
     def is_text_input_mode(self) -> bool:
         """ Проверка текстового режима ввода."""
 

components_derived/events_filter_panel.py

@@ -26,9 +26,11 @@ class EventsFilterPanel(BaseComponent):
         self.events_filter_locator = self.page.locator("div.menuable__content__active div.scrollarea__body")
 
         # Поля ввода даты начала и даты окончания события
-        loc = self.page.locator("div.menuable__content__active div.scrollarea__body").locator("//div/div").nth(0)
+        loc = self.page. \
+              locator("div.menuable__content__active div.scrollarea__body > div:nth-child(1) > div:nth-child(1)")
         self.start_time_filter = DateInput(page, loc)
-        loc = self.page.locator("div.menuable__content__active div.scrollarea__body > div > div:nth-child(3)")
+        loc = self.page. \
+              locator("div.menuable__content__active div.scrollarea__body > div:nth-child(1) > div:nth-child(3)")
         self.finish_time_filter = DateInput(page, loc)
 
         # Поля задания параметров фильтрации (произвольное количество)

components_derived/modal_view_task.py

@@ -0,0 +1,76 @@
+"""Модуль modal_view_task содержит класс для работы с модальным окном отображения задачи вкладки
+Действия панели событий.
+
+Класс ViewTaskModalWindow наследует базовый функционал ModalWindowComponent
+и реализует методы просмотра модального окна отображения задачи.
+"""
+
+from playwright.sync_api import Page
+from tools.logger import get_logger
+from locators.modal_window_locators import ModalWindowLocators
+from components.table_component import TableComponent
+from components.modal_window_component import ModalWindowComponent
+
+logger = get_logger("VIEW_TASK_MODAL_WINDOW")
+
+
+class ViewTaskModalWindow(ModalWindowComponent):
+    """Модальное окно отображения отображения задачи.
+
+    Наследует ModalWindowComponent и добавляет функционал для:
+    1. Инициализации модального окна
+    2. Закрытия модального окна через тулбар
+    3. Проверки содержимого модального окна
+    """
+
+    def __init__(self, page: Page):
+        """Инициализирует элементы формы модального окна отображения задачи."""
+        super().__init__(page)
+
+        self.window_title_locator = page.locator(ModalWindowLocators.TASK_MODAL_WINDOW). \
+                                    locator("//div[@class='v-toolbar__title']")
+
+        # Настройка кнопки закрытия
+        button_close_locator = page.locator(ModalWindowLocators.TASK_MODAL_WINDOW).get_by_role("button")
+        self.add_toolbar_button(button_close_locator, "close")
+
+        self.task_stages_table_locator = page.locator(ModalWindowLocators.TASK_MODAL_WINDOW). \
+                                         locator("//div[@class='scrolltable']/div/table")
+        self.task_stages_table = TableComponent(page)
+
+    # Действия:
+    def close(self):
+        """Закрывает окно кнопкой на тулбаре."""
+
+        self.click_toolbar_close_button()
+
+    def get_stages_table_content(self) -> list[list[str]]:
+        """Возвращает содержимое таблицы, включая заголовки.
+
+        Returns:
+            Двумерный список с содержимым таблицы.
+        """
+
+        return self.task_stages_table.read(self.task_stages_table_locator)
+
+    def get_window_title(self) -> str:
+        """Возвращает заголовок окна"""
+
+        return self.toolbar.get_toolbar_title_text(self.window_title_locator)
+
+    # Проверки:
+    def check_content(self) -> None:
+        """Проверяет наличие элементов окна.
+        """
+
+        self.toolbar.check_toolbar_presence_by_locator(self.page.locator(ModalWindowLocators.TASK_MODAL_WINDOW). \
+                                    locator("//nav"), "Toolbar is missing")
+        self.check_toolbar_button_visibility("close")
+        self.check_toolbar_button_tooltip("close", "Закрыть")
+
+        self.task_stages_table.check_visibility(self.task_stages_table_locator, "Task stages table is missing")
+
+    def check_stages_table_headers(self, actual_headers, expected_headers) -> None:
+        """ Проверка соответствия заголовка таблицы ожидаемому"""
+
+        self.task_stages_table.check_table_headers(actual_headers, expected_headers)

locators/event_panel_locators.py

@@ -33,6 +33,7 @@ class EventPanelLocators:
     TAB_MAINTENANCE = "//div[@data-testid='BASELINE__service_tab__toolbar']"
     TAB_SYSTEM_LOG = "//div[@data-testid='BASELINE__system journal_tab__toolbar']"
     TAB_AUDIT = "//div[@data-testid='BASELINE__audit_tab__toolbar']"
+    TAB_INFORMATION_SECURITY = "//div[@data-testid='BASELINE__information security_tab__toolbar']"
 
     BUTTONS_EVENT = "//nav/div[@class='v-toolbar__content']/div[@class='v-toolbar__items'][2]//span[contains(@class, 'v-tooltip')]"
 
@@ -43,7 +44,15 @@ class EventPanelLocators:
 
     FILTER_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='Фильтр']"
     EVENTS_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='События']"
+    MAINTENANCE_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='Обслуживание']"
+    REAL_TIME_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='Реальное время']"
+    ARCHIVE_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='Архив']"
     PDF_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='pdf']"
     CSV_TOOLBAR_BUTTON = "//div[contains(@class, 'journal-tab-button')]//span[text()='csv']"
 
+    CONTAINER_ACTIONS_TAB = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(2)"
+    CONTAINER_EVENTS_TAB = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(3)"
+    CONTAINER_MAINTENANCE_EVENTS = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(4)"
     CONTAINER_SYSTEM_LOG_EVENTS = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(5)"
+    CONTAINER_AUDIT_EVENTS = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(6)"
+    CONTAINER_INFORMATION_SECURITY = "#app > div.application--wrap > div > div:nth-child(3) > div:nth-child(6)"

locators/modal_window_locators.py

@@ -30,3 +30,4 @@ class ModalWindowLocators:
     MENU_ACTIVE_ITEMS = "//div[@role='list']//div[@role='listitem']"
     LABEL_INPUT_FORM_USER_DATA = "//label[contains(@class,'v-label')]/span"
 
+    TASK_MODAL_WINDOW =  "//div[@data-testid='BASELINE__dialog-drag__modal_0']"

pages/main_page.py

@@ -6,6 +6,10 @@
 
 from playwright.sync_api import Page
 from locators.navigation_panel_locators import NavigationPanelLocators
+from components_derived.container_actions_events import ActionsEventsContainer
+from components_derived.container_audit_events import AuditEventsContainer
+from components_derived.container_events import EventsTabContainer
+from components_derived.container_maintenance_events import MaintenanceEventsContainer
 from components_derived.container_system_log_events import SystemLogEventsContainer
 from components_derived.user_card import UserCard
 from components.eventbar_component import EventPanelComponent
@@ -45,6 +49,26 @@ class MainPage(BasePage):
 
         self.event_panel.click_expand_more_button()
 
+    def click_events_panel_actions_tab(self) -> ActionsEventsContainer:
+        """Выполняет нажатие tab-кнопки Действия."""
+
+        return self.event_panel.click_actions_tab()
+
+    def click_events_panel_audit_tab(self) -> AuditEventsContainer:
+        """Выполняет нажатие tab-кнопки Аудит."""
+
+        return self.event_panel.click_audit_tab()
+
+    def click_events_panel_events_tab(self) -> EventsTabContainer:
+        """Выполняет нажатие tab-кнопки События."""
+
+        return self.event_panel.click_events_tab()
+
+    def click_events_panel_maintenance_tab(self) -> MaintenanceEventsContainer:
+        """Выполняет нажатие tab-кнопки Обслуживание."""
+
+        return self.event_panel.click_maintenance_tab()
+
     def click_events_panel_system_log_tab(self) -> SystemLogEventsContainer:
         """Выполняет нажатие tab-кнопки Системный журнал."""
 

tests/e2e/event_panel/test_actions_events_container.py

@@ -0,0 +1,388 @@
+"""Модуль тестов контейнера для отображения событий вкладки Действия.
+
+Содержит тесты для проверки функциональности
+контейнера для отображения событий вкладки Действия.
+"""
+
+# import pytest
+from playwright.sync_api import Page
+from pages.main_page import MainPage
+from pages.login_page import LoginPage
+
+
+# @pytest.mark.smoke
+class TestActionsEventsContainer:
+    """Класс тестов для проверки контейнера для отображения событий вкладки Действия.
+
+    Атрибуты:
+        browser: Фикстура для работы с браузером.
+    """
+    # @pytest.mark.develop
+    def test_actions_events_tab_content(self, browser: Page) -> None:
+        """Проверяет содержимое контейнера для отображения событий вкладки Действия.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        actions_events_container = mp.click_events_panel_actions_tab()
+        actions_events_container.check_content()
+
+    def test_events_tables_row_highlighting(self, browser: Page):
+        """Проверяет выделение строк в таблицах событий: Реальное время и Архив.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        actions_events_container = mp.click_events_panel_actions_tab()
+
+        actions_events_container.click_real_time_button()
+        # Получение количества строк в таблице Реальное время
+        rows_count = actions_events_container.get_events_table_rows_count()
+
+        # Проверка выделения строк
+        actions_events_container.check_events_table_row_highlighting(0)
+        actions_events_container.check_events_table_row_highlighting(rows_count - 1)
+        actions_events_container.check_events_table_row_highlighting(int(rows_count / 2))
+
+        actions_events_container.click_archive_button()
+        # Получение количества строк в таблице Архив
+        rows_count = actions_events_container.get_events_table_rows_count()
+
+        # Проверка выделения строк
+        actions_events_container.check_events_table_row_highlighting(0)
+        actions_events_container.check_events_table_row_highlighting(rows_count - 1)
+        actions_events_container.check_events_table_row_highlighting(int(rows_count / 2))
+
+    # @pytest.mark.develop
+    def test_events_table_scrolling(self, browser: Page):
+        """Проверяет возможность скроллинга таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        actions_events_container = mp.click_events_panel_actions_tab()
+
+        events_panel_position = mp.get_events_panel_position()
+
+        # Проверка, что панель с таблицей открыта
+        assert events_panel_position != "bottom", "Panel with system log events should be opened"
+
+        is_scrollable = actions_events_container.check_events_table_verticall_scrolling()
+
+        # Убеждаемся, что панель открыта наполовину и проверяем скроллинг
+        assert events_panel_position == "center",\
+               "Panel with system log events should be located on the main page center"
+        assert is_scrollable, "System log events table should be scrollable"
+
+        # Скроллинг вниз
+        actions_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        actions_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        actions_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        actions_events_container.check_events_table_first_row_visibility()
+
+        # Раскрываем панель полностью и проверяем скроллинг
+        assert mp.check_expand_more_button(), \
+                "Expand more button should be present"
+        mp.click_events_panel_expand_more_button()
+        mp.wait_for_timeout(500)
+
+        events_panel_position = mp.get_events_panel_position()
+        assert events_panel_position == "top",\
+               "Panel with system log events should be located on the main page top"
+
+        is_scrollable = actions_events_container.check_events_table_verticall_scrolling()
+        assert is_scrollable, "System log events table should be scrollable in the full window"
+
+        # Скроллинг вниз
+        actions_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        actions_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        actions_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        actions_events_container.check_events_table_first_row_visibility()
+
+    # @pytest.mark.develop
+    def test_real_time_task_view(self, browser: Page):
+        """Проверяет содержимое окна вывода информации о задаче.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        index = 0
+        expected_task_headers = ['СООБЩЕНИЕ','СТАТУС', 'ОПИСАНИЕ']
+        expected_task_stages = []
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        actions_events_container = mp.click_events_panel_actions_tab()
+
+        actions_events_container.click_real_time_button()
+        task_view_window = actions_events_container.click_events_table_row(index)
+
+        task_view_window.check_content()
+
+        title, task_id = task_view_window.get_window_title().split(" ")
+        assert title == "Task", "Window title should start with the word 'Task'"
+
+        stages_table_content = task_view_window.get_stages_table_content()
+
+        task_view_window.check_stages_table_headers(stages_table_content[0], expected_task_headers)
+        stages_table_content.pop(0)
+
+        payload = {"filter": {"page": 1},
+                   "count": 40}
+
+        response = mp.send_post_api_request("e-nms/task_manager/showTaskWithFilter", payload)
+        if response.status == 200:
+            response_body = mp.get_response_body(response)
+
+            if response_body:
+                for item in response_body["data"]["data"]:
+                    if item["id"] == task_id:
+                        for stage in item["progress"]:
+                            expected_task_stages.append(stage)
+                        break
+
+        assert len(expected_task_stages) > 0, f"No expected task stages found for task with id {task_id}"
+
+        assert len (expected_task_stages) == len(stages_table_content), "Incorrect actual task stages list"
+        for i in range(len(expected_task_stages)):
+            expected_message = expected_task_stages[i]["message"]
+            actual_message = stages_table_content[i][0]
+            assert expected_message == actual_message, \
+                  f"Expected message {expected_message} is not equal actual message {actual_message} for {i} row"
+
+            expected_status = expected_task_stages[i]["status"]
+            if expected_status == "ok":
+                expected_status = "Норма"
+            actual_status = stages_table_content[i][1]
+            assert expected_status == actual_status, \
+                  f"Expected message {expected_status} is not equal actual message {actual_status} for {i} row"
+
+        task_view_window.close()
+
+    #  TO-DO: Вернуть тесты после прояснения как должна отображаться информация в таблицах Реальное время и Архив
+
+    # def test_events_table_column_sorting(self, browser: Page):
+    #     """Проверяет сортировку колонки 'Время' в таблице событий.
+
+    #     Args:
+    #         browser: Экземпляр страницы Playwright.
+    #     """
+
+    #     lp = LoginPage(browser)
+    #     lp.do_login()
+
+    #     mp = MainPage(browser)
+    #     mp.should_be_event_panel()
+
+    #     actions_events_container = mp.click_events_panel_actions_tab()
+
+    #     index = 0
+    #     state = actions_events_container.get_arrow_button_state(index)
+    #     assert state == "down", "Arrow button should be down"
+
+    #     actions_events_container.click_event_table_header_arrow(index)
+    #     browser.wait_for_timeout(500)
+
+    #     state = actions_events_container.get_arrow_button_state(index)
+    #     assert state == "up", "Arrow button should be up"
+    #     is_descending_order = actions_events_container.check_events_table_column_descending_order(index,
+    #                                                                                             convert2timestamp=True)
+    #     assert not is_descending_order, "Column data should be in ascending order"
+
+    #     actions_events_container.click_event_table_header_arrow(index)
+    #     browser.wait_for_timeout(500)
+    #     state = actions_events_container.get_arrow_button_state(index)
+    #     assert state == "down", "Arrow button should be down"
+    #     is_descending_order = actions_events_container.check_events_table_column_descending_order(index,
+    #                                                                                             convert2timestamp=True)
+    #     assert is_descending_order, "Column data should be in descending order"
+
+    # def test_events_table_pagination(self, browser: Page):
+    #     """Проверяет возможность пагинации таблицы событий.
+
+    #     Args:
+    #         browser: Экземпляр страницы Playwright.
+    #     """
+
+    #     lp = LoginPage(browser)
+    #     lp.do_login()
+
+    #     mp = MainPage(browser)
+    #     mp.should_be_event_panel()
+
+    #     actions_events_container = mp.click_events_panel_actions_tab()
+
+    #     audit_events_container.should_be_pagination_buttons()
+
+    #     # Проверка начального состояния
+    #     tested_pages = 1
+
+    #     # to do: некорректный запрос в бэк, должно быть "filter": {"page": 0}
+    #     payload = {"table": "default",
+    #                "filter": {
+    #                    "tags": [
+    #                        "testaudit",
+    #                        "type:action"
+    #                    ],
+    #                    "page": 1
+    #                },
+    #                "count": 40
+    #                }
+    #     response = mp.send_post_api_request("e-nms/logs_enode", payload)
+    #     if response.status == 200:
+    #         response_body = mp.get_response_body(response)
+
+    #         if response_body:
+    #             pages = response_body["data"]["pages"]
+
+    #             if pages > 5:
+    #                 tested_pages = 5
+    #             else:
+    #                 tested_pages = pages
+
+    #     current_number = audit_events_container.get_current_data_set_number()
+    #     assert current_number == 1, "The first page should be number one"
+
+    #     if tested_pages == 1:
+    #         audit_events_container.should_be_all_disabled()
+    #     else:
+    #         audit_events_container.should_be_initial_state()
+
+    #         # Переход на самую последнюю страницу, возврат на страницу назад, потом на страницу вперед
+    #         audit_events_container.click_last_page()
+    #         browser.wait_for_timeout(2000)
+
+    #         audit_events_container.should_be_final_state()
+
+    #         last_number = audit_events_container.get_current_data_set_number()
+
+    #         audit_events_container.click_chevron_left()
+    #         browser.wait_for_timeout(4000)
+
+    #         if last_number == 2:
+    #             audit_events_container.should_be_initial_state()
+    #         else:
+    #             audit_events_container.should_be_all_enabled()
+
+    #         counter = last_number - 1
+    #         current_number = audit_events_container.get_current_data_set_number()
+    #         assert current_number == counter, f"Expected page number {counter} is not equal actual {current_number}"
+
+    #         audit_events_container.click_chevron_right()
+    #         browser.wait_for_timeout(4000)
+
+    #         audit_events_container.should_be_final_state()
+
+    #         current_number = audit_events_container.get_current_data_set_number()
+    #         assert current_number == last_number, \
+    #                f"Expected page number {last_number} is not equal actual {current_number}"
+
+    #         # Переход на первую страницу, переход на следующую страницу, возврат на первую страницу
+    #         audit_events_container.click_first_page()
+    #         browser.wait_for_timeout(2000)
+
+    #         audit_events_container.should_be_initial_state()
+
+    #         current_number = audit_events_container.get_current_data_set_number()
+    #         assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+    #         audit_events_container.click_chevron_right()
+    #         browser.wait_for_timeout(4000)
+
+    #         if tested_pages == 2:
+    #             audit_events_container.should_be_final_state()
+    #         else:
+    #             audit_events_container.should_be_all_enabled()
+
+    #         current_number = audit_events_container.get_current_data_set_number()
+    #         assert current_number == 2, f"Expected page number 2 is not equal actual {current_number}"
+
+    #         audit_events_container.click_chevron_left()
+    #         browser.wait_for_timeout(4000)
+
+    #         audit_events_container.should_be_initial_state()
+
+    #         current_number = audit_events_container.get_current_data_set_number()
+    #         assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+    #         if tested_pages > 2:
+    #             # загрузка страниц от начала и до конца
+    #             # to_do: проверка, что происходит обновление содержимого таблицы
+    #             counter = 1
+
+    #             while counter < tested_pages:
+    #                 audit_events_container.click_chevron_right()
+    #                 counter += 1
+    #                 browser.wait_for_timeout(2000)
+
+    #                 if counter == tested_pages:
+    #                     audit_events_container.should_be_final_state()
+    #                 else:
+    #                     audit_events_container.should_be_all_enabled()
+    #                 current_number = audit_events_container.get_current_data_set_number()
+    #                 assert current_number == counter,\
+    #                     f"Expected page number {counter} is not equal actual {current_number}"
+
+    #             # загрузка страниц от конца к началу
+    #             # to_do: проверка, что происходит обновление содержимого таблицы
+    #             while counter > 2:
+    #                 audit_events_container.click_chevron_left()
+    #                 browser.wait_for_timeout(2000)
+
+    #                 audit_events_container.should_be_all_enabled()
+
+    #                 counter -= 1
+    #                 current_number = audit_events_container.get_current_data_set_number()
+    #                 assert current_number == counter,\
+    #                     f"Expected page number {counter} is not equal actual {current_number}"
+
+    #             # Проверка возврата к начальному состоянию
+    #             audit_events_container.click_chevron_left()
+    #             browser.wait_for_timeout(2000)
+
+    #             audit_events_container.should_be_initial_state()
+
+    #             current_number = audit_events_container.get_current_data_set_number()
+    #             assert current_number == 1, "The first page should be number one"

tests/e2e/event_panel/test_audit_events_container.py

@@ -0,0 +1,310 @@
+"""Модуль тестов контейнера для отображения событий аудита.
+
+Содержит тесты для проверки функциональности
+контейнера для отображения событий аудита.
+"""
+
+# import pytest
+from playwright.sync_api import Page
+from pages.main_page import MainPage
+from pages.login_page import LoginPage
+
+
+# @pytest.mark.smoke
+class TestAuditEventsContainer:
+    """Класс тестов для проверки контейнера для отображения событий аудита.
+
+    Атрибуты:
+        browser: Фикстура для работы с браузером.
+    """
+    # @pytest.mark.develop
+    def test_events_tab_content(self, browser: Page) -> None:
+        """Проверяет содержимое контейнера для отображения событий аудита.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        audit_events_container = mp.click_events_panel_audit_tab()
+        audit_events_container.check_content()
+
+    def test_events_table_row_highlighting(self, browser: Page):
+        """Проверяет выделение строк в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        audit_events_container = mp.click_events_panel_audit_tab()
+
+        # Получение количества строк в таблице
+        rows_count = audit_events_container.get_events_table_rows_count()
+
+        # Проверка выделения строк
+        audit_events_container.check_events_table_row_highlighting(0)
+        audit_events_container.check_events_table_row_highlighting(rows_count - 1)
+        audit_events_container.check_events_table_row_highlighting(int(rows_count / 2))
+
+    def test_events_table_scrolling(self, browser: Page):
+        """Проверяет возможность скроллинга таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        audit_events_container = mp.click_events_panel_audit_tab()
+
+        events_panel_position = mp.get_events_panel_position()
+
+        # Проверка, что панель с таблицей открыта
+        assert events_panel_position != "bottom", "Panel with system log events should be opened"
+
+        is_scrollable = audit_events_container.check_events_table_verticall_scrolling()
+
+        # Убеждаемся, что панель открыта наполовину и проверяем скроллинг
+        assert events_panel_position == "center",\
+               "Panel with system log events should be located on the main page center"
+        assert is_scrollable, "System log events table should be scrollable"
+
+        # Скроллинг вниз
+        audit_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        audit_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        audit_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        audit_events_container.check_events_table_first_row_visibility()
+
+        # Раскрываем панель полностью и проверяем скроллинг
+        assert mp.check_expand_more_button(), \
+                "Expand more button should be present"
+        mp.click_events_panel_expand_more_button()
+        mp.wait_for_timeout(500)
+
+        events_panel_position = mp.get_events_panel_position()
+        assert events_panel_position == "top",\
+               "Panel with system log events should be located on the main page top"
+
+        is_scrollable = audit_events_container.check_events_table_verticall_scrolling()
+        assert is_scrollable, "System log events table should be scrollable in the full window"
+
+        # Скроллинг вниз
+        audit_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        audit_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        audit_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        audit_events_container.check_events_table_first_row_visibility()
+
+    def test_events_table_column_sorting(self, browser: Page):
+        """Проверяет сортировку колонки 'Время' в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        audit_events_container = mp.click_events_panel_audit_tab()
+
+        index = 0
+        state = audit_events_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+
+        audit_events_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+
+        state = audit_events_container.get_arrow_button_state(index)
+        assert state == "up", "Arrow button should be up"
+        is_descending_order = audit_events_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert not is_descending_order, "Column data should be in ascending order"
+
+        audit_events_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+        state = audit_events_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+        is_descending_order = audit_events_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert is_descending_order, "Column data should be in descending order"
+
+    def test_events_table_pagination(self, browser: Page):
+        """Проверяет возможность пагинации таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        audit_events_container = mp.click_events_panel_audit_tab()
+
+        audit_events_container.should_be_pagination_buttons()
+
+        # Проверка начального состояния
+        tested_pages = 1
+
+        # to do: некорректный запрос в бэк, должно быть "filter": {"page": 0}
+        payload = {"table": "default",
+                   "filter": {
+                       "tags": [
+                           "testaudit",
+                           "type:action"
+                       ],
+                       "page": 1
+                   },
+                   "count": 40
+                   }
+        response = mp.send_post_api_request("e-nms/logs_enode", payload)
+        if response.status == 200:
+            response_body = mp.get_response_body(response)
+
+            if response_body:
+                pages = response_body["data"]["pages"]
+
+                if pages > 5:
+                    tested_pages = 5
+                else:
+                    tested_pages = pages
+
+        current_number = audit_events_container.get_current_data_set_number()
+        assert current_number == 1, "The first page should be number one"
+
+        if tested_pages == 1:
+            audit_events_container.should_be_all_disabled()
+        else:
+            audit_events_container.should_be_initial_state()
+
+            # Переход на самую последнюю страницу, возврат на страницу назад, потом на страницу вперед
+            audit_events_container.click_last_page()
+            browser.wait_for_timeout(2000)
+
+            audit_events_container.should_be_final_state()
+
+            last_number = audit_events_container.get_current_data_set_number()
+
+            audit_events_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            if last_number == 2:
+                audit_events_container.should_be_initial_state()
+            else:
+                audit_events_container.should_be_all_enabled()
+
+            counter = last_number - 1
+            current_number = audit_events_container.get_current_data_set_number()
+            assert current_number == counter, f"Expected page number {counter} is not equal actual {current_number}"
+
+            audit_events_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            audit_events_container.should_be_final_state()
+
+            current_number = audit_events_container.get_current_data_set_number()
+            assert current_number == last_number, \
+                   f"Expected page number {last_number} is not equal actual {current_number}"
+
+            # Переход на первую страницу, переход на следующую страницу, возврат на первую страницу
+            audit_events_container.click_first_page()
+            browser.wait_for_timeout(2000)
+
+            audit_events_container.should_be_initial_state()
+
+            current_number = audit_events_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            audit_events_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            if tested_pages == 2:
+                audit_events_container.should_be_final_state()
+            else:
+                audit_events_container.should_be_all_enabled()
+
+            current_number = audit_events_container.get_current_data_set_number()
+            assert current_number == 2, f"Expected page number 2 is not equal actual {current_number}"
+
+            audit_events_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            audit_events_container.should_be_initial_state()
+
+            current_number = audit_events_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            if tested_pages > 2:
+                # загрузка страниц от начала и до конца
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                counter = 1
+
+                while counter < tested_pages:
+                    audit_events_container.click_chevron_right()
+                    counter += 1
+                    browser.wait_for_timeout(2000)
+
+                    if counter == tested_pages:
+                        audit_events_container.should_be_final_state()
+                    else:
+                        audit_events_container.should_be_all_enabled()
+                    current_number = audit_events_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # загрузка страниц от конца к началу
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                while counter > 2:
+                    audit_events_container.click_chevron_left()
+                    browser.wait_for_timeout(2000)
+
+                    audit_events_container.should_be_all_enabled()
+
+                    counter -= 1
+                    current_number = audit_events_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # Проверка возврата к начальному состоянию
+                audit_events_container.click_chevron_left()
+                browser.wait_for_timeout(2000)
+
+                audit_events_container.should_be_initial_state()
+
+                current_number = audit_events_container.get_current_data_set_number()
+                assert current_number == 1, "The first page should be number one"

tests/e2e/event_panel/test_events_tab_container.py

@@ -0,0 +1,308 @@
+"""Модуль тестов контейнера для отображения событий системного журнала.
+
+Содержит тесты для проверки функциональности
+контейнера для отображения событий системного журнала.
+"""
+
+import pytest
+from playwright.sync_api import Page
+from pages.main_page import MainPage
+from pages.login_page import LoginPage
+
+
+# @pytest.mark.smoke
+class TestEventsTabContainer:
+    """Класс тестов для проверки контейнера для отображения событий вкладки События панели событий.
+
+    Атрибуты:
+        browser: Фикстура для работы с браузером.
+    """
+    # @pytest.mark.develop
+    def test_events_tab_content(self, browser: Page) -> None:
+        """Проверяет содержимое контейнера для отображения событий вкладки События панели событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        events_tab_container = mp.click_events_panel_events_tab()
+        events_tab_container.check_content()
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_row_highlighting(self, browser: Page):
+        """Проверяет выделение строк в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        events_tab_container = mp.click_events_panel_events_tab()
+
+        # Получение количества строк в таблице
+        rows_count = events_tab_container.get_events_table_rows_count()
+
+        # Проверка выделения строк
+        events_tab_container.check_events_table_row_highlighting(0)
+        events_tab_container.check_events_table_row_highlighting(rows_count - 1)
+        events_tab_container.check_events_table_row_highlighting(int(rows_count / 2))
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_scrolling(self, browser: Page):
+        """Проверяет возможность скроллинга таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        events_tab_container = mp.click_events_panel_events_tab()
+
+        events_panel_position = mp.get_events_panel_position()
+
+        # Проверка, что панель с таблицей открыта
+        assert events_panel_position != "bottom", "Panel with system log events should be opened"
+
+        is_scrollable = events_tab_container.check_events_table_verticall_scrolling()
+
+        # Убеждаемся, что панель открыта наполовину и проверяем скроллинг
+        assert events_panel_position == "center",\
+               "Panel with system log events should be located on the main page center"
+        assert is_scrollable, "System log events table should be scrollable"
+
+        # Скроллинг вниз
+        events_tab_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        events_tab_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        events_tab_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        events_tab_container.check_events_table_first_row_visibility()
+
+        # Раскрываем панель полностью и проверяем скроллинг
+        assert mp.check_expand_more_button(), \
+                "Expand more button should be present"
+        mp.click_events_panel_expand_more_button()
+        mp.wait_for_timeout(500)
+
+        events_panel_position = mp.get_events_panel_position()
+        assert events_panel_position == "top",\
+               "Panel with system log events should be located on the main page top"
+
+        is_scrollable = events_tab_container.check_events_table_verticall_scrolling()
+        assert is_scrollable, "System log events table should be scrollable in the full window"
+
+        # Скроллинг вниз
+        events_tab_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        events_tab_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        events_tab_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        events_tab_container.check_events_table_first_row_visibility()
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_column_sorting(self, browser: Page):
+        """Проверяет сортировку колонки 'Время' в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        events_tab_container = mp.click_events_panel_events_tab()
+
+        index = 0
+        state = events_tab_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+
+        events_tab_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+
+        state = events_tab_container.get_arrow_button_state(index)
+        assert state == "up", "Arrow button should be up"
+        is_descending_order = events_tab_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert not is_descending_order, "Column data should be in ascending order"
+
+        events_tab_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+        state = events_tab_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+        is_descending_order = events_tab_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert is_descending_order, "Column data should be in descending order"
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_pagination(self, browser: Page):
+        """Проверяет возможность пагинации таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        events_tab_container = mp.click_events_panel_events_tab()
+
+        events_tab_container.should_be_pagination_buttons()
+
+        # Проверка начального состояния
+        tested_pages = 1
+
+        # to do: некорректный запрос в бэк, должно быть "filter": {"page": 0}
+        payload = {"table": "syslogs",
+                   "filter": {"page": 1},
+                   "count": 40
+            }
+        response = mp.send_post_api_request("e-nms/logs_enode", payload)
+        if response.status == 200:
+            response_body = mp.get_response_body(response)
+
+            if response_body:
+                pages = response_body["data"]["pages"]
+
+                if pages > 5:
+                    tested_pages = 5
+                else:
+                    tested_pages = pages
+
+        current_number = events_tab_container.get_current_data_set_number()
+        assert current_number == 1, "The first page should be number one"
+
+        if tested_pages == 1:
+            events_tab_container.should_be_all_disabled()
+        else:
+            events_tab_container.should_be_initial_state()
+
+            # Переход на самую последнюю страницу, возврат на страницу назад, потом на страницу вперед
+            events_tab_container.click_last_page()
+            browser.wait_for_timeout(2000)
+
+            events_tab_container.should_be_final_state()
+
+            last_number = events_tab_container.get_current_data_set_number()
+
+            events_tab_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            if last_number == 2:
+                events_tab_container.should_be_initial_state()
+            else:
+                events_tab_container.should_be_all_enabled()
+
+            counter = last_number - 1
+            current_number = events_tab_container.get_current_data_set_number()
+            assert current_number == counter, f"Expected page number {counter} is not equal actual {current_number}"
+
+            events_tab_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            events_tab_container.should_be_final_state()
+
+            current_number = events_tab_container.get_current_data_set_number()
+            assert current_number == last_number, \
+                   f"Expected page number {last_number} is not equal actual {current_number}"
+
+            # Переход на первую страницу, переход на следующую страницу, возврат на первую страницу
+            events_tab_container.click_first_page()
+            browser.wait_for_timeout(2000)
+
+            events_tab_container.should_be_initial_state()
+
+            current_number = events_tab_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            events_tab_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            if tested_pages == 2:
+                events_tab_container.should_be_final_state()
+            else:
+                events_tab_container.should_be_all_enabled()
+
+            current_number = events_tab_container.get_current_data_set_number()
+            assert current_number == 2, f"Expected page number 2 is not equal actual {current_number}"
+
+            events_tab_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            events_tab_container.should_be_initial_state()
+
+            current_number = events_tab_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            if tested_pages > 2:
+                # загрузка страниц от начала и до конца
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                counter = 1
+
+                while counter < tested_pages:
+                    events_tab_container.click_chevron_right()
+                    counter += 1
+                    browser.wait_for_timeout(2000)
+
+                    if counter == tested_pages:
+                        events_tab_container.should_be_final_state()
+                    else:
+                        events_tab_container.should_be_all_enabled()
+                    current_number = events_tab_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # загрузка страниц от конца к началу
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                while counter > 2:
+                    events_tab_container.click_chevron_left()
+                    browser.wait_for_timeout(2000)
+
+                    events_tab_container.should_be_all_enabled()
+
+                    counter -= 1
+                    current_number = events_tab_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # Проверка возврата к начальному состоянию
+                events_tab_container.click_chevron_left()
+                browser.wait_for_timeout(2000)
+
+                events_tab_container.should_be_initial_state()
+
+                current_number = events_tab_container.get_current_data_set_number()
+                assert current_number == 1, "The first page should be number one"

tests/e2e/event_panel/test_maintenance_events_container.py

@@ -0,0 +1,309 @@
+"""Модуль тестов контейнера для отображения событий обслуживания.
+
+Содержит тесты для проверки функциональности
+контейнера для отображения событий обслуживания.
+"""
+
+import pytest
+from playwright.sync_api import Page
+from pages.main_page import MainPage
+from pages.login_page import LoginPage
+
+
+# @pytest.mark.smoke
+class TestMaintenanceEventsContainer:
+    """Класс тестов для проверки контейнера для отображения событий обслуживания.
+
+    Атрибуты:
+        browser: Фикстура для работы с браузером.
+    """
+    # @pytest.mark.develop
+    def test_events_tab_content(self, browser: Page) -> None:
+        """Проверяет содержимое контейнера для отображения событий обслуживания.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        maintenance_events_container = mp.click_events_panel_maintenance_tab()
+        maintenance_events_container.check_content()
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_row_highlighting(self, browser: Page):
+        """Проверяет выделение строк в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        maintenance_events_container = mp.click_events_panel_maintenance_tab()
+
+        # Получение количества строк в таблице
+        rows_count = maintenance_events_container.get_events_table_rows_count()
+
+        # Проверка выделения строк
+        maintenance_events_container.check_events_table_row_highlighting(0)
+        maintenance_events_container.check_events_table_row_highlighting(rows_count - 1)
+        maintenance_events_container.check_events_table_row_highlighting(int(rows_count / 2))
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_scrolling(self, browser: Page):
+        """Проверяет возможность скроллинга таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        maintenance_events_container = mp.click_events_panel_maintenance_tab()
+
+        events_panel_position = mp.get_events_panel_position()
+
+        # Проверка, что панель с таблицей открыта
+        assert events_panel_position != "bottom", "Panel with system log events should be opened"
+
+        is_scrollable = maintenance_events_container.check_events_table_verticall_scrolling()
+
+        # Убеждаемся, что панель открыта наполовину и проверяем скроллинг
+        assert events_panel_position == "center",\
+               "Panel with system log events should be located on the main page center"
+        assert is_scrollable, "System log events table should be scrollable"
+
+        # Скроллинг вниз
+        maintenance_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        maintenance_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        maintenance_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        maintenance_events_container.check_events_table_first_row_visibility()
+
+        # Раскрываем панель полностью и проверяем скроллинг
+        assert mp.check_expand_more_button(), \
+                "Expand more button should be present"
+        mp.click_events_panel_expand_more_button()
+        mp.wait_for_timeout(500)
+
+        events_panel_position = mp.get_events_panel_position()
+        assert events_panel_position == "top",\
+               "Panel with system log events should be located on the main page top"
+
+        is_scrollable = maintenance_events_container.check_events_table_verticall_scrolling()
+        assert is_scrollable, "System log events table should be scrollable in the full window"
+
+        # Скроллинг вниз
+        maintenance_events_container.scroll_events_table_down()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости последней строки после прокрутки
+        maintenance_events_container.check_events_table_last_row_visibility()
+
+        # Скроллинг вверх
+        maintenance_events_container.scroll_events_table_up()
+        browser.wait_for_timeout(1000)
+
+        # Проверка видимости первой строки после прокрутки
+        maintenance_events_container.check_events_table_first_row_visibility()
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_column_sorting(self, browser: Page):
+        """Проверяет сортировку колонки 'Время' в таблице событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        maintenance_events_container = mp.click_events_panel_maintenance_tab()
+
+        index = 0
+        state = maintenance_events_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+
+        maintenance_events_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+
+        state = maintenance_events_container.get_arrow_button_state(index)
+        assert state == "up", "Arrow button should be up"
+        is_descending_order = maintenance_events_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert not is_descending_order, "Column data should be in ascending order"
+
+        maintenance_events_container.click_event_table_header_arrow(index)
+        browser.wait_for_timeout(500)
+        state = maintenance_events_container.get_arrow_button_state(index)
+        assert state == "down", "Arrow button should be down"
+        is_descending_order = maintenance_events_container.check_events_table_column_descending_order(index,
+                                                                                                convert2timestamp=True)
+        assert is_descending_order, "Column data should be in descending order"
+
+    @pytest.mark.skip(reason="Отсутствуют данные для вывода в таблицу событий")
+    def test_events_table_pagination(self, browser: Page):
+        """Проверяет возможность пагинации таблицы событий.
+
+        Args:
+            browser: Экземпляр страницы Playwright.
+        """
+
+        lp = LoginPage(browser)
+        lp.do_login()
+
+        mp = MainPage(browser)
+        mp.should_be_event_panel()
+
+        maintenance_events_container = mp.click_events_panel_maintenance_tab()
+
+        maintenance_events_container.should_be_pagination_buttons()
+
+        # Проверка начального состояния
+        tested_pages = 1
+
+        # to do: некорректный запрос в бэк, должно быть "filter": {"page": 0}
+        payload = {"id": [ "/physical"],
+                   "notNull": True,
+                   "data": {"links": {"flatten": True}},
+                   "reducer": "events"
+                  }
+        response = mp.send_post_api_request("e-cmdb/api/query", payload)
+        if response.status == 200:
+            response_body = mp.get_response_body(response)
+
+            if response_body:
+                pages = response_body["data"]["pages"]
+
+                if pages > 5:
+                    tested_pages = 5
+                else:
+                    tested_pages = pages
+
+        current_number = maintenance_events_container.get_current_data_set_number()
+        assert current_number == 1, "The first page should be number one"
+
+        if tested_pages == 1:
+            maintenance_events_container.should_be_all_disabled()
+        else:
+            maintenance_events_container.should_be_initial_state()
+
+            # Переход на самую последнюю страницу, возврат на страницу назад, потом на страницу вперед
+            maintenance_events_container.click_last_page()
+            browser.wait_for_timeout(2000)
+
+            maintenance_events_container.should_be_final_state()
+
+            last_number = maintenance_events_container.get_current_data_set_number()
+
+            maintenance_events_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            if last_number == 2:
+                maintenance_events_container.should_be_initial_state()
+            else:
+                maintenance_events_container.should_be_all_enabled()
+
+            counter = last_number - 1
+            current_number = maintenance_events_container.get_current_data_set_number()
+            assert current_number == counter, f"Expected page number {counter} is not equal actual {current_number}"
+
+            maintenance_events_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            maintenance_events_container.should_be_final_state()
+
+            current_number = maintenance_events_container.get_current_data_set_number()
+            assert current_number == last_number, \
+                   f"Expected page number {last_number} is not equal actual {current_number}"
+
+            # Переход на первую страницу, переход на следующую страницу, возврат на первую страницу
+            maintenance_events_container.click_first_page()
+            browser.wait_for_timeout(2000)
+
+            maintenance_events_container.should_be_initial_state()
+
+            current_number = maintenance_events_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            maintenance_events_container.click_chevron_right()
+            browser.wait_for_timeout(4000)
+
+            if tested_pages == 2:
+                maintenance_events_container.should_be_final_state()
+            else:
+                maintenance_events_container.should_be_all_enabled()
+
+            current_number = maintenance_events_container.get_current_data_set_number()
+            assert current_number == 2, f"Expected page number 2 is not equal actual {current_number}"
+
+            maintenance_events_container.click_chevron_left()
+            browser.wait_for_timeout(4000)
+
+            maintenance_events_container.should_be_initial_state()
+
+            current_number = maintenance_events_container.get_current_data_set_number()
+            assert current_number == 1, f"Expected page number 1 is not equal actual {current_number}"
+
+            if tested_pages > 2:
+                # загрузка страниц от начала и до конца
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                counter = 1
+
+                while counter < tested_pages:
+                    maintenance_events_container.click_chevron_right()
+                    counter += 1
+                    browser.wait_for_timeout(2000)
+
+                    if counter == tested_pages:
+                        maintenance_events_container.should_be_final_state()
+                    else:
+                        maintenance_events_container.should_be_all_enabled()
+                    current_number = maintenance_events_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # загрузка страниц от конца к началу
+                # to_do: проверка, что происходит обновление содержимого таблицы
+                while counter > 2:
+                    maintenance_events_container.click_chevron_left()
+                    browser.wait_for_timeout(2000)
+
+                    maintenance_events_container.should_be_all_enabled()
+
+                    counter -= 1
+                    current_number = maintenance_events_container.get_current_data_set_number()
+                    assert current_number == counter,\
+                        f"Expected page number {counter} is not equal actual {current_number}"
+
+                # Проверка возврата к начальному состоянию
+                maintenance_events_container.click_chevron_left()
+                browser.wait_for_timeout(2000)
+
+                maintenance_events_container.should_be_initial_state()
+
+                current_number = maintenance_events_container.get_current_data_set_number()
+                assert current_number == 1, "The first page should be number one"

tests/e2e/event_panel/test_system_log_events_container.py

@@ -4,7 +4,7 @@
 контейнера для отображения событий системного журнала.
 """
 
-# import pytest
+import pytest
 from playwright.sync_api import Page
 from pages.main_page import MainPage
 from pages.login_page import LoginPage
@@ -20,7 +20,7 @@ class TestSystemLogEventsContainer:
     Атрибуты:
         browser: Фикстура для работы с браузером.
     """
-    # @pytest.mark.develop
+    @pytest.mark.develop
     def test_system_log_events_content(self, browser: Page) -> None:
         """Проверяет содержимое контейнера для отображения событий системного журнала.