def test_connect_invalid_password(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite run(conn_a.gather_candidates()) for candidate in conn_a.local_candidates: conn_b.add_remote_candidate(candidate) conn_b.add_remote_candidate(None) conn_b.remote_username = conn_a.local_username conn_b.remote_password = conn_a.local_password # accept run(conn_b.gather_candidates()) for candidate in conn_b.local_candidates: conn_a.add_remote_candidate(candidate) conn_a.add_remote_candidate(None) conn_a.remote_username = conn_b.local_username conn_a.remote_password = "******" # connect done, pending = run( asyncio.wait( [conn_a.connect(), conn_b.connect()], return_when=asyncio.FIRST_EXCEPTION, )) for task in pending: task.cancel() self.assertEqual(len(done), 1) self.assertTrue(isinstance(done.pop().exception(), ConnectionError)) # close run(conn_a.close()) run(conn_b.close())
def test_connect_with_stun_server_ipv6(self): stun_server = ('stun.l.google.com', 19302) conn_a = ice.Connection(ice_controlling=True, stun_server=stun_server, use_ipv4=False, use_ipv6=True) conn_b = ice.Connection(ice_controlling=False, use_ipv4=False, use_ipv6=True) # invite / accept run(invite_accept(conn_a, conn_b)) # we only want host candidates : no STUN for IPv6 self.assertTrue(len(conn_a.local_candidates) > 0) for candidate in conn_a.local_candidates: self.assertEqual(candidate.type, 'host') # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close())
def test_connect_invalid_username(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite run(conn_a.gather_candidates()) conn_b.remote_candidates = conn_a.local_candidates conn_b.remote_username = conn_a.local_username conn_b.remote_password = conn_a.local_password # accept run(conn_b.gather_candidates()) conn_a.remote_candidates = conn_b.local_candidates conn_a.remote_username = '******' conn_a.remote_password = conn_b.local_password # connect done, pending = run(asyncio.wait([conn_a.connect(), conn_b.connect()])) for task in pending: task.cancel() self.assertEqual(len(done), 2) self.assertTrue(isinstance(done.pop().exception(), ConnectionError)) self.assertTrue(isinstance(done.pop().exception(), ConnectionError)) # close run(conn_a.close()) run(conn_b.close())
def test_connect_with_stun_server_timeout(self): # start and immediately stop turn server stun_server = TurnServer() run(stun_server.listen()) run(stun_server.close()) conn_a = ice.Connection( ice_controlling=True, stun_server=stun_server.udp_address ) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we whould have only host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b"howdee")) data = run(conn_b.recv()) self.assertEqual(data, b"howdee") # send data b -> a run(conn_b.send(b"gotcha")) data = run(conn_a.recv()) self.assertEqual(data, b"gotcha") # close run(conn_a.close()) run(conn_b.close())
def test_set_selected_pair(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we should only have host candidates self.assertCandidateTypes(conn_a, set(['host'])) self.assertCandidateTypes(conn_b, set(['host'])) # force selected pair default_a = conn_a.get_default_candidate(1) default_b = conn_a.get_default_candidate(1) conn_a.set_selected_pair(1, default_a.foundation, default_b.foundation) conn_b.set_selected_pair(1, default_b.foundation, default_a.foundation) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close())
async def test_connect_early_checks(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite / accept await invite_accept(conn_a, conn_b) # connect await conn_a.connect() await asyncio.sleep(1) await conn_b.connect() # send data a -> b await conn_a.send(b"howdee") data = await conn_b.recv() self.assertEqual(data, b"howdee") # send data b -> a await conn_b.send(b"gotcha") data = await conn_a.recv() self.assertEqual(data, b"gotcha") # close await conn_a.close() await conn_b.close()
def test_connect_early_checks(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # connect run(conn_a.connect()) run(asyncio.sleep(1)) run(conn_b.connect()) # send data a -> b run(conn_a.send(b"howdee")) data = run(conn_b.recv()) self.assertEqual(data, b"howdee") # send data b -> a run(conn_b.send(b"gotcha")) data = run(conn_a.recv()) self.assertEqual(data, b"gotcha") # close run(conn_a.close()) run(conn_b.close())
def test_connect_to_ice_lite_nomination_fails(self): def mock_request_received(self, message, addr, protocol, raw_data): if "USE-CANDIDATE" in message.attributes: self.respond_error(message, addr, protocol, (500, "Internal Error")) else: self.real_request_received(message, addr, protocol, raw_data) conn_a = ice.Connection(ice_controlling=True) conn_a.remote_is_lite = True conn_b = ice.Connection(ice_controlling=False) conn_b.real_request_received = conn_b.request_received conn_b.request_received = functools.partial(mock_request_received, conn_b) # invite / accept run(invite_accept(conn_a, conn_b)) # connect with self.assertRaises(ConnectionError) as cm: run(asyncio.gather(conn_a.connect(), conn_b.connect())) self.assertEqual(str(cm.exception), "ICE negotiation failed") # close run(conn_a.close()) run(conn_b.close())
async def test_connect_with_stun_server_timeout(self): async with run_turn_server() as stun_server: # immediately stop turn server await stun_server.close() conn_a = ice.Connection(ice_controlling=True, stun_server=stun_server.udp_address) conn_b = ice.Connection(ice_controlling=False) # invite / accept await invite_accept(conn_a, conn_b) # we whould have only host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # connect await asyncio.gather(conn_a.connect(), conn_b.connect()) # send data a -> b await conn_a.send(b"howdee") data = await conn_b.recv() self.assertEqual(data, b"howdee") # send data b -> a await conn_b.send(b"gotcha") data = await conn_a.recv() self.assertEqual(data, b"gotcha") # close await conn_a.close() await conn_b.close()
def test_connect_with_stun_server(self): stun_server = ('stun.l.google.com', 19302) conn_a = ice.Connection(ice_controlling=True, stun_server=stun_server) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we whould have both host and server-reflexive candidates self.assertCandidateTypes(conn_a, set(['host', 'srflx'])) self.assertCandidateTypes(conn_b, set(['host'])) # the default candidate should be server-reflexive candidate = conn_a.get_default_candidate(1) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, 'srflx') # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close())
async def test_set_selected_pair(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite / accept await invite_accept(conn_a, conn_b) # we should only have host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # force selected pair default_a = conn_a.get_default_candidate(1) default_b = conn_a.get_default_candidate(1) conn_a.set_selected_pair(1, default_a.foundation, default_b.foundation) conn_b.set_selected_pair(1, default_b.foundation, default_a.foundation) # send data a -> b await conn_a.send(b"howdee") data = await conn_b.recv() self.assertEqual(data, b"howdee") # send data b -> a await conn_b.send(b"gotcha") data = await conn_a.recv() self.assertEqual(data, b"gotcha") # close await conn_a.close() await conn_b.close()
async def test_connect_invalid_username(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite await conn_a.gather_candidates() for candidate in conn_a.local_candidates: await conn_b.add_remote_candidate(candidate) await conn_b.add_remote_candidate(None) conn_b.remote_username = conn_a.local_username conn_b.remote_password = conn_a.local_password # accept await conn_b.gather_candidates() for candidate in conn_b.local_candidates: await conn_a.add_remote_candidate(candidate) await conn_a.add_remote_candidate(None) conn_a.remote_username = "******" conn_a.remote_password = conn_b.local_password # connect done, pending = await asyncio.wait([ asyncio.ensure_future(conn_a.connect()), asyncio.ensure_future(conn_b.connect()), ]) for task in pending: task.cancel() self.assertEqual(len(done), 2) self.assertTrue(isinstance(done.pop().exception(), ConnectionError)) self.assertTrue(isinstance(done.pop().exception(), ConnectionError)) # close await conn_a.close() await conn_b.close()
async def test_connect_ipv6(self): conn_a = ice.Connection(ice_controlling=True, use_ipv4=False, use_ipv6=True) conn_b = ice.Connection(ice_controlling=False, use_ipv4=False, use_ipv6=True) # invite / accept await invite_accept(conn_a, conn_b) self.assertTrue(len(conn_a.local_candidates) > 0) for candidate in conn_a.local_candidates: self.assertEqual(candidate.type, "host") # connect await asyncio.gather(conn_a.connect(), conn_b.connect()) # send data a -> b await conn_a.send(b"howdee") data = await conn_b.recv() self.assertEqual(data, b"howdee") # send data b -> a await conn_b.send(b"gotcha") data = await conn_a.recv() self.assertEqual(data, b"gotcha") # close await conn_a.close() await conn_b.close()
def test_connect_with_stun_server_timeout(self): stun_server = ('1.2.3.4', 19302) conn_a = ice.Connection(ice_controlling=True, stun_server=stun_server) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we whould have only host candidates self.assertCandidateTypes(conn_a, set(['host'])) self.assertCandidateTypes(conn_b, set(['host'])) # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close())
def test_connect_ipv6(self): conn_a = ice.Connection(ice_controlling=True, use_ipv4=False, use_ipv6=True) conn_b = ice.Connection(ice_controlling=False, use_ipv4=False, use_ipv6=True) # invite / accept run(invite_accept(conn_a, conn_b)) self.assertTrue(len(conn_a.local_candidates) > 0) for candidate in conn_a.local_candidates: self.assertEqual(candidate.type, 'host') # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close())
def test_connect_with_stun_server_dns_lookup_error(self): conn_a = ice.Connection(ice_controlling=True, stun_server=("invalid.", 1234)) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we whould have only host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b"howdee")) data = run(conn_b.recv()) self.assertEqual(data, b"howdee") # send data b -> a run(conn_b.send(b"gotcha")) data = run(conn_a.recv()) self.assertEqual(data, b"gotcha") # close run(conn_a.close()) run(conn_b.close())
def test_connect(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite run(conn_a.gather_candidates()) conn_b.remote_username = conn_a.local_username conn_b.remote_password = conn_a.local_password # accept run(conn_b.gather_candidates()) conn_a.remote_username = conn_b.local_username conn_a.remote_password = conn_b.local_password # we should only have host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # there should be a default candidate for component 1 candidate = conn_a.get_default_candidate(1) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, "host") # there should not be a default candidate for component 2 candidate = conn_a.get_default_candidate(2) self.assertIsNone(candidate) async def add_candidates_later(a, b): await asyncio.sleep(0.1) for candidate in b.local_candidates: a.add_remote_candidate(candidate) await asyncio.sleep(0.1) a.add_remote_candidate(None) # connect run( asyncio.gather( conn_a.connect(), conn_b.connect(), add_candidates_later(conn_a, conn_b), add_candidates_later(conn_b, conn_a), ) ) # send data a -> b run(conn_a.send(b"howdee")) data = run(conn_b.recv()) self.assertEqual(data, b"howdee") # send data b -> a run(conn_b.send(b"gotcha")) data = run(conn_a.recv()) self.assertEqual(data, b"gotcha") # close run(conn_a.close()) run(conn_b.close())
def test_connect_close(self): conn_a = ice.Connection(ice_controlling=True) conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # close run(conn_b.close()) with self.assertRaises(ConnectionError): run(asyncio.gather(conn_a.connect(), delay(conn_a.close)))
def test_connect_two_components(self): conn_a = ice.Connection(ice_controlling=True, components=2) conn_b = ice.Connection(ice_controlling=False, components=2) # invite / accept run(invite_accept(conn_a, conn_b)) # we should only have host candidates self.assertCandidateTypes(conn_a, set(['host'])) self.assertCandidateTypes(conn_b, set(['host'])) # there should be a default candidate for component 1 candidate = conn_a.get_default_candidate(1) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, 'host') # there should be a default candidate for component 2 candidate = conn_a.get_default_candidate(2) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, 'host') # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) self.assertEqual(conn_a._components, set([1, 2])) self.assertEqual(conn_b._components, set([1, 2])) # send data a -> b (component 1) run(conn_a.sendto(b'howdee', 1)) data, component = run(conn_b.recvfrom()) self.assertEqual(data, b'howdee') self.assertEqual(component, 1) # send data b -> a (component 1) run(conn_b.sendto(b'gotcha', 1)) data, component = run(conn_a.recvfrom()) self.assertEqual(data, b'gotcha') self.assertEqual(component, 1) # send data a -> b (component 2) run(conn_a.sendto(b'howdee 2', 2)) data, component = run(conn_b.recvfrom()) self.assertEqual(data, b'howdee 2') self.assertEqual(component, 2) # send data b -> a (component 2) run(conn_b.sendto(b'gotcha 2', 2)) data, component = run(conn_a.recvfrom()) self.assertEqual(data, b'gotcha 2') self.assertEqual(component, 2) # close run(conn_a.close()) run(conn_b.close())
async def test_connect_two_components(self): conn_a = ice.Connection(ice_controlling=True, components=2) conn_b = ice.Connection(ice_controlling=False, components=2) # invite / accept await invite_accept(conn_a, conn_b) # we should only have host candidates self.assertCandidateTypes(conn_a, set(["host"])) self.assertCandidateTypes(conn_b, set(["host"])) # there should be a default candidate for component 1 candidate = conn_a.get_default_candidate(1) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, "host") # there should be a default candidate for component 2 candidate = conn_a.get_default_candidate(2) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, "host") # connect await asyncio.gather(conn_a.connect(), conn_b.connect()) self.assertEqual(conn_a._components, set([1, 2])) self.assertEqual(conn_b._components, set([1, 2])) # send data a -> b (component 1) await conn_a.sendto(b"howdee", 1) data, component = await conn_b.recvfrom() self.assertEqual(data, b"howdee") self.assertEqual(component, 1) # send data b -> a (component 1) await conn_b.sendto(b"gotcha", 1) data, component = await conn_a.recvfrom() self.assertEqual(data, b"gotcha") self.assertEqual(component, 1) # send data a -> b (component 2) await conn_a.sendto(b"howdee 2", 2) data, component = await conn_b.recvfrom() self.assertEqual(data, b"howdee 2") self.assertEqual(component, 2) # send data b -> a (component 2) await conn_b.sendto(b"gotcha 2", 2) data, component = await conn_a.recvfrom() self.assertEqual(data, b"gotcha 2") self.assertEqual(component, 2) # close await conn_a.close() await conn_b.close()
async def test_add_remote_candidate_mdns_good(self): """ Add an mDNS candidate which can be resolved. """ hostname = mdns.create_mdns_hostname() publisher = await mdns.create_mdns_protocol() await publisher.publish(hostname, "1.2.3.4") conn_a = ice.Connection(ice_controlling=True) await conn_a.add_remote_candidate( Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host=hostname, port=1234, type="host", )) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a.remote_candidates[0].host, "1.2.3.4") self.assertEqual(conn_a._remote_candidates_end, False) # close await conn_a.close() await publisher.close()
def test_add_remote_candidate_mdns(self): """ mDNS is not supported yet, ignore such candidates. """ conn_a = ice.Connection(ice_controlling=True) conn_a.add_remote_candidate( Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host="a64e1aa4-8c7e-4671-ab02-e6a3483b1cd9.local", port=1234, type="host", )) self.assertEqual(len(conn_a.remote_candidates), 0) self.assertEqual(conn_a._remote_candidates_end, False) conn_a.add_remote_candidate( Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host="1.2.3.4", port=1234, type="host", )) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a.remote_candidates[0].host, "1.2.3.4") self.assertEqual(conn_a._remote_candidates_end, False)
async def test_add_remote_candidate(self): conn_a = ice.Connection(ice_controlling=True) remote_candidate = Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host="1.2.3.4", port=1234, type="host", ) # add candidate await conn_a.add_remote_candidate(remote_candidate) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a.remote_candidates[0].host, "1.2.3.4") self.assertEqual(conn_a._remote_candidates_end, False) # end-of-candidates await conn_a.add_remote_candidate(None) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True) # try adding another candidate with self.assertRaises(ValueError) as cm: await conn_a.add_remote_candidate(remote_candidate) self.assertEqual( str(cm.exception), "Cannot add remote candidate after end-of-candidates.") self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True)
def test_peer_reflexive(self): connection = ice.Connection(ice_controlling=True) connection.remote_password = '******' connection.remote_username = '******' protocol = ProtocolMock() request = stun.Message(message_method=stun.Method.BINDING, message_class=stun.Class.REQUEST) request.attributes['PRIORITY'] = 456789 connection.check_incoming(request, ('2.3.4.5', 2345), protocol) self.assertIsNone(protocol.sent_message) # check we have discovered a peer-reflexive candidate self.assertEqual(len(connection.remote_candidates), 1) candidate = connection.remote_candidates[0] self.assertEqual(candidate.component, 1) self.assertEqual(candidate.transport, 'udp') self.assertEqual(candidate.priority, 456789) self.assertEqual(candidate.host, '2.3.4.5') self.assertEqual(candidate.port, 2345) self.assertEqual(candidate.type, 'prflx') self.assertEqual(candidate.generation, None) # check a new pair was formed self.assertEqual(len(connection._check_list), 1) pair = connection._check_list[0] self.assertEqual(pair.protocol, protocol) self.assertEqual(pair.remote_candidate, candidate) # check a triggered check was scheduled self.assertIsNotNone(pair.handle) protocol.response_addr = ('2.3.4.5', 2345) protocol.response_message = 'bad' run(pair.handle)
def test_response_with_invalid_address(self): connection = ice.Connection(ice_controlling=True) connection.remote_password = "******" connection.remote_username = "******" protocol = ProtocolMock() protocol.response_addr = ("3.4.5.6", 3456) protocol.response_message = "bad" pair = ice.CandidatePair( protocol, Candidate( foundation="some-foundation", component=1, transport="udp", priority=2345, host="2.3.4.5", port=2345, type="host", ), ) self.assertEqual( repr(pair), "CandidatePair(('1.2.3.4', 1234) -> ('2.3.4.5', 2345))" ) run(connection.check_start(pair)) self.assertEqual(pair.state, ice.CandidatePair.State.FAILED)
def test_set_remote_candidates_mdns(self): conn_a = ice.Connection(ice_controlling=True) conn_a.remote_candidates = [ Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host="a64e1aa4-8c7e-4671-ab02-e6a3483b1cd9.local", port=1234, type="host", ), Candidate( foundation="some-foundation", component=1, transport="udp", priority=1234, host="1.2.3.4", port=1234, type="host", ), ] self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a.remote_candidates[0].host, "1.2.3.4") self.assertEqual(conn_a._remote_candidates_end, True)
def test_set_remote_candidates(self): conn_a = ice.Connection(ice_controlling=True) remote_candidates = [ Candidate(foundation='some-foundation', component=1, transport='udp', priority=1234, host='1.2.3.4', port=1234, type='host') ] # set candidates conn_a.remote_candidates = remote_candidates self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True) # try setting candidates again with self.assertRaises(ValueError) as cm: conn_a.remote_candidates = remote_candidates self.assertEqual( str(cm.exception), 'Cannot set remote candidates after end-of-candidates.') self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True)
def test_add_remote_candidate(self): conn_a = ice.Connection(ice_controlling=True) remote_candidate = Candidate(foundation='some-foundation', component=1, transport='udp', priority=1234, host='1.2.3.4', port=1234, type='host') # add candidate conn_a.add_remote_candidate(remote_candidate) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, False) # end-of-candidates conn_a.add_remote_candidate(None) self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True) # try adding another candidate with self.assertRaises(ValueError) as cm: conn_a.add_remote_candidate(remote_candidate) self.assertEqual( str(cm.exception), 'Cannot add remote candidate after end-of-candidates.') self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a._remote_candidates_end, True)
def test_set_remote_candidates_mdns(self): conn_a = ice.Connection(ice_controlling=True) conn_a.remote_candidates = [ Candidate( foundation='some-foundation', component=1, transport='udp', priority=1234, host='a64e1aa4-8c7e-4671-ab02-e6a3483b1cd9.local', port=1234, type='host', ), Candidate( foundation='some-foundation', component=1, transport='udp', priority=1234, host='1.2.3.4', port=1234, type='host', ) ] self.assertEqual(len(conn_a.remote_candidates), 1) self.assertEqual(conn_a.remote_candidates[0].host, '1.2.3.4') self.assertEqual(conn_a._remote_candidates_end, True)
def test_connect_with_turn_server(self): # start turn server loop = asyncio.get_event_loop() transport, turn_server = run( loop.create_datagram_endpoint( lambda: TurnServerProtocol(realm='test', users={'foo': 'bar'}), local_addr=('127.0.0.1', 0), family=socket.AF_INET)) turn_server_addr = transport.get_extra_info('sockname') # create connections conn_a = ice.Connection(ice_controlling=True, turn_server=turn_server_addr, turn_username='******', turn_password='******') conn_b = ice.Connection(ice_controlling=False) # invite / accept run(invite_accept(conn_a, conn_b)) # we whould have both host and relayed candidates self.assertCandidateTypes(conn_a, set(['host', 'relay'])) self.assertCandidateTypes(conn_b, set(['host'])) # the default candidate should be relayed candidate = conn_a.get_default_candidate(1) self.assertIsNotNone(candidate) self.assertEqual(candidate.type, 'relay') # connect run(asyncio.gather(conn_a.connect(), conn_b.connect())) # send data a -> b run(conn_a.send(b'howdee')) data = run(conn_b.recv()) self.assertEqual(data, b'howdee') # send data b -> a run(conn_b.send(b'gotcha')) data = run(conn_a.recv()) self.assertEqual(data, b'gotcha') # close run(conn_a.close()) run(conn_b.close()) turn_server.transport.close()