def test_sms_forward_sent_message(self): """ https://moztrap.mozilla.org/manage/case/11075/ """ # Launch the app messages = Messages(self.marionette) messages.launch() message_thread = messages.tap_first_received_message() sent_messages = len(message_thread.sent_messages) # Forward the last sent message last_sent_message = message_thread.sent_messages[-1] activities = last_sent_message.long_press_message() new_message = activities.tap_forward_message() # Check that the 'To' field is empty self.assertEqual(new_message.recipients[0].text, u'') # Check that the message field has the content we expect self.assertEqual(new_message.message, self._text_message_content) new_message.type_phone_number(self.testvars['plivo']['phone_number']) new_message.tap_send() # Wait for the message to be sent correctly self.wait_for_condition(lambda m: len(message_thread.sent_messages) > sent_messages) # Check that the last sent message has the content we expect self.assertEqual(message_thread.sent_messages[1].text, self._text_message_content)
def test_sms_forward_sent_message(self): """ https://moztrap.mozilla.org/manage/case/11075/ """ # Launch the app messages = Messages(self.marionette) messages.launch() message_thread = messages.tap_first_received_message() sent_messages = len(message_thread.sent_messages) # Forward the last sent message last_sent_message = message_thread.sent_messages[-1] activities = last_sent_message.long_press_message() new_message = activities.tap_forward_message() # Check that the 'To' field is empty self.assertEqual(new_message.recipients[0].text, u'') # Check that the message field has the content we expect self.assertEqual(new_message.message, self._text_message_content) new_message.type_phone_number(self.testvars['plivo']['phone_number']) new_message.tap_send() # Wait for the message to be sent correctly self.wait_for_condition( lambda m: len(message_thread.sent_messages) > sent_messages) # Check that the last sent message has the content we expect self.assertEqual(message_thread.sent_messages[1].text, self._text_message_content)
class TestContactMatch(GaiaTestCase): def test_contact_match(self): # insert contact self.contact = MockContact( tel={'value': '555%s' % repr(time.time()).replace('.', '')[8:]}) self.data_layer.insert_contact(self.contact) # launch Messages app self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() from gaiatest.apps.keyboard.app import Keyboard keyboard = Keyboard(self.marionette) keyboard.send(self.contact['name']) keyboard.tap_enter() # verify that contacts and tel number match self.assertEqual(self.contact['name'], new_message.first_recipient_name) self.assertEqual(self.contact['tel']['value'], new_message.first_recipient_number_attribute)
def tap_back_button(self): # In a message thread, tap the back button to return to main message list back_header_button = self.marionette.find_element(*self._back_header_link_locator) back_header_button.tap() messages = Messages(self.marionette) messages.wait_for_message_list() return messages
class TestDialerFromMessage(GaiaTestCase): def setUp(self): GaiaTestCase.setUp(self) def test_dialer_from_message(self): # Send a SMS to the device _text_message_content = "Automated Test %s" % str(time.time()) # Open first received message self.messages = Messages(self.marionette) self.messages.launch() self.data_layer.send_sms(self.testvars['carrier']['phone_number'], _text_message_content) self.apps.switch_to_displayed_app() self.messages.wait_for_message_received(timeout=180) message_thread = self.messages.tap_first_received_message() # Check the phone number message_thread.tap_header() keypad = message_thread.tap_call() self.assertEquals(keypad.phone_number, self.testvars['carrier']['phone_number'])
class TestContactValidation(GaiaTestCase): def test_sms_contact_validation(self): self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() keyboard = new_message.tap_recipient_section() keyboard.send('test_contact') keyboard.tap_enter() # Verify if recipient is invalid and uneditable self.assertIn('attention', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') new_message.tap_recipient_name() self.assertTrue(new_message.is_recipient_name_editable == 'true') # Type_message will tap in the field to focus it new_message.type_message('This is a test message') #TODO Wait for the javascript time.sleep(1) self.assertFalse(new_message.is_send_button_enabled)
def test_sms_send(self): # launch the app messages = Messages(self.marionette) messages.launch() # click new message new_message = messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(self._text_message_content) activities_list = new_message.tap_attachment() camera = activities_list.tap_camera() camera.tap_capture() camera.tap_select_button() # back to messages app frame new_message.wait_for_resizing_to_finish() #click send self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) # get the most recent listed and most recent received text message last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] # Check the most recent received message has the same text content self.assertEqual(self._text_message_content, last_received_message.text.strip('\n').strip()) # Check that most recent message is also the most recent received message self.assertEqual(last_received_message.id, last_message.id) # Check that message has attachments self.assertTrue(last_message.has_attachments)
def test_sms_notification_removed_when_sms_deleted(self): """ https://moztrap.mozilla.org/manage/case/8778/ """ _text_message_content = "Automated Test %s" % str(time.time()) messages = Messages(self.marionette) messages.launch() self.data_layer.send_sms(self.environment.phone_numbers[0], _text_message_content, skip_verification=True) system = System(self.marionette) # We will wait upto 300 seconds for the SMS to arrive due to network latency system.wait_for_notification_toaster_displayed(timeout=300) system.wait_for_notification_toaster_not_displayed() self.apps.switch_to_displayed_app() message_thread = messages.tap_first_received_message() Wait(self.marionette).until(lambda m: len(message_thread.received_messages) > 0) messages_number = len(message_thread.all_messages) last_received_message = message_thread.received_messages[-1] activities = last_received_message.long_press_message() activities.tap_delete_message() activities.confirm_delete_message() Wait(self.marionette).until(lambda m: len(message_thread.all_messages) == messages_number - 1) self.marionette.switch_to_frame() utility_tray = system.open_utility_tray() self.assertEqual(0, len(utility_tray.notifications))
class TestDialerFromMessage(GaiaTestCase): def setUp(self): GaiaTestCase.setUp(self) # Launch the SMS app self.messages = Messages(self.marionette) self.messages.launch() def test_dialer_from_message(self): # Send a SMS to the device _text_message_content = "Automated Test %s" % str(time.time()) # Tap new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(_text_message_content) # Tap send self.message_thread = new_message.tap_send() self.message_thread.tap_header() keypad = self.message_thread.tap_call() self.assertEquals(keypad.phone_number, self.testvars['carrier']['phone_number'])
def test_sms_semicolon_completes_the_entered_recipient(self): """ https://moztrap.mozilla.org/manage/case/10925/ """ self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() keyboard = new_message.tap_recipient_section() keyboard.send('074') keyboard.send(';') # Verify if recipient is valid and uneditable self.assertNotIn('invalid', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') keyboard.send('777') keyboard.send(';') self.assertEqual(new_message.number_of_recipients, 2) new_message.tap_message() self.assertEqual(new_message.number_of_recipients, 2) self.marionette.switch_to_frame() self.assertTrue(new_message.keyboard.is_keyboard_displayed)
class TestSmsAddContact(GaiaTestCase): def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact(tel={ 'type': 'Mobile', 'value': '555%s' % repr(time.time()).replace('.', '')[8:]}) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() # After tap, don't return a class; fall back to the displayed frame which should be Messages app contacts_app.contact(self.contact['givenName']).tap(return_class=None) self.assertIn(self.contact['givenName'], new_message.first_recipient_name) self.assertEquals(self.contact['tel']['value'], new_message.first_recipient_number_attribute) new_message.type_message(_text_message_content) self.assertTrue(new_message.is_send_button_enabled)
class TestDialerFromMessage(GaiaTestCase): def setUp(self): GaiaTestCase.setUp(self) def test_dialer_from_message(self): # Send a SMS to the device _text_message_content = "Automated Test %s" % str(time.time()) # Open first received message self.messages = Messages(self.marionette) self.messages.launch() self.data_layer.send_sms(self.testvars["carrier"]["phone_number"], _text_message_content) self.apps.switch_to_displayed_app() self.messages.wait_for_message_received(timeout=180) # Sometimes tap is done on the notification instead of message header self.marionette.switch_to_frame() system = System(self.marionette) system.wait_for_notification_toaster_not_displayed() self.apps.switch_to_displayed_app() message_thread = self.messages.tap_first_received_message() # Check the phone number keypad = message_thread.tap_call() self.assertEquals(keypad.phone_number, self.testvars["carrier"]["phone_number"])
class TestContactValidation(GaiaTestCase): def test_sms_contact_validation(self): self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() from gaiatest.apps.keyboard.app import Keyboard keyboard = Keyboard(self.marionette) keyboard.send('test_contact') keyboard.tap_enter() # Verify if recipient is invalid and uneditable self.assertIn('invalid', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') new_message.tap_recipient_name() self.assertTrue(new_message.is_recipient_name_editable == 'true') # Type_message will tap in the field to focus it new_message.type_message('Test message') self.assertFalse(new_message.is_send_button_enabled)
class TestSMSContactInput(GaiaTestCase): def test_sms_semicolon_completes_the_entered_recipient(self): """ https://moztrap.mozilla.org/manage/case/10925/ """ self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() from gaiatest.apps.keyboard.app import Keyboard keyboard = Keyboard(self.marionette) keyboard.send('074') keyboard.send(';') # Verify if recipient is valid and uneditable self.assertNotIn('invalid', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') keyboard.send('777') keyboard.send(';') self.assertEqual(new_message.number_of_recipients, 2) new_message.tap_message() self.assertEqual(new_message.number_of_recipients, 2) self.marionette.switch_to_frame() self.assertTrue(new_message.keyboard.is_keyboard_displayed)
class TestEnduranceSmsSendReceive(GaiaEnduranceTestCase): def setUp(self): GaiaEnduranceTestCase.setUp(self) # delete any existing SMS messages to start clean self.data_layer.delete_all_sms() # launch the app self.messages = Messages(self.marionette) self.messages.launch() def test_endurance_sms_send_receive(self): self.drive(test=self.sms_send_receive, app='messages') def sms_send_receive(self): # send a message to self, wait for it to arrive, back to main message list # setup received sms callback self.marionette.execute_async_script(""" SpecialPowers.setBoolPref("dom.sms.enabled", true); SpecialPowers.addPermission("sms", true, document); window.wrappedJSObject.gotEvent = false; window.navigator.mozMobileMessage.onreceived = function onreceived(event) { log("Received 'onreceived' smsmanager event"); window.wrappedJSObject.gotEvent = true; }; marionetteScriptFinished(1); """, special_powers=True) # create new message _text_message_content = "SMS %d of %d (send receive endurance test %s)" % ( self.iteration, self.iterations, str(time.time())) new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['local_phone_numbers'][0]) new_message.type_message(_text_message_content) # send self.message_thread = new_message.tap_send() # verify/wait for the webapi new message callback, give 5 minutes; probably # received the new sms message by now anyway self.marionette.set_script_timeout(300000) self.marionette.execute_async_script(""" function ready() { window.navigator.mozMobileMessage.onreceived = null; SpecialPowers.removePermission("sms", document); SpecialPowers.setBoolPref("dom.sms.enabled", false); marionetteScriptFinished(1); }; waitFor(ready, function() { return(window.wrappedJSObject.gotEvent); }); """, special_powers=True) # go back to main message list for next rep self.message_thread.tap_back_button() # sleep between reps time.sleep(30)
def test_sms_send(self): """ https://moztrap.mozilla.org/manage/case/10743/ """ messages = Messages(self.marionette) messages.launch() new_message = messages.create_new_message(recipients=[self.environment.phone_numbers[0]], message=self._text_message_content) activities_list = new_message.tap_attachment() camera = activities_list.tap_camera() camera.tap_capture() camera.tap_select_button() # back to messages app frame new_message.wait_for_resizing_to_finish() self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] self.assertEqual(self._text_message_content, last_received_message.text.strip('\n').strip()) self.assertEqual(last_received_message.id, last_message.id) self.assertTrue(last_message.has_attachments) view_image = last_message.tap_attachment() view_image.tap_save_image() self.assertIn('saved to Gallery', view_image.banner_message) # 2 pictures should be on the sd card: # One is the picture we sent, the other is the one saved self.assertEqual(2, len(self.data_layer.picture_files))
def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact(tel={ 'type': 'Mobile', 'value': '555%s' % repr(time.time()).replace('.', '')[8:] }, email=None) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() # After tap, don't return a class; fall back to the displayed frame which should be Messages app contacts_app.contact(self.contact['givenName']).tap(return_class=None) self.assertIn(self.contact['givenName'], new_message.first_recipient_name) self.assertEquals(self.contact['tel']['value'], new_message.first_recipient_number_attribute) new_message.type_message(_text_message_content) self.assertTrue(new_message.is_send_button_enabled)
class TestSmsAddContact(GaiaTestCase): def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact(tel=[{ 'type': ['Mobile'], 'value': "%s" % self.testvars['carrier']['phone_number']}]) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() contacts_app.contact(self.contact['givenName'][0]).tap(return_details=False) contacts_app.wait_for_contacts_frame_to_close() self.messages.switch_to_messages_frame() self.assertIn(self.contact['givenName'][0], new_message.first_recipient_name) new_message.type_message(_text_message_content) self.message_thread = new_message.tap_send() self.message_thread.wait_for_received_messages() last_received_message = self.message_thread.received_messages[-1] self.assertEqual(_text_message_content, last_received_message.text)
def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact(tel=[{ 'type': ['Mobile'], 'value': "%s" % self.testvars['carrier']['phone_number']}]) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() contacts_app.contact(self.contact['givenName'][0]).tap(return_details=False) self.messages.switch_to_messages_frame() self.assertIn(self.contact['givenName'][0], new_message.first_recipient_name) new_message.type_message(_text_message_content) self.message_thread = new_message.tap_send() self.message_thread.wait_for_received_messages() last_received_message = self.message_thread.received_messages[-1] self.assertEqual(_text_message_content, last_received_message.text)
class TestContactValidation(GaiaTestCase): def test_sms_contact_validation(self): self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() keyboard = new_message.tap_recipient_section() keyboard.send('test_contact') keyboard.tap_enter() self.messages.switch_to_messages_frame() # Verify if recipient is invalid and uneditable self.assertIn('attention', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') new_message.tap_recipient_name() self.assertTrue(new_message.is_recipient_name_editable == 'true') # extra step to place the cursor in the message field new_message.tap_message_field() new_message.type_message('This is a test message') self.assertFalse(new_message.is_send_button_enabled)
def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact( tel=[{ 'type': ['Mobile'], 'value': '555%s' % repr(time.time()).replace('.', '')[8:] }]) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() contacts_app.contact( self.contact['givenName'][0]).tap(return_details=False) contacts_app.wait_for_contacts_frame_to_close() # Now switch to the displayed frame which should be Messages app self.marionette.switch_to_frame(self.apps.displayed_app.frame) self.assertIn(self.contact['givenName'][0], new_message.first_recipient_name) self.assertEquals(self.contact['tel'][0]['value'], new_message.first_recipient_number_attribute) new_message.type_message(_text_message_content) self.assertTrue(new_message.is_send_button_enabled)
class TestSms(GaiaTestCase): def test_sms_send(self): """This test sends a text message to itself. It waits for a reply message. https://moztrap.mozilla.org/manage/case/1322/ https://moztrap.mozilla.org/manage/case/1293/ """ _text_message_content = "Automated Test %s" % str(time.time()) # launch the app self.messages = Messages(self.marionette) self.messages.launch() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(_text_message_content) #click send self.message_thread = new_message.tap_send() self.message_thread.wait_for_received_messages() # get the most recent listed and most recent received text message last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] # Check the most recent received message has the same text content self.assertEqual(_text_message_content, last_received_message.text) # Check that most recent message is also the most recent received message self.assertEqual(last_received_message.id, last_message.id)
def test_dialer_from_message(self): # Send a SMS to the device _text_message_content = "Automated Test %s" % str(time.time()) # Open first received message self.messages = Messages(self.marionette) self.messages.launch() self.data_layer.send_sms(self.testvars['carrier']['phone_number'], _text_message_content) self.apps.switch_to_displayed_app() self.messages.wait_for_message_received(timeout=180) # Sometimes tap is done on the notification instead of message header self.marionette.switch_to_frame() system = System(self.marionette) system.wait_for_notification_toaster_not_displayed() self.apps.switch_to_displayed_app() message_thread = self.messages.tap_first_received_message() # Check the phone number keypad = message_thread.tap_call() self.assertEquals(keypad.phone_number, self.testvars['carrier']['phone_number'])
def test_sms_send(self): """This test sends a text message to itself. It waits for a reply message. https://moztrap.mozilla.org/manage/case/1322/ """ self._text_message_content = "Automated Test %s" % str(time.time()) self._last_message = ".message-list li" self._unread = "#threads-container li" # launch the app self.launch_by_touch("sms") self.apps.switch_to_displayed_app() self.messages = Messages(self.marionette) self.messages.wait_for_message_list() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(self._text_message_content) #click send self.message_thread = new_message.tap_send() self.message_thread.tap_back_button() last_thread = self.marionette.find_element(By.CSS_SELECTOR, self._unread) self.wait_for_condition(self.wait_for_unread_thread, 23)
class TestSms(GaiaTestCase): def test_sms_send(self): """ This test sends a text message to itself. It waits for a reply message. https://moztrap.mozilla.org/manage/case/1322/ """ _text_message_content = "Automated Test %s" % str(time.time()) # launch the app self.messages = Messages(self.marionette) self.messages.launch() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(_text_message_content) #click send self.message_thread = new_message.tap_send() self.message_thread.wait_for_received_messages() # get the most recent listed and most recent received text message last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] # Check the most recent received message has the same text content self.assertEqual(_text_message_content, last_received_message.text) # Check that most recent message is also the most recent received message self.assertEqual(last_received_message.id, last_message.id)
class TestSms(GaiaMtbfTestCase): def test_sms_send(self): """This test sends a text message to itself. It waits for a reply message. https://moztrap.mozilla.org/manage/case/1322/ """ self._text_message_content = "Automated Test %s" % str(time.time()) self._last_message = ".message-list li" self._unread = "#threads-container li" # launch the app self.launch_by_touch("sms") self.apps.switch_to_displayed_app() self.messages = Messages(self.marionette) self.messages.wait_for_message_list() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(self._text_message_content) #click send self.message_thread = new_message.tap_send() self.message_thread.tap_back_button() last_thread = self.marionette.find_element(By.CSS_SELECTOR, self._unread) self.wait_for_condition(self.wait_for_unread_thread, 23) def tearDown(self): if hasattr(self, "message_thread"): self.apps.switch_to_displayed_app() self.message_thread.tap_back_button() GaiaMtbfTestCase.tearDown(self) def wait_for_unread_thread(self, m): self.apps.switch_to_displayed_app() threads = m.find_elements(By.CSS_SELECTOR, self._unread) last_thread = threads[0] if "unread" in last_thread.get_attribute("class"): last_thread.tap() self.wait_for_element_displayed( *self.message_thread._all_messages_locator) messages = (m.find_elements(By.CSS_SELECTOR, self._last_message)) last_message = messages[-1] if self._text_message_content in last_message.text: return True return False def wait_for_last_message(self, m): self.apps.switch_to_displayed_app() messages = m.find_elements(By.CSS_SELECTOR, self._last_message) if len(messages) < 2: return False last_message = messages[-1] if "incoming" in last_message.get_attribute( "class" ) and self._text_message_content in last_message.find_element( By.CSS_SELECTOR, ".bubble p").text: return True return False
def test_sms_contact_validation(self): self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() from gaiatest.apps.keyboard.app import Keyboard keyboard = Keyboard(self.marionette) keyboard.send('test_contact') keyboard.tap_enter() # Verify if recipient is invalid and uneditable self.assertIn('invalid', new_message.recipient_css_class) self.assertTrue(new_message.is_recipient_name_editable == 'false') new_message.tap_recipient_name() self.assertTrue(new_message.is_recipient_name_editable == 'true') # Type_message will tap in the field to focus it new_message.type_message('Test message') self.assertFalse(new_message.is_send_button_enabled)
def prepare_app(self): # launch the messages app and wait for the messages to be displayed, # the first launch after populating the data takes a long time. messages = Messages(self.device.marionette) messages.launch() Wait( self.device.marionette, 120, ignored_exceptions=(NoSuchElementException, ElementNotVisibleException) ).until(lambda m: m.find_element(By.CSS_SELECTOR, "#threads-container li").is_displayed())
def setUp(self): GaiaTestCase.setUp(self) _text_message_content = "Automated Test %s" % str(time.time()) self.data_layer.send_sms(self.environment.phone_numbers[0], _text_message_content) self.messages = Messages(self.marionette) self.messages.launch()
class TestEnduranceSmsSendReceive(GaiaEnduranceTestCase): def setUp(self): GaiaEnduranceTestCase.setUp(self) # delete any existing SMS messages to start clean self.data_layer.delete_all_sms() # launch the app self.messages = Messages(self.marionette) self.messages.launch() def test_endurance_sms_send_receive(self): self.drive(test=self.sms_send_receive, app='messages') def sms_send_receive(self): # send a message to self, wait for it to arrive, back to main message list # setup received sms callback self.marionette.execute_async_script(""" SpecialPowers.setBoolPref("dom.sms.enabled", true); SpecialPowers.addPermission("sms", true, document); window.wrappedJSObject.gotEvent = false; window.navigator.mozMobileMessage.onreceived = function onreceived(event) { log("Received 'onreceived' smsmanager event"); window.wrappedJSObject.gotEvent = true; }; marionetteScriptFinished(1); """, special_powers=True) # create new message _text_message_content = "SMS %d of %d (send receive endurance test %s)" % (self.iteration, self.iterations, str(time.time())) new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['local_phone_numbers'][0]) new_message.type_message(_text_message_content) # send self.message_thread = new_message.tap_send() # verify/wait for the webapi new message callback, give 5 minutes; probably # received the new sms message by now anyway self.marionette.set_script_timeout(300000); self.marionette.execute_async_script(""" function ready() { window.navigator.mozMobileMessage.onreceived = null; SpecialPowers.removePermission("sms", document); SpecialPowers.setBoolPref("dom.sms.enabled", false); marionetteScriptFinished(1); }; waitFor(ready, function() { return(window.wrappedJSObject.gotEvent); }); """, special_powers = True) # go back to main message list for next rep self.message_thread.tap_back_button() # sleep between reps time.sleep(30)
class TestSms(GaiaMtbfTestCase): def test_sms_send(self): """This test sends a text message to itself. It waits for a reply message. https://moztrap.mozilla.org/manage/case/1322/ """ self._text_message_content = "Automated Test %s" % str(time.time()) self._last_message = ".message-list li" self._unread = "#threads-container li" # launch the app self.launch_by_touch("sms") self.apps.switch_to_displayed_app() self.messages = Messages(self.marionette) self.messages.wait_for_message_list() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(self._text_message_content) #click send self.message_thread = new_message.tap_send() self.message_thread.tap_back_button() last_thread = self.marionette.find_element(By.CSS_SELECTOR, self._unread) self.wait_for_condition(self.wait_for_unread_thread, 23) def tearDown(self): if hasattr(self, "message_thread"): self.apps.switch_to_displayed_app() self.message_thread.tap_back_button() GaiaMtbfTestCase.tearDown(self) def wait_for_unread_thread(self, m): self.apps.switch_to_displayed_app() threads = m.find_elements(By.CSS_SELECTOR, self._unread) last_thread = threads[0] if "unread" in last_thread.get_attribute("class"): last_thread.tap() self.wait_for_element_displayed(*self.message_thread._all_messages_locator) messages = (m.find_elements(By.CSS_SELECTOR, self._last_message)) last_message = messages[-1] if self._text_message_content in last_message.text: return True return False def wait_for_last_message(self, m): self.apps.switch_to_displayed_app() messages = m.find_elements(By.CSS_SELECTOR, self._last_message) if len(messages) < 2: return False last_message = messages[-1] if "incoming" in last_message.get_attribute("class") and self._text_message_content in last_message.find_element(By.CSS_SELECTOR, ".bubble p").text: return True return False
def setUp(self): GaiaEnduranceTestCase.setUp(self) # delete any existing SMS messages to start clean self.data_layer.delete_all_sms() # launch the app self.messages = Messages(self.marionette) self.messages.launch()
def setUp(self): GaiaTestCase.setUp(self) _text_message_content = "Automated Test %s" % str(time.time()) self.data_layer.send_sms(self.testvars['carrier']['phone_number'], _text_message_content) self.messages = Messages(self.marionette) self.messages.launch()
def tap_back_button(self): # In a message thread, tap the back button to return to main message list # TODO: remove tap with coordinates after Bug 1061698 is fixed self.marionette.find_element(*self._header_link_locator).tap(25, 25) messages = Messages(self.marionette) messages.wait_for_message_list() return messages
def test_settings_from_inbox(self): #launch the app messages = Messages(self.marionette) messages.launch() #tap settings icon messaging_settings = messages.tap_settings() self.assertTrue(messaging_settings.is_messaging_settings_displayed())
def prepare_app(self): # launch the messages app and wait for the messages to be displayed, # the first launch after populating the data takes a long time. messages = Messages(self.device.marionette) messages.launch() Wait(self.device.marionette, 120, ignored_exceptions=( NoSuchElementException, ElementNotVisibleException)).until(lambda m: m.find_element( By.CSS_SELECTOR, '#threads-container li').is_displayed())
def setUp(self): GaiaTestCase.setUp(self) self.contact = MockContact() self.data_layer.insert_contact(self.contact) _text_message_content = "Automated Test %s" % str(time.time()) self.data_layer.send_sms(self.testvars['local_phone_numbers'][0], _text_message_content) self.messages = Messages(self.marionette) self.messages.launch()
def test_mms_add_subject(self): #launch the app messages = Messages(self.marionette) messages.launch() #click new message new_message = messages.tap_create_new_message() #tap options icon activities = new_message.tap_options() #tap add subject option activities.tap_add_subject() new_message.wait_for_subject_input_displayed()
def test_settings_from_message(self): # launch the app messages = Messages(self.marionette) messages.launch() # click new message new_message = messages.tap_create_new_message() # tap options icon activities = new_message.tap_options() # tap settings icon messaging_settings = activities.tap_settings() self.assertTrue(messaging_settings.is_messaging_settings_displayed())
def test_settings_from_message(self): #launch the app messages = Messages(self.marionette) messages.launch() #click new message new_message = messages.tap_create_new_message() #tap options icon activities = new_message.tap_options() #tap settings icon messaging_settings = activities.tap_settings() self.assertTrue(messaging_settings.is_messaging_settings_displayed())
def test_sms_add_contact(self): """ Add a contact to a message. """ _text_message_content = "Automated Test %s" % str(time.time()) # insert contact self.contact = MockContact(tel=[{ 'type': ['Mobile'], 'value': '555%s' % repr(time.time()).replace('.', '')[8:]}]) self.data_layer.insert_contact(self.contact) self.messages = Messages(self.marionette) self.messages.launch() new_message = self.messages.tap_create_new_message() contacts_app = new_message.tap_add_recipient() contacts_app.wait_for_contacts() contacts_app.contact(self.contact['givenName'][0]).tap(return_details=False) contacts_app.wait_for_contacts_frame_to_close() # Now switch to the displayed frame which should be Messages app self.marionette.switch_to_frame(self.apps.displayed_app.frame) self.assertIn(self.contact['givenName'][0], new_message.first_recipient_name) self.assertEquals(self.contact['tel'][0]['value'], new_message.first_recipient_number_attribute) new_message.type_message(_text_message_content) self.assertTrue(new_message.is_send_button_enabled)
def test_sms_send(self): """ https://moztrap.mozilla.org/manage/case/10743/ """ # launch the app messages = Messages(self.marionette) messages.launch() # click new message new_message = messages.tap_create_new_message() new_message.type_phone_number(self.environment.phone_numbers[0]) new_message.type_message(self._text_message_content) activities_list = new_message.tap_attachment() camera = activities_list.tap_camera() camera.tap_capture() camera.tap_select_button() # back to messages app frame new_message.wait_for_resizing_to_finish() #click send self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) # get the most recent listed and most recent received text message last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] # Check the most recent received message has the same text content self.assertEqual(self._text_message_content, last_received_message.text.strip('\n').strip()) # Check that most recent message is also the most recent received message self.assertEqual(last_received_message.id, last_message.id) # Check that message has attachments self.assertTrue(last_message.has_attachments) view_image = last_message.tap_attachment() view_image.tap_save_image() self.assertIn('saved to Gallery', view_image.banner_message) # Check that there are 2 picture on the sd card # One is the picture we sent, the second is the one saved self.assertEqual(2, len(self.data_layer.picture_files))
def test_sms_notification_removed_when_sms_deleted(self): """ https://moztrap.mozilla.org/manage/case/8778/ """ _text_message_content = "Automated Test %s" % str(time.time()) # launch messages app messages = Messages(self.marionette) messages.launch() # Send a SMS to the device self.data_layer.send_sms(self.environment.phone_numbers[0], _text_message_content, skip_verification=True) system = System(self.marionette) # We will wait upto 300 seconds for the SMS to arrive due to network latency system.wait_for_notification_toaster_displayed( timeout=300, message="Notification did not appear. SMS database dump: %s " % self.data_layer.get_all_sms()) system.wait_for_notification_toaster_not_displayed() self.apps.switch_to_displayed_app() # Tap on the latest received SMS message_thread = messages.tap_first_received_message() Wait(self.marionette).until( lambda m: len(message_thread.received_messages) > 0) messages_number = len(message_thread.all_messages) last_received_message = message_thread.received_messages[-1] # Delete latest received SMS activities = last_received_message.long_press_message() activities.tap_delete_message() activities.confirm_delete_message() Wait(self.marionette).until( lambda m: len(message_thread.all_messages) == messages_number - 1) self.marionette.switch_to_frame() # Check that SMS notification no longer appears in utility tray utility_tray = system.open_utility_tray() self.assertEqual(0, len(utility_tray.notifications))
def test_sms_cropped_picture(self): """ https://moztrap.mozilla.org/manage/case/10742/ """ messages = Messages(self.marionette) messages.launch() new_message = messages.create_new_message( recipients=[self.environment.phone_numbers[0]], message=self._text_message_content) activities_list = new_message.tap_attachment() gallery = activities_list.tap_gallery() # go through the crop process gallery.wait_for_thumbnails_to_load() gallery.thumbnails[0].tap() from gaiatest.apps.gallery.regions.crop_view import CropView crop_view = CropView(self.marionette) # can't actually crop the element crop_view.tap_crop_done() # back to messages app frame new_message.wait_for_resizing_to_finish() attachment_options = new_message.tap_image_attachment() view_image = attachment_options.tap_view_button() self.assertTrue(view_image.is_image_visible) view_image.tap_back_button() self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] self.assertEqual(self._text_message_content, last_received_message.text.strip('\n').strip()) self.assertEqual(last_received_message.id, last_message.id) self.assertTrue(last_message.has_attachments) view_image = last_message.tap_attachment() self.assertTrue(view_image.is_image_visible)
def test_sms_cropped_picture(self): """ https://moztrap.mozilla.org/manage/case/10742/ """ messages = Messages(self.marionette) messages.launch() new_message = messages.create_new_message(recipients=[self.environment.phone_numbers[0]], message=self._text_message_content) activities_list = new_message.tap_attachment() gallery = activities_list.tap_gallery() # go through the crop process gallery.wait_for_thumbnails_to_load() gallery.thumbnails[0].tap() from gaiatest.apps.gallery.regions.crop_view import CropView crop_view = CropView(self.marionette) # can't actually crop the element crop_view.tap_crop_done() # back to messages app frame new_message.wait_for_resizing_to_finish() attachment_options = new_message.tap_image_attachment() view_image = attachment_options.tap_view_button() self.assertTrue(view_image.is_image_visible) view_image.tap_back_button() self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] self.assertEqual(self._text_message_content, last_received_message.text.strip('\n').strip()) self.assertEqual(last_received_message.id, last_message.id) self.assertTrue(last_message.has_attachments) view_image = last_message.tap_attachment() self.assertTrue(view_image.is_image_visible)
class TestSmsCreateContact(GaiaTestCase): def setUp(self): GaiaTestCase.setUp(self) _text_message_content = "Automated Test %s" % str(time.time()) self.data_layer.send_sms(self.testvars['carrier']['phone_number'], _text_message_content) self.messages = Messages(self.marionette) self.messages.launch() 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 activities.tap_create_new_contact() # Populate new contact fields new_contact = NewContact(self.marionette) 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.messages.switch_to_messages_frame() 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'])
class TestSmsWithAttachments(GaiaTestCase): def test_sms_send(self): self.data_layer.connect_to_cell_data() _text_message_content = "Automated Test %s" % str(time.time()) # launch the app self.messages = Messages(self.marionette) self.messages.launch() # click new message new_message = self.messages.tap_create_new_message() new_message.type_phone_number(self.testvars['carrier']['phone_number']) new_message.type_message(_text_message_content) select_attachment = new_message.tap_attachment() camera = select_attachment.tap_camera() # switch frame to camera iframe camera.switch_to_camera_frame() camera.wait_for_camera_ready() camera.tap_capture() camera.wait_for_select_button_displayed() camera.tap_select_button() # switch back to messages app frame self.messages.switch_to_messages_frame() #click send self.message_thread = new_message.tap_send(timeout=300) self.message_thread.wait_for_received_messages(timeout=300) # get the most recent listed and most recent received text message last_received_message = self.message_thread.received_messages[-1] last_message = self.message_thread.all_messages[-1] # Check the most recent received message has the same text content self.assertEqual(_text_message_content, last_received_message.text.strip('\n').strip()) # Check that most recent message is also the most recent received message self.assertEqual(last_received_message.id, last_message.id) # Check that message has attachments self.assertTrue(last_message.has_attachments)