Merge branch 'main' of github.com:NHSDigital/bcss-playwright into feature/BCSS-20605-regression-tests-subject-notes

# Conflicts:
#	users.json

Author: mepr1

pages/base_page.py

@@ -239,9 +239,46 @@ def safe_accept_dialog(self, locator: Locator) -> None:
         Safely accepts a dialog triggered by a click, avoiding the error:
         playwright._impl._errors.Error: Dialog.accept: Cannot accept dialog which is already handled!
         If no dialog appears, continues without error.
+        Args:
+            locator (Locator): The locator that triggers the dialog when clicked.
+            example: If clicking a save button opens a dialog, pass that save button's locator.
         """
         self.page.once("dialog", self._accept_dialog)
         try:
             self.click(locator)
         except Exception as e:
             logging.error(f"Click failed: {e}")
+
+
+    def assert_dialog_text(self, expected_text: str) -> None:
+        """
+        Asserts that a dialog appears and contains the expected text.
+        If no dialog appears, logs an error.
+        Args:
+            expected_text (str): The text that should be present in the dialog.
+        """
+
+        def handle_dialog(dialog):
+            actual_text = dialog.message
+            assert (
+                actual_text == expected_text
+            ), f"Expected '{expected_text}', but got '{actual_text}'"
+            dialog.dismiss()  # Dismiss dialog
+
+        self.page.once("dialog", handle_dialog)
+
+    def safe_accept_dialog_select_option(self, locator: Locator, option: str) -> None:
+        """
+        Safely accepts a dialog triggered by selecting a dropdown, avoiding the error:
+        playwright._impl._errors.Error: Dialog.accept: Cannot accept dialog which is already handled!
+        If no dialog appears, continues without error.
+        Args:
+            locator (Locator): The locator that triggers the dialog when clicked.
+            example: If clicking a save button opens a dialog, pass that save button's locator.
+        """
+        self.page.once("dialog", self._accept_dialog)
+        try:
+            locator.select_option(option)
+        except Exception as e:
+            logging.error(f"Option selection failed: {e}")   
+            

pages/call_and_recall/create_a_plan_page.py

@@ -1,5 +1,6 @@
 from playwright.sync_api import Page, expect
 from pages.base_page import BasePage
+from utils.table_util import TableUtils
 
 
 class CreateAPlanPage(BasePage):
@@ -23,6 +24,20 @@ def __init__(self, page: Page):
         self.save_note_button = self.page.locator("#saveNote").get_by_role(
             "button", name="Save"
         )
+        # Create A Plan Table Locators
+        self.weekly_invitation_rate_field_on_table = self.page.locator(
+            "#invitationPlan > tbody > tr:nth-child(1) > td.input.border-right.dt-type-numeric > input"
+        )
+        self.invitations_sent_value = self.page.locator(
+            "tbody tr:nth-child(1) td:nth-child(8)"
+        )
+
+        self.resulting_position_value = self.page.locator(
+            "#invitationPlan > tbody > tr:nth-child(1) > td:nth-child(9)"
+        )
+
+        # Initialize TableUtils for different tables
+        self.create_a_plan_table = TableUtils(page, "#invitationPlan")
 
     def click_set_all_button(self) -> None:
         """Clicks the Set all button to set all values"""
@@ -59,3 +74,106 @@ def click_save_note_button(self) -> None:
     def verify_create_a_plan_title(self) -> None:
         """Verifies the Create a Plan page title"""
         self.bowel_cancer_screening_page_title_contains_text("View a plan")
+
+    def verify_weekly_invitation_rate_for_weeks(
+        self, start_week: int, end_week: int, expected_weekly_rate: str
+    ) -> None:
+        """
+        Verifies that the weekly invitation rate is correctly calculated and displayed for the specified range of weeks.
+
+        Args:
+        start_week (int): The starting week of the range.
+        end_week (int): The ending week of the range.
+        expected_weekly_rate (str): The expected weekly invitation rate.
+        """
+
+        # Verify the rate for the starting week
+        weekly_invitation_rate_selector = "#invitationPlan > tbody > tr:nth-child(2) > td.input.border-right.dt-type-numeric > input"
+        self.page.wait_for_selector(weekly_invitation_rate_selector)
+        weekly_invitation_rate = self.page.locator(
+            weekly_invitation_rate_selector
+        ).input_value()
+
+        assert (
+            weekly_invitation_rate == expected_weekly_rate
+        ), f"Expected weekly invitation rate '{expected_weekly_rate}' for week {start_week} but got '{weekly_invitation_rate}'"
+        # Verify the rate for the specified range of weeks
+        for week in range(start_week + 1, end_week + 1):
+            weekly_rate_locator = f"#invitationPlan > tbody > tr:nth-child({week + 2}) > td.input.border-right.dt-type-numeric > input"
+
+            # Wait for the element to be available
+            self.page.wait_for_selector(weekly_rate_locator)
+
+            # Get the input value safely
+            weekly_rate_element = self.page.locator(weekly_rate_locator)
+            assert (
+                weekly_rate_element.is_visible()
+            ), f"Week {week} rate element not visible"
+
+            # Verify the value
+            actual_weekly_rate = weekly_rate_element.input_value()
+            assert (
+                actual_weekly_rate == expected_weekly_rate
+            ), f"Week {week} invitation rate should be '{expected_weekly_rate}', but found '{actual_weekly_rate}'"
+
+            # Get the text safely
+        # Get the frame first
+        frame = self.page.frame(
+            url="https://bcss-bcss-18680-ddc-bcss.k8s-nonprod.texasplatform.uk/invitation/plan/23159/23162/create"
+        )
+
+        # Ensure the frame is found before proceeding
+        assert frame, "Frame not found!"
+
+        # Now locate the input field inside the frame and get its value
+        weekly_invitation_rate_selector = "#invitationPlan > tbody > tr:nth-child(2) > td.input.border-right.dt-type-numeric > input"
+        weekly_invitation_rate = frame.locator(
+            weekly_invitation_rate_selector
+        ).input_value()
+
+        # Assert the expected value
+        assert (
+            weekly_invitation_rate == expected_weekly_rate
+        ), f"Week 2 invitation rate should be '{expected_weekly_rate}', but found '{weekly_invitation_rate}'"
+
+    def increment_invitation_rate_and_verify_changes(self) -> None:
+        """
+        Increments the invitation rate by 1, then verifies that both the
+        'Invitations Sent' has increased by 1 and 'Resulting Position' has decreased by 1.
+        """
+        # Capture initial values before any changes
+        initial_invitations_sent = int(self.invitations_sent_value.inner_text().strip())
+        initial_resulting_position = int(
+            self.resulting_position_value.inner_text().strip()
+        )
+
+        # Increment the invitation rate
+        current_rate = int(
+            self.create_a_plan_table.get_cell_value("Invitation Rate", 1)
+        )
+        new_rate = str(current_rate + 1)
+        self.weekly_invitation_rate_field_on_table.fill(new_rate)
+        self.page.keyboard.press("Tab")
+
+        # Wait dynamically for updates
+        expect(self.invitations_sent_value).to_have_text(
+            str(initial_invitations_sent + 1)
+        )
+        expect(self.resulting_position_value).to_have_text(
+            str(initial_resulting_position + 1)
+        )
+
+        # Capture updated values
+        updated_invitations_sent = int(self.invitations_sent_value.inner_text().strip())
+        updated_resulting_position = int(
+            self.resulting_position_value.inner_text().strip()
+        )
+
+        # Assert changes
+        assert (
+            updated_invitations_sent == initial_invitations_sent + 1
+        ), f"Expected Invitations Sent to increase by 1. Was {initial_invitations_sent}, now {updated_invitations_sent}."
+
+        assert (
+            updated_resulting_position == initial_resulting_position + 1
+        ), f"Expected Resulting Position to increase by 1. Was {initial_resulting_position}, now {updated_resulting_position}."

pages/call_and_recall/generate_invitations_page.py

@@ -91,7 +91,7 @@ def wait_for_invitation_generation_complete(
         value = value.strip()  # Get text and remove extra spaces
         if int(value) < number_of_invitations:
             pytest.fail(
-                f"There are less than {number_of_invitations} invitations generated"
+                f"Expected {number_of_invitations} invitations generated but got {value}"
             )
 
         self_referrals_total_text = self.self_referrals_total.text_content()

pages/call_and_recall/non_invitations_days_page.py

@@ -1,5 +1,6 @@
 from playwright.sync_api import Page, expect
 from pages.base_page import BasePage
+from utils.date_time_utils import DateTimeUtils
 
 
 class NonInvitationDaysPage(BasePage):
@@ -9,7 +10,54 @@ def __init__(self, page: Page):
         super().__init__(page)
         self.page = page
         # Non Invitation Days - page locators, methods
+        self.enter_note_field = self.page.locator("#note")
+        self.enter_date_field = self.page.get_by_role("textbox", name="date")
+        self.add_non_invitation_day_button = self.page.get_by_role(
+            "button", name="Add Non-Invitation Day"
+        )
+        self.non_invitation_day_delete_button = self.page.get_by_role(
+            "button", name="Delete"
+        )
+        self.created_on_date_locator = self.page.locator(
+            "tr.oddTableRow td:nth-child(4)"
+        )
 
     def verify_non_invitation_days_tile(self) -> None:
         """Verifies the page title of the Non Invitation Days page"""
         self.bowel_cancer_screening_page_title_contains_text("Non-Invitation Days")
+
+    def enter_date(self, date: str) -> None:
+        """Enters a date in the date input field
+        Args:
+            date (str): The date to enter in the field, formatted as 'dd/mm/yyyy'.
+        """
+        self.enter_date_field.fill(date)
+
+    def enter_note(self, note: str) -> None:
+        """Enters a note in the note input field
+        Args:
+            note (str): The note to enter in the field.
+        """
+        self.enter_note_field.fill(note)
+
+    def click_add_non_invitation_day_button(self) -> None:
+        """Clicks the Add Non-Invitation Day button"""
+        self.click(self.add_non_invitation_day_button)
+
+    def click_delete_button(self) -> None:
+        """Clicks the Delete button for a non-invitation day"""
+        self.click(self.non_invitation_day_delete_button)
+
+    def verify_created_on_date_is_visible(self) -> None:
+        """Verifies that the specified date is visible on the page
+        Args:
+            date (str): The date to verify, formatted as 'dd/mm/yyyy'.
+        """
+        today = DateTimeUtils.current_datetime("%d/%m/%Y")
+        expect(self.created_on_date_locator).to_have_text(today)
+
+    def verify_created_on_date_is_not_visible(self) -> None:
+        """Verifies that the 'created on' date element is not visible on the page.
+        This is used to confirm that the non-invitation day has been successfully deleted.
+        """
+        expect(self.created_on_date_locator).not_to_be_visible

pages/communication_production/batch_list_page.py

@@ -93,6 +93,33 @@ def clear_deadline_filter_date(self) -> None:
     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
+    ) -> 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)").
+        """
+        # 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
+        expect(view_link).to_be_visible()
+        view_link.click()
+
 
 class ActiveBatchListPage(BatchListPage):
     """Active Batch List Page locators, and methods for interacting with the Active Batch List page"""

