Added test_headings_on_active_batch_list_screen and updated utils / pom accordingly

Author: Andyg79

pages/communication_production/batch_list_page.py

@@ -128,33 +128,42 @@ class ActiveBatchListPage(BatchListPage):
     def __init__(self, page):
         super().__init__(page)
 
+    def assert_column_present(self, column_name: str) -> None:
+        """Asserts that the specified column is present in the table header."""
+        headers = list(
+            TableUtils(self.page, "table#batchList").get_table_headers().values()
+        )
+        assert (
+            column_name in headers
+        ), f"Column '{column_name}' not found in table headers"
+
+    def assert_column_sortable(self, column_name: str) -> None:
+        """Asserts that the specified column is marked as sortable in the UI."""
+        sort_locator = self.page.locator(
+            "table#batchList thead tr:first-child th span.dt-column-title",
+            has_text=column_name,
+        )
+        assert (
+            sort_locator.count() > 0
+        ), f"Sortable header not found for column '{column_name}'"
+        assert (
+            sort_locator.first.get_attribute("role") == "button"
+        ), f"Column '{column_name}' is not sortable"
+
+    def assert_column_filterable(self, column_name: str) -> None:
+        """Asserts that the specified column has a filter control in the second header row."""
+        table = TableUtils(self.page, "table#batchList")
+        column_index = table.get_column_index(column_name) - 1  # Convert 1-based to 0-based
+
+        filter_locator = (
+            self.page.locator("table#batchList thead tr:nth-child(2) th")
+            .nth(column_index)
+            .locator("input, select, div.input-group")
+        )
+        assert (
+            filter_locator.count() > 0
+        ), f"Filter control not found for column '{column_name}'"
 
-    def verify_sortable_and_filterable_columns(self) -> None:
-        """
-        Validates the presence of expected columns in the Active Batch List table.
-        """
-        table = TableUtils(
-            self.page, "table.active-batch-list"
-        )  # Adjust selector as needed
-        expected_columns = [
-            "ID",
-            "Type",
-            "Original",
-            "Event Code",
-            "Description",
-            "Batch Split By",
-            "Screening Centre",
-            "Status",
-            "Priority",
-            "Deadline",
-            "Count",
-        ]
-
-        for column in expected_columns:
-            column_index = table.get_column_index(column)
-            assert (
-                column_index != -1
-            ), f"Column '{column}' not found in the batch list table"
 
 
 class ArchivedBatchListPage(BatchListPage):

tests/regression/communications_production/test_basic_active_batch_list_functionality_regression.py

@@ -1,12 +1,11 @@
 import pytest
-from playwright.sync_api import Page, expect
+from playwright.sync_api import Page
 from pages.base_page import BasePage
 from pages.communication_production.communications_production_page import (
     CommunicationsProductionPage,
 )
 from pages.communication_production.batch_list_page import ActiveBatchListPage
 from utils.user_tools import UserTools
-from utils.table_util import TableUtils
 
 
 @pytest.fixture(scope="function", autouse=True)
@@ -22,7 +21,43 @@ def before_each(page: Page):
     BasePage(page).go_to_communications_production_page()
     CommunicationsProductionPage(page).go_to_active_batch_list_page()
 
-# @BCSSAdditionalTests @LettersTests
+
+@pytest.mark.regression
+def test_headings_on_active_batch_list_screen(page: Page) -> None:
+    """
+    Scenario: Check headings on Active Batch List Screen
+    Given I log in to BCSS "England" as user role "HubManager"
+    When I view the active batch list
+    Then the table contains a sortable and filterable column for "<Column Name>"
+    """
+    batch_list_page = ActiveBatchListPage(page)
+
+    expected_columns = [
+        "ID",
+        "Type",
+        "Original",
+        "Event Code",
+        "Description",
+        "Batch Split By",
+        "Screening Centre",
+        "Status",
+        "Priority",
+        "Deadline",
+        "Count",
+    ]
+
+    for column in expected_columns:
+        # Step 1: Ensure the column is present
+        batch_list_page.assert_column_present(column)
+
+        # Step 2: Assert sortable UI attribute is present
+        batch_list_page.assert_column_sortable(column)
+
+        # Step 3: Assert filterable control is rendered
+        batch_list_page.assert_column_filterable(column)
+
+
+# TODO: @BCSSAdditionalTests @LettersTests
 # Feature: Basic Active Batch List functionality
 
 # Scenario: Check navigation from Active Batch List Screen to Manage Active Batch Screen
@@ -39,29 +74,3 @@ def before_each(page: Page):
 # When I navigate to the Communications Production > Active Batch List Page
 #     And I prepare the Pre-Invitation FIT letter batch
 # Then The Pre-Invitation FIT letter batch is no longer listed
