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()
