def test_dialer_airplane_mode(self):
# https://moztrap.mozilla.org/manage/case/2282/
# Disable the device radio, enable Airplane mode
self.data_layer.set_setting('airplaneMode.enabled', True)
# Check that we are in Airplane mode
self.assertTrue(self.data_layer.get_setting('airplaneMode.enabled'))
# Launch the device dialer
phone = Phone(self.marionette)
phone.launch()
# Make a call
test_phone_number = self.testvars['remote_phone_number']
phone.keypad.dial_phone_number(test_phone_number)
phone.keypad.tap_call_button(switch_to_call_screen=False)
# Check for the Airplane mode dialog
phone.wait_for_confirmation_dialog()
# Verify the correct dialog text for the case
self.assertEqual("Airplane mode activated", phone.confirmation_dialog_text)
# Verify that there is no active telephony state; window.navigator.mozTelephony.active is null
self.assertRaises(JavascriptException, self.marionette.execute_script,
"return window.navigator.mozTelephony.active.state;")
class TestDuplicatePhoneNumber(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact(givenName='Test', tel=None)
self.contact2 = MockContact(givenName=self.contact['givenName'], tel={
'type': 'Mobile',
'value': '123456789'})
self.data_layer.insert_contact(self.contact)
self.data_layer.insert_contact(self.contact2)
def test_duplicate_phone_number(self):
self.phone = Phone(self.marionette)
self.phone.launch()
number_to_add = self.contact2['tel']['value']
self.phone.keypad.dial_phone_number(number_to_add)
add_number = self.phone.keypad.tap_add_contact()
contacts_app = add_number.tap_add_to_existing_contact()
contacts_app.wait_for_contacts(2)
edit_contact = contacts_app.contacts[0].tap(return_class='EditContact')
duplicate_contact_found = edit_contact.tap_update(return_class='Merge')
merge_contact = duplicate_contact_found.tap_on_merge()
self.device.touch_home_button()
contacts = Contacts(self.marionette)
contacts.launch()
contacts.wait_for_contacts(1)
self.assertEqual(contacts_app.contacts[0].name, self.contact['givenName'])
def test_dialer_make_call(self):
"""https://moztrap.mozilla.org/manage/case/1298/"""
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
self.assertEqual('normal', self.data_layer.current_audio_channel)
call_screen = phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
self.assertEqual('telephony', self.data_layer.current_audio_channel)
call_screen.switch_to_call_screen_frame()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(test_phone_number) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number,
call_screen.outgoing_calling_contact)
else:
self.assertEqual(test_phone_number[:2],
call_screen.outgoing_calling_contact[:2])
def test_dialer_make_call(self):
"""https://moztrap.mozilla.org/manage/case/1298/"""
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
# FIXME: Bug 1011000: will need to switch it on
# Assert that the channel has been switched to telephony
# channel_change_call = self.data_layer.wait_for_audio_channel_changed()
call_screen = phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
# FIXME: Bug 1011000: will need to switch it on
# Assert that the channel has been switched back to normal
# channel_change_hang = self.data_layer.wait_for_audio_channel_changed()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(test_phone_number) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number, call_screen.outgoing_calling_contact)
else:
self.assertEqual(test_phone_number[:2], call_screen.outgoing_calling_contact[:2])
def test_dialer_airplane_mode(self):
# https://moztrap.mozilla.org/manage/case/2282/
# Disable the device radio, enable Airplane mode
self.data_layer.set_setting('ril.radio.disabled', True)
# Check that we are in Airplane mode
self.assertTrue(self.data_layer.get_setting('ril.radio.disabled'))
# Launch the device dialer
phone = Phone(self.marionette)
phone.launch()
# Make a call
test_phone_number = self.testvars['remote_phone_number']
phone.keypad.call_number(test_phone_number)
# Check for the Airplane mode dialog
phone.wait_for_confirmation_dialog()
# Verify the correct dialog text for the case
self.assertEqual("Airplane mode activated",
phone.confirmation_dialog_text)
# Verify that there is no active telephony state; window.navigator.mozTelephony.active is null
self.assertRaises(
JavascriptException, self.marionette.execute_script,
"return window.navigator.mozTelephony.active.state;")
def test_dialer_make_call(self):
"""https://moztrap.mozilla.org/manage/case/1298/"""
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
self.assertEqual('normal', self.data_layer.current_audio_channel)
call_screen = phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
self.assertEqual('telephony', self.data_layer.current_audio_channel)
call_screen.switch_to_call_screen_frame()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(test_phone_number) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number, call_screen.outgoing_calling_contact)
else:
self.assertEqual(test_phone_number[:2], call_screen.outgoing_calling_contact[:2])
def test_set_up_conference_call(self):
"""Set up a conference between the remote phone and Plivo."""
test_phone_number = self.testvars['remote_phone_number']
from gaiatest.utils.plivo.plivo_util import PlivoUtil
PLIVO_TIMEOUT = 30
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(test_phone_number)
call_screen.wait_for_outgoing_call()
call_screen.wait_for_condition(lambda m: self.data_layer.active_telephony_state == 'connected')
call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_while_on_call()
call_screen.answer_call_while_on_call()
# Wait for Plivo to report the call as connected
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_connected(call_uuid),
message='The call was not connected.')
call_screen.merge_calls()
self.assertEqual(call_screen.conference_label, 'Conference (2)')
class TestDialerFindContact(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# Seed the contact with the remote phone number so we don't call random people
self.contact = MockContact(
tel={
'type': 'Mobile',
'value': "%s" % self.testvars['remote_phone_number']
})
self.data_layer.insert_contact(self.contact)
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_find_contact(self):
number_to_verify = self.contact['tel']['value']
# Dial number
self.phone.keypad.dial_phone_number(number_to_verify[:5])
# Assert search popup is displayed
self.phone.keypad.wait_for_search_popup_visible()
# Assert name and phone number are the ones in the saved contact
self.assertEqual(self.phone.keypad.suggested_name,
self.contact['name'])
self.assertEqual(self.phone.keypad.suggested_phone_number,
number_to_verify)
# Tap search popup suggestion
call_screen = self.phone.keypad.tap_search_popup()
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(number_to_verify) <= call_screen.MAX_NUMBER_OF_DISPLAYED_DIGITS:
# Check the number displayed is the one we dialed
self.assertIn(number_to_verify,
call_screen.calling_contact_information)
else:
self.assertIn(number_to_verify[2:],
call_screen.calling_contact_information)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
class TestAccessibilityCallscreenVisibility(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.phone = Phone(self.marionette)
self.phone.launch()
def test_a11y_callscreen_visibility(self):
test_phone_number = self.contact['tel']['value']
# Make a call
self.phone.a11y_make_call(test_phone_number)
# Check that the keyboard view is hidden by default
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.call_screen._views_locator)))
# Check that the incoming container is hidden by default
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.call_screen._incoming_container_locator)))
# Check that the handled call hangup button is hidden by default
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.call_screen._hangup_button_locator)))
# Hang up
self.phone.a11y_hang_up()
class TestAccessibilityPhoneKeypad(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.phone = Phone(self.marionette)
self.phone.launch()
def test_phone_keypad(self):
# Delete is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.keypad._keypad_delete_locator)))
# Add contact button is disabled for the screen reader.
self.assertTrue(self.accessibility.is_disabled(self.marionette.find_element(
*self.phone.keypad._add_new_contact_button_locator)))
number_to_verify = self.contact['tel']['value']
# Screen reader dial number
self.phone.keypad.a11y_dial_phone_number(number_to_verify)
# Check that the number was entered correctly.
self.assertEqual(self.phone.keypad.phone_number, number_to_verify)
# Delete is visible to the screen reader.
self.assertFalse(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.keypad._keypad_delete_locator)))
# Call button is enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(self.marionette.find_element(
*self.phone.keypad._call_bar_locator)))
# Add contact button is enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(self.marionette.find_element(
*self.phone.keypad._add_new_contact_button_locator)))
def test_dialer_make_call(self):
"""https://moztrap.mozilla.org/manage/case/1298/"""
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
# FIXME: Bug 1011000: will need to switch it on
# Assert that the channel has been switched to telephony
# channel_change_call = self.data_layer.wait_for_audio_channel_changed()
call_screen = phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
# FIXME: Bug 1011000: will need to switch it on
# Assert that the channel has been switched back to normal
# channel_change_hang = self.data_layer.wait_for_audio_channel_changed()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(test_phone_number) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number,
call_screen.outgoing_calling_contact)
else:
self.assertEqual(test_phone_number[:2],
call_screen.outgoing_calling_contact[:2])
def test_dialer_make_call(self):
"""https://moztrap.mozilla.org/manage/case/1298/"""
test_phone_number = '0956820097'
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(test_phone_number)
def test_MMI_code_IMEI(self):
phone = Phone(self.marionette)
phone.launch()
# Dial the code
phone.keypad.phone_number = IMEI_CODE
attention_screen = AttentionScreen(self.marionette)
self.assertEqual(attention_screen.message, self.testvars['imei'])
def test_MMI_code_IMEI(self):
phone = Phone(self.marionette)
phone.launch()
# Dial the code
phone.keypad.dial_phone_number(IMEI_CODE)
attention_screen = AttentionScreen(self.marionette)
self.assertEqual(attention_screen.message, self.testvars['imei'])
class TestDialerFindContact(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# Seed the contact with the remote phone number so we don't call random people
self.contact = MockContact(tel={
'type': 'Mobile',
'value': "%s" % self.testvars['remote_phone_number']})
self.data_layer.insert_contact(self.contact)
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_find_contact(self):
number_to_verify = self.contact['tel']['value']
# Dial number
self.phone.keypad.dial_phone_number(number_to_verify[:5])
# Assert search popup is displayed
self.phone.keypad.wait_for_search_popup_visible()
# Assert name and phone number are the ones in the saved contact
self.assertEqual(self.phone.keypad.suggested_name, self.contact['name'])
self.assertEqual(self.phone.keypad.suggested_phone_number, number_to_verify)
# Tap search popup suggestion
call_screen = self.phone.keypad.tap_search_popup()
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
# Wait for the state to get to at least 'dialing'
active_states = ('dialing', 'alerting', 'connecting', 'connected')
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state in active_states,
timeout=30)
if len(number_to_verify) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(number_to_verify, call_screen.calling_contact_information.split(', ')[1])
else:
self.assertEqual(number_to_verify[:2], call_screen.calling_contact_information.split(', ')[1][:2])
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
def test_clear_phone_number(self):
"""
https://moztrap.mozilla.org/manage/case/2191/
"""
test_phone_number = '5551234567'
phone = Phone(self.marionette)
phone.launch()
phone.keypad.dial_phone_number(test_phone_number)
self.assertEquals(phone.keypad.phone_number, test_phone_number)
phone.keypad.clear_phone_number()
self.assertEquals(phone.keypad.phone_number, '')
class TestDialerAddContact(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_add_contact(self):
number_to_verify = self.contact['tel'][0]['value']
# Dial number
self.phone.keypad.dial_phone_number(number_to_verify)
# Assert that the number was entered correctly.
self.assertEqual(self.phone.keypad.phone_number, number_to_verify)
# Click Add contact button
add_new_number = self.phone.keypad.tap_add_contact()
# Tap on "Create New Contact"
new_contact = add_new_number.tap_create_new_contact()
# Enter data into fields
new_contact.type_given_name(self.contact['givenName'][0])
new_contact.type_family_name(self.contact['familyName'][0])
# Click Done button
new_contact.tap_done()
# Switch back to keypad-view
self.wait_for_condition(lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
#Go to Contact list and Verify result
contacts = self.phone.tap_contacts()
# Check only one contact is created
self.assertEqual(1, len(contacts.contacts))
# Tap on the new contact
contact_details = contacts.contacts[0].tap()
# Verify full name
full_name = self.contact['givenName'][0] + " " + self.contact['familyName'][0]
self.assertEqual(contact_details.full_name, full_name)
# Verify phone number
self.assertEqual(contact_details.phone_number, number_to_verify)
class TestCallLogAllCalls(GaiaMtbfTestCase):
def setUp(self):
GaiaMtbfTestCase.setUp(self)
# delete any existing call log entries - call log needs to be loaded
self.phone = Phone(self.marionette)
self.phone.launch()
def test_call_log_all_calls(self):
"""https://moztrap.mozilla.org/manage/case/1306/"""
call_log = self.phone.tap_call_log_toolbar_button()
self.wait_for_element_displayed("css selector", "div.view-body")
current_calls_count = call_log.all_calls_count
numbers = self.marionette.find_elements("css selector", "div.view-body article ol li:first-child")
if len(numbers) > 0:
verification_bit = 1
if self.testvars['remote_phone_number'] in numbers[0].text:
verification_bit = 0
test_phone_number = self.testvars['remote_phone_number']
self.phone.tap_keypad_toolbar_button()
# Make a call so it will appear in the call log
self.phone.make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.wait_for_condition(lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
call_log = self.phone.tap_call_log_toolbar_button()
call_log.tap_all_calls_tab()
# Check that 'All calls' tab is selected
self.assertTrue(call_log.is_all_calls_tab_selected)
# Now check that one call appears in the call log
self.wait_for_condition(lambda m: call_log.all_calls_count > 0)
self.assertEqual(call_log.all_calls_count, current_calls_count+verification_bit)
# Check that the call displayed is for the call we made
self.assertIn(test_phone_number, call_log.first_all_call_text)
def tearDown(self):
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaMtbfTestCase.tearDown(self)
class TestPhoneSelectToolbars(GaiaImageCompareTestCase):
def setUp(self):
GaiaImageCompareTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
def test_phone_select_toolbars(self):
# Screen reader activated call log button click.
self.phone.a11y_click_call_log_toolbar_button()
# Keypad is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is visible to the screen reader.
self.assertFalse(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
self.take_screenshot()
# Screen reader activated contacts button click.
self.phone.a11y_click_contacts()
self.apps.switch_to_displayed_app()
# Keypad is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is visible to the screen reader.
self.assertFalse(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
self.take_screenshot()
# Screen reader activated keypad button click.
self.phone.a11y_click_keypad_toolbar_button()
# Keypad is visible to the screen reader.
self.assertFalse(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
self.take_screenshot()
def test_MMI_code_IMEI(self):
phone = Phone(self.marionette)
phone.launch()
# Dial the code
phone.keypad.dial_phone_number(IMEI_CODE)
attention_screen = AttentionScreen(self.marionette)
# Go through all expected IMEIs and check they are in the message
for imei in self.testvars['imei']:
self.assertIn(imei, attention_screen.message)
def test_MMI_code_IMEI(self):
phone = Phone(self.marionette)
phone.launch()
# Dial the code
phone.keypad.dial_phone_number(IMEI_CODE)
attention_screen = AttentionScreen(self.marionette)
# Go through all expected IMEIs and check they are in the message
for imei in self.environment.imei_numbers:
self.assertIn(imei, attention_screen.message)
class TestRedialLastNumber(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.test_phone_number = self.testvars['remote_phone_number']
self.phone = Phone(self.marionette)
self.phone.launch()
mock_call = MockCall(self.test_phone_number, 'dialing')
self.data_layer.insert_call_entry(mock_call)
def test_redial_last_number(self):
"""
https://moztrap.mozilla.org/manage/case/9043/
"""
keypad = self.phone.keypad
# Check that there is no phone number displayed
self.assertEqual('', keypad.phone_number)
keypad.tap_call_button(False)
keypad.wait_for_phone_number_ready()
# Check that the last dialed number is displayed
self.assertEqual(self.test_phone_number, keypad.phone_number)
call_screen = keypad.tap_call_button()
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
if len(self.test_phone_number
) <= call_screen.MAX_NUMBER_OF_DISPLAYED_DIGITS:
# Check the number displayed is the one we dialed
self.assertEqual(self.test_phone_number,
call_screen.outgoing_calling_contact)
else:
self.assertEqual(self.test_phone_number[2:],
call_screen.outgoing_calling_contact[2:])
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
def test_dialer_dsds_make_phone_call_with_default_sim(self, default_sim):
"""
Place a phone call with the default SIM.
"""
self.data_layer.set_setting('ril.telephony.defaultServiceId', default_sim - 1)
remote_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(remote_phone_number)
call_screen.wait_for_outgoing_call()
self.assertIn(str(default_sim), call_screen.via_sim)
call_screen.hang_up()
def test_set_up_conference_call(self):
"""Set up a conference between the remote phone and Plivo."""
test_phone_number = self.testvars['remote_phone_number']
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
self.is_in_conference_call = False
self.is_in_regular_call = False
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(test_phone_number)
call_screen.wait_for_outgoing_call()
self.is_in_regular_call = True
call_screen.wait_for_condition(lambda m: self.data_layer.active_telephony_state == 'connected')
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_while_on_call()
call_screen.answer_call_while_on_call()
# Wait for Plivo to report the call as connected
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_connected(self.call_uuid),
message='The call was not connected.')
call_screen.merge_calls()
self.is_in_regular_call = False
self.is_in_conference_call = True
self.assertEqual(call_screen.conference_label, 'Conference (2)')
call_screen.hang_up()
self.is_in_conference_call = False
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_completed(self.call_uuid),
message="Plivo didn't report the call as completed")
self.call_uuid = None
class TestRedialLastNumber(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.test_phone_number = self.testvars['remote_phone_number']
self.phone = Phone(self.marionette)
self.phone.launch()
mock_call = MockCall(self.test_phone_number, 'dialing')
self.data_layer.insert_call_entry(mock_call)
def test_redial_last_number(self):
"""
https://moztrap.mozilla.org/manage/case/9043/
"""
keypad = self.phone.keypad
# Check that there is no phone number displayed
self.assertEqual('', keypad.phone_number)
keypad.tap_call_button(False)
keypad.wait_for_phone_number_ready()
# Check that the last dialed number is displayed
self.assertEqual(self.test_phone_number, keypad.phone_number)
call_screen = keypad.tap_call_button()
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
if len(self.test_phone_number) <= 12:
# Check the number displayed is the one we dialed
self.assertEqual(self.test_phone_number, call_screen.outgoing_calling_contact)
else:
self.assertEqual(self.test_phone_number[:2], call_screen.outgoing_calling_contact[:2])
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
class TestDialerAddContact(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_add_contact(self):
number_to_verify = self.contact['tel']['value']
# Dial number
self.phone.keypad.dial_phone_number(number_to_verify)
# Assert that the number was entered correctly.
self.assertEqual(self.phone.keypad.phone_number, number_to_verify)
# Click Add contact button
add_new_number = self.phone.keypad.tap_add_contact()
# Tap on "Create New Contact"
new_contact = add_new_number.tap_create_new_contact()
# Enter data into fields
new_contact.type_given_name(self.contact['givenName'])
new_contact.type_family_name(self.contact['familyName'])
# Click Done button, don't return Contacts because we return to Dialer
new_contact.tap_done(return_contacts=False)
#Go to Contact list and Verify result
contacts = self.phone.tap_contacts()
# Check only one contact is created
contacts.wait_for_contacts(1)
# Tap on the new contact
contact_details = contacts.contacts[0].tap()
# Verify full name
full_name = self.contact['givenName'] + " " + self.contact['familyName']
self.assertEqual(contact_details.full_name, full_name)
# Verify phone number
self.assertEqual(contact_details.phone_number, number_to_verify)
def test_dialer_dsds_make_phone_call_with_default_sim(self, default_sim):
"""
Place a phone call with the default SIM.
"""
self.data_layer.set_setting('ril.telephony.defaultServiceId',
default_sim - 1)
remote_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(remote_phone_number)
call_screen.wait_for_outgoing_call()
self.assertIn(str(default_sim), call_screen.via_sim)
call_screen.hang_up()
def test_dialer_dsds_make_phone_call_with_default_sim(self, default_sim_value, default_sim_name):
"""
Place a phone call with the default SIM.
"""
self.data_layer.set_setting('ril.telephony.defaultServiceId', default_sim_value)
remote_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(remote_phone_number)
call_screen.wait_for_outgoing_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(default_sim_name in call_screen.outgoing_via_sim)
call_screen.hang_up()
class TestAccessibilityPhoneEditContact(GaiaTestCase):
def setUp(self):
# Start application in Phone App
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
def test_a11y_phone_edit_contact(self):
# Add a random contact
contacts = self.phone.a11y_click_contacts()
# Add new contact
new_contact_form = contacts.a11y_click_new_contact()
# Enter data into fields
contact = MockContact()
new_contact_form.type_given_name(contact['givenName'])
# Save new contact
new_contact_form.a11y_click_done()
self.wait_for_condition(lambda m: len(contacts.contacts) == 1)
# Edit the contact
contact_item = contacts.contact(contact['givenName'])
contact_item_detail = contact_item.a11y_click()
contact_item_edit = contact_item_detail.a11y_click_edit()
self.apps.switch_to_displayed_app()
# Now check if toolbar is visible by Screen Reader
# Keypad is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._keypad_toolbar_button_locator)))
# Contacts is visible to the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._contacts_view_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._call_log_toolbar_button_locator)))
def test_dialer_dsds_make_phone_call_with_default_sim(self, default_sim_value, default_sim_name):
"""
Place a phone call with the default SIM.
"""
self.data_layer.set_setting('ril.telephony.defaultServiceId', default_sim_value)
remote_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(remote_phone_number)
call_screen.wait_for_outgoing_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(default_sim_name in call_screen.via_sim)
call_screen.hang_up()
class TestCallLogAllCalls(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# delete any existing call log entries - call log needs to be loaded
self.phone = Phone(self.marionette)
self.phone.launch()
def test_call_log_all_calls(self):
# https://moztrap.mozilla.org/manage/case/1306/
self.phone.tap_call_log_toolbar_button()
# switch back to keypad for the test
self.phone.tap_keypad_toolbar_button()
test_phone_number = self.testvars['remote_phone_number']
# Make a call so it will appear in the call log
self.phone.make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.wait_for_condition(lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
call_log = self.phone.tap_call_log_toolbar_button()
call_log.tap_all_calls_tab()
# Check that 'All calls' tab is selected
self.assertTrue(call_log.is_all_calls_tab_selected)
# Now check that one call appears in the call log
self.assertEqual(call_log.all_calls_count, 1)
# Check that the call displayed is for the call we made
self.assertIn(test_phone_number, call_log.first_all_call_text)
def tearDown(self):
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
class TestAccessibilityPhoneKeypad(GaiaImageCompareTestCase):
def setUp(self):
GaiaImageCompareTestCase.setUp(self)
self.contact = MockContact()
self.phone = Phone(self.marionette)
self.phone.launch()
def test_phone_keypad(self):
# Delete is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone.keypad._keypad_delete_locator)))
# Add contact button is disabled for the screen reader.
self.assertTrue(
self.accessibility.is_disabled(
self.marionette.find_element(
*self.phone.keypad._add_new_contact_button_locator)))
self.take_screenshot()
number_to_verify = '1234567890'
# Screen reader dial number
self.phone.keypad.a11y_dial_phone_number(number_to_verify)
# Check that the number was entered correctly.
self.take_screenshot()
self.assertEqual(self.phone.keypad.phone_number, number_to_verify)
# Delete is visible to the screen reader.
self.assertFalse(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone.keypad._keypad_delete_locator)))
# Call button is enabled for the screen reader.
self.assertFalse(
self.accessibility.is_disabled(
self.marionette.find_element(
*self.phone.keypad._call_bar_locator)))
# Add contact button is enabled for the screen reader.
self.assertFalse(
self.accessibility.is_disabled(
self.marionette.find_element(
*self.phone.keypad._add_new_contact_button_locator)))
class TestCallLogAllCalls(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# delete any existing call log entries - call log needs to be loaded
self.phone = Phone(self.marionette)
self.phone.launch()
def test_call_log_all_calls(self):
# https://moztrap.mozilla.org/manage/case/1306/
self.phone.tap_call_log_toolbar_button()
# switch back to keypad for the test
self.phone.tap_keypad_toolbar_button()
test_phone_number = self.testvars['remote_phone_number']
# Make a call so it will appear in the call log
self.phone.make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.wait_for_condition(
lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
call_log = self.phone.tap_call_log_toolbar_button()
call_log.tap_all_calls_tab()
# Check that 'All calls' tab is selected
self.assertTrue(call_log.is_all_calls_tab_selected)
# Now check that one call appears in the call log
self.assertEqual(call_log.all_calls_count, 1)
# Check that the call displayed is for the call we made
self.assertIn(test_phone_number, call_log.first_all_call_text)
def tearDown(self):
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
GaiaTestCase.tearDown(self)
def test_dialer_make_call(self):
# https://moztrap.mozilla.org/manage/case/1298/
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
phone.call_screen.wait_for_outgoing_call()
# Wait for the state to get to 'alerting' which means connection made
phone.call_screen.wait_for_condition(lambda m: self.data_layer.active_telephony_state == "alerting", timeout=30)
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number, phone.call_screen.outgoing_calling_number)
class TestAccessibilityPhoneEditContact(GaiaTestCase):
def setUp(self):
# Start application in Phone App
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
def test_a11y_phone_edit_contact(self):
# Add a random contact
contacts = self.phone.a11y_click_contacts()
# Add new contact
new_contact_form = contacts.a11y_click_new_contact()
# Enter data into fields
contact = MockContact()
new_contact_form.type_given_name(contact['givenName'])
# Save new contact
new_contact_form.a11y_click_done()
self.wait_for_condition(lambda m: len(contacts.contacts) == 1)
# Edit the contact
contact_item = contacts.contact(contact['givenName'])
contact_item_detail = contact_item.a11y_click()
contact_item_edit = contact_item_detail.a11y_click_edit()
self.apps.switch_to_displayed_app()
# Now check if toolbar is visible by Screen Reader
# Keypad is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._keypad_toolbar_button_locator)))
# Contacts is visible to the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._contacts_view_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone._call_log_toolbar_button_locator)))
def test_dialer_make_call(self):
# https://moztrap.mozilla.org/manage/case/1298/
test_phone_number = self.testvars['remote_phone_number']
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(test_phone_number)
# Wait for call screen to be dialing
call_screen.wait_for_outgoing_call()
# Wait for the state to get to 'dialing' which means dialer app has initiated telephony
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == "dialing",
timeout=30)
# Check the number displayed is the one we dialed
self.assertEqual(test_phone_number,
call_screen.outgoing_calling_contact)
def launch_app(self):
phone = Phone(self.device.marionette)
phone.launch()
phone.tap_call_log_toolbar_button()
time.sleep(30) # FIXME: actually wait for call log loading modal to be gone
self.log('Done waiting for call log loading modal to be gone')
call_log_container = self.device.marionette.find_element('id', 'call-log-container')
call_log_location = call_log_container.location
call_log_swipe_padding = 8
scroll_x1 = call_log_location['x'] + call_log_container.size['width'] / 2
scroll_y1 = call_log_location['y'] + (call_log_container.size['height'] -
call_log_swipe_padding)
scroll_y2 = call_log_location['y'] + call_log_swipe_padding
self.cmds = []
for i in range(int(self.scrolldown_amount)):
self.cmds.append(['drag', scroll_x1, scroll_y1, scroll_x1, scroll_y2, 100, 10])
class TestDeleteCallLog(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
test_phone_number = self.testvars['remote_phone_number']
mock_call = MockCall(test_phone_number, 'incoming')
self.data_layer.insert_call_entry(mock_call)
mock_call = MockCall(test_phone_number, 'dialing')
self.data_layer.insert_call_entry(mock_call)
def test_delete_call_log(self):
"""
https://moztrap.mozilla.org/manage/case/2267/
"""
call_log = self.phone.tap_call_log_toolbar_button()
call_log.tap_edit_button()
# Check that we are in edit mode
self.assertEqual('Edit', call_log.header_text)
call_log.tap_select_all_button()
call_list = call_log.call_list
# Check that the header contains the number of selected elements
# and that the checkboxes are selected
self.assertIn(str(len(call_list)), call_log.header_text)
for call in call_list:
self.assertTrue(call.is_checked)
call_log.tap_delete_button()
call_log.tap_delete_confirmation_button()
self.assertEqual('No calls recorded', call_log.no_logs_message)
def test_set_up_conference_call(self):
"""Set up a conference between the remote phone and Plivo."""
test_phone_number = self.testvars['remote_phone_number']
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
self.is_in_conference_call = False
self.is_in_regular_call = False
phone = Phone(self.marionette)
phone.launch()
call_screen = phone.keypad.call_number(test_phone_number)
call_screen.wait_for_outgoing_call()
self.is_in_regular_call = True
Wait(self.marionette).until(lambda m: self.data_layer.active_telephony_state == 'connected')
self.call_uuid = self.plivo.make_call(
to_number=self.environment.phone_numbers[0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_while_on_call()
call_screen.answer_call_while_on_call()
self.plivo.wait_for_call_connected(self.call_uuid)
call_screen.merge_calls()
self.is_in_regular_call = False
self.is_in_conference_call = True
self.assertEqual(call_screen.conference_label, 'Conference (2)')
call_screen.hang_up()
self.is_in_conference_call = False
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
class TestDeleteCallLog(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
test_phone_number = self.testvars['remote_phone_number']
mock_call = MockCall(test_phone_number, 'incoming')
self.data_layer.insert_call_entry(mock_call)
mock_call = MockCall(test_phone_number, 'dialing')
self.data_layer.insert_call_entry(mock_call)
def test_delete_call_log(self):
"""
https://moztrap.mozilla.org/manage/case/2267/
"""
call_log = self.phone.tap_call_log_toolbar_button()
call_log.tap_edit_button()
# Check that we are in edit mode
self.assertEqual('Edit', call_log.header_text)
call_log.tap_select_all_button()
call_list = call_log.call_list
# Check that the header contains the number of selected elements
# and that the checkboxes are selected
self.assertIn(str(len(call_list)), call_log.header_text)
for call in call_list:
self.assertTrue(call.is_checked)
call_log.tap_delete_button()
call_log.tap_delete_confirmation_button()
self.assertEqual('No calls recorded', call_log.no_logs_message)
class TestAccessibilityCallscreenOverlayVisibility(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.phone = Phone(self.marionette)
self.phone.launch()
def test_a11y_callscreen_overlay_visibility(self):
test_phone_number = self.contact['tel']['value']
# Make a call
self.phone.a11y_make_call(test_phone_number)
# Check that the bluetooth dialog overlay is hidden
self.assertTrue(self.accessibility.is_hidden(self.marionette.find_element(
*self.phone.call_screen._bluetooth_menu_locator)))
# Hang up
self.phone.a11y_hang_up()
def launch_app(self):
phone = Phone(self.device.marionette)
phone.launch()
phone.tap_call_log_toolbar_button()
time.sleep(30) # FIXME: wait for call log loading modal to be gone
self.log('Done waiting for call log loading modal to be gone')
call_log_container = self.device.marionette.find_element(
'id', 'call-log-container')
call_log_location = call_log_container.location
call_log_swipe_padding = 8
scroll_x1 = call_log_location[
'x'] + call_log_container.size['width'] / 2
scroll_y1 = call_log_location['y'] + (
call_log_container.size['height'] - call_log_swipe_padding)
scroll_y2 = call_log_location['y'] + call_log_swipe_padding
self.cmds = []
for i in range(int(self.scrolldown_amount)):
self.cmds.append(
['drag', scroll_x1, scroll_y1, scroll_x1, scroll_y2, 100, 10])
class TestCallLogGroups(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
current_time = repr(time.time()).replace('.', '')
self.phone_number_1 = '555%s' % current_time[-7:]
self.phone_number_2 = '444%s' % current_time[-7:]
self.yesterday_date = date.fromordinal(date.today().toordinal() - 1)
self.past_date_1 = date(2014, 12, 01)
self.past_date_2 = date(2013, 12, 01)
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_1))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_2))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_1,
date=self.yesterday_date))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_1, date=self.past_date_1))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_2, date=self.past_date_1))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_2, date=self.past_date_1))
self.data_layer.insert_call_entry(
MockCall(phone_number=self.phone_number_1, date=self.past_date_2))
def test_call_log_groups(self):
"""
https://moztrap.mozilla.org/manage/case/2103/
"""
call_log = self.phone.tap_call_log_toolbar_button()
group_calls = call_log.groups_list
self.assertEqual(4, len(group_calls))
self.assertEqual('TODAY', group_calls[0].header_text)
self.assertEqual('YESTERDAY', group_calls[1].header_text)
self.assertEqual('{:%m/%d/%Y}'.format(self.past_date_1),
group_calls[2].header_text)
self.assertEqual('{:%m/%d/%Y}'.format(self.past_date_2),
group_calls[3].header_text)
today_group_calls = group_calls[0].group_calls
yesterday_group_calls = group_calls[1].group_calls
group_calls_2014 = group_calls[2].group_calls
group_calls_2013 = group_calls[3].group_calls
self.assertEqual(2, len(today_group_calls))
self.assertEqual(self.phone_number_1,
today_group_calls[0].phone_number)
self.assertEqual(self.phone_number_2,
today_group_calls[1].phone_number)
self.assertEqual(1, len(yesterday_group_calls))
self.assertEqual(self.phone_number_1,
yesterday_group_calls[0].phone_number)
self.assertEqual(2, len(group_calls_2014))
self.assertEqual(self.phone_number_1, group_calls_2014[0].phone_number)
self.assertEqual(self.phone_number_2, group_calls_2014[1].phone_number)
self.assertEqual('2', group_calls_2014[1].retry_count)
self.assertEqual(1, len(group_calls_2013))
self.assertEqual(self.phone_number_1, group_calls_2013[0].phone_number)
class TestAccessibilityPhoneSelectToolbars(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
def test_phone_select_toolbars(self):
# Screen reader activated call log button click.
call_log = self.phone.a11y_click_call_log_toolbar_button()
# Keypad is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is visible to the screen reader.
self.assertTrue(
self.accessibility.is_visible(
self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
# Screen reader activated contacts button click.
self.phone.a11y_click_contacts()
self.apps.switch_to_displayed_app()
# Keypad is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is visible to the screen reader.
self.assertTrue(
self.accessibility.is_visible(
self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
# Screen reader activated keypad button click.
self.phone.a11y_click_keypad_toolbar_button()
# Keypad is visible to the screen reader.
self.assertTrue(
self.accessibility.is_visible(
self.marionette.find_element(
*self.phone._keypad_toolbar_locator)))
# Contacts is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._contacts_toolbar_locator)))
# Call log is hidden from the screen reader.
self.assertTrue(
self.accessibility.is_hidden(
self.marionette.find_element(
*self.phone._call_log_toolbar_locator)))
class TestCallLogGroups(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.phone = Phone(self.marionette)
self.phone.launch()
current_time = repr(time.time()).replace('.', '')
self.phone_number_1 = '555%s' % current_time[-7:]
self.phone_number_2 = '444%s' % current_time[-7:]
self.yesterday_date = date.fromordinal(date.today().toordinal()-1)
self.past_date_1 = date(2014, 12, 01)
self.past_date_2 = date(2013, 12, 01)
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_1))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_2))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_1, date=self.yesterday_date))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_1, date=self.past_date_1))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_2, date=self.past_date_1))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_2, date=self.past_date_1))
self.data_layer.insert_call_entry(MockCall(phone_number=self.phone_number_1, date=self.past_date_2))
def test_call_log_groups(self):
"""
https://moztrap.mozilla.org/manage/case/2103/
"""
call_log = self.phone.tap_call_log_toolbar_button()
group_calls = call_log.groups_list
self.assertEqual(4, len(group_calls))
self.assertEqual('TODAY', group_calls[0].header_text)
self.assertEqual('YESTERDAY', group_calls[1].header_text)
self.assertEqual(u'{:%m/%d/%y}'.format(self.past_date_1), group_calls[2].header_text)
self.assertEqual(u'{:%m/%d/%y}'.format(self.past_date_2), group_calls[3].header_text)
today_group_calls = group_calls[0].group_calls
yesterday_group_calls = group_calls[1].group_calls
group_calls_2014 = group_calls[2].group_calls
group_calls_2013 = group_calls[3].group_calls
self.assertEqual(2, len(today_group_calls))
self.assertEqual(self.phone_number_1, today_group_calls[0].phone_number)
self.assertEqual(self.phone_number_2, today_group_calls[1].phone_number)
self.assertEqual(1, len(yesterday_group_calls))
self.assertEqual(self.phone_number_1, yesterday_group_calls[0].phone_number)
self.assertEqual(2, len(group_calls_2014))
self.assertEqual(self.phone_number_1, group_calls_2014[0].phone_number)
self.assertEqual(self.phone_number_2, group_calls_2014[1].phone_number)
self.assertEqual('2', group_calls_2014[1].retry_count)
self.assertEqual(1, len(group_calls_2013))
self.assertEqual(self.phone_number_1, group_calls_2013[0].phone_number)
class TestCallLogAllCalls(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
# delete any existing call log entries - call log needs to be loaded
self.phone = Phone(self.marionette)
self.phone.launch()
def test_call_log_all_calls(self):
"""
https://moztrap.mozilla.org/manage/case/1306/
"""
test_phone_number = self.testvars['remote_phone_number']
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
plivo_phone_number = self.testvars['plivo']['phone_number'][1:]
# Make a call so it will appear in the call log
self.phone.make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.phone.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
self.call_uuid = self.plivo.make_call(
to_number=self.environment.phone_numbers[0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.plivo.hangup_call(self.call_uuid)
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
self.phone.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
call_log = self.phone.tap_call_log_toolbar_button()
# Check all calls tab
call_log.tap_all_calls_tab()
self.assertTrue(call_log.is_all_calls_tab_selected)
self.wait_for_condition(lambda m: len(call_log.call_list) == 2)
call_list = call_log.call_list
# Check that the calls displayed are for the calls we made/received
self.assertIn(plivo_phone_number, call_list[0].phone_number)
self.assertEqual('incoming', call_list[0].call_type)
self.assertIn(test_phone_number, call_list[1].phone_number)
self.assertEqual('dialing', call_list[1].call_type)
# Check missed calls tab
call_log.tap_missed_calls_tab()
self.assertTrue(call_log.is_missed_calls_tab_selected)
self.wait_for_condition(lambda m: len(call_log.call_list) == 1)
call_list = call_log.call_list
# Check that the calls displayed are for the calls we received
self.assertIn(plivo_phone_number, call_list[0].phone_number)
self.assertEqual('incoming', call_list[0].call_type)
def tearDown(self):
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
# Also ask Plivo to kill the call if needed
if self.call_uuid:
self.plivo.hangup_call(self.call_uuid)
GaiaTestCase.tearDown(self)
class TestDialerAddContact(GaiaTestCase):
# Dialer app
_keyboard_container_locator = ('id', 'keyboard-container')
_phone_number_view_locator = ('id', 'phone-number-view')
_add_new_contact_button_locator = ('id', 'keypad-callbar-add-contact')
_contacts_view_locator = ('id', 'option-contacts')
_create_new_contact_locator = ('id', 'create-new-contact-menuitem')
# Header buttons
_done_button_locator = ('id', 'save-button')
# New/Edit contact fields
_given_name_field_locator = ('id', 'givenName')
_family_name_field_locator = ('id', 'familyName')
_phone_field_locator = ('id', 'number_0')
# Contact details panel
_contact_list_locator = ('css selector', '#contacts-list-G li')
_contact_name_title_locator = ('id', 'contact-name-title')
_call_phone_number_button_locator = ('id', 'call-or-pick-0')
# frames
_new_contact_frame_locator = (
'css selector',
"iframe[src^='app://communications'][src$='contacts/index.html?new']")
_contact_frame_locator = ('css selector', '#iframe-contacts')
_keypad_frame_locator = (
'css selector',
"iframe[src^='app://communications'][src$='dialer/index.html#keyboard-view']"
)
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_add_contact(self):
self.wait_for_element_displayed(*self._keyboard_container_locator)
# Dial number
self.phone.keypad.dial_phone_number(self.contact['tel']['value'])
# Assert that the number was entered correctly.
phone_view = self.marionette.find_element(
*self._phone_number_view_locator)
self.assertEqual(phone_view.get_attribute('value'),
self.contact['tel']['value'])
# Click Add contact button
self.wait_for_element_displayed(*self._add_new_contact_button_locator)
add_new_contact = self.marionette.find_element(
*self._add_new_contact_button_locator)
self.marionette.tap(add_new_contact)
# Tap on "Create New Contact"
self.wait_for_element_displayed(*self._create_new_contact_locator)
create_new_contact = self.marionette.find_element(
*self._create_new_contact_locator)
self.marionette.tap(create_new_contact)
# Switch to add contacts frame
self.marionette.switch_to_frame()
self.wait_for_element_present(*self._new_contact_frame_locator)
new_contact_frame = self.marionette.find_element(
*self._new_contact_frame_locator)
self.marionette.switch_to_frame(new_contact_frame)
# Enter data into fields
self.wait_for_element_displayed(*self._done_button_locator)
self.marionette.find_element(
*self._given_name_field_locator).send_keys(
self.contact['givenName'])
self.marionette.find_element(
*self._family_name_field_locator).send_keys(
self.contact['familyName'])
# Click Done button
done_button = self.marionette.find_element(*self._done_button_locator)
self.marionette.tap(done_button)
# Switch back to keypad-view
self.marionette.switch_to_frame()
self.wait_for_element_present(*self._keypad_frame_locator)
keypad_frame = self.marionette.find_element(
*self._keypad_frame_locator)
self.marionette.switch_to_frame(keypad_frame)
#Go to Contact list and Verify result
contact_view = self.marionette.find_element(
*self._contacts_view_locator)
self.marionette.tap(contact_view)
# switch to contact frame
self.wait_for_element_present(*self._contact_frame_locator)
contact_frame = self.marionette.find_element(
*self._contact_frame_locator)
self.marionette.switch_to_frame(contact_frame)
# Check only one contact is created
self.wait_for_element_displayed(*self._contact_list_locator)
contact_list = self.marionette.find_elements(
*self._contact_list_locator)
self.assertEqual(1, len(contact_list))
# Tap on the new contact
contact = contact_list[0]
self.marionette.tap(contact)
# wait for contact details to be loaded
self.wait_for_element_displayed(
*self._call_phone_number_button_locator)
# Verify full name
full_name = self.contact['givenName'] + " " + self.contact['familyName']
self.assertEqual(
self.marionette.find_element(
*self._contact_name_title_locator).text, full_name)
# Verify phone number
self.assertEqual(
self.marionette.find_element(
*self._call_phone_number_button_locator).text,
self.contact['tel']['value'])
class TestAccessibilityPhoneCallLog(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.phone = Phone(self.marionette)
self.phone.launch()
def test_phone_call_log(self):
# Screen reader activated call log button click.
call_log = self.phone.a11y_click_call_log_toolbar_button()
# Edit call log button is disabled for the screen reader.
self.assertTrue(self.accessibility.is_disabled(self.marionette.find_element(
*call_log._call_log_edit_button_locator)))
# Screen reader activated keypad button click.
self.phone.a11y_click_keypad_toolbar_button()
test_phone_number = self.contact['tel']['value']
# Make a call so it will appear in the call log
self.phone.a11y_make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.wait_for_condition(lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
self.phone.a11y_click_call_log_toolbar_button()
# Edit call log button is enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(self.marionette.find_element(
*call_log._call_log_edit_button_locator)))
# Now check that one call appears in the call log
self.assertEqual(call_log.all_calls_count, 1)
# Check that the call displayed is for the call we made
self.assertIn(test_phone_number, call_log.first_all_call_text)
call_log_first_item = self.marionette.find_elements(
*call_log._all_calls_list_item_button_locator)[0]
# This needs to be uncommented once the screen reader can handle long press.
# Activate a first log item with the screen reader.
# self.accessibility.click(call_log_first_item)
# # Add contact action menu should be visible to the screen reader.
# self.assertTrue(self.accessibility.is_visible(self.marionette.find_element(
# *self.phone._call_group_menu_locator)))
# # Close the add contact action menu with the screen reader.
# self.accessibility.click(self.marionette.find_element(
# *self.phone._cancel_action_menu_locator))
self.accessibility.click(self.marionette.find_element(
*call_log._call_log_edit_button_locator))
call_log_edit_element = self.marionette.find_element(
*call_log._call_log_edit_dialog_locator)
delete = self.marionette.find_element(*call_log._call_log_edit_delete_button_locator)
deselect = self.marionette.find_element(
*call_log._call_log_edit_deselect_all_button_locator)
select = self.marionette.find_element(*call_log._call_log_edit_select_all_button_locator)
# Edit mode is visible to the screen reader.
self.assertTrue(self.accessibility.is_visible(call_log_edit_element))
# Delete button is disabled for the screen reader.
self.assertTrue(self.accessibility.is_disabled(delete))
# Deselect all button is disabled for the screen reader.
self.assertTrue(self.accessibility.is_disabled(deselect))
# Select all button is enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(select))
# Activate a first log item with the screen reader.
call_log_first_item = self.marionette.find_elements(
*call_log._all_calls_list_item_checkbox_locator)[0]
self.accessibility.click(call_log_first_item)
# Delete button is now enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(delete))
# Deselect all button is now enabled for the screen reader.
self.assertFalse(self.accessibility.is_disabled(deselect))
# Select all button is now disabled for the screen reader.
self.assertTrue(self.accessibility.is_disabled(select))
# First item in the list is selected.
self.assertTrue(call_log_first_item.get_attribute('checked'))
self.accessibility.click(call_log_first_item)
# First item in the list is unchecked.
self.assertFalse(call_log_first_item.get_attribute('checked'))
self.accessibility.click(self.marionette.find_element(
*call_log._call_log_edit_close_button_locator))
# Edit mode is hidden from the screen reader.
self.assertTrue(self.accessibility.is_hidden(call_log_edit_element))
class TestCallLogAllCalls(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
# delete any existing call log entries - call log needs to be loaded
self.phone = Phone(self.marionette)
self.phone.launch()
def test_call_log_all_calls(self):
"""https://moztrap.mozilla.org/manage/case/1306/"""
test_phone_number = self.testvars['remote_phone_number']
plivo_phone_number = self.testvars['plivo']['phone_number']
# Make a call so it will appear in the call log
self.phone.make_call_and_hang_up(test_phone_number)
# Wait for fall back to phone app
self.wait_for_condition(
lambda m: self.apps.displayed_app.name == self.phone.name)
self.apps.switch_to_displayed_app()
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number'])
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace(
'+', ''),
timeout=30)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.plivo.hangup_call(self.call_uuid)
self.apps.switch_to_displayed_app()
call_log = self.phone.tap_call_log_toolbar_button()
# Check all calls tab
call_log.tap_all_calls_tab()
self.assertTrue(call_log.is_all_calls_tab_selected)
call_list = call_log.call_list
self.assertEqual(len(call_list), 2)
# Check that the calls displayed are for the calls we made/received
self.assertIn(plivo_phone_number, call_list[0].phone_number)
self.assertEqual('incoming', call_list[0].call_type)
self.assertIn(test_phone_number, call_list[1].phone_number)
self.assertEqual('dialing', call_list[1].call_type)
# Check missed calls tab
call_log.tap_missed_calls_tab()
self.assertTrue(call_log.is_missed_calls_tab_selected)
call_list = call_log.call_list
self.assertEqual(len(call_list), 1)
# Check that the calls displayed are for the calls we received
self.assertIn(plivo_phone_number, call_list[0].phone_number)
self.assertEqual('incoming', call_list[0].call_type)
def tearDown(self):
# In case the assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_active_call()
# Also ask Plivo to kill the call if needed
if self.call_uuid:
self.plivo.hangup_call(self.call_uuid)
GaiaTestCase.tearDown(self)
class TestDialerAddContact(GaiaTestCase):
# Dialer app
_keyboard_container_locator = ("id", "keyboard-container")
_phone_number_view_locator = ("id", "phone-number-view")
_add_new_contact_button_locator = ("id", "keypad-callbar-add-contact")
_contacts_view_locator = ("id", "option-contacts")
_create_new_contact_locator = ("id", "create-new-contact-menuitem")
# Header buttons
_done_button_locator = ("id", "save-button")
# New/Edit contact fields
_given_name_field_locator = ("id", "givenName")
_family_name_field_locator = ("id", "familyName")
_phone_field_locator = ("id", "number_0")
# Contact details panel
_contact_list_locator = ("css selector", "#contacts-list-G li")
_contact_name_title_locator = ("id", "contact-name-title")
_call_phone_number_button_locator = ("id", "call-or-pick-0")
# frames
_new_contact_frame_locator = ("css selector", "iframe[src^='app://communications'][src$='contacts/index.html?new']")
_contact_frame_locator = ("css selector", "#iframe-contacts")
_keypad_frame_locator = (
"css selector",
"iframe[src^='app://communications'][src$='dialer/index.html#keyboard-view']",
)
def setUp(self):
GaiaTestCase.setUp(self)
self.contact = MockContact()
# launch the Phone app
self.phone = Phone(self.marionette)
self.phone.launch()
def test_dialer_add_contact(self):
self.wait_for_element_displayed(*self._keyboard_container_locator)
# Dial number
self.phone.keypad.phone_number = self.contact["tel"]["value"]
# Assert that the number was entered correctly.
phone_view = self.marionette.find_element(*self._phone_number_view_locator)
self.assertEqual(phone_view.get_attribute("value"), self.contact["tel"]["value"])
# Click Add contact button
self.wait_for_element_displayed(*self._add_new_contact_button_locator)
add_new_contact = self.marionette.find_element(*self._add_new_contact_button_locator)
self.marionette.tap(add_new_contact)
# Tap on "Create New Contact"
self.wait_for_element_displayed(*self._create_new_contact_locator)
create_new_contact = self.marionette.find_element(*self._create_new_contact_locator)
self.marionette.tap(create_new_contact)
# Switch to add contacts frame
self.marionette.switch_to_frame()
self.wait_for_element_present(*self._new_contact_frame_locator)
new_contact_frame = self.marionette.find_element(*self._new_contact_frame_locator)
self.marionette.switch_to_frame(new_contact_frame)
# Enter data into fields
self.wait_for_element_displayed(*self._done_button_locator)
self.marionette.find_element(*self._given_name_field_locator).send_keys(self.contact["givenName"])
self.marionette.find_element(*self._family_name_field_locator).send_keys(self.contact["familyName"])
# Click Done button
done_button = self.marionette.find_element(*self._done_button_locator)
self.marionette.tap(done_button)
# Switch back to keypad-view
self.marionette.switch_to_frame()
self.wait_for_element_present(*self._keypad_frame_locator)
keypad_frame = self.marionette.find_element(*self._keypad_frame_locator)
self.marionette.switch_to_frame(keypad_frame)
# Go to Contact list and Verify result
contact_view = self.marionette.find_element(*self._contacts_view_locator)
self.marionette.tap(contact_view)
# switch to contact frame
self.wait_for_element_present(*self._contact_frame_locator)
contact_frame = self.marionette.find_element(*self._contact_frame_locator)
self.marionette.switch_to_frame(contact_frame)
# Check only one contact is created
self.wait_for_element_displayed(*self._contact_list_locator)
contact_list = self.marionette.find_elements(*self._contact_list_locator)
self.assertEqual(1, len(contact_list))
# Tap on the new contact
contact = contact_list[0]
self.marionette.tap(contact)
# wait for contact details to be loaded
self.wait_for_element_displayed(*self._call_phone_number_button_locator)
# Verify full name
full_name = self.contact["givenName"] + " " + self.contact["familyName"]
self.assertEqual(self.marionette.find_element(*self._contact_name_title_locator).text, full_name)
# Verify phone number
self.assertEqual(
self.marionette.find_element(*self._call_phone_number_button_locator).text, self.contact["tel"]["value"]
)
