Added scenarios for fit self refer letter processing

Author: Andyg79

pages/call_and_recall/generate_invitations_page.py

@@ -6,6 +6,7 @@
 from utils.oracle.subject_selection_query_builder import SubjectSelectionQueryBuilder
 from classes.user import User
 from classes.subject import Subject
+from utils.table_util import TableUtils
 
 
 class GenerateInvitationsPage(BasePage):
@@ -108,6 +109,68 @@ def wait_for_invitation_generation_complete(
             logging.warning("No S1 Digital Leaflet batch will be generated")
             return False
 
+    def wait_for_self_referral_invitation_generation_complete(
+        self, expected_minimum: int = 1
+    ) -> bool:
+        """
+        Waits until the invitations have been generated and checks that 'Self Referrals Generated' meets the expected threshold.
+
+        Args:
+            expected_minimum (int): Minimum number of self-referrals expected to be generated (default is 1)
+
+        Returns:
+            bool: True if threshold is met, False otherwise.
+        """
+        # Reuse the existing table completion logic — consider extracting this into a shared method later
+        timeout = 120000
+        wait_interval = 5000
+        elapsed = 0
+        logging.info(
+            "[WAIT] Waiting for self-referral invitation generation to complete"
+        )
+
+        while elapsed < timeout:
+            table_text = self.display_rs.text_content()
+            if table_text is None:
+                pytest.fail("Failed to retrieve table text content")
+
+            if "Failed" in table_text:
+                pytest.fail("Invitation has failed to generate")
+            elif "Queued" in table_text or "In Progress" in table_text:
+                self.click_refresh_button()
+                self.page.wait_for_timeout(wait_interval)
+                elapsed += wait_interval
+            else:
+                break
+
+        try:
+            expect(self.display_rs).to_contain_text("Completed")
+            logging.info(
+                f"[STATUS] Generation finished after {elapsed / 1000:.1f} seconds"
+            )
+        except Exception as e:
+            pytest.fail(f"[ERROR] Invitations not generated successfully: {str(e)}")
+
+        # Dynamically check 'Self Referrals Generated'
+        table_utils = TableUtils(self.page, "#displayRS")
+
+        try:
+            value_text = table_utils.get_footer_value_by_header(
+                "Self Referrals Generated"
+            )
+            value = int(value_text.strip())
+            logging.info(f"[RESULT] 'Self Referrals Generated' = {value}")
+        except Exception as e:
+            pytest.fail(f"[ERROR] Unable to read 'Self Referrals Generated': {str(e)}")
+
+        if value >= expected_minimum:
+            return True
+        else:
+            logging.warning(
+                f"[ASSERTION] Expected at least {expected_minimum}, but got {value}"
+            )
+            return False
+
     def check_self_referral_subjects_ready(
         self, search_scope: str, volume: str
     ) -> None:

pages/communication_production/batch_list_page.py

@@ -91,9 +91,16 @@ def enter_id_filter(self, search_text: str) -> None:
         self.id_filter.fill(search_text)
         self.id_filter.press("Enter")
 
-    def enter_type_filter(self, search_text: str) -> None:
-        self.type_filter.fill(search_text)
-        self.type_filter.press("Enter")
+    def enter_type_filter(self, option_text: str) -> None:
+        """
+        Selects the given option from the 'Type' filter dropdown.
+
+        Args:
+            option_text (str): The visible label of the option to select (e.g. "Original", "All")
+        """
+        self.type_filter.select_option(label=option_text)
+        logging.info(f"[FILTER] Type filter set to '{option_text}'")
+
 
     def enter_original_filter(self, search_text: str) -> None:
         self.original_filter.fill(search_text)
@@ -184,19 +191,6 @@ def is_batch_present(self, batch_type: str) -> bool:
         )
         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(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()
-        expect(row).not_to_be_visible(timeout=5000)
-
     def get_open_original_batch_row(self) -> Locator | None:
         """
         Returns the first table row where:
@@ -298,29 +292,26 @@ def __init__(self, page: Page):
     def assert_letter_component_present(self, letter_type: str, format: str) -> None:
         """
         Asserts that a letter component with the given type and format is listed.
+        This version works with div-based structures, not tables.
 
         Args:
-            letter_type (str): The letter type (e.g. "Invitation & Test Kit (Self-referral) (FIT)")
-            format (str): The file format (e.g. "PDF-A4-V03")
+            letter_type (str): Visible component description
+            format (str): File format label (e.g., "PDF-A4-V03", "FIT-KIT-CSV")
         """
-        row_locator = self.letter_table.locator("tbody tr")
+        descriptions = self.page.locator("div.letterDescription")
+        formats = self.page.locator("div.letterFormat")
         match_found = False
 
-        for i in range(row_locator.count()):
-            row = row_locator.nth(i)
-            type_cell = row.locator("td").nth(1)
-            format_cell = row.locator("td").nth(2)
-
+        for i in range(min(descriptions.count(), formats.count())):
             if (
-                letter_type.lower() in type_cell.inner_text().lower()
-                and format.lower() in format_cell.inner_text().lower()
+                letter_type.lower() in descriptions.nth(i).inner_text().lower()
+                and format.lower() in formats.nth(i).inner_text().lower()
             ):
                 match_found = True
                 break
 
-        assert (
-            match_found
-        ), f"Letter type '{letter_type}' with format '{format}' not found"
+        assert match_found, f"Letter type '{letter_type}' with format '{format}' not found"
+
 
     def get_first_subject_nhs_number(self) -> str:
         """

pages/communication_production/manage_active_batch_page.py

@@ -37,12 +37,6 @@ def assert_active_batch_details_visible(self) -> None:
         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")

pages/screening_subject_search/subject_screening_search_page.py

@@ -192,8 +192,13 @@ def click_send_kit_button(self) -> None:
                 f"[PAGE TRANSITION FAILED] Did not reach Send a kit page: {e}"
             )
             raise
