def wait_for_antenna_change(self): # wait for radio to change state wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.antenna_change")) except: self.fail("Failed to receive mozFMRadio.onantennaavailablechange event")
def create_notification(self, text): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_onshow = false; var text = arguments[0]; console.log("Creating new notification"); var notification = new Notification(text); // setup callback notification.onshow = function() { console.log("Received Notification.onshow event"); window.wrappedJSObject.rcvd_onshow = true; } marionetteScriptFinished(1); """, script_args=[text]) # wait for notification to be displayed wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_onshow")) except: self.fail("Did not receive the Notification.onshow event")
def set_wifi_enabled(self, enable): self.marionette.execute_async_script(""" var enable = arguments[0]; window.wrappedJSObject.rcvd_enabled_event = false; window.wrappedJSObject.rcvd_disabled_event = false; window.wrappedJSObject.rcvd_error = false; var mozWifi = window.navigator.mozWifiManager; mozWifi.onenabled = function() { console.log("Received mozWifiManager.onenabled event"); window.wrappedJSObject.rcvd_enabled_event = true; }; mozWifi.ondisabled = function() { console.log("Received mozWifiManager.ondisabled event"); window.wrappedJSObject.rcvd_disabled_event = true; }; if (enable) { console.log("Turning on Wifi via settings"); } else { console.log("Turning off Wifi via settings"); } var lock = window.navigator.mozSettings.createLock(); var result = lock.set({ 'wifi.enabled': enable }); result.onerror = function() { if (enable) { console.log("Failed to changed Wifi setting to ON"); } else { console.log("Failed to changed Wifi setting to OFF"); } window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[enable]) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: if enable: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.rcvd_enabled_event;")) else: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.rcvd_disabled_event;")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error;"): self.fail( "Error received while changing the wifi enabled setting") else: if enable: self.fail("Failed to enable wifi via mozSettings") else: self.fail("Failed to disable wifi via mozSettings")
def stop_bt_discovery(self): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; console.log("Stopping bluetooth discovery"); var request = mozBtAdapter.stopDiscovery(); request.onsuccess = function() { console.log("BluetoothAdapter.stopDiscovery request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.stopDiscovery returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.stopDiscovery returned error") else: self.fail("BluetoothAdapter.stopDiscovery failed") # verify no longer discovering self.assertFalse(self.get_bt_discovering(), "Failed to stop bluetooth discovery")
def set_geolocation_enabled(self, enable): # turn on geolocation via the device settings self.marionette.execute_async_script(""" var enable = arguments[0]; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; if (enable) { console.log("Enabling geolocation via settings"); } else { console.log("Disabling geolocation via settings"); } var lock = window.navigator.mozSettings.createLock(); var result = lock.set({ 'geolocation.enabled': enable }); result.onsuccess = function() { console.log("Success changing geolocation.enabled setting"); window.wrappedJSObject.rcvd_success = true; }; result.onerror = function(error) { console.log("Failed to change geolocation.enabled setting " + error); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[enable]) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error;"): self.fail("Error received while changing the geolocation enabled setting") else: self.fail("Failed to change the geolocation.enabled setting")
def test_active_state(self): self.instruct("About to test active state. Please click OK and then watch the screen") self.marionette.execute_script(""" window.wrappedJSObject.testActiveObserver = { time : 5, onidle : function() { window.navigator.mozPower.screenBrightness = 0.1; window.wrappedJSObject.rcvd_idle = true; }, onactive : function() { window.navigator.mozPower.screenBrightness = 0.5; window.wrappedJSObject.rcvd_active = true; } }; navigator.addIdleObserver(window.wrappedJSObject.testActiveObserver); """) wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_idle;")) except: self.fail("Failed to attain idle state") self.confirm("Did you notice decrease in brightness?") self.instruct("Touch on the screen to wake up the device") wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_active;")) except: self.fail("Failed to attain active state") self.confirm("Did you notice increase in brightness?")
def delete_message(self, msg_id): self.marionette.execute_async_script(""" var mm = window.navigator.mozMobileMessage; window.wrappedJSObject.msg_deleted = false; window.wrappedJSObject.rcvd_error = false; // Bug 952875 mm.getThreads(); let requestRet = mm.delete(arguments[0]); requestRet.onsuccess = function(event) { if (event.target.result) { window.wrappedJSObject.msg_deleted = true; } else { window.wrappedJSObject.msg_deleted = false; } }; requestRet.onerror = function() { window.wrappedJSObject.rcvd_error = true; log("Delete message returned error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id], special_powers=True) # wait for request.onsuccess wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.msg_deleted")) except errors.TimeoutException: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error;"): self.fail("Error received while deleting message") else: self.fail("Failed to delete message")
def is_geolocation_enabled(self): self.marionette.execute_async_script(""" window.wrappedJSObject.geo_enabled = null; window.wrappedJSObject.get_success = false; var lock = navigator.mozSettings.createLock(); var setting = lock.get('geolocation.enabled'); setting.onsuccess = function () { console.log('geolocation.enabled: ' + setting.result); window.wrappedJSObject.get_success = true; window.wrappedJSObject.geo_enabled = setting.result["geolocation.enabled"]; } setting.onerror = function () { console.log('An error occured: ' + setting.error); } marionetteScriptFinished(1); """) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.get_success")) except: self.fail("Failed to get the geolocation.enabled setting") return self.marionette.execute_script( "return window.wrappedJSObject.geo_enabled")
def get_message(self, msg_id): """ Get the sms or mms for the given id. Return the message, or none if it doesn't exist""" self.marionette.execute_async_script(""" var mm = window.navigator.mozMobileMessage; window.wrappedJSObject.event_sms = null; window.wrappedJSObject.rcvd_event = false; // Bug 952875 mm.getThreads(); let requestRet = mm.getMessage(arguments[0]); requestRet.onsuccess = function(event) { if(event.target.result){ window.wrappedJSObject.rcvd_event = true; window.wrappedJSObject.event_sms = event.target.result; } }; requestRet.onerror = function() { window.wrappedJSObject.rcvd_event = true; log("Get message returned error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id], special_powers=True) # wait for a result wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_event")) except errors.TimeoutException: self.fail("mozMobileMessage.getMessage() failed") # return the message if it was found, otherwise none return self.marionette.execute_script("return window.wrappedJSObject.event_sms")
def resume_held_call(self): self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; window.wrappedJSObject.received_statechange = false; active.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "resuming") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.onresuming_call_ok = false; active.onresuming = function onresuming(event) { log("Received 'onresuming' call event."); if (event.call.state == "resuming") { window.wrappedJSObject.onresuming_call_ok = true; }; }; active.resume(); marionetteScriptFinished(1); """, special_powers=True) # should have received event associated with a resumed call wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.onresuming_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_statechange")) except: # failed to resume self.fail("Failed to resume the held call")
def create_notification(self, text): self.marionette.execute_async_script( """ window.wrappedJSObject.rcvd_onshow = false; var text = arguments[0]; console.log("Creating new notification"); var notification = new Notification(text); // setup callback notification.onshow = function() { console.log("Received Notification.onshow event"); window.wrappedJSObject.rcvd_onshow = true; } marionetteScriptFinished(1); """, script_args=[text]) # wait for notification to be displayed wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until( lambda x: x.execute_script("return window.wrappedJSObject.rcvd_onshow") ) except: self.fail("Did not receive the Notification.onshow event")
def test_telephony_outgoing_busy(self): self.instruct("Make a call to second non firefox OS phone from third non firefox " "OS phone, answer the call on second phone and press OK") # keep a short delay before making an outgoing call to second phone time.sleep(2) # use the webapi to make an outgoing call to user-specified number self.user_guided_outgoing_call() # verify one outgoing call self.calls = self.marionette.execute_script("return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['length'], 1, "There should be 1 call") self.assertEqual(self.calls['0'], self.outgoing_call) # should have received busy event associated with an outgoing call wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_busy")) except: self.fail("Busy event is not found, but should have been, since the outgoing call " "is initiated to busy line") # keep call ringing for a while time.sleep(1) # disconnect the outgoing call self.hangup_call(call_type="Outgoing") self.calls = self.marionette.execute_script("return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['length'], 0, "There should be 0 calls")
def setup_incoming_call(self): self.marionette.execute_script(self.returnable_calls) # listen for and answer incoming call self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; window.wrappedJSObject.received_incoming = false; telephony.onincoming = function onincoming(event) { log("Received 'incoming' call event."); window.wrappedJSObject.received_incoming = true; window.wrappedJSObject.incoming_call = event.call; window.wrappedJSObject.returnable_incoming_call = { number: event.call.number, state: event.call.state }; window.wrappedJSObject.calls = telephony.calls; }; window.wrappedJSObject.received_callschanged = false; telephony.oncallschanged = function oncallschanged(event) { log("Received Telephony 'oncallschanged' event."); window.wrappedJSObject.received_callschanged = true; }; marionetteScriptFinished(1); """, special_powers=True) wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_callschanged")) except: self.fail("Telephony.oncallschanged event not found, but should have been " "since initiated incoming call to firefox OS device")
def resume_held_call(self): self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; window.wrappedJSObject.received_statechange = false; active.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "resuming") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.onresuming_call_ok = false; active.onresuming = function onresuming(event) { log("Received 'onresuming' call event."); if (event.call.state == "resuming") { window.wrappedJSObject.onresuming_call_ok = true; }; }; active.resume(); marionetteScriptFinished(1); """, special_powers=True) # should have received event associated with a resumed call wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.onresuming_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) except: # failed to resume self.fail("Failed to resume the held call")
def answer_call(self, incoming=True): # answer incoming call via the webapi; have user answer outgoing call on target self.marionette.execute_async_script(""" let incoming = arguments[0]; if (incoming) { var call_to_answer = window.wrappedJSObject.incoming_call; } else { var call_to_answer = window.wrappedJSObject.outgoing_call; }; window.wrappedJSObject.connecting_call_ok = false; call_to_answer.onconnecting = function onconnecting(event) { log("Received 'onconnecting' call event."); if (event.call.state == "connecting") { window.wrappedJSObject.connecting_call_ok = true; }; }; window.wrappedJSObject.connected_call_ok = false; call_to_answer.onconnected = function onconnected(event) { log("Received 'onconnected' call event."); if (event.call.state == "connected") { window.wrappedJSObject.active_call = window.navigator.mozTelephony.active; window.wrappedJSObject.connected_call_ok = true; }; }; // answer incoming call via webapi; outgoing will be by user interaction if (incoming) { call_to_answer.answer(); }; marionetteScriptFinished(1); """, script_args=[incoming], special_powers=True) # answer outgoing call via user answering on target if not incoming: self.instruct("Please answer the call on the target phone, then click 'OK'") # should have received both events associated with answering a call wait = Wait(self.marionette, timeout=90, interval=0.5) try: if incoming: # only receive 'onconnecting' for incoming call wait.until(lambda x: x.execute_script("return window.wrappedJSObject.connecting_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.connected_call_ok")) except: self.fail("Failed to answer call") # verify the active call self.active_call = self.marionette.execute_script("return window.wrappedJSObject.active_call") self.assertTrue(self.active_call['state'], "connected") if incoming: self.assertEqual(self.active_call['number'], self.incoming_call['number']) else: self.assertEqual(self.active_call['number'], self.outgoing_call['number']) self.calls = self.marionette.execute_script("return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 1, "There should be 1 active call" ) self.assertEqual(self.calls['0'], self.active_call)
def set_wifi_enabled(self, enable): self.marionette.execute_async_script( """ var enable = arguments[0]; window.wrappedJSObject.rcvd_enabled_event = false; window.wrappedJSObject.rcvd_disabled_event = false; window.wrappedJSObject.rcvd_error = false; var mozWifi = window.navigator.mozWifiManager; mozWifi.onenabled = function() { console.log("Received mozWifiManager.onenabled event"); window.wrappedJSObject.rcvd_enabled_event = true; }; mozWifi.ondisabled = function() { console.log("Received mozWifiManager.ondisabled event"); window.wrappedJSObject.rcvd_disabled_event = true; }; if (enable) { console.log("Turning on Wifi via settings"); } else { console.log("Turning off Wifi via settings"); } var lock = window.navigator.mozSettings.createLock(); var result = lock.set({ 'wifi.enabled': enable }); result.onerror = function() { if (enable) { console.log("Failed to changed Wifi setting to ON"); } else { console.log("Failed to changed Wifi setting to OFF"); } window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[enable], ) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: if enable: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_enabled_event;")) else: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.rcvd_disabled_event;")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error;"): self.fail("Error received while changing the wifi enabled setting") else: if enable: self.fail("Failed to enable wifi via mozSettings") else: self.fail("Failed to disable wifi via mozSettings")
def get_default_bt_adapter(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.bt_adapter = null; var mozBt = window.navigator.mozBluetooth; console.log("Getting default bluetooth adaptor"); var request = mozBt.getDefaultAdapter(); request.onsuccess = function() { console.log("mozBluetooth.getDefaultAdapter request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.bt_adapter = request.result; }; request.onerror = function() { console.log("mozBluetooth.getDefaultAdapter request returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for adapter to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("mozBluetooth.getDefaultAdapter returned error") else: self.fail("mozBluetooth.getDefaultAdapter failed") # https://developer.mozilla.org/en-US/docs/Web/API/BluetoothAdapter # TODO: work around until bug https://bugzilla.mozilla.org/show_bug.cgi?id=1138331 is fixed adapter = {} adapter['name'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.name") adapter['class'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.class") adapter['address'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.address") adapter['discoverable'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.discoverable") adapter['discoverableTimeout'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.discoverableTimeout") adapter['discovering'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.discovering") adapter['devices'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.devices") adapter['uuids'] = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.uuids") self.assertIsNotNone(adapter, "mozBluetooth.getDefaultAdapter returned none") self.have_adapter = True return adapter
def wait_for_antenna_change(self): # wait for radio to change state wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.antenna_change")) except: self.fail( "Failed to receive mozFMRadio.onantennaavailablechange event")
def set_bt_discoverable_mode(self, set_discoverable): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var set_discoverable = arguments[0]; if (set_discoverable == true){ console.log("Turning on bluetooth discoverable mode"); } else { console.log("Turning off bluetooth discoverable mode"); } var request = mozBtAdapter.setDiscoverable(set_discoverable); request.onsuccess = function() { console.log("BluetoothAdapter.setDiscoverable request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.setDiscoverable returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[set_discoverable]) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.setDiscoverable returned error") else: self.fail("BluetoothAdapter.setDiscoverable failed") discoverable_setting = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter.discoverable") if set_discoverable: self.assertTrue( discoverable_setting, "Firefox OS BluetoothAdapter.discoverable should be TRUE") else: self.assertFalse( discoverable_setting, "Firefox OS BluetoothAdapter.discoverable should be FALSE")
def set_bt_discoverable_timeout(self, timeout): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") # no point in setting if it is already set to the requested value if self.get_bt_discoverable_timeout() == timeout: return self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.discoverable_timeout = null; var mozBt = window.navigator.mozBluetooth; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var new_timeout = arguments[0]; console.log("Setting bluetooth discoverable timeout"); var request = mozBtAdapter.setDiscoverableTimeout(new_timeout); request.onsuccess = function() { console.log("BluetoothAdapter.setDiscoverableTimeout request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.discoverable_timeout = mozBtAdapter.discoverableTimeout; }; request.onerror = function() { console.log("BluetoothAdapter.setDiscoverableTimeout returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[timeout]) # wait for timeout to be set wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail( "BluetoothAdapter.setDiscoverableTimeout returned error") else: self.fail("BluetoothAdapter.setDiscoverableTimeout failed") set_timeout = self.get_bt_discoverable_timeout() self.assertEqual( set_timeout, timeout, "BluetoothAdapter.discoverableTimeout value was not set correctly")
def setup_incoming_call(self): self.marionette.execute_script(self.returnable_calls) # listen for and answer incoming call self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; window.wrappedJSObject.received_incoming = false; telephony.onincoming = function onincoming(event) { log("Received 'incoming' call event."); window.wrappedJSObject.received_incoming = true; window.wrappedJSObject.incoming_call = event.call; window.wrappedJSObject.returnable_incoming_call = { number: event.call.number, state: event.call.state }; window.wrappedJSObject.calls = telephony.calls; }; window.wrappedJSObject.received_callschanged = false; telephony.oncallschanged = function oncallschanged(event) { log("Received Telephony 'oncallschanged' event."); window.wrappedJSObject.received_callschanged = true; }; window.wrappedJSObject.received_ready = false; telephony.ready.then( function() { console.log("Telephony got ready"); window.wrappedJSObject.received_ready = true; }, function() { console.log("Telephony not ready"); window.wrappedJSObject.received_ready = false; } ); marionetteScriptFinished(1); """, special_powers=True) wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_ready")) except: self.fail( "Telephony.oncallschanged event not found, but should have been " "since initiated incoming call to firefox OS device")
def start_bt_discovery(self): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.found_device_count = 0; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; // Setup callback for when a bt device is found mozBtAdapter.ondevicefound = function () { console.log("Discovery found a bluetooth device nearby"); window.wrappedJSObject.found_device_count++; }; // Begin discovery and verify request success console.log("Starting bluetooth discovery"); var request = mozBtAdapter.startDiscovery(); request.onsuccess = function() { console.log("BluetoothAdapter.startDiscovery request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.startDiscovery returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.startDiscovery returned error") else: self.fail("BluetoothAdapter.startDiscovery failed") # verify in discovering mode self.assertTrue(self.get_bt_discovering(), "Failed to start bluetooth discovery")
def get_default_bt_adapter(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.bt_adapter = null; var mozBt = window.navigator.mozBluetooth; console.log("Getting default bluetooth adaptor"); var request = mozBt.getDefaultAdapter(); request.onsuccess = function() { console.log("mozBluetooth.getDefaultAdapter request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.bt_adapter = request.result; }; request.onerror = function() { console.log("mozBluetooth.getDefaultAdapter request returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for adapter to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("mozBluetooth.getDefaultAdapter returned error") else: self.fail("mozBluetooth.getDefaultAdapter failed") # https://developer.mozilla.org/en-US/docs/Web/API/BluetoothAdapter # TODO: work around until bug https://bugzilla.mozilla.org/show_bug.cgi?id=1138331 is fixed adapter = {} adapter['name'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.name") adapter['class'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.class") adapter['address'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.address") adapter['discoverable'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.discoverable") adapter['discoverableTimeout'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.discoverableTimeout") adapter['discovering'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.discovering") adapter['devices'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.devices") adapter['uuids'] = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.uuids") self.assertIsNotNone(adapter, "mozBluetooth.getDefaultAdapter returned none") self.have_adapter = True return adapter
def set_bt_adapter_name(self, new_name): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") # no point in changing name if it is already set the same if self.get_bt_adaptor_name() == new_name: return self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var new_name = arguments[0]; console.log("Changing bluetooth adaptor name to '%s'" %new_name); var request = mozBtAdapter.setName(new_name); request.onsuccess = function() { console.log("BluetoothAdapter.setName request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.setName returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[new_name]) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.setName returned error") else: self.fail("BluetoothAdapter.setName failed") self.assertEqual(new_name, self.get_bt_adaptor_name(), "The bluetooth adaptor name is incorrect")
def get_current_position(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.position = null; var mozGeo = window.navigator.geolocation; function success(position) { console.log("geolocation.getCurrentPosition success"); window.wrappedJSObject.position = position; window.wrappedJSObject.rcvd_success = true; } function error(error) { console.log("Error " + error.code + " when requesting location"); window.wrappedJSObject.rcvd_error = true; } console.log("Getting current position"); mozGeo.getCurrentPosition(success, error); marionetteScriptFinished(1); """) # ask user to accept and dismiss the default gaia app location share prompt self.instruct( "On the Firefox OS device, if a location request dialog is displayed, please " "click the 'Share' button. If there is no dialog on the device, just continue." ) # wait for the position request to finish wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("geolocation.getCurrentPosition returned error") else: self.fail( "Failed to get position; either geolocation is broken -or- WiFi is not connected" ) position = self.marionette.execute_script( "return window.wrappedJSObject.position") self.assertIsNotNone(position, "mozBluetooth.getCurrentPosition returned none") return position
def hangup_active_call(self): # hangup the active call, verify self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; window.wrappedJSObject.disconnecting_call_ok = false; active.ondisconnecting = function ondisconnecting(event) { log("Received 'ondisconnecting' call event."); if (event.call.state == "disconnecting") { window.wrappedJSObject.disconnecting_call_ok = true; }; }; window.wrappedJSObject.disconnected_call_ok = false; active.ondisconnected = function ondisconnected(event) { log("Received 'ondisconnected' call event."); if (event.call.state == "disconnected") { window.wrappedJSObject.disconnected_call_ok = true; }; }; active.hangUp(); marionetteScriptFinished(1); """, special_powers=True) # should have received both events associated with a call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.disconnecting_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") # verify no active call self.active_call = self.marionette.execute_script( "return window.wrappedJSObject.active_call") self.assertTrue(self.active_call, None) self.calls = self.marionette.execute_script( "return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 0, "There should be 0 calls")
def set_bt_discoverable_mode(self, set_discoverable): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var set_discoverable = arguments[0]; if (set_discoverable == true){ console.log("Turning on bluetooth discoverable mode"); } else { console.log("Turning off bluetooth discoverable mode"); } var request = mozBtAdapter.setDiscoverable(set_discoverable); request.onsuccess = function() { console.log("BluetoothAdapter.setDiscoverable request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.setDiscoverable returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[set_discoverable]) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.setDiscoverable returned error") else: self.fail("BluetoothAdapter.setDiscoverable failed") discoverable_setting = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter.discoverable") if set_discoverable: self.assertTrue(discoverable_setting, "Firefox OS BluetoothAdapter.discoverable should be TRUE") else: self.assertFalse(discoverable_setting, "Firefox OS BluetoothAdapter.discoverable should be FALSE")
def get_wifi_networks(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.wifi_networks = null; window.wrappedJSObject.error_msg = null; var mozWifi = window.navigator.mozWifiManager; console.log("Getting wifi networks"); var request = mozWifi.getNetworks(); request.onsuccess = function() { console.log("mozWifiManager.getNetworks request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.wifi_networks = this.result; }; request.onerror = function() { console.log("mozWifiManager.getNetworks request returned error: " + this.error.name); window.wrappedJSObject.rcvd_error = true; window.wrappedJSObject.error_msg = this.error.name; }; marionetteScriptFinished(1); """) # wait for wifi networks to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("mozWifiManager.getNetworks returned error: " + self.marionette.execute_script( "return window.wrappedJSObject.error_msg")) else: self.fail("mozWifiManager.getNetworks failed") wifi_networks = self.marionette.execute_script( "return window.wrappedJSObject.wifi_networks") self.assertIsNotNone(wifi_networks, "mozWifiManager.getNetowrk returned none") return wifi_networks
def get_wifi_networks(self): self.marionette.execute_async_script( """ window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.wifi_networks = null; window.wrappedJSObject.error_msg = null; var mozWifi = window.navigator.mozWifiManager; console.log("Getting wifi networks"); var request = mozWifi.getNetworks(); request.onsuccess = function() { console.log("mozWifiManager.getNetworks request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.wifi_networks = this.result; }; request.onerror = function() { console.log("mozWifiManager.getNetworks request returned error: " + this.error.name); window.wrappedJSObject.rcvd_error = true; window.wrappedJSObject.error_msg = this.error.name; }; marionetteScriptFinished(1); """ ) # wait for wifi networks to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail( "mozWifiManager.getNetworks returned error: " + self.marionette.execute_script("return window.wrappedJSObject.error_msg") ) else: self.fail("mozWifiManager.getNetworks failed") wifi_networks = self.marionette.execute_script("return window.wrappedJSObject.wifi_networks") self.assertIsNotNone(wifi_networks, "mozWifiManager.getNetowrk returned none") return wifi_networks
def start_bt_discovery(self): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.found_device_count = 0; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; // Setup callback for when a bt device is found mozBtAdapter.ondevicefound = function () { console.log("Discovery found a bluetooth device nearby"); window.wrappedJSObject.found_device_count++; }; // Begin discovery and verify request success console.log("Starting bluetooth discovery"); var request = mozBtAdapter.startDiscovery(); request.onsuccess = function() { console.log("BluetoothAdapter.startDiscovery request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.startDiscovery returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.startDiscovery returned error") else: self.fail("BluetoothAdapter.startDiscovery failed") # verify in discovering mode self.assertTrue(self.get_bt_discovering(), "Failed to start bluetooth discovery")
def mark_message_status(self, msg_id, is_read=False): self.marionette.execute_async_script(""" var msg_id = arguments[0]; var is_read = arguments[1]; var requestRet = null; var mm = window.navigator.mozMobileMessage; // Bug 952875 mm.getThreads(); requestRet = mm.markMessageRead(msg_id, is_read); window.wrappedJSObject.rcvd_req_success_read = false; window.wrappedJSObject.rcvd_req_success_unread = false; requestRet.onsuccess = function(event) { log("Received 'onsuccess' event."); if (event.target.result) { window.wrappedJSObject.rcvd_req_success_read = true; } else { window.wrappedJSObject.rcvd_req_success_unread = true; log("request returned false for manager.markMessageRead"); } } requestRet.onerror = function() { log("Failed to mark message read status, received error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id, is_read], special_powers=True) wait = Wait(self.marionette, timeout=15, interval=0.5) try: if is_read is True: wait.until(lambda m: self.marionette.execute_script( "return window.wrappedJSObject.rcvd_req_success_read")) else: wait.until(lambda m: self.marionette.execute_script( "return window.wrappedJSObject.rcvd_req_success_unread")) except errors.TimeoutException: # msg read status wasn't marked self.fail("Failed to update the read status of message.")
def get_default_bt_adapter(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.bt_adapter = null; var mozBt = window.navigator.mozBluetooth; console.log("Getting default bluetooth adaptor"); var request = mozBt.getDefaultAdapter(); request.onsuccess = function() { console.log("mozBluetooth.getDefaultAdapter request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.bt_adapter = request.result; }; request.onerror = function() { console.log("mozBluetooth.getDefaultAdapter request returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for adapter to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("mozBluetooth.getDefaultAdapter returned error") else: self.fail("mozBluetooth.getDefaultAdapter failed") adapter = self.marionette.execute_script( "return window.wrappedJSObject.bt_adapter") self.assertIsNotNone(adapter, "mozBluetooth.getDefaultAdapter returned none") self.have_adapter = True return adapter
def change_radio_state(self, turning_on): # turn on or off radio and verify request self.marionette.execute_async_script(""" var turning_on = arguments[0]; var fm = window.navigator.mozFMRadio; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; // turn on or off accordingly if (turning_on) { var request = fm.enable(99.9); } else { var request = fm.disable(); }; // verify request request.onsuccess = function() { window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[turning_on]) # wait for radio to change state wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): if turning_on: self.fail("MozFMRadio.enable returned error") else: self.fail("MozFMRadio.disable returned error") else: if turning_on: self.fail("Failed to turn on the fm radio") else: self.fail("Failed to turn off the fm radio")
def change_radio_state(self, turning_on): # turn on or off radio and verify request self.marionette.execute_async_script( """ var turning_on = arguments[0]; var fm = window.navigator.mozFMRadio; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; // turn on or off accordingly if (turning_on) { var request = fm.enable(99.9); } else { var request = fm.disable(); }; // verify request request.onsuccess = function() { window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[turning_on], ) # wait for radio to change state wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): if turning_on: self.fail("MozFMRadio.enable returned error") else: self.fail("MozFMRadio.disable returned error") else: if turning_on: self.fail("Failed to turn on the fm radio") else: self.fail("Failed to turn off the fm radio")
def set_bt_discoverable_timeout(self, timeout): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") # no point in setting if it is already set to the requested value if self.get_bt_discoverable_timeout() == timeout: return self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.discoverable_timeout = null; var mozBt = window.navigator.mozBluetooth; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var new_timeout = arguments[0]; console.log("Setting bluetooth discoverable timeout"); var request = mozBtAdapter.setDiscoverableTimeout(new_timeout); request.onsuccess = function() { console.log("BluetoothAdapter.setDiscoverableTimeout request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.discoverable_timeout = mozBtAdapter.discoverableTimeout; }; request.onerror = function() { console.log("BluetoothAdapter.setDiscoverableTimeout returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[timeout]) # wait for timeout to be set wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.setDiscoverableTimeout returned error") else: self.fail("BluetoothAdapter.setDiscoverableTimeout failed") set_timeout = self.get_bt_discoverable_timeout() self.assertEqual(set_timeout, timeout, "BluetoothAdapter.discoverableTimeout value was not set correctly")
def set_geolocation_enabled(self, enable): # turn on geolocation via the device settings self.marionette.execute_async_script(""" var enable = arguments[0]; window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; if (enable) { console.log("Enabling geolocation via settings"); } else { console.log("Disabling geolocation via settings"); } var lock = window.navigator.mozSettings.createLock(); var result = lock.set({ 'geolocation.enabled': enable }); result.onsuccess = function() { console.log("Success changing geolocation.enabled setting"); window.wrappedJSObject.rcvd_success = true; }; result.onerror = function(error) { console.log("Failed to change geolocation.enabled setting " + error); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[enable]) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error;"): self.fail( "Error received while changing the geolocation enabled setting" ) else: self.fail("Failed to change the geolocation.enabled setting")
def set_bt_adapter_name(self, new_name): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") # no point in changing name if it is already set the same if self.get_bt_adaptor_name() == new_name: return self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; var new_name = arguments[0]; console.log("Changing bluetooth adaptor name to '%s'" %new_name); var request = mozBtAdapter.setName(new_name); request.onsuccess = function() { console.log("BluetoothAdapter.setName request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.setName returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """, script_args=[new_name]) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.setName returned error") else: self.fail("BluetoothAdapter.setName failed") self.assertEqual(new_name, self.get_bt_adaptor_name(), "The bluetooth adaptor name is incorrect")
def initiate_outgoing_call(self, destination): # use the webapi to initiate a call to the specified number self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; var destination = arguments[0] var out_call = telephony.dial(destination); window.wrappedJSObject.received_dialing = false; if (out_call.state == "dialing") { window.wrappedJSObject.received_dialing = true; }; window.wrappedJSObject.received_statechange = false; out_call.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.received_alerting = false; out_call.onalerting = function onalerting(event) { log("Received TelephonyCall 'onalerting' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_alerting = true; window.wrappedJSObject.outgoing_call = out_call; window.wrappedJSObject.calls = telephony.calls; }; }; window.wrappedJSObject.received_busy = false; out_call.onbusy = function onbusy(event) { log("Received TelephonyCall 'onbusy' event."); if (event.call.state == "busy") { window.wrappedJSObject.received_busy = true; }; }; marionetteScriptFinished(1); """, script_args=[destination], special_powers=True) # should have received all events associated with an outgoing call wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_dialing")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_statechange")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_alerting")) except: # failed to initiate call; check if the destination phone's line was busy busy = self.marionette.execute_script("return window.wrappedJSObject.received_busy") self.assertFalse(busy, "Received busy signal; ensure target phone is available and try again") self.fail("Failed to initiate call; mozTelephony.dial is broken -or- \ perhaps there is no mobile network signal. Please try again") # verify one outgoing call self.calls = self.marionette.execute_script("return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 1, "There should be 1 call" ) self.outgoing_call = self.marionette.execute_script("return window.wrappedJSObject.outgoing_call") self.assertEqual(self.outgoing_call['state'], "alerting", "Call state should be 'alerting'") self.assertEqual(self.calls['0'], self.outgoing_call)
def hangup_active_call(self): # hangup the active call, verify self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; window.wrappedJSObject.disconnecting_call_ok = false; active.ondisconnecting = function ondisconnecting(event) { log("Received 'ondisconnecting' call event."); if (event.call.state == "disconnecting") { window.wrappedJSObject.disconnecting_call_ok = true; }; }; window.wrappedJSObject.disconnected_call_ok = false; active.ondisconnected = function ondisconnected(event) { log("Received 'ondisconnected' call event."); if (event.call.state == "disconnected") { window.wrappedJSObject.disconnected_call_ok = true; }; }; active.hangUp(); marionetteScriptFinished(1); """, special_powers=True) # should have received both events associated with a call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.disconnecting_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") # verify no active call self.active_call = self.marionette.execute_script("return window.wrappedJSObject.active_call") self.assertTrue(self.active_call, None) self.calls = self.marionette.execute_script("return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 0, "There should be 0 calls" )
def stop_bt_discovery(self): self.assertTrue(self.have_adapter, "Must get default bluetooth adapter first") self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; var mozBtAdapter = window.wrappedJSObject.bt_adapter; console.log("Stopping bluetooth discovery"); var request = mozBtAdapter.stopDiscovery(); request.onsuccess = function() { console.log("BluetoothAdapter.stopDiscovery request success"); window.wrappedJSObject.rcvd_success = true; }; request.onerror = function() { console.log("BluetoothAdapter.stopDiscovery returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for request success wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error"): self.fail("BluetoothAdapter.stopDiscovery returned error") else: self.fail("BluetoothAdapter.stopDiscovery failed") # verify no longer discovering self.assertFalse(self.get_bt_discovering(), "Failed to stop bluetooth discovery")
def hangup_call(self, call_type="Active", remote_hangup=False): # hangup the active/incoming call, verify self.marionette.execute_async_script(""" var call_type = arguments[0]; var remote_hangup = arguments[1]; if (call_type == "Incoming") { var call_to_hangup = window.wrappedJSObject.incoming_call; } else if (call_type == "Outgoing") { var call_to_hangup = window.wrappedJSObject.outgoing_call; } else { var call_to_hangup = window.wrappedJSObject.active_call; }; window.wrappedJSObject.disconnecting_call_ok = false; call_to_hangup.ondisconnecting = function ondisconnecting(event) { log("Received 'ondisconnecting' call event."); if (event.call.state == "disconnecting") { window.wrappedJSObject.disconnecting_call_ok = true; }; }; window.wrappedJSObject.disconnected_call_ok = false; call_to_hangup.ondisconnected = function ondisconnected(event) { log("Received 'ondisconnected' call event."); if (event.call.state == "disconnected") { window.wrappedJSObject.disconnected_call_ok = true; }; }; if (!remote_hangup) { call_to_hangup.hangUp(); } marionetteScriptFinished(1); """, script_args=[call_type, remote_hangup], special_powers=True) if remote_hangup == False: # should have received both events associated with a active call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.disconnecting_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") else: self.instruct("Hangup the call from secondary phone and press 'OK'") # should have received only disconnected event associated with a active call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") #verify that the call disconnected from phone which is not the device under test disconnecting = self.marionette.execute_script("return window.wrappedJSObject.disconnecting_call_ok") self.assertFalse(disconnecting, "Telephony.ondisconnecting event found, but should not have been " "since the call was terminated remotely")
def get_message(self, msg_id): """ Get the sms or mms for the given id. Return the message, or none if it doesn't exist""" self.marionette.execute_async_script(""" var mm = window.navigator.mozMobileMessage; window.wrappedJSObject.event_sms = null; window.wrappedJSObject.rcvd_event = false; // Bug 952875 mm.getThreads(); let requestRet = mm.getMessage(arguments[0]); requestRet.onsuccess = function(event) { if(event.target.result){ window.wrappedJSObject.rcvd_event = true; window.wrappedJSObject.event_sms = event.target.result; } }; requestRet.onerror = function() { window.wrappedJSObject.rcvd_event = true; log("Get message returned error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id], special_powers=True) # wait for a result wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.rcvd_event")) except errors.TimeoutException: self.fail("mozMobileMessage.getMessage() failed") # return the message if it was found, otherwise none return self.marionette.execute_script( "return window.wrappedJSObject.event_sms")
def mark_message_status(self, msg_id, is_read=False): self.marionette.execute_async_script(""" var msg_id = arguments[0]; var is_read = arguments[1]; var requestRet = null; var mm = window.navigator.mozMobileMessage; // Bug 952875 mm.getThreads(); requestRet = mm.markMessageRead(msg_id, is_read); window.wrappedJSObject.rcvd_req_success_read = false; window.wrappedJSObject.rcvd_req_success_unread = false; requestRet.onsuccess = function(event) { log("Received 'onsuccess' event."); if (event.target.result) { window.wrappedJSObject.rcvd_req_success_read = true; } else { window.wrappedJSObject.rcvd_req_success_unread = true; log("request returned false for manager.markMessageRead"); } } requestRet.onerror = function() { log("Failed to mark message read status, received error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id, is_read], special_powers=True) wait = Wait(self.marionette, timeout=15, interval=0.5) try: if is_read is True: wait.until(lambda m: self.marionette.execute_script("return window.wrappedJSObject.rcvd_req_success_read")) else: wait.until(lambda m: self.marionette.execute_script("return window.wrappedJSObject.rcvd_req_success_unread")) except errors.TimeoutException: # msg read status wasn't marked self.fail("Failed to update the read status of message.")
def assert_message_sent(self): """ After sending an SMS/MMS, call this method to wait for the message to be sent. Verify that a mobile message was sent by checking if the expected events were triggered. Once verified, set the out_msg attribute to point to the message that has been sent. """ wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda m: self.marionette.execute_script( "return window.wrappedJSObject.rcvd_req_success")) except errors.TimeoutException: # msg wasn't sent; either the api is broken or mobile network signal is insufficient self.fail( "Failed to send SMS or MMS; mozMobileMessage.send is broken -or- " "perhaps there is no mobile network signal. Please try again") # verify the remaining msg send events rcvd_failed = self.marionette.execute_script( "return window.wrappedJSObject.rcvd_on_failed") self.assertFalse( rcvd_failed, "Failed to send message; received mozMobileMessage.onfailed event") rcvd_sending = self.marionette.execute_script( "return window.wrappedJSObject.rcvd_on_sending") self.assertTrue( rcvd_sending, "Failed to send message; mozMobileMessage.onsending event not received" ) rcvd_sent = self.marionette.execute_script( "return window.wrappedJSObject.rcvd_on_sent") self.assertTrue( rcvd_sent, "Failed to send message; mozMobileMessage.onsent event not received" ) # get message event self.out_msg = self.marionette.execute_script( "return window.wrappedJSObject.out_msg")
def is_geolocation_enabled(self): self.marionette.execute_async_script(""" window.wrappedJSObject.geo_enabled = null; window.wrappedJSObject.get_success = false; var lock = navigator.mozSettings.createLock(); var setting = lock.get('geolocation.enabled'); setting.onsuccess = function () { console.log('geolocation.enabled: ' + setting.result); window.wrappedJSObject.get_success = true; window.wrappedJSObject.geo_enabled = setting.result["geolocation.enabled"]; } setting.onerror = function () { console.log('An error occured: ' + setting.error); } marionetteScriptFinished(1); """) # wait for enabled/disabled event wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script("return window.wrappedJSObject.get_success")) except: self.fail("Failed to get the geolocation.enabled setting") return self.marionette.execute_script("return window.wrappedJSObject.geo_enabled")
def delete_message(self, msg_id): self.marionette.execute_async_script(""" var mm = window.navigator.mozMobileMessage; window.wrappedJSObject.msg_deleted = false; window.wrappedJSObject.rcvd_error = false; // Bug 952875 mm.getThreads(); let requestRet = mm.delete(arguments[0]); requestRet.onsuccess = function(event) { if (event.target.result) { window.wrappedJSObject.msg_deleted = true; } else { window.wrappedJSObject.msg_deleted = false; } }; requestRet.onerror = function() { window.wrappedJSObject.rcvd_error = true; log("Delete message returned error: %s" % requestRet.error.name); }; marionetteScriptFinished(1); """, script_args=[msg_id], special_powers=True) # wait for request.onsuccess wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda m: m.execute_script( "return window.wrappedJSObject.msg_deleted")) except errors.TimeoutException: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error;"): self.fail("Error received while deleting message") else: self.fail("Failed to delete message")
def hold_active_call(self): self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; window.wrappedJSObject.onholding_call_ok = false; active.onholding = function ondisconnecting(event) { log("Received 'onholding' call event."); if (event.call.state == "holding") { window.wrappedJSObject.onholding_call_ok = true; }; }; window.wrappedJSObject.onheld_call_ok = false; active.onheld = function ondisconnected(event) { log("Received 'onheld' call event."); if (event.call.state == "held") { window.wrappedJSObject.onheld_call_ok = true; }; }; active.hold(); marionetteScriptFinished(1); """, special_powers=True) # should have received both events associated with a call on hold wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.onholding_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.onheld_call_ok")) except: # failed to hold self.fail("Failed to hold call") # verify the held call self.active_call = self.marionette.execute_script("return window.wrappedJSObject.active_call") self.assertEqual(self.active_call['state'], "held", "Call state should he 'held'") self.assertEqual(self.calls['length'], 1, "There should be 1 call")
def get_current_position(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.position = null; var mozGeo = window.navigator.geolocation; function success(position) { console.log("geolocation.getCurrentPosition success"); window.wrappedJSObject.position = position; window.wrappedJSObject.rcvd_success = true; } function error(error) { console.log("Error " + error.code + " when requesting location"); window.wrappedJSObject.rcvd_error = true; } console.log("Getting current position"); mozGeo.getCurrentPosition(success, error); marionetteScriptFinished(1); """) # ask user to accept and dismiss the default gaia app location share prompt self.instruct("On the Firefox OS device, if a location request dialog is displayed, please " "click the 'Share' button. If there is no dialog on the device, just continue.") # wait for the position request to finish wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("geolocation.getCurrentPosition returned error") else: self.fail("Failed to get position; either geolocation is broken -or- WiFi is not connected") position = self.marionette.execute_script("return window.wrappedJSObject.position") self.assertIsNotNone(position, "mozBluetooth.getCurrentPosition returned none") return position
def get_default_bt_adapter(self): self.marionette.execute_async_script(""" window.wrappedJSObject.rcvd_success = false; window.wrappedJSObject.rcvd_error = false; window.wrappedJSObject.bt_adapter = null; var mozBt = window.navigator.mozBluetooth; console.log("Getting default bluetooth adaptor"); var request = mozBt.getDefaultAdapter(); request.onsuccess = function() { console.log("mozBluetooth.getDefaultAdapter request success"); window.wrappedJSObject.rcvd_success = true; window.wrappedJSObject.bt_adapter = request.result; }; request.onerror = function() { console.log("mozBluetooth.getDefaultAdapter request returned error"); window.wrappedJSObject.rcvd_error = true; }; marionetteScriptFinished(1); """) # wait for adapter to be found wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.rcvd_success")) except: if self.marionette.execute_script("return window.wrappedJSObject.rcvd_error"): self.fail("mozBluetooth.getDefaultAdapter returned error") else: self.fail("mozBluetooth.getDefaultAdapter failed") adapter = self.marionette.execute_script("return window.wrappedJSObject.bt_adapter") self.assertIsNotNone(adapter, "mozBluetooth.getDefaultAdapter returned none") self.have_adapter = True return adapter
def assert_message_sent(self): """ After sending an SMS/MMS, call this method to wait for the message to be sent. Verify that a mobile message was sent by checking if the expected events were triggered. Once verified, set the out_msg attribute to point to the message that has been sent. """ wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda m: self.marionette.execute_script("return window.wrappedJSObject.rcvd_req_success")) except errors.TimeoutException: # msg wasn't sent; either the api is broken or mobile network signal is insufficient self.fail("Failed to send message. The API is broken -or- " "perhaps there is no mobile network signal. Please try again") # verify the remaining msg send events rcvd_failed = self.marionette.execute_script("return window.wrappedJSObject.rcvd_on_failed") self.assertFalse(rcvd_failed, "Failed to send message; received mozMobileMessage.onfailed event") rcvd_sending = self.marionette.execute_script("return window.wrappedJSObject.rcvd_on_sending") self.assertTrue(rcvd_sending, "Failed to send message; mozMobileMessage.onsending event not received") rcvd_sent = self.marionette.execute_script("return window.wrappedJSObject.rcvd_on_sent") self.assertTrue(rcvd_sent, "Failed to send message; mozMobileMessage.onsent event not received") # get message event self.out_msg = self.marionette.execute_script("return window.wrappedJSObject.out_msg")
def hold_active_call(self, user_initiate_hold=True): self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; var user_initiate_hold = arguments[0]; window.wrappedJSObject.onholding_call_ok = false; active.onholding = function ondisconnecting(event) { log("Received 'onholding' call event."); if (event.call.state == "holding") { window.wrappedJSObject.onholding_call_ok = true; }; }; window.wrappedJSObject.received_statechange = false; active.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "held") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.onheld_call_ok = false; active.onheld = function ondisconnected(event) { log("Received 'onheld' call event."); if (event.call.state == "held") { window.wrappedJSObject.onheld_call_ok = true; }; }; if (user_initiate_hold) { active.hold(); } marionetteScriptFinished(1); """, script_args=[user_initiate_hold], special_powers=True) if user_initiate_hold == True: # should have received both events associated with a call on hold wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.onholding_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.onheld_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) except: # failed to hold self.fail("Failed to put call on hold initiated by user")
def hold_active_call(self, user_initiate_hold=True): self.marionette.execute_async_script(""" let active = window.wrappedJSObject.active_call; var user_initiate_hold = arguments[0]; window.wrappedJSObject.onholding_call_ok = false; active.onholding = function ondisconnecting(event) { log("Received 'onholding' call event."); if (event.call.state == "holding") { window.wrappedJSObject.onholding_call_ok = true; }; }; window.wrappedJSObject.received_statechange = false; active.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "held") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.onheld_call_ok = false; active.onheld = function ondisconnected(event) { log("Received 'onheld' call event."); if (event.call.state == "held") { window.wrappedJSObject.onheld_call_ok = true; }; }; if (user_initiate_hold) { active.hold(); } marionetteScriptFinished(1); """, script_args=[user_initiate_hold], special_powers=True) if user_initiate_hold == True: # should have received both events associated with a call on hold wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.onholding_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.onheld_call_ok")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_statechange")) except: # failed to hold self.fail("Failed to put call on hold initiated by user")
def answer_call(self, incoming=True): # answer incoming call via the webapi; have user answer outgoing call on target self.marionette.execute_async_script(""" let incoming = arguments[0]; if (incoming) { var call_to_answer = window.wrappedJSObject.incoming_call; } else { var call_to_answer = window.wrappedJSObject.outgoing_call; }; window.wrappedJSObject.connecting_call_ok = false; call_to_answer.onconnecting = function onconnecting(event) { log("Received 'onconnecting' call event."); if (event.call.state == "connecting") { window.wrappedJSObject.connecting_call_ok = true; }; }; window.wrappedJSObject.connected_call_ok = false; call_to_answer.onconnected = function onconnected(event) { log("Received 'onconnected' call event."); if (event.call.state == "connected") { window.wrappedJSObject.active_call = window.navigator.mozTelephony.active; window.wrappedJSObject.connected_call_ok = true; }; }; // answer incoming call via webapi; outgoing will be by user interaction if (incoming) { call_to_answer.answer(); }; marionetteScriptFinished(1); """, script_args=[incoming], special_powers=True) # answer outgoing call via user answering on target if not incoming: self.instruct( "Please answer the call on the target phone, then click 'OK'") # should have received both events associated with answering a call wait = Wait(self.marionette, timeout=90, interval=0.5) try: if incoming: # only receive 'onconnecting' for incoming call wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.connecting_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.connected_call_ok")) except: self.fail("Failed to answer call") # verify the active call self.active_call = self.marionette.execute_script( "return window.wrappedJSObject.active_call") self.assertTrue(self.active_call['state'], "connected") if incoming: self.assertEqual(self.active_call['number'], self.incoming_call['number']) else: self.assertEqual(self.active_call['number'], self.outgoing_call['number']) self.calls = self.marionette.execute_script( "return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 1, "There should be 1 active call") self.assertEqual(self.calls['0'], self.active_call)
def initiate_outgoing_call(self, destination): # use the webapi to initiate a call to the specified number self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; var destination = arguments[0] var out_call = telephony.dial(destination); window.wrappedJSObject.received_dialing = false; if (out_call.state == "dialing") { window.wrappedJSObject.received_dialing = true; }; window.wrappedJSObject.received_statechange = false; out_call.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.received_alerting = false; out_call.onalerting = function onalerting(event) { log("Received TelephonyCall 'onalerting' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_alerting = true; window.wrappedJSObject.outgoing_call = out_call; window.wrappedJSObject.calls = telephony.calls; }; }; window.wrappedJSObject.received_busy = false; out_call.onbusy = function onbusy(event) { log("Received TelephonyCall 'onbusy' event."); if (event.call.state == "busy") { window.wrappedJSObject.received_busy = true; }; }; marionetteScriptFinished(1); """, script_args=[destination], special_powers=True) # should have received all events associated with an outgoing call wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_dialing")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_alerting")) except: # failed to initiate call; check if the destination phone's line was busy busy = self.marionette.execute_script( "return window.wrappedJSObject.received_busy") self.assertFalse( busy, "Received busy signal; ensure target phone is available and try again" ) self.fail( "Failed to initiate call; mozTelephony.dial is broken -or- there is no network signal. Try again" ) # verify one outgoing call self.calls = self.marionette.execute_script( "return window.wrappedJSObject.calls") self.assertEqual(self.calls['length'], 1, "There should be 1 call") self.outgoing_call = self.marionette.execute_script( "return window.wrappedJSObject.outgoing_call") self.assertEqual(self.outgoing_call['state'], "alerting", "Call state should be 'alerting'") self.assertEqual(self.calls['0'], self.outgoing_call)
def test_telephony_incoming_multiple(self): # ask user to make first call to the device; answer and verify via webapi self.user_guided_incoming_call() self.calls = self.marionette.execute_script( "return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['0'], self.incoming_call) self.answer_call() self.assertEqual(self.active_call_list[0]['state'], "connected", "Call state should be 'connected'") self.assertEqual(self.active_call_list[0]['number'], self.incoming_call['number']) self.calls = self.marionette.execute_script( "return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['length'], 1, "There should be 1 active call") # keep call active for a while time.sleep(5) # ask user to again call to the test device; answer and verify via webapi self.user_guided_incoming_call() self.calls = self.marionette.execute_script( "return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['1'], self.incoming_call) self.assertEqual(self.calls['0'], self.active_call_list[0]) # setup the 'onheld' event handler self.hold_active_call(user_initiate_hold=False) self.answer_call() self.assertEqual(self.active_call_list[1]['state'], "connected", "Call state should be 'connected'") self.assertEqual(self.active_call_list[1]['number'], self.incoming_call['number']) self.calls = self.marionette.execute_script( "return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['length'], 2, "There should be 2 active calls") wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.onheld_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) except: # failed to hold self.fail( "Failed to put first active call on hold while second call becomes active" ) onholding = self.marionette.execute_script( "return window.wrappedJSObject.onholding_call_ok") self.assertFalse( onholding, "Telephony.onholding event found, but should not have been " "since the phone user did not initiate holding the call") # keep call active for a while time.sleep(5) # verify call state change self.assertEqual(self.calls['0']['state'], "held", "Call state should be 'held'") self.assertEqual(self.calls['1']['state'], "connected", "Call state should be 'connected'") # disconnect the two active calls self.hangup_call(active_call_selected=1) # verify number of remaining calls and its state wait = Wait(self.marionette, timeout=10, interval=0.5) try: wait.until(lambda x: x.execute_script( "return (window.wrappedJSObject.calls.length == 1)")) wait.until(lambda x: x.execute_script( "return (window.wrappedJSObject.calls[0].state == \"connected\")" )) except: self.fail( "Failed to hangup the second call or change the state of first call" ) self.hangup_call(active_call_selected=0) self.calls = self.marionette.execute_script( "return window.wrappedJSObject.get_returnable_calls()") self.assertEqual(self.calls['length'], 0, "There should be 0 calls")
def initiate_outgoing_call(self, destination): self.marionette.execute_script(self.returnable_calls) # use the webapi to initiate a call to the specified number self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; var destination = arguments[0] telephony.dial(destination).then(out_call => { window.wrappedJSObject.received_dialing = false; if (out_call.state == "dialing") { window.wrappedJSObject.received_dialing = true; }; window.wrappedJSObject.received_statechange = false; out_call.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.received_alerting = false; out_call.onalerting = function onalerting(event) { log("Received TelephonyCall 'onalerting' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_alerting = true; window.wrappedJSObject.outgoing_call = out_call; window.wrappedJSObject.returnable_outgoing_call = { number: out_call.number, state: out_call.state }; window.wrappedJSObject.calls = telephony.calls; }; }; window.wrappedJSObject.received_callschanged = false; telephony.oncallschanged = function oncallschanged(event) { log("Received Telephony 'oncallschanged' event."); window.wrappedJSObject.received_callschanged = true; }; window.wrappedJSObject.received_busy = false; out_call.onerror = function onerror(event) { log("Received TelephonyCall 'onerror' event."); if (event.call.error.name == "BusyError") { window.wrappedJSObject.received_busy = true; }; }; }); window.wrappedJSObject.received_ready = false; telephony.ready.then( function() { console.log("Telephony got ready"); window.wrappedJSObject.received_ready = true; }, function() { console.log("Telephony not ready"); window.wrappedJSObject.received_ready = false; } ); marionetteScriptFinished(1); """, script_args=[destination], special_powers=True) # should have received all events associated with an outgoing call wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_dialing")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_alerting")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_ready")) except: # failed to initiate call; check if the destination phone's line was busy busy = self.marionette.execute_script( "return window.wrappedJSObject.received_busy") self.assertFalse( busy, "Received busy signal; ensure target phone is available and try again" ) self.fail( "Failed to initiate call; mozTelephony.dial is broken -or- there is no network signal. Try again" ) # verify outgoing call state to be 'alerting' self.outgoing_call = self.marionette.execute_script( "return window.wrappedJSObject.returnable_outgoing_call") self.assertEqual(self.outgoing_call['state'], "alerting", "Call state should be 'alerting'")
def hangup_call(self, call_type="Active", remote_hangup=False, active_call_selected=0): # hangup the active/incoming call, verify self.marionette.execute_async_script( """ var call_type = arguments[0]; var remote_hangup = arguments[1]; var active_call_selected = arguments[2]; window.wrappedJSObject.rcvd_error = false; if (call_type == "Incoming") { var call_to_hangup = window.wrappedJSObject.incoming_call; } else if (call_type == "Outgoing") { var call_to_hangup = window.wrappedJSObject.outgoing_call; } else { if (active_call_selected >=0 && active_call_selected < window.wrappedJSObject.calls.length) { var call_to_hangup = window.wrappedJSObject.calls[active_call_selected]; } else { window.wrappedJSObject.rcvd_error = true; marionetteScriptFinished(0); } }; window.wrappedJSObject.disconnecting_call_ok = false; call_to_hangup.ondisconnecting = function ondisconnecting(event) { log("Received 'ondisconnecting' call event."); if (event.call.state == "disconnecting") { window.wrappedJSObject.disconnecting_call_ok = true; }; }; window.wrappedJSObject.received_statechange = false; call_to_hangup.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "disconnected") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.disconnected_call_ok = false; call_to_hangup.ondisconnected = function ondisconnected(event) { log("Received 'ondisconnected' call event."); if (event.call.state == "disconnected") { window.wrappedJSObject.disconnected_call_ok = true; }; }; if (!remote_hangup) { call_to_hangup.hangUp(); } if (window.wrappedJSObject.calls.length > 0) { window.wrappedJSObject.calls[0].resume(); } marionetteScriptFinished(1); """, script_args=[call_type, remote_hangup, active_call_selected], special_powers=True) if remote_hangup == False: if self.marionette.execute_script( "return window.wrappedJSObject.rcvd_error;"): self.fail("Received invalid value for active_call_selected") # should have received both events associated with a active call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.disconnecting_call_ok")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") else: self.instruct( "Hangup the call from secondary phone and press 'OK'") # should have received only disconnected event associated with a active call hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.disconnected_call_ok")) except: # failed to hangup self.fail("Failed to hangup call") # verify that the call disconnected from phone which is not the device under test disconnecting = self.marionette.execute_script( "return window.wrappedJSObject.disconnecting_call_ok") self.assertFalse( disconnecting, "Telephony.ondisconnecting event found, but should not have been " "since the call was terminated remotely") # should have received events associated with a state and calls change for with or without remote hangup wait = Wait(self.marionette, timeout=90, interval=0.5) try: wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_statechange")) wait.until(lambda x: x.execute_script( "return window.wrappedJSObject.received_callschanged")) except: self.fail( "Failed to receive either statechange or callschanged events") # remove the call from list if call_type == "Active": self.active_call_list.pop(active_call_selected)
def initiate_outgoing_call(self, destination): self.marionette.execute_script(self.returnable_calls) # use the webapi to initiate a call to the specified number self.marionette.execute_async_script(""" var telephony = window.navigator.mozTelephony; var destination = arguments[0] telephony.dial(destination).then(out_call => { window.wrappedJSObject.received_dialing = false; if (out_call.state == "dialing") { window.wrappedJSObject.received_dialing = true; }; window.wrappedJSObject.received_statechange = false; out_call.onstatechange = function onstatechange(event) { log("Received TelephonyCall 'onstatechange' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_statechange = true; }; }; window.wrappedJSObject.received_alerting = false; out_call.onalerting = function onalerting(event) { log("Received TelephonyCall 'onalerting' event."); if (event.call.state == "alerting") { window.wrappedJSObject.received_alerting = true; window.wrappedJSObject.outgoing_call = out_call; window.wrappedJSObject.returnable_outgoing_call = { number: out_call.number, state: out_call.state }; window.wrappedJSObject.calls = telephony.calls; }; }; window.wrappedJSObject.received_callschanged = false; telephony.oncallschanged = function oncallschanged(event) { log("Received Telephony 'oncallschanged' event."); window.wrappedJSObject.received_callschanged = true; }; window.wrappedJSObject.received_busy = false; out_call.onerror = function onerror(event) { log("Received TelephonyCall 'onerror' event."); if (event.call.error.name == "BusyError") { window.wrappedJSObject.received_busy = true; }; }; }); window.wrappedJSObject.received_ready = false; telephony.ready.then( function() { console.log("Telephony got ready"); window.wrappedJSObject.received_ready = true; }, function() { console.log("Telephony not ready"); window.wrappedJSObject.received_ready = false; } ); marionetteScriptFinished(1); """, script_args=[destination], special_powers=True) # should have received all events associated with an outgoing call wait = Wait(self.marionette, timeout=30, interval=0.5) try: wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_dialing")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_statechange")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_alerting")) wait.until(lambda x: x.execute_script("return window.wrappedJSObject.received_ready")) except: # failed to initiate call; check if the destination phone's line was busy busy = self.marionette.execute_script("return window.wrappedJSObject.received_busy") self.assertFalse(busy, "Received busy signal; ensure target phone is available and try again") self.fail("Failed to initiate call; mozTelephony.dial is broken -or- there is no network signal. Try again") # verify outgoing call state to be 'alerting' self.outgoing_call = self.marionette.execute_script("return window.wrappedJSObject.returnable_outgoing_call") self.assertEqual(self.outgoing_call['state'], "alerting", "Call state should be 'alerting'")
def wait_for_obj(self, object): wait = Wait(self.marionette, timeout=5, interval=0.5) try: wait.until(lambda m: m.execute_script("return !!%s;" % object)) except errors.TimeoutException: self.fail("Object '%s' does not exist" % object)