import re from time import sleep from typing import List from selenium.webdriver import Firefox from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.remote.webelement import WebElement from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.select import Select from modules.browser_object import Navigation from modules.classes.autofill_base import AutofillAddressBase from modules.classes.credit_card import CreditCardBase from modules.components.dropdown import Dropdown from modules.page_base import BasePage from modules.util import Utilities class AboutPrefs(BasePage): """ Page Object Model for about:preferences Attributes ---------- driver: selenium.webdriver.Firefox WebDriver object under test """ URL_TEMPLATE = "about:preferences#{category}" iframe = None def __init__(self, driver: Firefox, **kwargs): super().__init__(driver, **kwargs) self.driver = driver # number of tabs to reach the country tab TABS_TO_COUNTRY = 6 TABS_TO_SAVE_CC = 5 class HttpsOnlyStatus: """Fake enum: return a string based on a constant name""" def __init__(self): self.HTTPS_ONLY_ALL = "httpsonly-radio-enabled" self.HTTPS_ONLY_PRIVATE = "httpsonly-radio-enabled-pbm" self.HTTPS_ONLY_DISABLED = "httpsonly-radio-disabled" HTTPS_ONLY_STATUS = HttpsOnlyStatus() # Function Organization ## Search and Settings def search_engine_dropdown(self) -> Dropdown: """Returns the Dropdown region for search engine prefs""" return Dropdown( self, self.driver, root=self.get_element("search-engine-dropdown-root") ) def find_in_settings(self, term: str) -> BasePage: """Search via the Find in Settings bar, return self.""" search_input = self.get_element("find-in-settings-input") search_input.clear() search_input.send_keys(term) return self def set_alternative_language(self, lang_code: str) -> BasePage: """Changes the browser language""" self.get_element("language-set-alternative-button").click() self.driver.switch_to.frame(self.get_iframe()) # Download the language options select_language = self.get_element("language-settings-select") select_language.click() search_languages = self.get_element("language-settings-search") search_languages.click() select_language.click() # Select the language, add, and make sure it appears select_language.click() self.get_element("language-option-by-code", labels=[lang_code]).click() select_language.click() self.get_element("language-settings-add-button").click() self.expect_element_attribute_contains( "language-added-list", "last-selected", f"locale-{lang_code}" ) self.get_element("language-settings-ok").click() return self def select_https_only_setting(self, option_id: HttpsOnlyStatus) -> BasePage: """ Click the HTTPS Only option given """ self.find_in_settings("HTTPS") self.element_clickable(str(option_id)) self.click_on(str(option_id)) self.expect_element_attribute_contains(str(option_id), "checked", "") return self def set_default_zoom_level(self, zoom_percentage: int) -> BasePage: """ Sets the Default Zoom level in about:preferences. """ self.click_on("default-zoom-dropdown") with self.driver.context(self.driver.CONTEXT_CHROME): self.click_on("default-zoom-dropdown-value", labels=[f"{zoom_percentage}"]) self.click_on("default-zoom-dropdown") return self def select_content_and_action(self, content_type: str, action: str) -> BasePage: """ From the applications list that handles how downloaded media is used, select a content type and action """ el = self.get_element("actions-menu", labels=[content_type]) el.click() self.click_on("actions-menu-option", labels=[content_type, action]) self.wait.until(lambda _: el.get_attribute("label") == action) return self def get_history_menulist(self) -> WebElement: """ Gets the webelement for the list of history items that appear in about:preferences """ return self.get_element("history_menulist") ## Payment and Address Management def verify_cc_json( self, cc_info_json: dict, credit_card_fill_obj: CreditCardBase ) -> BasePage: """ Does the assertions that ensure all the extracted information (the cc_info_json) is the same as the generated fake credit_card_fill_obj data. ... Attributes ---------- cc_info_json: dict The dictionary that is the json representation of the extracted information from a web page credit_card_fill_obj: CreditCardBase The object that contains all the generated information """ assert cc_info_json["name"] == credit_card_fill_obj.name assert cc_info_json["number"][-4:] == credit_card_fill_obj.card_number[-4:] assert int(cc_info_json["month"]) == int(credit_card_fill_obj.expiration_month) return self def verify_cc_edit_saved_payments_profile( self, credit_card_fill_obj: CreditCardBase ): """ Verify saved payment profile data is the same as the generated fake credit_card_fill_obj data. Make sure cvv is not displayed. Arguments: credit_card_fill_obj: CreditCardBase The object that contains all the generated information """ self.switch_to_edit_saved_payments_popup_iframe() form_container = self.get_element("form-container") input_elements = form_container.find_elements(By.TAG_NAME, "input") expected_cc_data = [ int(val) if val.isnumeric() else val for val in credit_card_fill_obj.__dict__.values() ] expected_cvv = int(credit_card_fill_obj.cvv) for element in input_elements: field_name = element.get_attribute("id") if field_name.startswith("cc"): field_value = element.get_attribute("value") if field_value.isnumeric(): field_value = int(field_value) assert field_value in expected_cc_data, ( f"{(field_name, field_value)} not found in generated data." ) assert field_value != expected_cvv, "CVV is displayed." select_elements = form_container.find_elements(By.TAG_NAME, "select") for element in select_elements: field_name = element.get_attribute("id") if field_name.startswith("cc"): val = Select(element) # Only get the last two digits field_value = val.first_selected_option.get_attribute("value")[-2:] if field_value.isnumeric(): field_value = int(field_value) assert field_value in expected_cc_data, ( f"{(field_name, field_value)} not found in generated data." ) assert field_value != expected_cvv, "CVV is displayed." return self def get_saved_payments_popup(self) -> WebElement: """ Open saved payments dialog panel """ return self.get_element("prefs-button", labels=["Saved payment methods"]) def click_edit_on_dialog_element(self): """ Click on edit button on dialog panel """ edit_button = self.get_element( "panel-popup-button", labels=["autofill-manage-edit-button"] ) self.expect(EC.element_to_be_clickable(edit_button)) edit_button.click() return self def click_add_on_dialog_element(self): """ Click on add button on dialog panel """ add_button = self.get_element( "panel-popup-button", labels=["autofill-manage-add-button"] ) self.expect(EC.element_to_be_clickable(add_button)) add_button.click() return self def open_and_switch_to_saved_payments_popup(self) -> BasePage: """ Open and Switch to saved payments popup frame. """ saved_payments_iframe = self.get_saved_payments_popup_iframe() self.driver.switch_to.frame(saved_payments_iframe) return self def fill_and_save_cc_panel_information( self, credit_card_fill_information: CreditCardBase ): """ Takes the sample cc object and fills it into the popup panel in the about:prefs section under saved payment methods. Arguments: credit_card_fill_information: The object containing all the sample data """ fields = { "card_number": credit_card_fill_information.card_number, "expiration_month": credit_card_fill_information.expiration_month, "expiration_year": f"20{credit_card_fill_information.expiration_year}", "name": credit_card_fill_information.name, } for field in fields: self.actions.send_keys(fields[field] + Keys.TAB).perform() # Press tab again to navigate to the next field (this accounts for the second tab after the name field) self.actions.send_keys(Keys.TAB).perform() # Finally, press enter self.actions.send_keys(Keys.ENTER).perform() def add_entry_to_saved_payments(self, cc_data: CreditCardBase): """ Takes the sample AutofillAddressBase object and adds an entry to the saved addresses list. Switches the appropriate frames to accommodate the operation. Exits after adding entry Arguments: cc_data: The object containing all the sample data """ self.switch_to_saved_payments_popup_iframe() self.fill_and_save_cc_panel_information(cc_data) self.switch_to_default_frame() self.close_dialog_box() return self def close_dialog_box(self): """Close dialog box for saved addresses or payments.""" self.element_clickable("panel-popup-button", labels=["close-button"]) self.get_element("panel-popup-button", labels=["close-button"]).click() return self def update_cc_field_panel(self, field_name: str, value: str | int) -> BasePage: """ Updates a field in the credit card popup panel in about:prefs Change value of the field_name given """ fields = { "card_number": "cc-number", "expiration_month": "cc-exp-month", "expiration_year": "cc-exp-year", "name": "cc-name", } if field_name not in fields.keys(): raise ValueError( f"{field_name} is not a valid field name for the cc dialog form." ) self.switch_to_edit_saved_payments_popup_iframe() value_field = self.find_element(By.ID, fields[field_name]) if value_field.tag_name != "select": value_field.clear() value_field.send_keys(value) self.get_element("save-button").click() return self def get_saved_addresses_popup(self) -> WebElement: """ Returns saved addresses button element """ return self.get_element("prefs-button", labels=["Saved addresses"]) def open_and_switch_to_saved_addresses_popup(self) -> BasePage: """ Open and Switch to saved addresses popup frame. """ saved_address_iframe = self.get_saved_addresses_popup_iframe() self.driver.switch_to.frame(saved_address_iframe) return self def add_entry_to_saved_addresses(self, address_data: AutofillAddressBase): """ Takes the sample AutofillAddressBase object and adds an entry to the saved addresses list. Switches the appropriate frames to accommodate the operation. Exits after adding entry Arguments: address_data: The object containing all the sample data """ self.switch_to_edit_saved_addresses_popup_iframe() self.fill_and_save_address_panel_information(address_data) self.switch_to_default_frame() self.close_dialog_box() return self def get_all_saved_cc_profiles(self) -> List[WebElement]: """Gets the saved credit card profiles in the cc panel""" self.switch_to_saved_payments_popup_iframe() element = Select(self.get_element("cc-saved-options")) return element.options def get_all_saved_address_profiles(self) -> List[WebElement]: """Gets the saved credit card profiles in the cc panel""" self.switch_to_saved_addresses_popup_iframe() select_el = self.get_element("address-saved-options") if len(select_el.get_attribute("innerHTML")) > 1: return Select(select_el).options return [] def extract_address_data_from_saved_addresses_entry( self, util: Utilities, region: str = "US" ) -> AutofillAddressBase: """ Extracts the data from the saved addresses entry to a AutofillAddressBase object. Arguments: util: Utility instance region: country code in use """ self.switch_to_edit_saved_addresses_popup_iframe() fields = { "name": "", "organization": "", "street-address": "", "address-level2": "", "address-level1": "", "postal-code": "", "tel": "", "country": "", "email": "", } for key in fields.keys(): el = self.find_element(By.ID, key) if el.tag_name == "select": fields[key] = Select(el).first_selected_option.text else: fields[key] = el.get_attribute("value") return AutofillAddressBase( name=fields.get("name"), given_name=fields.get("name", "").split()[0], family_name=fields.get("name", "").split()[1], organization=fields.get("organization"), street_address=fields.get("street-address"), address_level_2=fields.get("address-level2"), address_level_1=fields.get("address-level1"), postal_code=fields.get("postal-code"), country=fields.get("country"), country_code=region, email=fields.get("email"), telephone=util.normalize_regional_phone_numbers(fields.get("tel"), region), ) ## UI Navigation and Iframe Handling def get_saved_payments_popup_iframe(self) -> WebElement: """ Returns the iframe object for the dialog panel in the popup """ self.get_saved_payments_popup().click() iframe = self.get_element("browser-popup") return iframe def switch_to_edit_saved_payments_popup_iframe(self) -> BasePage: """ Switch to form iframe to edit saved payments. """ self.switch_to_default_frame() self.switch_to_iframe(2) return self def press_button_get_popup_dialog_iframe(self, button_label: str) -> WebElement: """ Returns the iframe object for the dialog panel in the popup after pressing some button that triggers a popup """ self.get_element("prefs-button", labels=[button_label]).click() iframe = self.get_element("browser-popup") return iframe def get_saved_addresses_popup_iframe(self) -> WebElement: """ Returns the iframe object for the dialog panel in the popup """ self.get_saved_addresses_popup().click() iframe = self.get_element("browser-popup") return iframe def switch_to_saved_addresses_popup_iframe(self) -> BasePage: """ switch to save addresses popup frame. """ self.switch_to_default_frame() self.switch_to_iframe(1) return self def switch_to_saved_payments_popup_iframe(self) -> BasePage: """ switch to save payments popup frame. """ self.switch_to_default_frame() self.switch_to_iframe(1) return self def switch_to_edit_saved_addresses_popup_iframe(self) -> BasePage: """ Switch to form iframe to edit saved addresses. """ self.switch_to_default_frame() self.switch_to_iframe(2) return self def get_iframe(self) -> WebElement: """ Gets the webelement for the iframe that commonly appears in about:preferences """ return self.get_element("browser-popup") def get_password_exceptions_popup_iframe(self) -> WebElement: """ Returns the iframe object for the Password Exceptions dialog panel in the popup. """ # Click on the "Password Exceptions" button self.get_element("logins-exceptions").click() # Get the iframe element for the popup iframe = self.get_element("browser-popup") return iframe ## Data Extraction and Processing def set_country_autofill_panel(self, country: str) -> BasePage: """Sets the country value in the autofill view""" select_country = Select(self.driver.find_element(By.ID, "country")) select_country.select_by_value(country) return self def fill_and_save_address_panel_information( self, address_data: AutofillAddressBase ) -> BasePage: """ Takes the sample AutofillAddressBase object and fills it into the popup panel in the about:prefs section under saved addresses methods. Arguments: address_data: The object containing all the sample data """ fields = { "name": address_data.name, "organization": address_data.organization, "street-address": address_data.street_address, "address-level2": address_data.address_level_2, "address-level1": address_data.address_level_1, "postal-code": address_data.postal_code, "tel": address_data.telephone, "email": address_data.email, } self.set_country_autofill_panel(address_data.country_code) form_element = self.get_element("form-container") children = [ x.get_attribute("id") for x in form_element.find_elements(By.CSS_SELECTOR, "*") ] for key, val in fields.items(): if key in children: form_element.find_element(By.ID, key).send_keys(val) self.get_element("save-button").click() return self def get_clear_cookie_data_value(self) -> int | None: """ With the 'Clear browsing data and cookies' popup open, returns the value of the option for 'Cookies and site data ()'. The value for no cookies is '0 bytes', otherwise values are '### MB', or '### KB' """ # Find the dialog option elements containing the checkbox label options = self.get_elements("clear-data-dialog-options") # Extract the text from the label the second option second_option = options[1] label_text = second_option.text print(f"The text of the option is: {label_text}") # Use a regular expression to find the memory usage match = re.search(r"\d+", label_text) if match: number_str = match.group() # Extract the matched number as a string number = int(number_str) # Convert the number to an integer print(f"The extracted value is: {number}") return number else: print("No number found in the string") def get_manage_data_site_element(self, site: str) -> WebElement: """ Returns the WebElement for the given site in the manage site data popup """ element = self.get_element("manage-cookies-site", labels=[site]) return element ## Utility Functions def import_bookmarks(self, browser_name: str) -> BasePage: """ Press the import browser data button """ MAX_TRIES = 16 self.click_on("import-browser-data") sleep(2) tries = 0 # Keep cycling through the options until you get it # Using keys for most of this because clicking elements is flaky for some reason while ( browser_name.lower() not in self.get_element("browser-profile-selector").text.lower() and tries < MAX_TRIES ): self.actions.send_keys(" ").perform() for _ in range(tries): self.actions.send_keys(Keys.DOWN).perform() self.actions.send_keys(" ").perform() sleep(1) tries += 1 self.click_on("migration-import-button") # There are two messages that indicate a successful migration self.wait.until( lambda _: self.get_element("migration-progress-header").text in ["Data Imported Successfully", "Data Import Complete"] ) self.actions.send_keys(" ").perform() return self def click_popup_panel_button(self, field: str) -> BasePage: """Clicks the popup panel button for the specified field""" if self.iframe: with self.driver.switch_to.frame(self.iframe): self.get_element("panel-popup-button", labels=[field]).click() else: self.get_element("panel-popup-button", labels=[field]).click() return self class AboutAddons(BasePage): """ The POM for the about:addons page Attributes ---------- driver: selenium.webdriver.Firefox WebDriver object under test """ URL_TEMPLATE = "about:addons" def choose_sidebar_option(self, option: str): """ Clicks the corresponding sidebar option from the about:addons page. """ self.get_element("sidebar-options", labels=[option]).click() def activate_theme( self, nav: Navigation, theme_name: str, intended_color: str, perform_assert=True ): """ Clicks the theme card and presses enable. Then verifies that the theme is the correct color. Attributes ---------- nav: Navigation The navgiation object theme_name: str The name of the theme to press intended_color: str The RGB string that is the intended color of the element """ self.get_element("theme-card", labels=[theme_name]).click() self.get_element("enable-theme").click() self.expect( EC.text_to_be_present_in_element_attribute( self.get_selector("enable-theme"), "innerText", "Disable" ) ) with self.driver.context(self.driver.CONTEXT_CHROME): navigation_component = nav.get_element("navigation-background-component") background_color = navigation_component.value_of_css_property( "background-color" ) if perform_assert: assert background_color == intended_color else: return background_color def is_devedition(self): active_theme_el = self.driver.find_element( By.CSS_SELECTOR, ".card.addon[active] h3.addon-name" ) active_theme_name = active_theme_el.text.lower() return "dark" in active_theme_name or "developer edition" in active_theme_name def enabled_theme_matches(self, expected_theme: str) -> bool: """ Check the enabled theme name against any string. """ enabled_theme = self.get_element("enabled-theme-title").get_attribute( "innerText" ) return enabled_theme == expected_theme def check_theme_has_changed(self, original_theme: str) -> BasePage: """ Ensure that the theme has changed. """ assert not self.enabled_theme_matches(original_theme) return self