-
-@pytest.mark.regression
-def test_headings_on_active_batch_list_screen(page: Page) -> None:
-    """
-    Confirms that the active batch list table contains a sortable and filterable column for "ID", "Type", "Original",
-    "Event Code", "Description", "Batch Split By", "Screening Centre", "Status", "Priority", "Deadline" and "Count"
-    """
-    # Scenario: Check headings on Active Batch List Screen
-    # Given I log in to BCSS "England" as user role "HubManager"
-    # When I view the active batch list
-    # Then the table contains a sortable and filterable column for "ID"
-    # And the table contains a sortable and filterable column for "Type"
-    # And the table contains a sortable and filterable column for "Original"
-    # And the table contains a sortable and filterable column for "Event Code"
-    # And the table contains a sortable and filterable column for "Description"
-    # And the table contains a sortable and filterable column for "Batch Split By"
-    # And the table contains a sortable and filterable column for "Screening Centre"
-    # And the table contains a sortable and filterable column for "Status"
-    # And the table contains a sortable and filterable column for "Priority"
-    # And the table contains a sortable and filterable column for "Deadline"
-    # And the table contains a sortable and filterable column for "Count"
-    batch_list_page = ActiveBatchListPage(page)
-    # 🔍 TEMPORARY DEBUGGING
-    table = TableUtils(page, "table.active-batch-list")
-    print("DEBUG - Headers Found:", table.get_table_headers())
-    batch_list_page.verify_sortable_and_filterable_columns()

utils/table_util.py

@@ -1,5 +1,4 @@
-from playwright.sync_api import Page, Locator, expect
-from pages.base_page import BasePage
+from playwright.sync_api import Page, Locator
 import logging
 import secrets
 
@@ -51,17 +50,21 @@ def get_column_index(self, column_name: str) -> int:
         header_texts = headers.evaluate_all("ths => ths.map(th => th.innerText.trim())")
         logging.info(f"First Row Headers Found: {header_texts}")
 
-        # Extract detailed second-row headers if first-row headers seem generic
+        # Attempt to extract a second row of headers (commonly used for filters or alternate titles)
         second_row_headers = self.table.locator(
             "thead tr:nth-child(2) th"
         ).evaluate_all("ths => ths.map(th => th.innerText.trim())")
-        # Merge both lists: Prioritize second-row headers if available
-        if second_row_headers:
+
+        # Use the second row only if it contains meaningful text (not filters, dropdowns, or placeholder values)
+        if second_row_headers and all(
+            h and not any(c in h.lower() for c in ("input", "all", "select"))
+            for h in second_row_headers
+        ):
             header_texts = second_row_headers
+        logging.info(f"Second Row Headers Found: {second_row_headers}")
 
-        logging.info(f"Second Row Headers Found: {header_texts}")
         for index, header in enumerate(header_texts):
-            if column_name.lower() in header.lower():
+            if column_name.strip().lower() == header.strip().lower():
                 return index + 1  # Convert to 1-based index
         return -1  # Column not found
 
@@ -130,36 +133,52 @@ def get_table_headers(self) -> dict:
             dict: A mapping of column index (1-based) to header text.
         """
         # Strategy 1: Try <thead> with <tr><th><span class="dt-column-title">Header</span></th>
-        header_spans = self.page.locator(f"{self.table_id} > thead tr:first-child th span.dt-column-title")
+        header_spans = self.page.locator(
+            f"{self.table_id} > thead tr:first-child th span.dt-column-title"
+        )
         if header_spans.count():
             try:
-                header_texts = header_spans.evaluate_all("els => els.map(el => el.textContent.trim())")
+                header_texts = header_spans.evaluate_all(
+                    "els => els.map(el => el.textContent.trim())"
+                )
+                print("[DEBUG] Parsed header texts:", repr(header_texts))
                 return {idx + 1: text for idx, text in enumerate(header_texts)}
             except Exception as e:
-                logging.warning(f"[get_table_headers] span.dt-column-title fallback failed: {e}")
+                logging.warning(
+                    f"[get_table_headers] span.dt-column-title fallback failed: {e}"
+                )
 
         # Strategy 2: Fallback to standard <thead> > tr > th inner text
-        header_cells = self.page.locator(f"{self.table_id} > thead tr").first.locator("th")
+        header_cells = self.page.locator(f"{self.table_id} > thead tr").first.locator(
+            "th"
+        )
         if header_cells.count():
             try:
-                header_texts = header_cells.evaluate_all("els => els.map(th => th.innerText.trim())")
+                header_texts = header_cells.evaluate_all(
+                    "els => els.map(th => th.innerText.trim())"
+                )
                 return {idx + 1: text for idx, text in enumerate(header_texts)}
             except Exception as e:
                 logging.warning(f"[get_table_headers] basic <th> fallback failed: {e}")
 
         # Strategy 3: Last resort — try to find header from tbody row (some old tables use <tbody> only)
-        fallback_row = self.table.locator("tbody tr").filter(has=self.page.locator("th")).first
+        fallback_row = (
+            self.table.locator("tbody tr").filter(has=self.page.locator("th")).first
+        )
         if fallback_row.locator("th").count():
             try:
-                header_texts = fallback_row.locator("th").evaluate_all("els => els.map(th => th.innerText.trim())")
+                header_texts = fallback_row.locator("th").evaluate_all(
+                    "els => els.map(th => th.innerText.trim())"
+                )
                 return {idx + 1: text for idx, text in enumerate(header_texts)}
             except Exception as e:
                 logging.warning(f"[get_table_headers] tbody fallback failed: {e}")
 
-        logging.warning(f"[get_table_headers] No headers found for table: {self.table_id}")
+        logging.warning(
+            f"[get_table_headers] No headers found for table: {self.table_id}"
+        )
         return {}
 
-
     def get_row_count(self) -> int:
         """
         This returns the total rows visible on the table (on the screen currently)