Completing scenario 10

Author: adrianoaru-nhs

investigation_dataset_ui_app/dataset_fields.json

@@ -352,7 +352,7 @@
       },
       {
         "key": "polyp appears fully resected endoscopically",
-        "type": "YesNoOptions",
+        "type": "YesNoUncertainOptions",
         "description": "Whether the polyp appears fully resected endoscopically",
         "optional": true
       }

pages/datasets/investigation_dataset_page.py

@@ -99,6 +99,13 @@ def __init__(self, page: Page):
         self.antibiotics_administered_string = "Antibiotics Administered"
         self.other_drugs_administered_string = "Other Drugs Administered"
 
+        # Other:
+        self.list_of_multi_line_fields = [
+            "failure reasons",
+            "early complications",
+            "late complications",
+        ]
+
     def select_site_lookup_option(self, option: str) -> None:
         """
         This method is designed to select a site from the site lookup options.
@@ -628,7 +635,7 @@ def get_dataset_section(self, dataset_section_name: str) -> Optional[Locator]:
         Args:
             dataset_section_name (str): The name of the dataset section to locate.
         Returns:
-            Optioanl[Locator]: A Playwright Locator for the matching section if visible, or None if not found or not visible.
+            Optional[Locator]: A Playwright Locator for the matching section if visible, or None if not found or not visible.
         """
         logging.info(f"START: Looking for section '{dataset_section_name}'")
 
@@ -1172,6 +1179,167 @@ def get_drug_dosage_text_locator(self, drug_type: str, drug_number: int) -> Loca
             locator_prefix = "#HILITE_spanAntibioticDosageUnit"
         return self.page.locator(f"{locator_prefix}{drug_number}")
 
