Removing unneeeded method

Author: adrianoaru-nhs

pages/datasets/investigation_dataset_page.py

@@ -1182,266 +1182,6 @@ 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})"
-        )
-        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() not in actual_value.lower():
-                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.info(
-            f"[UI ASSERTIONS COMPLETE] Value as expected. Expected: {expected_value}, Actual: '{actual_value}'"
-        )
-        logging.debug("END: does_field_contain_expected_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():
-            fields_with_values[field_label] = self._extract_field_value(element)
-
-        logging.debug("end: map_fields_and_values()")
-        return fields_with_values
-
-    def _extract_field_value(self, element: Locator) -> str:
-        """
-        Extracts the value from a field element, handling different HTML tags.
-
-        Args:
-            element (Locator): The Playwright Locator for the field element.
-
-        Returns:
-            str: The extracted value as a string.
-        """
-        value_list = element.locator("xpath=.//*").all()
-        if not value_list:
-            return element.inner_text()
-        field_value = ""
-        for value_from_list in value_list:
-            tag_name = value_from_list.evaluate("el => el.tagName.toLowerCase()")
-            match tag_name:
-                case "select":
-                    selected_option = value_from_list.locator("option:checked")
-                    field_value += selected_option.inner_text()
-                case "li":
-                    input_elem = value_from_list.locator("input")
-                    if input_elem.is_checked():
-                        label_elem = value_from_list.locator("label")
-                        return label_elem.inner_text()
-                case "input":
-                    input_type = value_from_list.get_attribute("type")
-                    if input_type == "text":
-                        field_value += value_from_list.input_value()
-                case "p":
-                    field_value += value_from_list.inner_text()
-                case _:
-                    logging.debug(f"tag type not specified, tag ignored = {tag_name}")
-        return field_value
-
-    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()
-        self._process_rows_for_field_mapping(
-            list_of_rows, fields_and_elements, previous_field, field_name, line_counter
-        )
-
-        logging.debug("end: map_fields_and_elements()")
-        return fields_and_elements
-
-    def _process_rows_for_field_mapping(
-        self,
-        list_of_rows: list,
-        fields_and_elements: dict,
-        previous_field: str,
-        field_name: str,
-        line_counter: int,
-    ) -> None:
-        """
-        Processes each row in the dataset section/subsection and maps field labels to their corresponding Locator elements.
-
-        Args:
-            list_of_rows (list): List of Playwright Locator rows in the section/subsection.
-            fields_and_elements (dict): Dictionary to store field label to Locator mappings.
-            previous_field (str): The previous field label encountered.
-            field_name (str): The current field label being processed.
-            line_counter (int): Counter for multi-line fields.
-        """
-        for row in list_of_rows:
-            elements_in_row = row.locator("xpath=.//*").all()
-            field_name, previous_field, element_to_map = (
-                self._extract_field_and_element(
-                    elements_in_row, field_name, previous_field, fields_and_elements
-                )
-            )
-            if element_to_map is None:
-                raise ValueError(
-                    f"Could not find element to map for field '{field_name}'"
-                )
-            line_counter = self._update_fields_and_elements(
-                fields_and_elements,
-                field_name,
-                previous_field,
-                element_to_map,
-                line_counter,
-            )
-
-    def _extract_field_and_element(
-        self,
-        elements_in_row: list,
-        field_name: str,
-        previous_field: str,
-        fields_and_elements: dict,
-    ) -> tuple[str, str, Optional[Locator]]:
-        """
-        Extracts the field name and element to map from the elements in a row.
-
-        Args:
-            elements_in_row (list): List of Playwright Locator elements in the row.
-            field_name (str): The current field label being processed.
-            previous_field (str): The previous field label encountered.
-            fields_and_elements (dict): Dictionary to store field label to Locator mappings.
-
-        Returns:
-            tuple[str, str, Locator]: Updated field_name, previous_field, and element_to_map.
-        """
-        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:
-                    field_name = self._resolve_field_name_conflict(
-                        fields_and_elements, field_name
-                    )
-            elif "userInput" in element_class:
-                element_to_map = element
-        return field_name, previous_field, element_to_map
-
-    def _resolve_field_name_conflict(
-        self, fields_and_elements: dict, field_name: str
-    ) -> str:
-        """
-        Resolves field name conflicts by appending a counter.
-
-        Args:
-            fields_and_elements (dict): Dictionary to store field label to Locator mappings.
-            field_name (str): The field name to resolve.
-
-        Returns:
-            str: The resolved field name with a counter appended.
-        """
-        name_counter = 2
-        while f"{field_name} ({name_counter})" in fields_and_elements:
-            name_counter += 1
-        return f"{field_name} ({name_counter})"
-
-    def _update_fields_and_elements(
-        self,
-        fields_and_elements: dict,
-        field_name: str,
-        previous_field: str,
-        element_to_map: Locator,
-        line_counter: int,
-    ) -> int:
-        """
-        Updates the fields_and_elements dictionary with the field name and element, handling multi-line fields.
-
-        Args:
-            fields_and_elements (dict): Dictionary to store field label to Locator mappings.
-            field_name (str): The current field label being processed.
-            previous_field (str): The previous field label encountered.
-            element_to_map (Locator): The element to map.
-            line_counter (int): Counter for multi-line fields.
-
-        Returns:
-            int: The updated line_counter value.
-        """
-        if field_name.replace(" ", "") != "":
-            fields_and_elements[field_name] = element_to_map
-            return 2
-        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
-            return line_counter + 1
-        return line_counter
-
     def assert_test_result(self, expected_text: str) -> None:
         """
         Asserts that the text in the test result matches the expected text.

tests/regression/regression_tests/surveillance_regression_tests/test_surveillance_scenario_10.py

@@ -244,8 +244,8 @@ def test_scenario_10(page: Page, general_properties: dict) -> None:
     )
 
     # Then I confirm the "Investigation Dataset" section of the dataset contains the field "Actual Type of Test" with the value of "Flexible Sigmoidoscopy"
-    InvestigationDatasetsPage(page).does_field_contain_expected_value(
-        "Investigation Dataset", None, "Actual Type of Test", "Flexible Sigmoidoscopy"
+    DatasetFieldUtil(page).assert_cell_to_right_has_expected_text(
+        "Actual Type of Test", "Flexible Sigmoidoscopy"
     )
 
     # Then I get a confirmation prompt that "contains" "Are you sure you want to change the actual type of diagnostic test to Colonoscopy?"
@@ -262,8 +262,8 @@ def test_scenario_10(page: Page, general_properties: dict) -> None:
     )
 
     # Then I confirm the "Investigation Dataset" section of the dataset contains the field "Actual Type of Test" with the value of "Colonoscopy"
-    InvestigationDatasetsPage(page).does_field_contain_expected_value(
-        "Investigation Dataset", None, "Actual Type of Test", "Colonoscopy"
+    DatasetFieldUtil(page).assert_cell_to_right_has_expected_text(
+        "Actual Type of Test", "Colonoscopy"
     )
 
     # When I add the following bowel preparation drugs and values within the Investigation Dataset for this subject: