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_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 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_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 setUp(self): GaiaTestCase.setUp(self) self.contact = MockContact() # launch the Phone app self.phone = Phone(self.marionette) self.phone.launch()
def setUp(self): GaiaTestCase.setUp(self) self.phone = Phone(self.marionette) self.phone.launch() self.data_layer.insert_call_entry(MockCall()) self.data_layer.insert_call_entry(MockCall(call_type='dialing'))
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() self.phone.tap_call_log_toolbar_button() self.data_layer.delete_all_call_log_entries() # switch back to keypad for the test self.phone.tap_keypad_toolbar_button()
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_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 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 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_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_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_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.via_sim) call_screen.hang_up()
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 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 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])
def setUp(self): # Start application in Phone App GaiaTestCase.setUp(self) self.phone = Phone(self.marionette) self.phone.launch()
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 setUp(self): GaiaTestCase.setUp(self) self.phone = Phone(self.marionette) self.phone.launch()
def setUp(self): GaiaImageCompareTestCase.setUp(self) self.contact = MockContact() self.phone = Phone(self.marionette) self.phone.launch()