+    def does_field_contain_expected_value(
+        self,
+        dataset_area: str,
+        dataset_subsection: str | None,
+        field_name: str,
+        expected_value: str,
+    ) -> None:
+        """
+        Checks if the specified field contains the expected value in the given dataset area and subsection.
+        Args:
+            dataset_area (str): The dataset section name.
+            dataset_subsection (str | None): The dataset subsection name.
+            field_name (str): The field label to check.
+            expected_value (str): The expected value to look for.
+        """
+        logging.debug(
+            f"START: does_field_contain_expected_value({dataset_area}, {dataset_subsection}, {field_name}, {expected_value})"
+        )
+        field_and_value_found = False
+        map_of_field_and_elements = self.map_fields_and_values(
+            dataset_area, dataset_subsection
+        )
+        actual_value = map_of_field_and_elements.get(field_name.lower())
+        if actual_value is not None:
+            actual_value = actual_value.replace("\xa0", "").replace(" ", "")
+            if actual_value.replace(" ", "") == "":
+                actual_value = ""
+            if expected_value.lower() in actual_value.lower():
+                field_and_value_found = True
+            else:
+                raise ValueError(
+                    f"Value not as expected. Expected: {expected_value}, Actual: '{actual_value}'"
+                )
+        else:
+            raise ValueError(
+                f"Field '{field_name}' not found in the dataset area '{dataset_area}' and subsection '{dataset_subsection}'."
+            )
+        logging.debug("END: does_field_contain_expected_value")
+        if field_and_value_found:
+            logging.info(
+                f"[UI ASSERTIONS COMPLETE] Value as expected. Expected: {expected_value}, Actual: '{actual_value}'"
+            )
+
+    def map_fields_and_values(
+        self, dataset_section: str, dataset_subsection: str | None
+    ) -> dict[str, str]:
+        """
+        Maps field labels to their values for a given dataset section and subsection.
+        Args:
+            dataset_section (str): The name of the dataset section.
+            dataset_subsection (str | None): The name of the dataset subsection.
+        Returns:
+            dict[str, str]: A dictionary mapping field labels to their corresponding values.
+        """
+        logging.debug("start: map_fields_and_values()")
+        fields_and_elements = self.map_fields_and_elements(
+            dataset_section, dataset_subsection
+        )
+        fields_with_values = {}
+
+        for field_label, element in fields_and_elements.items():
+            # Find all child elements
+            value_list = element.locator("xpath=.//*").all()
+            field_value = ""
+            if not value_list:
+                field_value = element.inner_text()
+            else:
+                for value_from_list in value_list:
+                    tag_name = value_from_list.evaluate(
+                        "el => el.tagName.toLowerCase()"
+                    )
+                    if tag_name == "select":
+                        # Get selected option text
+                        selected_option = value_from_list.locator("option:checked")
+                        field_value += selected_option.inner_text()
+                    elif tag_name == "li":
+                        input_elem = value_from_list.locator("input")
+                        if input_elem.is_checked():
+                            label_elem = value_from_list.locator("label")
+                            field_value = label_elem.inner_text()
+                    elif tag_name == "input":
+                        input_type = value_from_list.get_attribute("type")
+                        if input_type == "text":
+                            field_value += value_from_list.input_value()
+                    elif tag_name == "p":
+                        field_value += value_from_list.inner_text()
+                    else:
+                        logging.debug(
+                            f"tag type not specified, tag ignored = {tag_name}"
+                        )
+            fields_with_values[field_label] = field_value
+
+        logging.debug("end: map_fields_and_values()")
+        return fields_with_values
+
+    def map_fields_and_elements(
+        self, dataset_section: str, dataset_subsection: Optional[str] = None
+    ) -> dict[str, Locator]:
+        """
+        Maps field labels to their corresponding Playwright Locator elements for a given dataset section and subsection.
+        Args:
+            dataset_section (str): The name of the dataset section.
+            dataset_subsection (Optional[str]): The name of the dataset subsection, if any.
+        Returns:
+            dict[str, Locator]: A dictionary mapping field labels to their corresponding Locator elements.
+        """
+        logging.debug(
+            f"start: map_fields_and_elements({dataset_section}, {dataset_subsection})"
+        )
+        fields_and_elements = {}
+
+        previous_field = ""
+        field_name = ""
+        line_counter = 2
+
+        if dataset_subsection is None:
+            section = self.get_dataset_section(dataset_section)
+        else:
+            section = self.get_dataset_subsection(dataset_section, dataset_subsection)
+
+        if section is None:
+            raise ValueError(
+                f"Section '{dataset_section}'{' / ' + dataset_subsection if dataset_subsection else ''} not found."
+            )
+
+        list_of_rows = section.locator(".noTableRow").all()
+
+        for row in list_of_rows:
+            elements_in_row = row.locator("xpath=.//*").all()
+            element_to_map = None
+
+            for element in elements_in_row:
+                element_class = element.get_attribute("class") or ""
+                if "label" in element_class:
+                    previous_field = field_name
+                    field_name = element.inner_text().lower().replace(" ?", "").strip()
+                    if field_name in fields_and_elements:
+                        name_counter = 2
+                        while f"{field_name} ({name_counter})" in fields_and_elements:
+                            name_counter += 1
+                        field_name = f"{field_name} ({name_counter})"
+                elif "userInput" in element_class:
+                    element_to_map = element
+
+            if field_name.replace(" ", "") != "":
+                fields_and_elements[field_name] = element_to_map
+                line_counter = 2
+            else:
+                if (
+                    hasattr(self, "list_of_multi_line_fields")
+                    and previous_field in self.list_of_multi_line_fields
+                ):
+                    field_name = previous_field
+                    fields_and_elements[f"{field_name} ({line_counter})"] = (
+                        element_to_map
+                    )
+                    line_counter += 1
+
+        logging.debug("end: map_fields_and_elements()")
+        return fields_and_elements
+
 
 def normalize_label(text: str) -> str:
     """

pages/screening_subject_search/advance_episode_page.py

@@ -142,6 +142,9 @@ def __init__(self, page: Page):
         self.date_of_symptomatic_procedure_input = self.page.get_by_role(
             "textbox", name="Date of Symptomatic Procedure"
         )
+        self.initiate_close_button = self.page.get_by_role(
+            "button", name="Initiate Close"
+        )
 
         # Contact recording locators
         self.contact_direction_dropdown = self.page.get_by_label("Contact Direction")
@@ -201,6 +204,10 @@ def click_other_post_investigation_button(self) -> None:
         """Click the 'Other Post-investigation' button."""
         self.safe_accept_dialog(self.other_post_investigation_button)
 
+    def click_initiate_close_button(self) -> None:
+        """Click the 'Initiate Close' button."""
+        self.safe_accept_dialog(self.initiate_close_button)
+
     def get_latest_event_status_cell(self, latest_event_status: str) -> Locator:
         """Get the cell containing the latest event status."""
         return self.page.get_by_role("cell", name=latest_event_status, exact=True)

pages/screening_subject_search/diagnostic_test_outcome_page.py

@@ -1,8 +1,7 @@
-import logging
-from click import option
 from playwright.sync_api import Page, expect, Locator
 from pages.base_page import BasePage
 from enum import StrEnum
+from typing import List
 
 
 class ReferralProcedureType(StrEnum):
@@ -69,6 +68,22 @@ def select_test_outcome_option(self, option: str) -> None:
         """
         self.test_outcome_dropdown.select_option(option)
 
