Fix failing logout tests

conftest.py

@@ -51,6 +51,8 @@ def format_nhs_number(nhs_number):
     formatted_number = re.sub(r"(\d{3})(\d{3})(\d{4})", r"\1 \2 \3", nhs_number)
     return formatted_number
 
+
+
 @pytest.fixture(scope='function')
 def playwright_helper(request):
     helper = PlaywrightHelper(get_working_directory(), config)

helpers/playwrightHelper.py

@@ -118,8 +118,8 @@ def navigate_to_url(self,url):
         self.page.wait_for_load_state()
 
     def wait_for_page_to_load(self, timeout=0.1):
-        self.page.wait_for_selector('*', timeout=timeout * 100)
-        self.page.wait_for_load_state('domcontentloaded', timeout=timeout * 100)
+        self.page.wait_for_selector('*', timeout=timeout * 1000)
+        self.page.wait_for_load_state('domcontentloaded', timeout=timeout * 1000)
 
     def find_elements(self, selector):
         return self.page.query_selector_all(selector)
@@ -131,15 +131,18 @@ def wait_for_element_to_appear(self, locator_or_element, timeout=5):
                 # If it's a selector string, wait for the element to be visible
                 self.page.wait_for_selector(locator_or_element, state='visible', timeout=timeout * 1000)
                 element = self.page.locator(locator_or_element)
-            else:
-                # If it's already a pre-located element (Locator), use it directly
+            elif isinstance(locator_or_element, object) and hasattr(locator_or_element, 'wait_for'):
+                # If it's a pre-located Playwright Locator, use it directly
+                locator_or_element.wait_for(state='visible', timeout=timeout * 1000)
                 element = locator_or_element
-                element.wait_for(state='visible', timeout=timeout * 1000)
+            else:
+                raise ValueError(f"Invalid locator or element type: {type(locator_or_element)}")
 
-            print(f"Element with locator '{element}' appeared on the page.")
+            print(f"Element with locator '{locator_or_element}' appeared on the page.")
         except Exception as e:
             print(f"Error waiting for element '{locator_or_element}' to appear: {e}")
 
+
     def wait_for_selector_to_disappear(self, selector, timeout=5):
         try:
             self.page.wait_for_selector(selector, state='hidden', timeout=timeout)
