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)
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
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_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 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 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_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)
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)
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_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 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()
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 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 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_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 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()
end_time = time.time() + 120
while time.time() < end_time:
try:
message = self.device.marionette.find_element(
By.CSS_SELECTOR, '#threads-container li')
if message.is_displayed():
break
except (NoSuchElementException, StaleElementException):
pass
time.sleep(0.5)
else:
raise TimeoutException('No messages displayed')
self.device.gaiaApps.kill(messages.app)
def test_delete_threads(self):
""" https://moztrap.mozilla.org/manage/case/15927/ """
messages = Messages(self.marionette)
messages.launch()
new_message = messages.create_new_message(recipients=[self.environment.phone_numbers[0]],
message=self._generate_text())
new_message.save_as_draft()
self.assertGreaterEqual(len(messages.threads), 2)
messages.enter_select_mode()
for thread in messages.threads:
thread.choose()
messages.delete_selection()
self.assertEqual(len(messages.threads), 0)
self.assertFalse(messages.is_in_select_mode)
def test_sms_auto_save_draft(self):
"""
https://moztrap.mozilla.org/manage/case/7806/
"""
_text_message_content = "Automated Test %s" % str(time.time())
# launch messages app
messages = Messages(self.marionette)
messages.launch()
# click new message
new_message = messages.tap_create_new_message()
self.marionette.switch_to_frame()
Wait(self.marionette).until(
lambda m: new_message.keyboard.is_keyboard_displayed)
self.apps.switch_to_displayed_app()
new_message.type_message(_text_message_content)
self.assertEqual(new_message.message, _text_message_content)
# close message app and leave cards view
self.device.hold_home_button()
from gaiatest.apps.system.regions.cards_view import CardsView
cards_view = CardsView(self.marionette)
cards_view.wait_for_cards_view()
# wait for first app ready
cards_view.wait_for_card_ready('sms')
cards_view.close_app('sms')
self.assertFalse(cards_view.is_app_present('sms'),
"Killed app not expected to appear in cards view")
# wait for homescreen to be displayed
self.wait_for_condition(
lambda m: self.apps.displayed_app.name == Homescreen.name)
# re-open messages app
messages.launch()
self.assertTrue(messages.draft_message[0].is_draft_icon_displayed)
new_message = messages.draft_message[0].tap_draft_message()
# check that last message draft is shown correctly
self.assertEqual(new_message.message, _text_message_content)
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)
def test_dialer_from_message(self):
# Send a SMS to the device
_text_message_content = "Automated Test %s" % str(time.time())
self.data_layer.send_sms(self.testvars['carrier']['phone_number'],
_text_message_content)
# Open first received message
self.messages = Messages(self.marionette)
self.messages.launch()
self.messages.wait_for_message_received(timeout=180)
self.message_thread = self.messages.tap_first_received_message()
# Check the phone number
self.message_thread.tap_header()
keypad = self.message_thread.tap_call()
self.assertEquals(keypad.phone_number,
self.testvars['carrier']['phone_number'])
def test_sms_report(self):
time_test_began = time.time()
_text_message_content = "Automated Test %s" % str(time_test_began)
_test_phone_number = self.environment.phone_numbers[0]
error_range_sent_in_seconds = 120
error_range_received_in_seconds = 300
# Sending the message
self.messages = Messages(self.marionette)
self.messages.launch()
new_message = self.messages.create_new_message(recipients=_test_phone_number,
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]
last_message = self.message_thread.all_messages[-1]
report = last_received_message.open_report()
# Checking that the data in the received report is correct
self.assertTrue(report.is_message_an_sms)
self.assertEqual(_test_phone_number, report.sender)
date_sent_maximum_delay = time_test_began + error_range_sent_in_seconds
self.assertLessEqual(report.sent_date, date_sent_maximum_delay)
date_received_maximum_delay = time_test_began + error_range_received_in_seconds
self.assertLessEqual(report.received_date, date_received_maximum_delay)
report.close()
last_sent_message = self.message_thread.sent_messages[0]
report = last_sent_message.open_report()
# Checking that the data in the sent report is correct
self.assertTrue(report.is_message_an_sms)
self.assertLessEqual(report.sent_date, date_sent_maximum_delay)
self.assertEqual(_test_phone_number, report.receiver)
def test_sms_auto_save_draft(self):
"""
https://moztrap.mozilla.org/manage/case/7806/
"""
_text_message_content = "Automated Test %s" % str(time.time())
# launch messages app
messages = Messages(self.marionette)
messages.launch()
# click new message
new_message = messages.tap_create_new_message()
self.marionette.switch_to_frame()
Wait(self.marionette).until(
lambda m: new_message.keyboard.is_keyboard_displayed)
self.apps.switch_to_displayed_app()
new_message.type_message(_text_message_content)
self.assertEqual(new_message.message, _text_message_content)
# close message app and leave cards view
self.device.hold_home_button()
cards_view = CardsView(self.marionette)
cards_view.wait_for_cards_view()
# wait for first app ready
cards_view.cards[0].wait_for_centered()
cards_view.cards[0].close()
self.assertEqual(len(cards_view.cards), 0)
# wait for homescreen to be displayed
Homescreen(self.marionette).wait_to_be_displayed()
# re-open messages app
messages.launch()
self.assertTrue(messages.draft_threads[0].is_draft_icon_displayed)
new_message = messages.draft_threads[0].open()
# check that last message draft is shown correctly
self.assertEqual(new_message.message, _text_message_content)
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.wait_for_camera_ready()
camera.switch_to_camera_frame()
camera.tap_capture()
camera.wait_for_select_button_displayed()
camera.tap_select_button()
# switch back to messages app frame
self.wait_for_condition(
lambda m: self.apps.displayed_app.name == messages.name)
self.apps.switch_to_displayed_app()
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)