+    def test_outcome_dropdown_contains_options(self, options: List[str]) -> None:
+        """
+        Asserts that all provided options are present in the Outcome of Diagnostic Test dropdown.
+
+        Args:
+            options (List[str]): List of option strings to check.
+        """
+        dropdown_options = [
+            opt.inner_text()
+            for opt in self.test_outcome_dropdown.locator("option").all()
+        ]
+        for item in options:
+            assert (
+                item in dropdown_options
+            ), f"Dropdown is missing expected option: '{item}'"
+
     def verify_reason_for_symptomatic_referral(self, symptomatic_reason: str) -> None:
         """
         Verify reason for symptomatic referral is visible.

pages/screening_subject_search/handover_into_symptomatic_care_page.py

@@ -15,13 +15,17 @@ def __init__(self, page: Page):
         self.calendar_button = self.page.get_by_role("button", name="Calendar")
         self.consultant_link = self.page.locator("#UI_NS_CONSULTANT_PIO_SELECT_LINK")
         self.practitioner_dropdown = self.page.locator("#UI_SCREENING_PRACTITIONER")
+        self.non_screening_practitioner_link = self.page.locator(
+            "#UI_NS_PRACTITIONER_PIO_SELECT_LINK"
+        )
         self.notes_textbox = self.page.get_by_role("textbox", name="Notes")
         self.save_button = self.page.get_by_role("button", name="Save")
         self.cease_from_program_dropdown = self.page.locator(
             "#UI_CEASE_FROM_PROGRAM_ID"
         )
         self.mdt_date_field = self.page.locator("#UI_MDT_DATE")
         self.site_dropdown = self.page.locator("#UI_NS_SITE_SELECT_LINK")
+        self.date_responsibility_accepted_field = self.page.locator("#UI_OTHER_DATE")
 
     def select_referral_dropdown_option(self, value: str) -> None:
         """
@@ -34,12 +38,27 @@ def select_referral_dropdown_option(self, value: str) -> None:
 
     def select_practitioner_from_index(self, practitioner_index: int) -> None:
         """
-        Select the first option from the Practitioner dropdown.
+        Select the an option from the Practitioner dropdown via index.
         Args:
             practitioner_index (int): The index of the practitioner to select.
         """
         self.practitioner_dropdown.select_option(index=practitioner_index)
 
+    def select_non_screening_practitioner_link(self, practitioner_index: int) -> None:
+        """
+        Select the a non screening practitioner from the non screening practitioner dropdown.
+        Args:
+            practitioner_index (int): The index of the non screening practitioner to select.
+        """
+        self.non_screening_practitioner_link.click()
+        select_locator = self.page.locator('select[id^="UI_RESULTS_"]:visible')
+        select_locator.first.wait_for(state="visible")
+
+        # Find all option elements inside the select and click the one at the given index
+        option_elements = select_locator.first.locator("option")
+        option_elements.nth(practitioner_index).wait_for(state="visible")
+        self.click(option_elements.nth(practitioner_index))
+
     def click_calendar_button(self) -> None:
         """Click the calendar button to open the calendar picker."""
         self.click(self.calendar_button)
@@ -56,6 +75,21 @@ def select_consultant(self, value: str) -> None:
         option_locator.wait_for(state="visible")
         self.click(option_locator)
 
+    def select_consultant_from_index(self, consultant_index: int) -> None:
+        """
+        Select the a consultant from the consultant dropdown.
+        Args:
+            consultant_index (int): The index of the consultant to select.
+        """
+        self.click(self.consultant_link)
+        select_locator = self.page.locator('select[id^="UI_RESULTS_"]:visible')
+        select_locator.first.wait_for(state="visible")
+
+        # Find all option elements inside the select and click the one at the given index
+        option_elements = select_locator.first.locator("option")
+        option_elements.nth(consultant_index).wait_for(state="visible")
+        self.click(option_elements.nth(consultant_index))
+
     def fill_notes(self, notes: str) -> None:
         """
         Fill the 'Notes' textbox with the provided text.
@@ -88,6 +122,16 @@ def enter_mdt_date(self, date: datetime) -> None:
         """
         CalendarPicker(self.page).calendar_picker_ddmmyyyy(date, self.mdt_date_field)
 
+    def enter_date_responsibility_accepted_field(self, date: datetime) -> None:
+        """
+        Enters a date into the 'Date Responsibility Accepted' field
+        Args:
+            date (datetime): The date to enter.
+        """
+        CalendarPicker(self.page).calendar_picker_ddmmyyyy(
+            date, self.date_responsibility_accepted_field
+        )
+
     def select_site_dropdown_option_index(self, index: int) -> None:
         """
         Select a given option from the site dropdown.
@@ -118,3 +162,20 @@ def fill_with_cancer_details(self) -> None:
         self.fill_notes("Handover notes for Cancer scenario")
         self.click_save_button()
         self.page.wait_for_timeout(500)  # Timeout to allow subject to update in the DB.
+
+    def perform_referral_to_specific_clinician_scenario(self) -> None:
+        """
+        Complete the Handover into Symptomatic Care form with the Referral to Specific Clinician scenario:
+            Referral: Referral to Specific Clinician
+            Date Responsibility Accepted: Today
+            Non Screening Consultant: Last option
+            Non Screening Practitioner: Last option
+            Note: Handover notes - referral to Specific Clinician
+        """
+        self.select_referral_dropdown_option("Referral to Specific Clinician")
+        self.enter_date_responsibility_accepted_field(datetime.today())
+        self.select_consultant_from_index(-1)
+        self.select_non_screening_practitioner_link(-1)
+        self.fill_notes("Handover notes - referral to Specific Clinician")
+        self.click_save_button()
+        self.page.wait_for_timeout(500)  # Timeout to allow subject to update in the DB.