def test_keyboard_basic(self): # Use the contacts app to enter some text contact = MockContact() contacts_app = Contacts(self.marionette) contacts_app.launch() new_contact_form = contacts_app.tap_new_contact() new_contact_form.type_phone(contact['tel'][0]['value']) new_contact_form.type_comment('') # initialize the keyboard app keyboard = new_contact_form.keyboard # send first 15 characters, delete last character, send a space, and send all others keyboard.send(self._string[:15]) keyboard.tap_backspace() keyboard.tap_space() keyboard.send(self._string[15:]) # select special character using extended character selector keyboard.choose_extended_character('A', 8) # go back to app frame and finish this contacts_app.launch() new_contact_form.tap_done() self.wait_for_condition(lambda m: len(contacts_app.contacts) == 1) contact_details = contacts_app.contacts[0].tap() output_text = contact_details.comments self.assertEqual( self._string[:14] + ' ' + self._string[15:] + 'Æ'.decode("UTF-8"), output_text)
def test_call_contact(self): # NB This is not a listed smoke test # Call phone from a contact # https://moztrap.mozilla.org/manage/case/5679/ contacts = Contacts(self.marionette) contacts.launch() contacts.wait_for_contacts() # tap on the created contact contact_details = contacts.contact(self.contact['givenName'][0]).tap() # tap the phone number and switch to call screen frame call_screen = contact_details.tap_phone_number() call_screen.wait_for_outgoing_call() # Check the number displayed is the one we dialed self.assertIn(self.contact['tel'][0]['value'], call_screen.calling_contact_information) self.assertIn(self.contact['givenName'][0], call_screen.outgoing_calling_contact) call_screen.hang_up() # Switch back to main frame before Marionette loses track bug #840931 self.marionette.switch_to_frame()
def test_change_keyboard_language_settings(self): settings = Settings(self.marionette) settings.launch() keyboard_settings = settings.open_keyboard() # Tap 'add more keyboards' button add_more_keyboards = keyboard_settings.tap_add_more_keyboards() # Select keyboard language, then click back to make it "stick" add_more_keyboards.select_language(u'Espa\u00F1ol') add_more_keyboards.go_back() keyboard_settings.wait_for_built_in_keyboard(u'Espa\u00F1ol') # launch the Contacts app to verify the keyboard layout contacts_app = Contacts(self.marionette) contacts_app.launch() new_contact_form = contacts_app.tap_new_contact() new_contact_form.type_given_name('') # Switch to keyboard frame and switch language new_contact_form.keyboard.switch_to_keyboard() new_contact_form.keyboard.tap_keyboard_language_key() new_contact_form.keyboard.switch_to_keyboard() special_key = self.marionette.find_element( *self._special_key_locator).text # Checking if exists the special key - "ñ" self.assertEqual(special_key, self._expected_key)
def test_sms_create_new_contact(self): self.contact = MockContact() self.message_thread = self.messages.tap_first_received_message() self.message_thread.wait_for_received_messages() # Check that we received the correct message self.assertEqual(self.message_thread.header_text, self.testvars['carrier']['phone_number']) activities = self.message_thread.tap_header() # Create a new contact new_contact = activities.tap_create_new_contact() # Populate new contact fields new_contact.type_given_name(self.contact['givenName']) new_contact.type_family_name(self.contact['familyName']) new_contact.type_email(self.contact['email']['value']) new_contact.type_street(self.contact['adr']['streetAddress']) new_contact.type_zip_code(self.contact['adr']['postalCode']) new_contact.type_city(self.contact['adr']['locality']) new_contact.type_country(self.contact['adr']['countryName']) new_contact.type_comment(self.contact['note']) new_contact.tap_done(return_contacts=False) self.wait_for_condition( lambda m: self.message_thread.header_text == self.contact['name']) contacts = Contacts(self.marionette) contacts.launch() contact_details = contacts.contacts[0].tap() self.assertEqual(contact_details.phone_numbers[0], self.testvars['carrier']['phone_number'])
def test_change_keyboard_language_settings(self): settings = Settings(self.marionette) settings.launch() keyboard_settings = settings.open_keyboard_settings() # Select keyboard language keyboard_settings.select_language('spanish') # launch the Contacts app to verify the keyboard layout contacts_app = Contacts(self.marionette) contacts_app.launch() new_contact_form = contacts_app.tap_new_contact() new_contact_form.type_comment('') # Switch to keyboard frame and switch language self.keyboard.switch_keyboard_language("es") keybframe = self.marionette.find_element( *self._select_keyb_frame_locator) self.marionette.switch_to_frame(keybframe, focus=False) self.wait_for_element_displayed(*self._special_key_locator) special_key = self.marionette.find_element( *self._special_key_locator).text # Checking if exists the special key - "ñ" self.assertEqual(special_key, self._expected_key)
def tap_done(self): self.marionette.find_element( *self._settings_close_button_locator).tap() self.wait_for_element_not_displayed( *self._settings_close_button_locator) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def test_delete_contact(self): """ Test delete contact https://github.com/mozilla/gaia-ui-tests/issues/493 """ contacts_app = Contacts(self.marionette) contacts_app.launch() contacts_app.wait_for_contacts() pre_contacts_count = len(contacts_app.contacts) self.assertEqual( pre_contacts_count, 1, "Should insert one contact before running this test.") contact_item = contacts_app.contact(self.contact['givenName'][0]) contact_item_detail = contact_item.tap() contact_item_edit = contact_item_detail.tap_edit() contact_item_edit.tap_delete() contact_item_edit.tap_confirm_delete() post_contacts_count = len(contacts_app.contacts) self.assertEqual(post_contacts_count, 0, "Should have no contact after run this test.")
def test_change_keyboard_language_settings(self): settings = Settings(self.marionette) settings.launch() keyboard_settings = settings.open_keyboard_settings() # Tap on active keyboard link select_keyboard = keyboard_settings.tap_selected_keyboards() # Tap 'add more keyboards' button add_more_keyboards = select_keyboard.tap_add_more_keyboards() # Select keyboard language add_more_keyboards.select_language(u'Espa\u00F1ol') # launch the Contacts app to verify the keyboard layout contacts_app = Contacts(self.marionette) contacts_app.launch() new_contact_form = contacts_app.tap_new_contact() new_contact_form.type_given_name('') self.wait_for_condition(lambda m: new_contact_form.keyboard.is_displayed()) # Switch to keyboard frame and switch language new_contact_form.keyboard.switch_to_keyboard() new_contact_form.keyboard.tap_keyboard_language_key() self.wait_for_element_displayed(*self._special_key_locator) special_key = self.marionette.find_element(*self._special_key_locator).text # Checking if exists the special key - "ñ" self.assertEqual(special_key, self._expected_key)
def test_import_contacts_menu_no_network(self): ''' https://moztrap.mozilla.org/manage/case/15183/ ''' contacts_app = Contacts(self.marionette) contacts_app.launch() contacts_settings = contacts_app.tap_settings() contacts_settings.tap_import_contacts() self.assertFalse(contacts_settings.is_gmail_import_service_in_error) self.assertTrue(contacts_settings.is_gmail_import_enabled) self.assertFalse(contacts_settings.is_outlook_import_service_in_error) self.assertTrue(contacts_settings.is_outlook_import_enabled) self.assertFalse(contacts_settings.is_error_message_displayed) self.disable_all_network_connections() self.apps.switch_to_displayed_app() self.assertTrue(contacts_settings.is_gmail_import_service_in_error) self.assertFalse(contacts_settings.is_gmail_import_enabled) self.assertTrue(contacts_settings.is_outlook_import_service_in_error) self.assertFalse(contacts_settings.is_outlook_import_enabled) self.assertTrue(contacts_settings.is_error_message_displayed)
def tap_done(self): close = self.marionette.find_element( *self._settings_close_button_locator) close.tap() Wait(self.marionette).until(expected.element_not_displayed(close)) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def test_unlink_facebook_contact(self): """ https://moztrap.mozilla.org/manage/case/5858/ """ username = self.testvars['facebook']['username'] password = self.testvars['facebook']['password'] contacts_app = Contacts(self.marionette) contacts_app.launch() contacts_app.wait_for_contacts() self.assertEqual(len(contacts_app.contacts), 1, 'Should insert one contact before running this test') # Go to contact item details contact_item = contacts_app.contact(self.contact['givenName']) contact_item_detail = contact_item.tap() facebook = contact_item_detail.tap_link_contact() contact_import_picker = facebook.login(username, password) contact_import_picker.tap_first_friend() contact_item_detail.tap_unlink_contact() contact_item_detail.tap_back() contacts_app.wait_for_contacts(2) self.assertEqual( len(contacts_app.contacts), 2, 'After unlinking the facebook contact should have been added')
def test_sms_add_number_to_existing_contact(self): # open the message thread screen self.message_thread = self.messages.tap_first_received_message() self.message_thread.wait_for_received_messages() # Check that we received the correct message self.assertEqual(self.message_thread.header_text, self.testvars['carrier']['phone_number']) activities = self.message_thread.tap_header() contacts = activities.tap_add_to_contact() contacts.wait_for_contacts(1) edit_contact = contacts.contacts[0].tap(return_class='EditContact') edit_contact.tap_update(return_details=False) self.wait_for_condition( lambda m: self.message_thread.header_text == self.contact['name']) contacts = Contacts(self.marionette) contacts.launch() contact_details = contacts.contacts[0].tap() self.assertEqual(contact_details.phone_numbers[1], self.testvars['carrier']['phone_number'])
def tap_add_to_contact(self): self.marionette.find_element( *self._add_to_contact_button_locator).tap() from gaiatest.apps.contacts.app import Contacts contacts = Contacts(self.marionette) contacts.switch_to_contacts_frame() return contacts
def _switch_to_contacts_frame(self): # This is a nested frame and we cannot locate it with AppWindowManager frame = Wait(self.marionette).until( expected.element_present(*self._contacts_frame_locator)) self.marionette.switch_to_frame(frame) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def tap_back(self): el = self.marionette.find_element(*self._details_header_locator) Wait(self.marionette).until(expected.element_displayed(el)) # TODO: remove tap with coordinates after Bug 1061698 is fixed el.tap(25, 25) Wait(self.marionette).until(expected.element_not_displayed(el)) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def tap_add_to_existing_contact(self): element = self.marionette.find_element( *self._add_to_existing_contact_locator) Wait(self.marionette).until(expected.element_displayed(element)) element.tap() contact = Contacts(self.marionette) contact.switch_to_contacts_frame() return contact
def test_import_edit_export_contact(self): """ https://moztrap.mozilla.org/manage/case/14115/ """ contacts_app = Contacts(self.marionette) contacts_app.launch() sim_contacts_number_before_import = len(self.data_layer.sim_contacts) self.apps.switch_to_displayed_app() # import contacts from SIM contacts_settings = contacts_app.tap_settings() contacts_settings.tap_import_contacts() contacts_settings.tap_import_from_sim() contacts_settings.tap_back_from_import_contacts() contacts_settings.tap_done() contact_first_name = self.sim_contact['name'][0].split()[0] contact_details = contacts_app.contact(contact_first_name).tap() edit_contact = contact_details.tap_edit() contact_new_family_name = 'New' edit_contact.type_family_name(contact_new_family_name) contact_details = edit_contact.tap_update() contact_details.tap_back() contacts_settings = contacts_app.tap_settings() contacts_settings.tap_export_contacts() contacts_settings.tap_export_to_sim() contacts_app.contact(contact_first_name).tap( return_class='SelectContact') contacts_app.tap_export() self.assertIn('contacts exported', contacts_app.status_message) sim_contacts = self.data_layer.sim_contacts self.assertEqual(len(sim_contacts), sim_contacts_number_before_import) for contact in sim_contacts: if contact['tel'][0]['value'] == self.sim_contact['tel'][0][ 'value']: self.sim_contact = contact break self.assertEqual( self.sim_contact['name'][0], '%s %s' % (contact_first_name, contact_new_family_name)) self.assertEqual(self.sim_contact['tel'][0]['value'], self.contact.tel['value'])
def setUp(self): GaiaEnduranceTestCase.setUp(self) # Remove any existing contacts self.data_layer.remove_all_contacts(60000) # Launch the Contacts app self.contacts = Contacts(self.marionette) self.contacts.launch()
def tap_back(self): self.wait_for_element_displayed(*self._details_header_locator) # TODO: remove tap with coordinates after Bug 1061698 is fixed self.marionette.find_element(*self._details_header_locator).tap(25, 25) self.wait_for_element_not_displayed(*self._details_header_locator) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def gmail_login(self, user, passwd): self.wait_for_element_displayed(*self._email_locator) self.marionette.find_element(*self._email_locator).tap() self.marionette.find_element(*self._email_locator).send_keys(user) self.marionette.find_element(*self._password_locator).tap() self.marionette.find_element(*self._password_locator).send_keys(passwd) self.marionette.find_element(*self._sign_in_locator).tap() from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def tap_contacts(self): self.marionette.find_element(*self._contacts_view_locator).tap() self.wait_for_element_present(*self._contacts_frame_locator) frame = self.marionette.find_element(*self._contacts_frame_locator) self.marionette.switch_to_frame(frame) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def tap_grant_access(self): grant_access_button = self.marionette.find_element( *self._grant_access_button_locator) self.wait_for_condition(lambda m: grant_access_button.is_enabled()) self.marionette.execute_script("arguments[0].scrollIntoView(false);", [grant_access_button]) grant_access_button.tap() from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette)
def launch_app(self): self.log("Launching app and waiting for it to be ready!") # launch the contacts app and wait for the contacts to be displayed, # the first launch after populating the data takes a long time. contacts = Contacts(self.device.marionette) contacts.launch() self.wait_for_content_ready()
def tap_done(self, return_contacts=True): # NewContact can be opened as an Activity from other apps. In this scenario we don't return Contacts self.marionette.find_element(*self._done_button_locator).tap() if return_contacts: self.wait_for_element_not_displayed(*self._done_button_locator) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette) else: # Bug 947317 Marionette exception after tap closes a frame time.sleep(2)
def wait_for_done(self, return_contacts=True): # NewContact can be opened as an Activity from other apps. In this scenario we don't return Contacts if return_contacts: self.apps.switch_to_displayed_app() from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette) else: Wait(self.marionette).until(lambda m: self.apps.displayed_app.name != 'Communications') # Fall back to the underlying app self.apps.switch_to_displayed_app()
def test_add_photo_from_gallery_to_contact(self): # https://moztrap.mozilla.org/manage/case/5551/ contacts_app = Contacts(self.marionette) contacts_app.launch() contacts_app.wait_for_contacts() contact_details = contacts_app.contact(self.contact['givenName']).tap() full_name = ' '.join( [self.contact['givenName'], self.contact['familyName']]) self.assertEqual(full_name, contact_details.full_name) saved_contact_image_style = contact_details.image_style edit_contact = contact_details.tap_edit() self.assertEqual('Edit contact', edit_contact.title) saved_picture_style = edit_contact.picture_style actions_list = edit_contact.tap_picture() # choose the source as gallery app gallery = actions_list.tap_gallery() # switch to the gallery app gallery.switch_to_gallery_frame() gallery.wait_for_thumbnails_to_load() self.assertGreater(gallery.gallery_items_number, 0, 'No photos were found in the gallery.') image = gallery.tap_first_gallery_item() image.tap_crop_done() # switch back to the contacts app contacts_app.launch() self.assertEqual('Edit contact', edit_contact.title) edit_contact.wait_for_image_to_load() new_picture_style = edit_contact.picture_style self.assertNotEqual( new_picture_style, saved_picture_style, 'The picture associated with the contact was not changed.') contact_details = edit_contact.tap_update() self.assertEqual(full_name, contact_details.full_name) self.assertNotEqual( contact_details.image_style, saved_contact_image_style, 'The picture associated with the contact was not changed.')
def tap_grant_access(self): grant_access = self.marionette.find_element( *self._grant_access_button_locator) Wait(self.marionette).until(expected.element_enabled(grant_access)) grant_access.tap() # Go back to displayed Contacts app before waiting for the picker from gaiatest.apps.contacts.app import Contacts Contacts(self.marionette).wait_to_be_displayed() self.apps.switch_to_displayed_app() from gaiatest.apps.contacts.regions.contact_import_picker import ContactImportPicker return ContactImportPicker(self.marionette)
def wait_for_done(self, return_contacts=True): # NewContact can be opened as an Activity from other apps. In this scenario we don't return Contacts if return_contacts: self.wait_for_element_not_displayed(*self._done_button_locator) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette) else: from gaiatest.apps.contacts.app import Contacts Wait(self.marionette).until(lambda m: self.apps.displayed_app.name != Contacts.name) # Fall back to the underlying app self.apps.switch_to_displayed_app()
def wait_for_done(self, return_contacts=True): # NewContact can be opened as an Activity from other apps. In this scenario we don't return Contacts if return_contacts: self.wait_for_element_not_displayed(*self._done_button_locator) from gaiatest.apps.contacts.app import Contacts return Contacts(self.marionette) else: # Bug 947317 Marionette exception after tap closes a frame time.sleep(2) # Fall back to the underlying app self.apps.switch_to_displayed_app()
def tap_update(self, return_details=True): self.wait_for_update_button_enabled() update = self.marionette.find_element(*self._update_locator) update.tap() if return_details: from gaiatest.apps.contacts.regions.contact_details import ContactDetails return ContactDetails(self.marionette) else: # else we drop back to the underlying app from gaiatest.apps.contacts.app import Contacts Contacts(self.marionette).wait_to_not_be_displayed() self.apps.switch_to_displayed_app()