Added test_prepare_retrieve_and_confirm_active_letter_batch

Author: Andyg79

pages/communication_production/batch_list_page.py

@@ -1,4 +1,4 @@
-from playwright.sync_api import Page, expect
+from playwright.sync_api import Page, expect, Locator
 from pages.base_page import BasePage
 from datetime import datetime
 from utils.calendar_picker import CalendarPicker
@@ -130,29 +130,36 @@ def verify_deadline_date_filter_input(self, expected_text: str) -> None:
         expect(self.deadline_date_filter_with_input).to_have_value(expected_text)
 
     def open_letter_batch(
-        self, batch_type: str, status: str, level: str, description: str
+        self,
+        batch_type: str = "",
+        status: str = "",
+        level: str = "",
+        description: str = "",
     ) -> None:
         """
-        Finds and opens the batch row based on type, status, level, and description.
-        Args:
-            batch_type (str): The type of the batch (e.g., "Original").
-            status (str): The status of the batch (e.g., "Open").
-            level (str): The level of the batch (e.g., "S1").
-            description (str): The description of the batch (e.g., "Pre-invitation (FIT)").
+        Finds and opens the batch row based on non-empty filters.
         """
-        # Step 1: Match the row using nested filters, one per column value
-        row = (
-            self.page.locator("table tbody tr")
-            .filter(has=self.page.locator("td", has_text=batch_type))
-            .filter(has=self.page.locator("td", has_text=status))
-            .filter(has=self.page.locator("td", has_text=level))
-            .filter(has=self.page.locator("td", has_text=description))
-        )
-
-        # Step 2: Click the "View" link in the matched row
-        view_link = row.locator(
-            "a"
-        )  # Click the first link in the row identified in step 1
+        row_locator = self.page.locator(f"{self.table_selector} tbody tr")
+
+        if batch_type:
+            row_locator = row_locator.filter(
+                has=self.page.locator("td", has_text=batch_type)
+            )
+        if status:
+            row_locator = row_locator.filter(
+                has=self.page.locator("td", has_text=status)
+            )
+        if level:
+            row_locator = row_locator.filter(
+                has=self.page.locator("td", has_text=level)
+            )
+        if description:
+            row_locator = row_locator.filter(
+                has=self.page.locator("td", has_text=description)
+            )
+
+        row = row_locator.first
+        view_link = row.locator("a").first
         expect(view_link).to_be_visible()
         view_link.click()
 
@@ -189,6 +196,28 @@ def prepare_batch(self, batch_type: str) -> None:
         prepare_button.click()
         expect(row).not_to_be_visible(timeout=5000)
 
+    def get_open_original_batch_row(self) -> Locator | None:
+        """
+        Returns the first table row where:
+        - The 'Type' column contains 'Original'
+        - The 'Status' column contains 'Open'
+
+        Returns:
+            Locator of the matching <tr> element, or None if not found.
+        """
+        rows = self.page.locator(f"{self.table_selector} tbody tr")
+        for i in range(rows.count()):
+            row = rows.nth(i)
+            type_cell = row.locator("td").nth(1)  # Assuming Type is 2nd column
+            status_cell = row.locator("td").nth(8)  # Assuming Status is 9th column
+
+            if (
+                "Original" in type_cell.inner_text()
+                and "Open" in status_cell.inner_text()
+            ):
+                return row
+        return None
+
 
 class ArchivedBatchListPage(BatchListPage):
     """Archived Batch List Page-specific setup."""

pages/communication_production/manage_active_batch_page.py

@@ -1,6 +1,7 @@
 from playwright.sync_api import Page
 from pages.base_page import BasePage
 from playwright.sync_api import expect
+import re
 
 
 class ManageActiveBatchPage(BasePage):
@@ -35,3 +36,29 @@ 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")
+
+    def prepare_and_print(self) -> None:
+        """Clicks the Prepare and Print button."""
+        button = self.page.get_by_role("button", name="Prepare and Print")
+        expect(button).to_be_enabled()
+        button.click()
+
+    def retrieve_and_confirm_letters(self) -> None:
+        """Clicks the Retrieve and Confirm Letters button."""
+        button = self.page.get_by_role("button", name="Retrieve and Confirm Letters")
+        expect(button).to_be_enabled()
+        button.click()
+
+    def assert_confirmation_success_message(self) -> None:
+        """Verifies the confirmation message is shown after printing."""
+        message = self.page.locator('text="Batch Successfully Archived and Printed"')
+        expect(message).to_be_visible()
+
+    def get_batch_id(self) -> str:
+        """Extracts the batch ID from the page title."""
+        title_text = self.page.locator("#page-title").inner_text()
+        print(f"[DEBUG] Page title text: '{title_text}'")
+        match = re.search(r"\d+", title_text)
+        if match:
+            return match.group()
+        raise ValueError("Batch ID not found in page title.")

tests/regression/communications_production/test_basic_manage_active_batch_functionality.py

@@ -1,13 +1,62 @@
-# @LettersTests
-# Feature: Basic Manage Active Batch functionality
+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 ActiveBatchListPage
+from utils.user_tools import UserTools
+from pages.communication_production.manage_active_batch_page import (
+    ManageActiveBatchPage,
+)
+from pages.communication_production.batch_list_page import ActiveBatchListPage
+from utils.batch_processing import prepare_and_print_batch
 
 
-# Scenario: I can prepare, retrieve and confirm a letter batch of any number of files
-# The first open batch will be picked up for processing, regardless of letter type
+@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_active_batch_list_page()
+        return page
 
-# Given I log in to BCSS "England" as user role "HubManagerStateRegistered"
-# When I view the active batch list
-# And There are open letter batches to process in the active batch list
-# Then I view the "Original" type "Open" status active letter batch for "" ""
-# And I prepare the letter batch
-# And I retrieve and confirm the letters
+    return _login_as
+
+
+@pytest.mark.letters_tests
+@pytest.mark.regression
+def test_prepare_retrieve_and_confirm_active_letter_batch(select_user) -> None:
+    """
+    Scenario: I can prepare, retrieve and confirm a letter batch of any number of files
+    Given I log in to BCSS "England" as user role "HubManagerStateRegistered"
+    When I view the active batch list
+    And there are open letter batches to process in the active batch list
+    Then I view the "Original" type "Open" status active letter batch
+    And I prepare the letter batch
+    And I retrieve and confirm the letters
+    """
+    # Step 1: Log in as Hub Manager (State Registered) and access Active Batch List
+    page = select_user("Hub Manager State Registered at BCS01")
+    batch_list_page = ActiveBatchListPage(page)
+
+    # Step 2: Ensure the active batch list table is visible
+    batch_list_page.assert_batch_table_visible()
+
+    # Step 3: Locate the first batch with type "Original" and status "Open"
+    row = batch_list_page.get_open_original_batch_row()
+    if not row:
+        pytest.skip("No open 'Original' batches found in the active batch list.")
+
+    # Step 4: Capture the batch ID from the selected row and click to open
+    batch_id = row.locator("a").first.inner_text()
+    row.locator("a").first.click()
+
+    # Step 5: Assert that Manage Active Batch page has loaded
+    manage_page = ManageActiveBatchPage(page)
+    manage_page.assert_batch_details_visible()
+
+    # Step 6: Prepare, retrieve and confirm the batch using utility method
+    prepare_and_print_batch(page, link_text=batch_id)