@@ -261,57 +264,6 @@ def find_element_with_locator_and_perform_action(self, element, action, inputVal
         else:
             raise ValueError(f"Unsupported action: {action}")
 
-    # def find_element_and_perform_action(self, selector, action, inputValue=None):
-    #     selector_filename = "".join(c if c.isalnum() else "_" for c in selector)
-    #     self.capture_screenshot(selector_filename)
-    #     try:
-    #         element=self.page.locator(selector)
-    #         self.page.set_viewport_size({"width": 1500, "height":1500})
-    #         element.scroll_into_view_if_needed()
-    #         if action.lower() == "click":
-    #             if element.is_visible():
-    #                 if element.is_enabled():
-    #                     element.click()
-    #                     print(f"Clicked the {selector} successfully.")
-    #             else:
-    #                 print(f"Element with {selector} is not enabled.")
-    #         elif action.lower() == "input_text":
-    #             text = element.text_content()
-    #             if element.is_visible():
-    #                 if text != '':
-    #                     element.clear()
-    #                 element.fill(inputValue)
-    #                 print(f"Entered text into the {selector} successfully.")
-    #         elif action.lower() == "type_text":
-    #             if element.is_visible():
-    #                 text = element.text_content()
-    #                 if text != '':
-    #                     element.clear()
-    #                 element.type(inputValue)
-    #                 print(f"Entered text into the {selector} successfully.")
-    #         elif action.lower() == "get_text":
-    #             text = element.text_content()
-    #             print(f"Text from the {selector}: {text}")
-    #             return text
-    #         elif action.lower() == "select_option":
-    #             if element.is_visible():
-    #                 element.select_option(inputValue)
-    #                 print(f"Selected option with value '{inputValue}' from the {selector} successfully.")
-    #         elif action.lower() == "click_checkbox":
-    #             if element.is_visible():
-    #                 if not element.is_checked():
-    #                     element.check()
-    #                     print(f"{selector} checkbox checked successfully.")
-    #                 else:
-    #                     print(f"{selector} checkbox is already checked.")
-    #         else:
-    #             print(f"Unsupported action: {action}")
-    #     except TimeoutError:
-    #         print(f"Timeout waiting for selector: {selector} to perform {action}")
-    #     except Exception as e:
-    #         print(f"Exception: {e}. Element not found: {selector}")
-    #     self.capture_screenshot(selector_filename)
-
     def find_element_and_perform_action(self, locator_or_element, action, inputValue=None):
         # Check if the input is a string (locator) or already an element
         if isinstance(locator_or_element, str):
@@ -350,6 +302,9 @@ def find_element_and_perform_action(self, locator_or_element, action, inputValue
                 if element.is_visible():
                     element.select_option(inputValue)
                     print(f"Selected option '{inputValue}' successfully.")
+            elif action == "clear":
+                element.fill('')
+                print(f"Cleared text from the element: {element}.")
             elif action.lower() == "input_text":
                 if inputValue is None:
                     raise ValueError("`inputValue` cannot be None for 'input_text' action.")

init_helpers.py

@@ -1,4 +1,5 @@
 import os
+import re
 from helpers.apiHelper import ApiHelper
 from helpers.datetimeHelper import DatetimeHelper
 from helpers.playwrightHelper import PlaywrightHelper
@@ -59,23 +60,32 @@ def load_config_from_env():
     }
     return config
 
+def sanitize_filename(filename):
+    """
+    Remove or replace illegal characters in filenames for cross-platform compatibility.
+    For example, Windows does not allow: \\ / : * ? " < > |
+    """
+    return re.sub(r'[<>:"/\\|?*]', '_', filename)
+
 def attach_screenshot(filename):
     logging.basicConfig(level=logging.DEBUG)
     if config["browser"] == "mobile":
         filename = config["test_environment"] + "_" + config["browser"] + "_" + config["device"] + "_" + get_browser_version() + "_" + filename + ".png"
     else:
         filename = config["test_environment"] + "_" + config["browser"] + "_" + get_browser_version() + "_" + filename + ".png"
 
-    directory = os.path.dirname(filename)
-    if directory:
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
+    filename = sanitize_filename(filename)
+    directory = os.path.join('data', 'attachments')
+    full_path = os.path.join(directory, filename)
+
+    os.makedirs(os.path.dirname(full_path), exist_ok=True)
 
-    logging.debug(f"Filename: {filename}")
+    logging.debug(f"Filename: {full_path}")
 
     try:
-        screenshot = capture_screenshot(filename)
+        screenshot = capture_screenshot(full_path)
         logging.debug(f"Screenshot saved at: {screenshot}")
-        allure.attach.file(screenshot, name=f"{filename}", attachment_type=allure.attachment_type.PNG)
+        allure.attach.file(screenshot, name=f"{full_path}", attachment_type=allure.attachment_type.PNG)
     except Exception as e:
         logging.error(f"Failed to capture screenshot: {e}")
 
@@ -130,6 +140,34 @@ def find_elements(selector):
 def wait_for_page_to_load(timeout=1):
     playwright_helper_instance.wait_for_page_to_load(timeout)
 
+def click_element(element):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "click")
+
+def get_element_text(element):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "get_text")
+
+def clear_element(element):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "clear")
+
+def check_element(element):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "check")
+
+def check_if_element_exists(element, wait=False):
+    element = get_element_by_type(*element)
+    return check_element_exists(element, wait)
+
+def input_text_into_element(element, text):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "input_text", text)
+
+def select_option(element, option):
+    element = get_element_by_type(*element)
+    find_element_and_perform_action(element, "select_option", option)
+
 def check_element_exists(element, wait=False):
     try:
         return playwright_helper_instance.check_element_exists(element, wait)
