def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
self.call_uuid = False
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.device.lock()
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()
call_screen.reject_call()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
self.assertTrue(self.device.is_locked)
def test_receive_call(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
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=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.answer_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.')
# Wait for the state to be connected
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == 'connected',
timeout=30)
call_screen.hang_up()
# Wait for Plivo to report the call as completed
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_completed(self.call_uuid),
message='The call was not completed.')
self.call_uuid = None
def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace(
'+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def test_receive_call_with_locked_screen(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace(
'+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
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[sim_value].replace(
'+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(
lambda m: self.data_layer.active_telephony_state == 'connected')
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
class TestReceiveCall(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
def test_receive_call(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
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=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.answer_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.')
# Wait for the state to be connected
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == 'connected',
timeout=30)
call_screen.hang_up()
# Wait for Plivo to report the call as completed
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_completed(self.call_uuid),
message='The call was not completed.')
self.call_uuid = None
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 TestReceiveCallScreenLocked(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace('+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
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
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
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.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.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.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)
class TestReceiveCallScreenLocked(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
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
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
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 test_dialer_clear_miss_call_notification(self):
"""
Pre-requisites:
Have a voicemail in the notification bar and a missed call notification
Repro Steps:
1) Open the notification panel and tap the missed call notification.
2) After the call log appears, drop down the notification panel again.
3) The notification for the call that was just tapped is no longer present.
"""
plivo_phone_number = self.testvars['plivo']['phone_number']
# Create a missed call notification
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
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
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
system.wait_for_notification_toaster_not_displayed()
# Open the notification panel
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 2)
self.assertEqual(notifications[0].title, 'Missed call')
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
self.assertTrue(plivo_phone_number[1:] in notifications[0].content)
self.assertEqual(notifications[1].title, 'Voicemail')
notifications[0].tap_notification()
self.marionette.switch_to_frame()
system.open_utility_tray()
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0].title, 'Voicemail')
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
PLIVO_TIMEOUT = 30
self.device.lock()
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['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
self.plivo.hangup_call(self.call_uuid)
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
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
lock_screen.wait_for_notification()
# Check if the screen is turned on
self.assertTrue(self.device.is_screen_enabled)
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
self.assertTrue(lock_screen.notifications[0].is_visible)
self.assertEqual(lock_screen.notifications[0].title, 'Missed call')
self.assertTrue(
self.contact.givenName in lock_screen.notifications[0].content)
self.device.unlock()
system = System(self.marionette)
system.wait_for_notification_toaster_not_displayed()
# Expand the notification bar
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
class TestReceiveCallScreenLocked(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
def test_receive_call_with_locked_screen(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
self.call_uuid = False
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
self.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace('+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 TestReceiveCallScreenLocked(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
def test_receive_call_with_locked_screen(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace(
'+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
def test_dialer_receive_call_with_contact_photo(self):
"""
https://moztrap.mozilla.org/manage/case/1544/
"""
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['local_phone_numbers'][0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn('background-image:',
call_screen.contact_background_style)
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
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
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['local_phone_numbers'][sim_value].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(lambda m: self.data_layer.active_telephony_state == 'connected')
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
def test_receive_call_with_locked_screen(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
self.call_uuid = False
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
self.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace('+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
def test_receive_call(self):
"""Make a phone call from Plivo to the phone."""
PLIVO_TIMEOUT = 30
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=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.answer_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.')
# Wait for the state to be connected
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == 'connected',
timeout=30)
call_screen.hang_up()
# Wait for Plivo to report the call as completed
Wait(self.plivo, timeout=PLIVO_TIMEOUT).until(
lambda p: p.is_call_completed(self.call_uuid),
message='The call was not completed.')
self.call_uuid = None
def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['local_phone_numbers'][0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.reject_call()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
self.assertTrue(self.device.is_locked)
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)')
def test_receive_call_with_locked_screen(self):
"""
Verify that the User can receive a call whilst the device is locked
https://moztrap.mozilla.org/manage/case/1300/
"""
PLIVO_TIMEOUT = 30
self.call_uuid = False
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.device.lock()
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['carrier']['phone_number'].replace('+', ''),
timeout=PLIVO_TIMEOUT)
# Wait for the incoming call screen to show up
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
# Reject the call
call_screen.reject_call()
# Check that the screen is still locked
self.assertTrue(self.device.is_locked)
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 test_dialer_clear_miss_call_notification(self):
"""
Pre-requisites:
Have a voicemail in the notification bar and a missed call notification
Repro Steps:
1) Open the notification panel and tap the missed call notification.
2) After the call log appears, drop down the notification panel again.
3) The notification for the call that was just tapped is no longer present.
"""
PLIVO_TIMEOUT = 30
plivo_phone_number = self.testvars["plivo"]["phone_number"]
# Create a missed call notification
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars["plivo"]["auth_id"], self.testvars["plivo"]["auth_token"], plivo_phone_number
)
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()
self.plivo.hangup_call(self.call_uuid)
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
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
system.wait_for_notification_toaster_not_displayed()
# Open the notification panel
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 2)
self.assertEqual(notifications[0].title, "Missed call")
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
self.assertTrue(plivo_phone_number[1:] in notifications[0].content)
self.assertEqual(notifications[1].title, "Voicemail")
notifications[0].tap_notification()
self.marionette.switch_to_frame()
system.open_utility_tray()
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0].title, "Voicemail")
def setUp(self):
GaiaTestCase.setUp(self)
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
self.testvars['plivo']['phone_number']
)
plivo.send_sms(to_number=self.environment.phone_numbers[0].replace('+', ''),
message=self._generate_text())
system = System(self.marionette)
system.wait_for_notification_toaster_displayed(timeout=300)
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
PLIVO_TIMEOUT = 30
self.device.lock()
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['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
self.plivo.hangup_call(self.call_uuid)
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
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
lock_screen.wait_for_notification()
# Check if the screen is turned on
self.assertTrue(self.device.is_screen_enabled)
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
self.assertTrue(lock_screen.notifications[0].is_visible)
self.assertEqual(lock_screen.notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in lock_screen.notifications[0].content)
self.device.unlock()
system = System(self.marionette)
system.wait_for_notification_toaster_not_displayed()
# Expand the notification bar
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
class TestReceiveCallWithContactPhoto(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
with open(self.resource('IMG_0001.jpg'), 'rb') as f:
encoded_string = base64.b64encode(f.read())
self.contact = MockContact()
self.contact.update(photo='%s' % encoded_string,
tel={
'type': 'Mobile',
'value': self.testvars['plivo']['phone_number']
})
self.data_layer.insert_contact(self.contact)
def test_dialer_receive_call_with_contact_photo(self):
"""
https://moztrap.mozilla.org/manage/case/1544/
"""
PLIVO_TIMEOUT = 30
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['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn('background-image:',
call_screen.contact_background_style)
def tearDown(self):
self.plivo.hangup_call(self.call_uuid)
GaiaTestCase.tearDown(self)
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
PLIVO_TIMEOUT = 30
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['local_phone_numbers'][sim_value].replace(
'+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_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.')
# Wait for the state to be connected
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == 'connected',
timeout=30)
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
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
def test_dialer_clear_miss_call_notification(self):
"""
Pre-requisites:
Have a voicemail in the notification bar and a missed call notification
Repro Steps:
1) Open the notification panel and tap the missed call notification.
2) After the call log appears, drop down the notification panel again.
3) The notification for the call that was just tapped is no longer present.
"""
plivo_phone_number = self.testvars['plivo']['phone_number']
# Create a missed call notification
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
plivo_phone_number,
)
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['local_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
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
system.wait_for_notification_toaster_not_displayed()
# Open the notification panel
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 2)
self.assertEqual(notifications[0].title, 'Missed call')
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
self.assertTrue(plivo_phone_number[1:] in notifications[0].content)
self.assertEqual(notifications[1].title, 'Voicemail')
notifications[0].tap_notification()
self.marionette.switch_to_frame()
system.open_utility_tray()
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0].title, 'Voicemail')
class TestSetUpConferenceCall(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
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)')
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an assertion fails this will still kill the call
# An open call creates problems for future tests
self.data_layer.kill_conference_call()
GaiaTestCase.tearDown(self)
class TestDsdsReceiveCallOnBothSims(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
@parameterized("1", 0, 'SIM1')
@parameterized("2", 1, 'SIM2')
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
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[sim_value].replace(
'+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(
lambda m: self.data_layer.active_telephony_state == 'connected')
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 TestDsdsReceiveCallOnBothSims(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
@parameterized("1", 0, 'SIM1')
@parameterized("2", 1, 'SIM2')
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
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['local_phone_numbers'][sim_value].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(lambda m: self.data_layer.active_telephony_state == 'connected')
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
def test_receive_call(self):
"""Make a phone call from Plivo to the phone."""
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['local_phone_numbers'][0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(
lambda m: self.data_layer.active_telephony_state == 'connected')
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
class TestReceiveCallWithContactPhoto(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
with open(self.resource('IMG_0001.jpg'), 'rb') as f:
encoded_string = base64.b64encode(f.read())
self.contact = MockContact()
self.contact.update(photo='%s' % encoded_string,
tel={'type': 'Mobile', 'value': self.testvars['plivo']['phone_number']})
self.data_layer.insert_contact(self.contact)
def test_dialer_receive_call_with_contact_photo(self):
"""
https://moztrap.mozilla.org/manage/case/1544/
"""
PLIVO_TIMEOUT = 30
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['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn('background-image:', call_screen.contact_background_style)
def tearDown(self):
self.plivo.hangup_call(self.call_uuid)
GaiaTestCase.tearDown(self)
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
self.device.lock()
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
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
lock_screen.wait_for_notification()
# Check if the screen is turned on
self.assertTrue(self.device.is_screen_enabled)
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
self.assertTrue(lock_screen.notifications[0].is_visible)
self.assertEqual(lock_screen.notifications[0].title, "Missed call")
self.assertTrue(self.contact.givenName in lock_screen.notifications[0].content)
self.device.unlock()
system = System(self.marionette)
system.wait_for_notification_toaster_not_displayed()
# Expand the notification bar
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, "Missed call")
self.assertTrue(self.contact.givenName in notifications[0].content)
def test_dsds_receive_call_on_both_sims(self, sim_number):
"""Make a phone call from Plivo to each SIM."""
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[sim_number -
1].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn(str(sim_number), call_screen.via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(
lambda m: self.data_layer.active_telephony_state == 'connected')
self.assertIn(str(sim_number), call_screen.via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
def test_dialer_receive_call_with_contact_photo(self):
"""
https://moztrap.mozilla.org/manage/case/1544/
"""
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['local_phone_numbers'][0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn('background-image:', call_screen.contact_background_style)
def test_dsds_receive_call_on_both_sims(self, sim_value, sim_name):
"""Make a phone call from Plivo to each SIM."""
PLIVO_TIMEOUT = 30
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['local_phone_numbers'][sim_value].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.answer_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.')
# Wait for the state to be connected
call_screen.wait_for_condition(
lambda m: self.data_layer.active_telephony_state == 'connected',
timeout=30)
# TODO Replace the following line by a check on the l10n ID
# once bug 1104667 lands
self.assertTrue(sim_name in call_screen.incoming_via_sim)
call_screen.hang_up()
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
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
def test_receive_call(self):
"""Make a phone call from Plivo to the phone."""
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['local_phone_numbers'][0].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(lambda m: self.data_layer.active_telephony_state == 'connected')
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
def test_dsds_receive_call_on_both_sims(self, sim_number):
"""Make a phone call from Plivo to each SIM."""
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[sim_number - 1].replace('+', ''))
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call()
self.assertIn(str(sim_number), call_screen.via_sim)
call_screen.answer_call()
self.plivo.wait_for_call_connected(self.call_uuid)
Wait(self.marionette).until(lambda m: self.data_layer.active_telephony_state == 'connected')
self.assertIn(str(sim_number), call_screen.via_sim)
call_screen.hang_up()
self.plivo.wait_for_call_completed(self.call_uuid)
self.call_uuid = None
class TestReceiveCallFromKnownContactNotification(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.contact.update(tel={
'type': 'Mobile',
'value': self.testvars['plivo']['phone_number']}
)
self.data_layer.insert_contact(self.contact)
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
PLIVO_TIMEOUT = 30
self.device.lock()
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=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
self.plivo.hangup_call(self.call_uuid)
self.call_uuid = None
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
lock_screen = LockScreen(self.marionette)
notifications = lock_screen.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
system.wait_for_notification_toaster_not_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
self.device.unlock()
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 TestDialerClearMissCallNotification(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
# We mock the voicemail notification as we have no way to clear a real voicemail after this test
self.data_layer.add_notification('Voicemail', {
"body": "Dial some number",
"icon": "app://system.gaiamobile.org/style/icons/voicemail.png",
"tag": "voicemailNotification:0"
})
def test_dialer_clear_miss_call_notification(self):
"""
Pre-requisites:
Have a voicemail in the notification bar and a missed call notification
Repro Steps:
1) Open the notification panel and tap the missed call notification.
2) After the call log appears, drop down the notification panel again.
3) The notification for the call that was just tapped is no longer present.
"""
plivo_phone_number = self.testvars['plivo']['phone_number']
# Create a missed call notification
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
plivo_phone_number,
)
self.call_uuid = self.plivo.make_call(
to_number=self.testvars['local_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
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
system.wait_for_notification_toaster_not_displayed()
# Open the notification panel
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 2)
self.assertEqual(notifications[0].title, 'Missed call')
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
self.assertTrue(plivo_phone_number[1:] in notifications[0].content)
self.assertEqual(notifications[1].title, 'Voicemail')
notifications[0].tap_notification()
self.marionette.switch_to_frame()
system.open_utility_tray()
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0].title, 'Voicemail')
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
self.data_layer.clear_notifications()
GaiaTestCase.tearDown(self)
class TestReceiveCallFromKnownContactNotification(GaiaTestCase):
def setUp(self):
try:
self.testvars["plivo"]
except KeyError:
raise SkipTest("Plivo account details not present in test variables")
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.contact.update(tel={"type": "Mobile", "value": self.testvars["plivo"]["phone_number"]})
self.data_layer.insert_contact(self.contact)
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
self.device.lock()
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
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
lock_screen.wait_for_notification()
# Check if the screen is turned on
self.assertTrue(self.device.is_screen_enabled)
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
self.assertTrue(lock_screen.notifications[0].is_visible)
self.assertEqual(lock_screen.notifications[0].title, "Missed call")
self.assertTrue(self.contact.givenName in lock_screen.notifications[0].content)
self.device.unlock()
system = System(self.marionette)
system.wait_for_notification_toaster_not_displayed()
# Expand the notification bar
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, "Missed call")
self.assertTrue(self.contact.givenName in notifications[0].content)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 TestSetUpConferenceCall(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
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.testvars['local_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
def tearDown(self):
# In case an assertion fails this will still kill the call
# An open call creates problems for future tests
if self.is_in_regular_call:
self.data_layer.kill_active_call()
if self.is_in_conference_call:
self.data_layer.kill_conference_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 TestDialerClearMissCallNotification(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
# We mock the voicemail notification as we have no way to clear a real voicemail after this test
self.data_layer.add_notification(
'Voicemail', {
"body": "Dial some number",
"icon":
"app://system.gaiamobile.org/style/icons/voicemail.png",
"tag": "voicemailNotification:0"
})
def test_dialer_clear_miss_call_notification(self):
"""
Pre-requisites:
Have a voicemail in the notification bar and a missed call notification
Repro Steps:
1) Open the notification panel and tap the missed call notification.
2) After the call log appears, drop down the notification panel again.
3) The notification for the call that was just tapped is no longer present.
"""
plivo_phone_number = self.testvars['plivo']['phone_number']
# Create a missed call notification
from gaiatest.utils.plivo.plivo_util import PlivoUtil
self.plivo = PlivoUtil(
self.testvars['plivo']['auth_id'],
self.testvars['plivo']['auth_token'],
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
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
system.wait_for_notification_toaster_not_displayed()
# Open the notification panel
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
# Verify the user sees the missed call event in the notification center
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 2)
self.assertEqual(notifications[0].title, 'Missed call')
# Remove the first digit (country code) which is not displayed for AT&T/USA - Bug 1088756
self.assertTrue(plivo_phone_number[1:] in notifications[0].content)
self.assertEqual(notifications[1].title, 'Voicemail')
notifications[0].tap_notification()
self.marionette.switch_to_frame()
system.open_utility_tray()
notifications = utility_tray.notifications
self.assertEqual(len(notifications), 1)
self.assertEqual(notifications[0].title, 'Voicemail')
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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)
self.data_layer.clear_notifications()
GaiaTestCase.tearDown(self)
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 TestReceiveCallFromKnownContactNotification(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest(
'Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
self.contact = MockContact()
self.contact.update(tel={
'type': 'Mobile',
'value': self.testvars['plivo']['phone_number']
})
self.data_layer.insert_contact(self.contact)
def test_dialer_miss_call_from_known_contact_notification(self):
"""
https://moztrap.mozilla.org/manage/case/9294/
"""
PLIVO_TIMEOUT = 30
self.device.lock()
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['local_phone_numbers'][0].replace('+', ''),
timeout=PLIVO_TIMEOUT)
call_screen = CallScreen(self.marionette)
call_screen.wait_for_incoming_call_with_locked_screen()
self.plivo.hangup_call(self.call_uuid)
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
# Verify the user sees a missed call notification message
# and the known contacts info is shown.
system = System(self.marionette)
self.marionette.switch_to_frame()
system.wait_for_notification_toaster_displayed()
lock_screen = LockScreen(self.marionette)
notifications = lock_screen.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
system.wait_for_notification_toaster_not_displayed()
# Verify the user sees the missed call event in the notification center
# and the known contacts info is shown.
self.device.unlock()
system.wait_for_status_bar_displayed()
utility_tray = system.open_utility_tray()
utility_tray.wait_for_notification_container_displayed()
notifications = utility_tray.notifications
self.assertEqual(notifications[0].title, 'Missed call')
self.assertTrue(self.contact.givenName in notifications[0].content)
def tearDown(self):
# Switch back to main frame before Marionette loses track bug #840931
self.marionette.switch_to_frame()
# In case an 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 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 TestSetUpConferenceCall(GaiaTestCase):
def setUp(self):
try:
self.testvars['plivo']
except KeyError:
raise SkipTest('Plivo account details not present in test variables')
GaiaTestCase.setUp(self)
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
def tearDown(self):
# In case an assertion fails this will still kill the call
# An open call creates problems for future tests
if self.is_in_regular_call:
self.data_layer.kill_active_call()
if self.is_in_conference_call:
self.data_layer.kill_conference_call()
# Also ask Plivo to kill the call if needed
if self.call_uuid:
self.plivo.hangup_call(self.call_uuid)
GaiaTestCase.tearDown(self)