pages/screening_subject_search/subject_events_notes.py

@@ -27,7 +27,7 @@ def __init__(self, page: Page):
         self.update_notes_button = self.page.get_by_role("button", name="Update Notes")
         self.note_type = self.page.locator("#UI_ADDITIONAL_CARE_NEED_FILTER")
         self.note_status = self.page.locator(
-            "select[name^='UI_SUPPORTING_NOTE_STATUS_']"
+            "//table[@id='displayRS']/tbody/tr[2]/td[3]/select"
         )
 
     def select_additional_care_note(self) -> None:
@@ -87,47 +87,27 @@ def fill_notes(self, notes: str) -> None:
         """Fills the notes field with the provided text."""
         self.notes_upto_500_char.fill(notes)
 
-    def dismiss_dialog_and_update_notes(self) -> None:
+    def accept_dialog_and_update_notes(self) -> None:
         """Clicks the 'Update Notes' button and handles the dialog by clicking 'OK'."""
         self.page.once("dialog", lambda dialog: dialog.accept())
         self.update_notes_button.click()
 
-    def dismiss_dialog_and_add_replacement_note(self) -> None:
+    def accept_dialog_and_add_replacement_note(self) -> None:
         """
         Dismisses the dialog and clicks the 'Add Replacement Note' button.
         """