@@ -157,11 +195,11 @@ def check_element_by_locator_enabled(element, wait=False):
 def scroll_into_view(element):
     return playwright_helper_instance.scroll_into_view(element)
 
-def wait_for_element_to_appear(selector):
-    playwright_helper_instance.wait_for_element_to_appear(selector)
+def wait_for_element_to_appear(*selector):
+    playwright_helper_instance.wait_for_element_to_appear(*selector)
 
-def clear_element(element):
-    return playwright_helper_instance.clear_element(element)
+# def clear_element(element):
+#     return playwright_helper_instance.clear_element(element)
 
 def capture_screenshot(filename):
     return playwright_helper_instance.capture_screenshot(filename)

pages/choose_vaccines_page.py

@@ -1,3 +1,4 @@
+import time
 from init_helpers import *
 from test_data.get_values_from_models import get_covid_consent_vaccine_xpath, get_flu_consent_vaccine_xpath, get_rsv_consent_vaccine_xpath, get_pertussis_consent_vaccine_xpath
 
@@ -12,48 +13,48 @@
 MIN_INTERVAL_BASED_WARNING = ("text", "You may have not reached the minimal interval between COVID-19 vaccine doses for this patient. This could depend on the clinical circumstances. For vaccination guidance, visit ")
 
 def click_site_radiobutton(site):
-    element = get_element_by_type("label", site)
-    find_element_with_locator_and_perform_action(element, "check")
+    element = ("label", site)
+    click_element(element)
 
 def click_back_button_choosing_vaccine_for_patient():
-    element = get_element_by_type(BACK_ELEMENT)
-    find_element_with_locator_and_perform_action(element, "click")
+    click_element(BACK_ELEMENT)
 
 def click_delivery_team_radiobutton(deliveryTeam):
-    element = get_element_by_type("label", deliveryTeam)
-    if element:
-        find_element_with_locator_and_perform_action(element, "check")
+    element = ("label", deliveryTeam)
+    if check_if_element_exists(element, True) == True:
+        check_element(element)
     else:
         print("Delivery team not available at organization")
 
 def click_vaccine_type_radiobutton(vaccine_type):
-    element = get_element_by_type("label", vaccine_type)
-    if element:
-        find_element_with_locator_and_perform_action(element, "check")
+    element = ("label", vaccine_type)
+    if check_if_element_exists(element, True) == True:
+        check_element(element)
     else:
         print("Vaccine type not available")
 
 def click_vaccine_radiobutton(vaccine):
-    element = get_element_by_type("label", vaccine)
-    if element:
-        find_element_with_locator_and_perform_action(element, "check")
+    element = ("label", vaccine)
+    if check_if_element_exists(element, True) == True:
+        check_element(element)
     else:
         print("Vaccine not available")
 
 def check_back_button_exists():
-    return check_element_by_locator_exists(get_element_by_type(*BACK_ELEMENT), True)
+    return check_if_element_exists(BACK_ELEMENT, True)
 
 def check_age_based_warning_exists():
-    return check_element_by_locator_exists(get_element_by_type(*AGE_BASED_WARNING), False)
+    time.sleep(1)
+    return check_if_element_exists(AGE_BASED_WARNING, True)
 
 def check_minimum_interval_based_warning_exists():
-    return check_element_by_locator_exists(get_element_by_type(*MIN_INTERVAL_BASED_WARNING), False)
+    return check_if_element_exists(MIN_INTERVAL_BASED_WARNING, False)
 
 def check_covid_radiobutton_exists():
-    return check_element_exists(COVID_RADIOBUTTON, True)
+    return check_if_element_exists(COVID_RADIOBUTTON, True)
 
 def check_flu_radiobutton_exists():
-    return check_element_exists(COVID_RADIOBUTTON, True)
+    return check_if_element_exists(FLU_RADIOBUTTON, True)
 
 def click_continue_to_assess_patient_button():
-    find_element_with_locator_and_perform_action(get_element_by_type(*CONTINUE_BUTTON), "click")
+    click_element(CONTINUE_BUTTON)