audio_cstream.CompleteSendingStateChange( cs.CALL_STREAM_FLOW_STATE_STOPPED, dbus_interface = cs.CALL_STREAM_IFACE_MEDIA) video_cstream.CompleteSendingStateChange( cs.CALL_STREAM_FLOW_STATE_STOPPED, dbus_interface = cs.CALL_STREAM_IFACE_MEDIA) q.expect_many( EventPattern('dbus-signal', signal='HoldStateChanged', args=[cs.HS_HELD, cs.HSR_RESOURCE_NOT_AVAILABLE]), EventPattern('dbus-signal', signal='SendingStateChanged', args = [cs.CALL_STREAM_FLOW_STATE_STOPPED], interface = cs.CALL_STREAM_IFACE_MEDIA), EventPattern('dbus-signal', signal='SendingStateChanged', args = [cs.CALL_STREAM_FLOW_STATE_STOPPED], interface = cs.CALL_STREAM_IFACE_MEDIA), EventPattern('dbus-signal', signal='ReceivingStateChanged', args = [cs.CALL_STREAM_FLOW_STATE_STOPPED], interface = cs.CALL_STREAM_IFACE_MEDIA), ) sync_stream(q, stream) q.unforbid_events(self.unhold_event + self.hold_event) if self.jp.has_mutable_streams(): self.mutable_stream_tests() if __name__ == '__main__': test_all_dialects(partial(run_call_test, klass=CallHoldAVTest, incoming=False))
predicate=jp.action_predicate('session-accept')), EventPattern('dbus-signal', signal='SetStreamSending', args=[True]), EventPattern('dbus-signal', signal='SetStreamPlaying', args=[True]), EventPattern('dbus-signal', signal='StreamDirectionChanged', args=[stream_id, cs.MEDIA_STREAM_DIRECTION_BIDIRECTIONAL, 0]), ) stream.send(make_result_iq(stream, acc.stanza)) # Also, if this is a Jingle dialect that supports it, Gabble should send an # <active/> notification when the session-accept is acked (until the # Telepathy spec lets the UI say it's not ringing any more). active_event = jp.rtp_info_event("active") if active_event is not None: q.expect_many(active_event) # we are now both in members members = media_chan.GetMembers() assert set(members) == set([self_handle, remote_handle]), members # Connected! Blah, blah, ... # 'Nuff said jt.terminate() q.expect('dbus-signal', signal='Closed', path=path) if __name__ == '__main__': test_all_dialects(test) test_all_dialects(lambda jp, q, bus, conn, stream: test(jp, q, bus, conn, stream, '*****@*****.**'))
# Checked that DeferredTones is properly reset assertEquals( '', content.Get(cs.CALL_CONTENT_IFACE_DTMF, 'DeferredTones', dbus_interface=dbus.PROPERTIES_IFACE)) content.Media.AcknowledgeDTMFChange(7, cs.CALL_SENDING_STATE_SENDING) q.expect('dbus-signal', signal='SendingTones', args=['7']), call_async(q, content.DTMF, 'StopTone') q.expect_many( EventPattern('dbus-signal', signal='DTMFChangeRequested', args=[7, cs.CALL_SENDING_STATE_PENDING_STOP_SENDING]), EventPattern('dbus-return', method='StopTone'), ) content.Media.AcknowledgeDTMFChange(7, cs.CALL_SENDING_STATE_NONE) q.expect('dbus-signal', signal='StoppedTones', args=[False]) def pickup(self): CallTest.pickup(self) self.test_dtmf() if __name__ == '__main__': test_all_dialects( partial(run_call_test, klass=CallDtmfTest, incoming=False))
'1,1' * 100) q.expect('dbus-return', method='MultipleTones') call_async(q, chan.DTMF, 'MultipleTones', '9') q.expect('dbus-error', method='MultipleTones', name=cs.SERVICE_BUSY) call_async(q, chan.DTMF, 'StartTone', 666, 9) q.expect('dbus-error', method='StartTone', name=cs.SERVICE_BUSY) call_async(q, chan.DTMF, 'StopTone', 666) q.expect_many( EventPattern('dbus-signal', signal='StopTelephonyEvent', path=audio_path), EventPattern('dbus-signal', signal='StopTelephonyEvent', path=audio2_path), EventPattern('dbus-signal', signal='StoppedTones', args=[True], path=chan_path), EventPattern('dbus-return', method='StopTone'), ) # emitting any sound resets TonesDeferred assertEquals('', chan.Properties.Get(cs.CHANNEL_IFACE_DTMF, 'DeferredTones')) q.unforbid_events(forbidden) chan.Group.RemoveMembers([self_handle], 'closed') e = q.expect('dbus-signal', signal='Closed', path=chan_path) if __name__ == '__main__': test_all_dialects(test)
""" from functools import partial from servicetest import call_async from jingletest2 import test_all_dialects from call_helper import CallTest, run_call_test from config import VOIP_ENABLED if not VOIP_ENABLED: print "NOTE: built with --disable-voip" raise SystemExit(77) class CallDtmfNoAudioTest(CallTest): # We want vieo only channel initial_audio = False initial_video = True def pickup(self): CallTest.pickup(self) # Check the DTMF method does not exist call_async(self.q, self.video_content.DTMF, "StartTone", 3) self.q.expect("dbus-error", method="StartTone") if __name__ == "__main__": test_all_dialects(partial(run_call_test, klass=CallDtmfNoAudioTest, incoming=False))
self.chan.Hangup(0, "", "", dbus_interface=cs.CHANNEL_TYPE_CALL) self.check_channel_state(cs.CALL_STATE_ENDED, wait = True) def run(self): if self.initial_video: if not self.initial_audio and not self.jp.can_do_video_only(): return elif not self.jp.can_do_video(): return self.advertise() self.prepare() self.initiate() self.accept_outgoing() self.connect() self.pickup() self.hangup() def run_call_test(jp, q, bus, conn, stream, klass=CallTest, incoming=False, params={}): test = klass(jp, q, bus, conn, stream, incoming, params) test.run() if __name__ == '__main__': test_all_dialects(partial(run_call_test, incoming=False)) test_all_dialects(partial(run_call_test, incoming=True))
msg, jp)) # Bye bye members. mc = q.expect('dbus-signal', signal='MembersChanged', interface=cs.CHANNEL_IFACE_GROUP, path=channel_path, args=[msg, [], [self_handle, remote_handle], [], [], self_handle, group_change_reason]) q.expect('dbus-signal', signal='StreamError', interface=cs.CHANNEL_TYPE_STREAMED_MEDIA, args=[stream_id, stream_error, msg]) # Bye bye stream q.expect('dbus-signal', signal='Close') q.expect('dbus-signal', signal='StreamRemoved') # Bye bye channel. q.expect('dbus-signal', signal='Closed') q.expect('dbus-signal', signal='ChannelClosed') def test_connection_error(jp, q, bus, conn, stream): _test(jp, q, bus, conn, stream, "connectivity-error", cs.GC_REASON_ERROR, cs.MEDIA_STREAM_ERROR_NETWORK_ERROR) def test_codec_negotiation_fail(jp, q, bus, conn, stream): _test(jp, q, bus, conn, stream, "failed-application", cs.GC_REASON_ERROR, cs.MEDIA_STREAM_ERROR_CODEC_NEGOTIATION_FAILED) if __name__ == '__main__': test_all_dialects(test_connection_error) test_all_dialects(test_codec_negotiation_fail)
EventPattern('dbus-return', method='RequestHold', value=()), ) # Ensure that if Gabble sent the <unhold/> stanza too early it's already # arrived. sync_stream(q, stream) q.unforbid_events(self.unhold_event) cstream.CompleteReceivingStateChange( cs.CALL_STREAM_FLOW_STATE_STARTED, dbus_interface = cs.CALL_STREAM_IFACE_MEDIA) cstream.CompleteSendingStateChange( cs.CALL_STREAM_FLOW_STATE_STARTED, dbus_interface = cs.CALL_STREAM_IFACE_MEDIA) q.expect_many( EventPattern('dbus-signal', signal='HoldStateChanged', args=[cs.HS_UNHELD, cs.HSR_REQUESTED]), EventPattern('dbus-signal', signal='SendingStateChanged', args = [cs.CALL_STREAM_FLOW_STATE_STARTED], interface = cs.CALL_STREAM_IFACE_MEDIA), EventPattern('dbus-signal', signal='ReceivingStateChanged', args = [cs.CALL_STREAM_FLOW_STATE_STARTED], interface = cs.CALL_STREAM_IFACE_MEDIA), *self.unhold_event ) if __name__ == '__main__': test_all_dialects(partial(run_call_test, klass=CallHoldAudioTest, incoming=False))
if a == None and v != None and not jp.can_do_video_only(): continue jt.incoming_call(audio=a, video=v) e = q.expect('dbus-signal', signal='NewChannels', predicate=lambda e: cs.CHANNEL_TYPE_CONTACT_LIST not in e.args[0][0][1].values()) chans = e.args[0] assertLength(1, chans) path, props = chans[0] assertEquals(cs.CHANNEL_TYPE_STREAMED_MEDIA, props[cs.CHANNEL_TYPE]) assertEquals(a != None, props[cs.INITIAL_AUDIO]) assertEquals(v != None, props[cs.INITIAL_VIDEO]) # FIXME: This doesn't check non-Google contacts that can only do one # media type, as such contacts as simulated by JingleTest2 can always # do both. assertEquals(not jp.can_do_video() or not jp.can_do_video_only(), props[cs.IMMUTABLE_STREAMS]) chan = wrap_channel(bus.get_object(conn.bus_name, path), cs.CHANNEL_TYPE_STREAMED_MEDIA) chan.Close() if __name__ == '__main__': test_all_dialects(outgoing) test_all_dialects(incoming)
assertEquals(cs.CALL_STREAM_FLOW_STATE_STOPPED, o.args[0]) jt2.content_modify(content_name, "initiator", "both") ret = q.expect_many( EventPattern('dbus-signal', signal='ReceivingStateChanged'), EventPattern('dbus-signal', signal='RemoteMembersChanged')) assertEquals(cs.CALL_STREAM_FLOW_STATE_PENDING_START, ret[0].args[0]) assert ret[1].args[0].has_key(remote_handle) assertEquals(cs.CALL_SENDING_STATE_SENDING, ret[1].args[0][remote_handle]) cstream.CompleteReceivingStateChange( cs.CALL_STREAM_FLOW_STATE_STARTED, dbus_interface = cs.CALL_STREAM_IFACE_MEDIA) o = q.expect('dbus-signal', signal='ReceivingStateChanged') assertEquals(cs.CALL_STREAM_FLOW_STATE_STARTED, o.args[0]) try: self.test_content_addition() except DBusException, e: assertEquals(cs.NOT_AVAILABLE, e.get_dbus_name()) assert not jp.can_do_video() if __name__ == '__main__': test_all_dialects( partial(run_call_test, klass=CallBasicsTest, incoming=True)) test_all_dialects( partial(run_call_test, klass=CallBasicsTest, incoming=False))
) q.expect_many( EventPattern('dbus-signal', signal='StoppedTones', args=[False], path=chan_path), ) # This is technically a race condition, but this dialstring is almost # certainly long enough that the Python script will win the race, i.e. # cancel before Gabble processes the whole dialstring. call_async(q, chan.DTMF, 'MultipleTones', '1,1' * 100) q.expect('dbus-return', method='MultipleTones') call_async(q, chan.DTMF, 'MultipleTones', '9') q.expect('dbus-error', method='MultipleTones', name=cs.SERVICE_BUSY) call_async(q, chan.DTMF, 'StartTone', 666, 9) q.expect('dbus-error', method='StartTone', name=cs.SERVICE_BUSY) call_async(q, chan.DTMF, 'StopTone', 666) q.expect_many( EventPattern('dbus-signal', signal='StoppedTones', args=[True], path=chan_path), EventPattern('dbus-return', method='StopTone'), ) chan.Hangup (0, "", "", dbus_interface=cs.CHANNEL_TYPE_CALL) if __name__ == '__main__': test_all_dialects(lambda jp, q, bus, conn, stream: run_test(jp, q, bus, conn, stream))
assertEquals({remote_handle: cs.CALL_SENDING_STATE_SENDING}, stream_props["RemoteMembers"]) assertEquals(cs.CALL_SENDING_STATE_NONE, stream_props["LocalSendingState"]) cstream.SetSending(True, dbus_interface=cs.CALL_STREAM) q.expect( "dbus-signal", signal="LocalSendingStateChanged", interface=cs.CALL_STREAM, args=[cs.CALL_SENDING_STATE_SENDING] ) stream_props = cstream.GetAll(cs.CALL_STREAM, dbus_interface=dbus.PROPERTIES_IFACE) assertEquals({remote_handle: cs.CALL_SENDING_STATE_SENDING}, stream_props["RemoteMembers"]) assertEquals(cs.CALL_SENDING_STATE_SENDING, stream_props["LocalSendingState"]) try: test_content_addition(jt2, jp, q, bus, conn, chan, self_handle) except DBusException, e: assertEquals(cs.NOT_AVAILABLE, e.get_dbus_name()) assert not jp.can_do_video() if incoming: jt2.terminate() else: chan.Hangup(0, "", "", dbus_interface=cs.CHANNEL_TYPE_CALL) check_state(q, chan, cs.CALL_STATE_ENDED, wait=True) if __name__ == "__main__": test_all_dialects(lambda jp, q, bus, conn, stream: run_test(jp, q, bus, conn, stream, False)) test_all_dialects(lambda jp, q, bus, conn, stream: run_test(jp, q, bus, conn, stream, True))
jt.terminate(reason=jingle_reason, text=text) mc = q.expect('dbus-signal', signal='MembersChanged') message, added, removed, lp, rp, actor, reason = mc.args assert added == [], added assert set(removed) == set([self_handle, remote_handle]), \ (removed, self_handle, remote_handle) assert lp == [], lp assert rp == [], rp assert actor == remote_handle, (actor, remote_handle) if jp.is_modern_jingle(): assertEquals(text, message) assertEquals(group_change_reason, reason) if jp.is_modern_jingle() and stream_error: se = q.expect('dbus-signal', signal='StreamError') assertEquals(stream_error, se.args[1]) q.expect('dbus-signal', signal='Close') #XXX - match against the path def test_busy(jp, q, bus, conn, stream): _test(jp, q, bus, conn, stream, "busy", cs.GC_REASON_BUSY, None) def test_codec_fail(jp, q, bus, conn, stream): _test(jp, q, bus, conn, stream, "failed-application", cs.GC_REASON_ERROR, cs.MEDIA_STREAM_ERROR_CODEC_NEGOTIATION_FAILED) if __name__ == '__main__': test_all_dialects(test_busy) test_all_dialects(test_codec_fail)
# Test the call's Stream's properties call_stream = make_channel_proxy(conn, content_props[0], 'Call.Stream.Interface.Media.Draft') stream_props = call_stream.GetAll(cs.CALL_STREAM_IFACE_MEDIA, dbus_interface=dbus.PROPERTIES_IFACE) assertEquals(cs.CALL_STREAM_TRANSPORT_GTALK_P2P, stream_props['Transport']) test_stun_server(stream_props['STUNServers'], expected_stun_servers) assertEquals(expected_relays, stream_props['RelayInfo']) assertEquals(True, stream_props['HasServerInfo']) if __name__ == '__main__': # Call tests test_all_dialects(partial(test_call, google=False)) test_all_dialects(partial(test_call, google=False, expected_stun_servers=[('5.4.3.2', 54321)]), params={ 'fallback-stun-server': 'resolves-to-5.4.3.2', 'fallback-stun-port': dbus.UInt16(54321) }) test_all_dialects(partial(test_call, google=False, expected_stun_servers=[('5.4.3.2', 1)]), params={'account': '*****@*****.**'}) if GOOGLE_RELAY_ENABLED: test_all_dialects(partial(test_call, google=True,
hts = [] for mc in media_classes: fixed, allowed = mc hts.append (fixed[cs.TARGET_HANDLE_TYPE]) expected_allowed = [ cs.TARGET_ID, cs.TARGET_HANDLE, cs.CALL_INITIAL_VIDEO, cs.CALL_INITIAL_AUDIO, cs.CALL_INITIAL_VIDEO_NAME, cs.CALL_INITIAL_AUDIO_NAME, cs.CALL_MUTABLE_CONTENTS ] allowed.sort() expected_allowed.sort() assertEquals(expected_allowed, allowed) assertEquals(sorted([cs.HT_CONTACT, cs.HT_ROOM]), sorted(hts)) if __name__ == '__main__': exec_test(rccs) test_all_dialects(create) test_all_dialects(request_anonymous) test_all_dialects(request_anonymous_and_add) test_all_dialects(request_nonymous) test_all_dialects(partial(create, peer='*****@*****.**')) test_all_dialects(partial(request_anonymous, peer='*****@*****.**')) test_all_dialects(partial(request_anonymous_and_add, peer='*****@*****.**')) test_all_dialects(partial(request_nonymous, peer='*****@*****.**'))
jt2.send_presence_and_caps() # Two peers happen to pick the same Jingle session ID jt1.sid = '1' jt2.sid = '1' jt1.incoming_call() q.expect('dbus-signal', signal='NewChannels', predicate=lambda e: cs.CHANNEL_TYPE_CALL in e.args[0][0][1][ cs.CHANNEL_TYPE]) # If Gabble confuses the two sessions, it'll NAK the IQ rather than # realising this is a new call. jt2.incoming_call() q.expect('dbus-signal', signal='NewChannels', predicate=lambda e: cs.CHANNEL_TYPE_CALL in e.args[0][0][1][ cs.CHANNEL_TYPE]) # On the other hand, if the same person calls twice with the same sid, # Gabble _should_ NAK the second s-i. jt2.incoming_call() q.expect('stream-iq', iq_type='error', predicate=jp.action_predicate('session-initiate')) if __name__ == '__main__': test_all_dialects(test)
# Test the call's Stream's properties call_stream = make_channel_proxy(conn, content_props[0], 'Call.Stream.Interface.Media.Draft') stream_props = call_stream.GetAll(cs.CALL_STREAM_IFACE_MEDIA, dbus_interface=dbus.PROPERTIES_IFACE) assertEquals(cs.CALL_STREAM_TRANSPORT_GTALK_P2P, stream_props['Transport']) test_stun_server(stream_props['STUNServers'], expected_stun_servers) assertEquals(expected_relays, stream_props['RelayInfo']) assertEquals(True, stream_props['HasServerInfo']) if __name__ == '__main__': # Call tests test_all_dialects(partial(test_call, google=False)) test_all_dialects(partial(test_call, google=False, expected_stun_servers=[('5.4.3.2', 54321)]), params={'fallback-stun-server': 'resolves-to-5.4.3.2', 'fallback-stun-port': dbus.UInt16(54321)}) test_all_dialects(partial(test_call, google=False, expected_stun_servers=[('5.4.3.2', 1)]), params={'account': '*****@*****.**'}) if GOOGLE_RELAY_ENABLED: test_all_dialects(partial(test_call, google=True, expected_stun_servers=[('1.2.3.4', 12345)]), protocol=GoogleXmlStream) test_all_dialects(partial(test_call, google=True, expected_stun_servers=[('5.4.3.2', 54321)]), protocol=GoogleXmlStream,
EventPattern('stream-iq', predicate=jp.action_predicate('session-terminate')), EventPattern('dbus-signal', signal='MembersChanged'), EventPattern('dbus-signal', signal='Closed'), ) _, added, removed, lp, rp, actor, reason = mc.args assert added == [], added assert set(removed) == set([self_handle, remote_handle]), \ (removed, self_handle, remote_handle) assert lp == [], lp assert rp == [], rp assert actor == self_handle, (actor, self_handle) if busy: assert reason == cs.GC_REASON_BUSY, reason else: assert reason == cs.GC_REASON_NONE, reason if jp.is_modern_jingle(): jingle = iq.query if busy: r = "/jingle/reason/busy" else: r = "/jingle/reason/cancel" assert xpath.queryForNodes(r, jingle) is not None, (jingle.toXml(), r) if __name__ == '__main__': test_all_dialects(test_busy) test_all_dialects(test_no_reason)
def rccs(q, bus, conn, stream): """ Tests that the connection's RequestableChannelClasses for StreamedMedia are sane. """ conn.Connect() q.expect('dbus-signal', signal='StatusChanged', args=[cs.CONN_STATUS_CONNECTED, cs.CSR_REQUESTED]) rccs = conn.Properties.Get(cs.CONN_IFACE_REQUESTS, 'RequestableChannelClasses') media_classes = [ rcc for rcc in rccs if rcc[0][cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAMED_MEDIA ] assertLength(1, media_classes) fixed, allowed = media_classes[0] assertEquals(cs.HT_CONTACT, fixed[cs.TARGET_HANDLE_TYPE]) assertContains(cs.TARGET_HANDLE, allowed) assertContains(cs.TARGET_ID, allowed) if __name__ == '__main__': exec_test(rccs) test_all_dialects(request_anonymous) test_all_dialects(request_anonymous_and_add) test_all_dialects(request_nonymous)