-        self.page.once("dialog", lambda dialog: dialog.dismiss())
+        self.page.once("dialog", lambda dialog: dialog.accept())
         self.page.get_by_role("button", name="Add Replacement Note").click()
 
-    def dismiss_dialog(self) -> None:
-        """
-        Dismisses a dialog when it appears.
-        """
-        self.page.once("dialog", lambda dialog: dialog.dismiss())
-
     def get_title_and_note_from_row(self, row_number: int = 0) -> dict:
         """
         Extracts title and note from a specific row's 'Notes' column using dynamic column index.
         """
-        row_count = self.table_utils.get_row_count()
-        if row_count == 0:
-            raise ValueError("The table is empty.")
-
-        # Find the 'Notes' column index (1-based)
-        notes_col_index = self.table_utils.get_column_index("Notes")
-        if notes_col_index == -1:
-            raise ValueError("The 'Notes' column was not found in the table.")
-
-        # Locate the cell at the specific row and column
-        cell = self.page.locator(
-            f"{self.table_utils} > tbody > tr:nth-child({row_number + 1}) > td:nth-child({notes_col_index})"
-        )
-        cell_text = cell.inner_text().strip()
-
-        lines = cell_text.split("\n")
+        cell_text= self.table_utils.get_cell_value("Notes", row_number)
+        lines = cell_text.split("\n\n")
         title = lines[0].strip() if len(lines) > 0 else ""
         note = lines[1].strip() if len(lines) > 1 else ""
