Added manage_archived_batch pom

Added tests for basic archived batch list functionality
Refactored BatchListPage

Author: Andyg79

pages/communication_production/batch_list_page.py

@@ -6,12 +6,14 @@
 
 
 class BatchListPage(BasePage):
-    """Batch List Page locators, and methods for interacting with the page"""
+    """Shared base class for both Active and Archived Batch List Pages."""
 
-    def __init__(self, page: Page):
+    def __init__(self, page: Page, table_selector: str = "table#batchList"):
         super().__init__(page)
         self.page = page
-        # Batch List - page filters
+        self.table_selector = table_selector
+
+        # Common filters
         self.id_filter = self.page.locator("#batchIdFilter")
         self.type_filter = self.page.locator("#batchTypeFilter")
         self.original_filter = self.page.locator("#originalBatchIdFilter")
@@ -33,61 +35,94 @@ def __init__(self, page: Page):
         )
         self.deadline_date_clear_button = self.page.get_by_role("cell", name="Clear")
 
+    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, self.table_selector).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(
+            f"{self.table_selector} 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, self.table_selector)
+        column_index = (
+            table.get_column_index(column_name) - 1
+        )  # Convert 1-based to 0-based
+
+        filter_locator = (
+            self.page.locator(f"{self.table_selector} 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 assert_batch_table_visible(self) -> None:
+        """Asserts that the batch list table is present and rendered."""
+        expect(self.page.locator(self.table_selector)).to_be_visible()
+
     def verify_batch_list_page_title(self, text) -> None:
-        """Verify the Batch List page title is displayed as expected"""
+        """Verify the Batch List page title is displayed as expected."""
         self.bowel_cancer_screening_page_title_contains_text(text)
 
     def verify_table_data(self, value) -> None:
-        """Verify the table data is displayed as expected"""
+        """Verify the table data is displayed as expected."""
         expect(self.table_data.filter(has_text=value)).to_be_visible()
 
+    # Shared filter entry methods
     def enter_id_filter(self, search_text: str) -> None:
-        """Enter text in the ID filter and press Enter"""
         self.id_filter.fill(search_text)
         self.id_filter.press("Enter")
 
     def enter_type_filter(self, search_text: str) -> None:
-        """Enter text in the Type filter and press Enter"""
         self.type_filter.fill(search_text)
         self.type_filter.press("Enter")
 
     def enter_original_filter(self, search_text: str) -> None:
-        """Enter text in the Original filter and press Enter"""
         self.original_filter.fill(search_text)
         self.original_filter.press("Enter")
 
     def enter_event_code_filter(self, search_text: str) -> None:
-        """Enter text in the Event Code filter and press Enter"""
         self.event_code_filter.fill(search_text)
         self.event_code_filter.press("Enter")
 
     def enter_description_filter(self, search_text: str) -> None:
-        """Enter text in the Description filter and press Enter"""
         self.description_filter.fill(search_text)
         self.description_filter.press("Enter")
 
     def enter_batch_split_by_filter(self, search_text: str) -> None:
-        """Enter text in the 'Batch Split By' filter and press Enter"""
         self.batch_split_by_filter.fill(search_text)
         self.batch_split_by_filter.press("Enter")
 
     def enter_screening_centre_filter(self, search_text: str) -> None:
-        """Enter text in the Screening Centre filter and press Enter"""
         self.screening_centre_filter.fill(search_text)
         self.screening_centre_filter.press("Enter")
 
     def enter_count_filter(self, search_text: str) -> None:
-        """Enter text in the Count filter and press Enter"""
         self.count_filter.fill(search_text)
         self.count_filter.press("Enter")
 
     def enter_deadline_date_filter(self, date: datetime) -> None:
-        """Enter a date in the Deadline Date filter and press Enter"""
         self.click(self.deadline_calendar_picker)
         CalendarPicker(self.page).v2_calendar_picker(date)
 
     def clear_deadline_filter_date(self) -> None:
-        """Clear the date in the Deadline Date filter"""
         self.click(self.deadline_calendar_picker)
         self.click(self.deadline_date_clear_button)
 
@@ -123,82 +158,48 @@ def open_letter_batch(
 
 
 class ActiveBatchListPage(BatchListPage):
-    """Active Batch List Page locators, and methods for interacting with the Active Batch List page"""
-
-    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
+    """Active Batch List Page-specific methods."""
 
-        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 assert_batch_table_visible(self) -> None:
-        """Asserts that the batch list table is present and rendered."""
-        expect(self.page.locator("table#batchList")).to_be_visible()
+    def __init__(self, page: Page):
+        super().__init__(page, table_selector="table#batchList")
 
     def select_first_active_batch(self) -> None:
         """Clicks the first batch ID link in the active batch list."""
-        first_batch_link = self.page.locator("table#batchList tbody tr td.id a").first
-        assert first_batch_link.count() > 0, "No active batch links found"
-        first_batch_link.click()
+        first_link = self.page.locator(f"{self.table_selector} tbody tr td.id a").first
+        assert first_link.count() > 0, "No active batch links found"
+        first_link.click()
 
     def is_batch_present(self, batch_type: str) -> bool:
         """Checks if a batch of the given type exists in the active batch list."""
-        locator = self.page.locator(f"table#batchList tbody tr td", has_text=batch_type)
+        locator = self.page.locator(
+            f"{self.table_selector} tbody tr td", has_text=batch_type
+        )
         return locator.count() > 0
 
     def prepare_batch(self, batch_type: str) -> None:
         """Finds and clicks the Prepare button for the specified batch type."""
         row = (
-            self.page.locator("table#batchList tbody tr")
+            self.page.locator(f"{self.table_selector} tbody tr")
             .filter(has=self.page.locator("td", has_text=batch_type))
             .first
         )
 
         prepare_button = row.locator("a", has_text="Prepare").first
         expect(prepare_button).to_be_visible()
         prepare_button.click()
-
-        # Optional: wait for row to disappear
         expect(row).not_to_be_visible(timeout=5000)
 
 
 class ArchivedBatchListPage(BatchListPage):
-    """Archived Batch List Page locators, and methods for interacting with the Archived Batch List page"""
+    """Archived Batch List Page-specific setup."""
 
-    def __init__(self, page):
-        super().__init__(page)
+    def __init__(self, page: Page):
+        super().__init__(page, table_selector="table#batchList")
+
+    def select_first_archived_batch(self) -> None:
+        """Clicks the first batch ID link in the archived batch list."""
+        first_batch_link = self.page.locator(
+            f"{self.table_selector} tbody tr td.id a"
+        ).first
+        assert first_batch_link.count() > 0, "No archived batch links found"
+        first_batch_link.click()

pages/communication_production/manage_active_batch_page.py

@@ -35,4 +35,3 @@ def assert_batch_details_visible(self) -> None:
         """Asserts that the Manage Active Batch screen has loaded by checking the page title."""
         page_title = self.page.locator("#page-title")
         expect(page_title).to_have_text("Manage Active Batch")
-

pages/communication_production/manage_archived_batch_page.py

@@ -0,0 +1,15 @@
+from playwright.sync_api import Page
+from pages.base_page import BasePage
+from playwright.sync_api import expect
+
+
+class ManageArchivedBatchPage(BasePage):
+    """Page object for the Manage Archived Batch Screen."""
+
+    def __init__(self, page: Page):
+        super().__init__(page)
+
+    def assert_batch_details_visible(self) -> None:
+        """Verifies the Manage Archived Batch page has loaded."""
+        header = self.page.locator("#page-title")
+        expect(header).to_have_text("Manage Archived Batch")

tests/regression/communications_production/test_basic_archived_batch_list_functionality.py

@@ -1,26 +1,90 @@
-# @BCSSAdditionalTests @LettersTests
-# Feature: Basic Archived Batch List functionality
-
-# Scenario: Check headings on Archived Batch List Screen
-# Given I log in to BCSS "England" as user role "HubManager"
-# When I view the archived 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 "Letter Group"
-# 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 "Date On Letter"
-# And the table contains a sortable and filterable column for "Date Archived"
-# And the table contains a sortable and filterable column for "Count"
-
-
-# Scenario: Check navigation from Archived Batch List Screen to Manage Archived Batch Screen
-# Given I log in to BCSS "England" as user role "HubManager"
-# When I view the archived batch list
-# And I select an archived batch
-# Then I view the details of an archived batch
+import pytest
+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 (
+    ArchivedBatchListPage,
+)
+from utils.user_tools import UserTools
+from pages.communication_production.manage_archived_batch_page import (
+    ManageArchivedBatchPage,
+)
+
+
+@pytest.fixture
+def select_user(page: Page):
+    def _login_as(user_role: str):
+        # Log in with the specified user
+        UserTools.user_login(page, user_role)
+        # Navigate to Active Batch List
+        BasePage(page).go_to_communications_production_page()
+        CommunicationsProductionPage(page).go_to_archived_batch_list_page()
+        return page
+
+    return _login_as
+
+
+@pytest.mark.letters_tests
+@pytest.mark.regression
+def test_headings_on_archived_batch_list_screen(select_user) -> None:
+    """
+    Scenario: Check headings on Archived Batch List Screen
+    Given I log in to BCSS "England" as user role "HubManager"
+    When I view the archived batch list
+    Then the table contains a sortable and filterable column for each expected header
+    """
+    page = select_user("Hub Manager at BCS01")
+
+    archived_batch_list_page = ArchivedBatchListPage(page)
+
+    expected_columns = [
+        "ID",
+        "Type",
+        "Original",
+        "Letter Group",
+        "Event Code",
+        "Description",
+        "Batch Split By",
+        "Screening Centre",
+        "Status",
+        "Priority",
+        "Date On Letter",
+        "Date Archived",
+        "Count",
+    ]
+
+    for column in expected_columns:
+        # Step 1: Ensure the column is present
+        archived_batch_list_page.assert_column_present(column)
+
+        # Step 2: Assert sortable UI attribute is present
+        archived_batch_list_page.assert_column_sortable(column)
+
+        # Step 3: Assert filterable control is rendered
+        archived_batch_list_page.assert_column_filterable(column)
+
+
+@pytest.mark.letters_tests
+@pytest.mark.regression
+def test_navigation_to_manage_archived_batch_screen(select_user) -> None:
+    """
+    Scenario: Check navigation from Archived Batch List Screen to Manage Archived Batch Screen
+    Given I log in to BCSS "England" as user role "HubManager"
+    When I view the archived batch list
+    And I select an archived batch
+    Then I view the details of an archived batch
+    """
+    page = select_user("Hub Manager at BCS01")
+    archived_batch_list_page = ArchivedBatchListPage(page)
+
+    # Step 1: Ensure the archived batch table is visible
+    archived_batch_list_page.assert_batch_table_visible()
+
+    # Step 2: Click into the first available archived batch
+    archived_batch_list_page.select_first_archived_batch()
+
+    # Step 3: Assert navigation to the Manage Archived Batch page
+    manage_batch_page = ManageArchivedBatchPage(page)
+    manage_batch_page.assert_batch_details_visible()