-    
-    def complete_send_kit_form(self, request_from: str = "Subject", previous_kit_status: str = "Lost", note_text: str = "Test") -> None:
+
+    def complete_send_kit_form(
+        self,
+        request_from: str = "Subject",
+        previous_kit_status: str = "Lost",
+        note_text: str = "Test",
+    ) -> None:
         """
         Completes the 'Send a kit' form by:
         - Selecting who requested the kit
@@ -218,6 +223,17 @@ def complete_send_kit_form(self, request_from: str = "Subject", previous_kit_sta
         expect(send_button).to_be_enabled()
         send_button.click()
 
+        # Handle confirmation modal if it appears
+        success_button = self.page.locator("button[data-testid='successButton']")
+        if success_button.is_visible():
+            expect(success_button).to_be_enabled()
+            success_button.click()
+            logging.info("[MODAL CLOSED] Success modal dismissed")
+        else:
+            logging.warning(
+                "[MODAL NOT FOUND] Success button not visible after kit request"
+            )
+
         logging.info("[KIT REQUEST] 'Send a kit' form submitted successfully")
 
 

pages/screening_subject_search/subject_screening_summary_page.py

@@ -60,6 +60,9 @@ def __init__(self, page: Page):
         self.temporary_address_popup = self.page.locator("#idTempAddress")
         self.close_button = self.page.get_by_role("img", name="close")
 
+        # List of Subject Episodes - page filters
+        self.view_events_link = self.page.get_by_role("link", name="events")
+
     def wait_for_page_title(self) -> None:
         """Waits for the page to be the Subject Screening Summary"""
         self.subject_screening_summary.wait_for()
@@ -227,36 +230,35 @@ def click_close_button(self) -> None:
         """Click on the close button in the temporary address popup."""
         self.click(self.close_button)
 
+    def click_view_events_link(self) -> None:
+        """Click on the 'View Events' link."""
+        self.click(self.view_events_link)
+
     def assert_view_letter_links_for_event(
         self, event_name: str, expected_count: int
     ) -> None:
-        """
-        Asserts that the specified event row contains the expected number of 'View Letter' links.
-
-        Args:
-            event_name (str): The name of the event to locate (e.g. "S84 - Invitation and Test Kit Sent (Self-referral)")
-            expected_count (int): The expected number of 'View Letter' links in that row
-        """
-        # Locate the event row by its name
+        # Locate the row where the 3rd <td> contains the target event status
         event_row = (
-            self.page.locator("table#subjectEvents tbody tr")
-            .filter(has=self.page.locator("td", has_text=event_name))
+            self.page.locator("table#displayRS tbody tr")
+            .filter(has=self.page.locator("td:nth-child(3)", has_text=event_name))
             .first
         )
 
+        event_row.wait_for(timeout=10000)
+
         if event_row.count() == 0:
-            raise RuntimeError(f"Event row for '{event_name}' not found")
+            raise RuntimeError(f"[ERROR] Event row for '{event_name}' not found")
 
-        # Count the 'View Letter' links in that row
-        view_links = event_row.locator("a", has_text="View Letter")
-        actual_count = view_links.count()
+        # Count the number of 'View Letter' links inside the 5th column (Item)
+        letter_links = event_row.locator("td:nth-child(5) a", has_text="View Letter")
+        actual_count = letter_links.count()
 
         logging.info(
-            f"Found {actual_count} 'View Letter' links for event '{event_name}'"
+            f"[DEBUG] Found {actual_count} 'View Letter' links for event: {event_name}"
         )
         assert (
             actual_count == expected_count
-        ), f"Expected {expected_count} 'View Letter' links for event '{event_name}', but found {actual_count}"
+        ), f"[ASSERTION FAILED] Expected {expected_count} 'View Letter' links for '{event_name}', but found {actual_count}"
 
 
 class ChangeScreeningStatusOptions(Enum):