import json import logging from typing import List, Optional from selenium.webdriver import Firefox from selenium.webdriver.support.select import Select from modules.browser_object_autofill_popup import AutofillPopup from modules.classes.autofill_base import AutofillAddressBase from modules.classes.credit_card import CreditCardBase from modules.page_base import BasePage from modules.util import BrowserActions, Utilities BASE_CC_URL_TEMPLATE = "https://mozilla.github.io/form-fill-examples/basic_cc.html" BASE_ADDRESS_URL_TEMPLATE = "https://mozilla.github.io/form-fill-examples/basic.html" # Class Attributes: Element Selectors base_cc_field_mapping = { "name": "cc-name", "card_number": "cc-number", "expiration_month": "cc-exp-month", "expiration_year": "cc-exp-year", "cvv": "cc-csc", } base_address_field_mapping = { "name": "name", "organization": "organization", "street_address": "street-address", "address_level_2": "address-level2", "address_level_1": "address-level1", "postal_code": "postal-code", "country_code": "country", "email": "email", "telephone": "tel", } # Element Selectors base_cc_fields = ["cc-name", "cc-number", "cc-exp-month", "cc-exp-year"] base_address_fields = [ "name", "organization", "street-address", "address-level2", # city "address-level1", # state/province "postal-code", "country", "email", "tel", ] # Preview field mappings base_preview_address_mapping = { "family_name": "family-name", "given_name": "given-name", "street_address": "street-address", "address_level_2": "address-level2", "address_level_1": "address-level1", "postal_code": "postal-code", "country_code": "country", "telephone": "tel", } base_preview_cc_mapping = { "name": "cc-name", "card_number": "cc-number", "expiration_month": "cc-exp-month", "expiration_year": "cc-exp-year", } class Autofill(BasePage): """ Page Object Model for auto site (https://mozilla.github.io/form-fill-examples/) base parent object of all autofill page related objects """ # Default; subclasses will override field_mapping = {} fields = {} preview_fields = {} URL_TEMPLATE = "https://mozilla.github.io/form-fill-examples/" def __init__(self, driver: Firefox, **kwargs): super().__init__(driver, **kwargs) self.driver = driver self.browser_actions = BrowserActions(self.driver) self.util = Utilities() self.autofill_popup = AutofillPopup(self.driver) def _fill_input_element(self, field_name: str, term: str): """ Given BrowserActions object, the string of the element to be identified and the string term to be sent to the input, identify the webelement and send the term to the input field without any additional keystrokes. Arguments: field_name : The name of the input field to be identified term: The string to be sent to the input field """ form_field_element = self.get_element("form-field", labels=[field_name]) if form_field_element.tag_name.lower() == "select": selected_form = Select(form_field_element) shortened_state = self.util.get_state_province_abbreviation(term) selected_form.select_by_value(shortened_state) else: self.browser_actions.clear_and_fill( form_field_element, term, press_enter=False ) def scroll_to_form_field(self): """ Scrolls to the first available field value. Note: First field in mapping must be the first field that is visible to be selected. """ if not self.field_mapping: # Method is meant to be called by one of the classes that inherit AutoFill (CreditCardFill or AddressFill) # Should not be called directly from an Autofill instance. raise NotImplementedError( "Method should only be called in inherited classes." ) first_field = self.get_element("form-field", labels=[self.fields[0]]) self.driver.execute_script("arguments[0].scrollIntoView();", first_field) return self def _click_form_button(self, field_name): """Clicks submit on the form""" self.element_clickable("submit-button", labels=[field_name]) self.click_on("submit-button", labels=[field_name]) def is_field_present(self, attr_name: str): """checks whether the attribute name exists in the mapping.""" field = self.field_mapping.get(attr_name, None) return True if field else False def select_first_form_field(self, autofill: bool = False): """ Click first available form field option. If autofill flag is true, select autofill option for first available field. """ if autofill: self.select_autofill_option(self.fields[0]) else: self.click_form_field(self.fields[0]) return self def click_form_field(self, attr_name: str): """Click the form field given the attribute name.""" field = self.field_mapping.get(attr_name, None) if field: self.double_click("form-field", labels=[field]) else: logging.warning(f"The field: {attr_name} is not available in the site.") def verify_no_dropdown_on_field_interaction(self, attr_name): """ Click on the form field given the attribute name and ensure that the field does not activate the dropdown. """ field = self.field_mapping.get(attr_name, None) if field: self.double_click("form-field", labels=[field]) self.autofill_popup.ensure_autofill_dropdown_not_visible() else: logging.warning(f"The field: {attr_name} is not available in the site.") def fill_and_submit(self, data_object: CreditCardBase | AutofillAddressBase | dict): """Fill and submit from data object or dictionary. Arguments: data_object: object containing autofill data. """ if not self.field_mapping: # Method is meant to be called by one of the classes that inherit AutoFill (CreditCardFill or AddressFill) # Should not be called directly from an Autofill instance. raise NotImplementedError( "Method should only be called in inherited classes." ) for attr_name, field_name in self.field_mapping.items(): value = ( getattr(data_object, attr_name, None) if not isinstance(data_object, dict) else data_object.get(field_name) ) if value is not None: self._fill_input_element(field_name, value) self._click_form_button("submit") def update_form_data( self, sample_data: AutofillAddressBase | CreditCardBase, field: str, value: str | int, ): """ Update the form field with the new value. Arguments: sample_data: sample data instance used to verify change. field: field being changed. value: value being added. """ # updating the profile accordingly self.update_and_save(field, value) # autofill data self.select_autofill_option(field) # verifying the correct data self.verify_form_data(sample_data) return self def verify_form_data(self, sample_data: CreditCardBase | AutofillAddressBase): """Verify that form is filled correctly against sample data.""" if not self.field_mapping: # Method is meant to be called by one of the classes that inherit AutoFill (CreditCardFill or AddressFill) # Should not be called directly from an Autofill instance. raise NotImplementedError( "Method should only be called in inherited classes." ) is_address_fill = self.__class__ == AddressFill non_us_ca_address = is_address_fill and sample_data.country_code not in [ "US", "CA", ] for attr_name, field_name in self.field_mapping.items(): if non_us_ca_address and field_name == "address-level1": continue if field_name != "cc-csc": expected_value = getattr(sample_data, attr_name, None) autofilled_field = self.get_element("form-field", labels=[field_name]) if autofilled_field.tag_name.lower() != "select": autofilled_field_value = autofilled_field.get_attribute("value") # self.expect_element_attribute_contains( # "form-field", "value", expected_value, labels=[field_name] # ) else: autofilled_field_value = Select( autofilled_field ).first_selected_option.text if ( field_name == "address-level1" and autofilled_field_value != expected_value ): expected_value = self.util.get_state_province_abbreviation( expected_value ) assert expected_value in autofilled_field_value, ( f"{autofilled_field_value} is different from {expected_value}" ) def verify_field_autofill_dropdown( self, fields_to_test: List[str] = None, excluded_fields: Optional[List[str]] = None, region: Optional[str] = None, ): """ A common method to check which fields trigger the autofill dropdown. This is used in both CC and Address pages. Arguments: fields_to_test: The primary list of fields for this page (cc fields, address fields). excluded_fields: Fields that should NOT trigger an autofill dropdown. region: If provided, handle region-specific behavior (e.g., skip address-level1 for DE/FR). """ if not self.field_mapping: # Method is meant to be called by one of the classes that inherit AutoFill (CreditCardFill or AddressFill) # Should not be called directly from an Autofill instance. raise NotImplementedError( "Method should only be called in inherited classes." ) if fields_to_test is None: fields_to_test = [x for x in self.field_mapping.keys() if x != "cvv"] # Handle region-specific behavior if region not in {"US", "CA"} and "address_level_1" in fields_to_test: fields_to_test.remove("address_level_1") # Check fields that SHOULD trigger the autofill dropdown for field_name in fields_to_test: field = self.field_mapping.get(field_name, None) # How do i simplify this logic? if field: autofill_field = self.get_element("form-field", labels=[field]) if autofill_field.tag_name.lower() != "select": # more general way of activating the dropdown self.double_click("form-field", labels=[field]) autofill_field.send_keys("") self.autofill_popup.ensure_autofill_dropdown_visible() logging.info(f"Autofill dropdown appears for field '{field}'.") else: logging.info( f"Field: {field_name} is a select element. No autofill option." ) else: logging.warning( f"The field: {field_name} is not available in the site." ) # Check fields that should NOT trigger the autofill dropdown if excluded_fields: for field_name in excluded_fields: field = self.field_mapping.get(field_name, None) if field: self.double_click("form-field", labels=[field_name]) self.autofill_popup.ensure_autofill_dropdown_not_visible() logging.info( f"No autofill dropdown appears for field '{field_name}', as expected." ) else: logging.warning( f"The field: {field_name} is not available in the site." ) return self def verify_field_highlight( self, fields_to_test: List[str] = None, expected_highlighted_fields: Optional[List[str]] = None, extra_fields: Optional[List[str]] = None, region: str = None, ): """ A common method to check which fields have the "yellow highlight". This is used in both CC and Address pages. Arguments: fields_to_test: The primary list of fields for this page (cc fields, address fields). expected_highlighted_fields: Which ones are expected to be highlighted. Defaults to all in `fields_to_test`. extra_fields: If some pages have extra fields to test (e.g. 'cc-csc'), pass them here. region: region to test """ if not self.field_mapping: # Method is meant to be called by one of the classes that inherit AutoFill (CreditCardFill or AddressFill) # Should not be called directly from an Autofill instance. raise NotImplementedError( "Method should only be called in inherited classes." ) if fields_to_test is None: fields_to_test = set(self.field_mapping.keys()) if region not in {"US", "CA"} and "address_level_1" in fields_to_test: fields_to_test.remove("address_level_1") if expected_highlighted_fields is None: # By default, everything in fields_to_test is expected to be highlighted except cvv for cc expected_highlighted_fields = fields_to_test if "cvv" in expected_highlighted_fields: expected_highlighted_fields.remove("cvv") if extra_fields: fields_to_actually_check = fields_to_test + extra_fields else: fields_to_actually_check = fields_to_test def is_yellow_highlight(rgb_tuple): """ Returns True if the color tuple is bright yellow-ish. """ if len(rgb_tuple) == 3: r, g, b = rgb_tuple else: r, g, b, *_ = rgb_tuple return (r >= 250) and (g >= 250) and (180 < b < 220) for field_name in fields_to_actually_check: field = self.field_mapping.get(field_name, None) if field: autofill_field = self.get_element("form-field", labels=[field]) if autofill_field.tag_name.lower() != "select": # Focus the field so the highlight is visible self.click_on("form-field", labels=[field]) # Get all colors in the field selector = self.get_selector("form-field", labels=[field]) colors = self.browser_actions.get_all_colors_in_element(selector) logging.info(f"Colors found in '{field}': {colors}") # Check the highlight is_field_highlighted = any( is_yellow_highlight(color) for color in colors ) should_be_highlighted = field_name in expected_highlighted_fields # Assert based on expectation if should_be_highlighted: assert is_field_highlighted, ( f"Expected yellow highlight on '{field}', but none found." ) logging.info(f"Yellow highlight found in '{field}'.") else: assert not is_field_highlighted, ( f"Expected NO yellow highlight on '{field}', but found one." ) logging.info(f"No yellow highlight in '{field}', as expected.") else: logging.info( f"Field: {field} is a select element. No autofill option." ) else: logging.warning(f"The field: {field} is not available in the site.") return self def verify_all_fields_cleared(self): """ Verifies that all autofill fields are empty. """ for field_name in self.fields: field_element = self.get_element("form-field", labels=[field_name]) value = field_element.get_attribute("value") if field_element.tag_name.lower() != "select": assert not value, f"Field '{field_name}' is not empty: Found '{value}'" @BasePage.context_chrome def verify_autofill_data_on_hover( self, autofill_data: CreditCardBase | AutofillAddressBase ): """ Verifies that the autofill preview data matches the expected values when hovering Arguments: autofill_data: CreditCardBase | AutofillAddressBase object containing expected fake data. """ # Get preview data from hovering through the chrome context try: # Attempt to parse the string as JSON container = json.loads( self.autofill_popup.get_element("preview-form-container").get_attribute( "ac-comment" ) ) except json.JSONDecodeError: # If parsing fails, raise ValueError. raise ValueError("Given preview data is incomplete.") container_data = container.get("fillMessageData", {}).get("profile", {}) assert container_data, "No preview data available." assert all(field in container_data.keys() for field in self.preview_fields), ( f"Not all fields present in preview data." ) # sanitize data if autofill_data.__class__ == CreditCardBase: autofill_data.card_number = autofill_data.card_number[-4:] else: if autofill_data.country_code in {"US", "CA"} and ( len(container_data["address-level1"]) == 2 and len(autofill_data.address_level_1) > 2 ): autofill_data.address_level_1 = ( self.util.get_state_province_abbreviation( autofill_data.address_level_1 ) ) for field, value in container_data.items(): if field in self.preview_fields: value = self.sanitize_preview_data(field, str(value)) # Check if this value exists in our CreditCardBase | AutofillAddressBase object is_present = any( [value in val for val in autofill_data.__dict__.values()] ) assert is_present, ( f"Mismatched data: {(field, value)} not in {autofill_data.__dict__.values()}." ) def sanitize_preview_data(self, field, value): if field == "cc-number": value = value[-4:] elif field == "cc-exp-year": value = value[-2:] elif value[0] == "+": value = self.util.normalize_phone_number(value) return value def select_autofill_option(self, field, index: int = 1): """ Presses the autofill panel that pops up after you double-click an input field Argument: autofill_popup: AutofillPopup field: field to click to show autofill option. index: which autofill option to pick. """ autofill_field = self.get_element("form-field", labels=[field]) if autofill_field.tag_name.lower() != "select": self.double_click("form-field", labels=[field]) self.autofill_popup.ensure_autofill_dropdown_visible() self.autofill_popup.select_nth_element(index) else: logging.info(f"Field: {field} is a select element. No autofill option.") return self def fill_and_save( self, region: str = "US", door_hanger: bool = True ) -> AutofillAddressBase | CreditCardBase: """ Fills form with randomly generated data and interacts with the autofill popup. Arguments: region: Country code in use door_hanger: check to click save on door hanger """ autofill_data = ( self.util.fake_autofill_data(region) if self.__class__ == AddressFill else self.util.fake_credit_card_data(region) ) self.fill_and_submit(autofill_data) if door_hanger: self.autofill_popup.click_doorhanger_button("save") return autofill_data def update_and_save(self, field: str, value: str | int, door_hanger: bool = True): """ Update form with new field value and save. Arguments: field: field label. value: new value to be updated. door_hanger: bool to indication interaction with door_hanger. """ self._fill_input_element(field, value) self._click_form_button("submit") if door_hanger: if field == "cc-number": self.autofill_popup.click_doorhanger_button("save") else: self.autofill_popup.click_doorhanger_button("update") def check_autofill_preview_for_field( self, field_label: str, sample_data: CreditCardBase | AutofillAddressBase, region: str = None, ): """ Check that hovering over a field autofill option will prefill the other fields. Arguments: field_label: field name. sample_data: autofill sample data. region: region being tested. """ if ( self.__class__ == AddressFill and field_label == "address_level_1" and region not in {"US", "CA"} ): return field = self.field_mapping.get(field_label, None) if field: autofill_field = self.get_element("form-field", labels=[field]) if autofill_field.tag_name.lower() != "select": self.double_click("form-field", labels=[field]) self.autofill_popup.ensure_autofill_dropdown_visible() self.autofill_popup.hover("select-form-option") self.verify_autofill_data_on_hover(sample_data) self.click_on("form-field", labels=[field]) else: logging.info( f"Field: {field_label} is a select element. No autofill option." ) else: logging.info(f"The field: {field_label} is not present in the site.") def clear_and_verify_all_fields( self, sample_data: AutofillAddressBase | CreditCardBase = None, region: str = None, ): """ Autofill all form fields and verifies that they are empty. Arguments: region: region being tested sample_data: verify autofill against sample data if present """ fields = [x for x in self.field_mapping.keys() if x != "cvv"] for field in fields: self.clear_and_verify(field, sample_data, region) def clear_and_verify( self, field_label: str, sample_data: CreditCardBase | AutofillAddressBase = None, region: str = None, ): """ Autofills a form field, clears it, and verifies that it is empty. If sample data is present, will verify that data is filled correctly. Arguments: field_label : The label of the field being autofilled. region : region being tested sample_data: sample data for cc or address form. """ # Skip address-level1 (State) selection for DE and FR if ( region not in {"US", "CA"} and self.__class__ == AddressFill and field_label == "address_level_1" ): return field = self.field_mapping.get(field_label, None) if field: autofill_field = self.get_element("form-field", labels=[field]) if autofill_field.tag_name.lower() != "select": # Double-click a field and choose the first element from the autocomplete dropdown self.double_click("form-field", labels=[field]) self.autofill_popup.ensure_autofill_dropdown_visible() self.autofill_popup.select_nth_element(1) if sample_data: ## verify data self.verify_form_data(sample_data) # Clear form autofill self.double_click("form-field", labels=[field]) self.autofill_popup.ensure_autofill_dropdown_visible() self.autofill_popup.click_clear_form_option() # Verify all fields are cleared self.verify_all_fields_cleared() else: logging.info( f"Field: {field_label} is a select element. No autofill option." ) else: logging.warning(f"The field: {field_label} is not available in the site.") def generate_field_data( self, sample_data: AutofillAddressBase | CreditCardBase, field: str, region: str ) -> str | int: """ Generates a new data for sample data according to field given, updates the information in the form. Arguments: sample_data: sample data instance being updated field: field being updated region: region being tested """ faker_method = ( self.util.fake_credit_card_data if self.__class__ == CreditCardFill else self.util.fake_autofill_data ) inverted_mapping = {v: k for k, v in self.field_mapping.items()} new_sample_data_value = getattr( faker_method(country_code=region), inverted_mapping[field] ) while new_sample_data_value == getattr(sample_data, inverted_mapping[field]): new_sample_data_value = getattr( faker_method(country_code=region), inverted_mapping[field] ) setattr(sample_data, inverted_mapping[field], new_sample_data_value) return new_sample_data_value class AddressFill(Autofill): """ Page Object Model for address autofill site. base site is: (https://mozilla.github.io/form-fill-examples/basic.html) """ def __init__( self, driver: Firefox, url_template=None, field_mapping=None, fields=None, **kwargs, ): super().__init__(driver, **kwargs) self.field_mapping = ( field_mapping if field_mapping else base_address_field_mapping ) self.fields = fields if fields else base_address_fields self.preview_fields = set( map( lambda field: base_preview_address_mapping.get(field, field), self.field_mapping.keys(), ) ) self.URL_TEMPLATE = url_template if url_template else BASE_ADDRESS_URL_TEMPLATE class CreditCardFill(Autofill): """ Page Object Model for cc autofill site base site is: (https://mozilla.github.io/form-fill-examples/basic_cc.html) """ def __init__( self, driver: Firefox, url_template=None, field_mapping=None, fields=None, **kwargs, ): super().__init__(driver, **kwargs) self.field_mapping = field_mapping if field_mapping else base_cc_field_mapping self.fields = fields if fields else base_cc_fields self.preview_fields = set( map( lambda field: base_preview_cc_mapping.get(field), self.field_mapping.keys(), ) ) self.preview_fields = { field for field in self.preview_fields if field is not None } self.URL_TEMPLATE = url_template if url_template else BASE_CC_URL_TEMPLATE class LoginAutofill(Autofill): """ Page Object Model for the form autofill demo page with many logins """ URL_TEMPLATE = "https://mozilla.github.io/form-fill-examples/password_manager/login_and_pw_change_forms.html" class LoginForm: """ Subclass of the Login Autofill Form where you can interact with the Login Form """ def __init__(self, parent: "LoginAutofill") -> None: self.parent = parent self.username_field = None self.password_field = None self.submit_button = None def fill_username(self, username: str) -> None: """Fill the username field after ensuring it's clickable.""" self.parent.element_clickable("username-login-field") if self.username_field is None: self.username_field = self.parent.get_element("username-login-field") self.username_field.send_keys(username) def fill_password(self, password: str) -> None: """Fill the password field after ensuring it's clickable.""" self.parent.element_clickable("password-login-field") if self.password_field is None: self.password_field = self.parent.get_element("password-login-field") self.password_field.send_keys(password) def submit(self) -> None: if self.submit_button is None: self.submit_button = self.parent.get_element("submit-button-login") self.submit_button.click() class TextAreaFormAutofill(Autofill): """ Page Object Model for the form autofill demo page with a textarea """ URL_TEMPLATE = "https://mozilla.github.io/form-fill-examples/textarea_select.html"