-
+        logging.info(f"Extracted title: '{title}' and note: '{note}' from row {row_number}")    
         return {"title": title, "note": note}
 
 

pages/screening_subject_search/subject_screening_search_page.py

@@ -10,6 +10,8 @@ class SubjectScreeningPage(BasePage):
     def __init__(self, page: Page):
         super().__init__(page)
         self.page = page
+        self.results_table_locator = "table#subject-search-results"
+
         # Subject Search Criteria - page filters
         self.episodes_filter = self.page.get_by_role("radio", name="Episodes")
         self.demographics_filter = self.page.get_by_role("radio", name="Demographics")
@@ -159,6 +161,7 @@ def select_dob_using_calendar_picker(self, date) -> None:
         CalendarPicker(self.page).v1_calender_picker(date)
 
     def verify_date_of_birth_filter_input(self, expected_text: str) -> None:
+        """Verifies that the Date of Birth filter input field has the expected value."""
         expect(self.date_of_birth_filter).to_have_value(expected_text)
 
 

pytest.ini

@@ -37,3 +37,5 @@ markers =
     compartment6: only for compartment 6
     compartment1_plan_creation: to run the plan creation for compartment 1
     vpn_required: for tests that require a VPN connection
+    regression: tests that are part of the regression test suite
+    call_and_recall: tests that are part of the call and recall test suite

tests/bcss_tests.properties

@@ -21,3 +21,9 @@ forename=Pentagram
 surname=Absurd
 subject_dob=11/01/1934
 episode_closed_date=22/09/2020
+
+# ----------------------------------
+# CALL AND RECALL TEST DATA
+# ----------------------------------
+daily_invitation_rate=6
+weekly_invitation_rate=130