def test_mark_received(self):
client_transport = DummyDtlsTransport()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
# receive 1
self.assertFalse(client._mark_received(1))
self.assertEqual(client._last_received_tsn, 1)
self.assertEqual(client._sack_misordered, set())
# receive 3
self.assertFalse(client._mark_received(3))
self.assertEqual(client._last_received_tsn, 1)
self.assertEqual(client._sack_misordered, set([3]))
# receive 4
self.assertFalse(client._mark_received(4))
self.assertEqual(client._last_received_tsn, 1)
self.assertEqual(client._sack_misordered, set([3, 4]))
# receive 6
self.assertFalse(client._mark_received(6))
self.assertEqual(client._last_received_tsn, 1)
self.assertEqual(client._sack_misordered, set([3, 4, 6]))
# receive 2
self.assertFalse(client._mark_received(2))
self.assertEqual(client._last_received_tsn, 4)
self.assertEqual(client._sack_misordered, set([6]))
def test_t2_expired_when_shutdown_sent(self):
async def mock_send_chunk(chunk):
pass
client_transport = DummyDtlsTransport()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
client._send_chunk = mock_send_chunk
chunk = ShutdownChunk()
# fails once
client.state = RTCSctpTransport.State.SHUTDOWN_SENT
client._t2_start(chunk)
client._t2_expired()
self.assertEqual(client._t2_failures, 1)
self.assertIsNotNone(client._t2_handle)
self.assertEqual(client.state, RTCSctpTransport.State.SHUTDOWN_SENT)
# fails 10 times
client._t2_failures = 9
client._t2_expired()
self.assertEqual(client._t2_failures, 10)
self.assertIsNotNone(client._t2_handle)
self.assertEqual(client.state, RTCSctpTransport.State.SHUTDOWN_SENT)
# fails 11 times
client._t2_expired()
self.assertEqual(client._t2_failures, 11)
self.assertIsNone(client._t2_handle)
self.assertEqual(client.state, RTCSctpTransport.State.CLOSED)
def test_receive_data_out_of_order(self):
client_transport, _ = dummy_dtls_transport_pair()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
# build chunks
chunks = []
chunk = DataChunk(flags=SCTP_DATA_FIRST_FRAG)
chunk.user_data = b'foo'
chunk.tsn = 1
chunks.append(chunk)
chunk = DataChunk()
chunk.user_data = b'bar'
chunk.tsn = 2
chunks.append(chunk)
chunk = DataChunk(flags=SCTP_DATA_LAST_FRAG)
chunk.user_data = b'baz'
chunk.tsn = 3
chunks.append(chunk)
# receive first chunk
run(client._receive_chunk(chunks[0]))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [])
self.assertEqual(client._sack_misordered, set())
self.assertEqual(client._last_received_tsn, 1)
client._sack_needed = False
# receive last chunk
run(client._receive_chunk(chunks[2]))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [])
self.assertEqual(client._sack_misordered, set([3]))
self.assertEqual(client._last_received_tsn, 1)
client._sack_needed = False
# receive middle chunk
run(client._receive_chunk(chunks[1]))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [])
self.assertEqual(client._sack_misordered, set([]))
self.assertEqual(client._last_received_tsn, 3)
client._sack_needed = False
# receive last chunk again
run(client._receive_chunk(chunks[2]))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [3])
self.assertEqual(client._sack_misordered, set([]))
self.assertEqual(client._last_received_tsn, 3)
client._sack_needed = False
def test_receive_sack_discard(self):
client_transport, _ = dummy_dtls_transport_pair()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
# receive sack
sack_point = client._last_sacked_tsn
chunk = SackChunk()
chunk.cumulative_tsn = tsn_minus_one(sack_point)
run(client._receive_chunk(chunk))
# sack point must not changed
self.assertEqual(client._last_sacked_tsn, sack_point)
def test_send_sack(self):
sack = None
async def mock_send_chunk(c):
nonlocal sack
sack = c
client_transport = DummyDtlsTransport()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 123
client._send_chunk = mock_send_chunk
run(client._send_sack())
self.assertIsNotNone(sack)
self.assertEqual(sack.duplicates, [])
self.assertEqual(sack.gaps, [])
self.assertEqual(sack.cumulative_tsn, 123)
def test_receive_heartbeat(self):
client_transport, server_transport = dummy_dtls_transport_pair()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
client._remote_port = 5000
# receive heartbeat
chunk = HeartbeatChunk()
chunk.params.append((1, b'\x01\x02\x03\x04'))
chunk.tsn = 1
run(client._receive_chunk(chunk))
# check response
data = run(server_transport.recv())
packet = Packet.parse(data)
self.assertEqual(len(packet.chunks), 1)
self.assertTrue(isinstance(packet.chunks[0], HeartbeatAckChunk))
self.assertEqual(packet.chunks[0].params, [(1, b'\x01\x02\x03\x04')])
def test_send_sack_with_gaps(self):
sack = None
async def mock_send_chunk(c):
nonlocal sack
sack = c
client_transport = DummyDtlsTransport()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 12
client._sack_misordered = [14, 15, 17]
client._send_chunk = mock_send_chunk
run(client._send_sack())
self.assertIsNotNone(sack)
self.assertEqual(sack.duplicates, [])
self.assertEqual(sack.gaps, [(2, 3), (5, 5)])
self.assertEqual(sack.cumulative_tsn, 12)
def test_receive_data(self):
client_transport, _ = dummy_dtls_transport_pair()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
# receive chunk
chunk = DataChunk(flags=(SCTP_DATA_FIRST_FRAG | SCTP_DATA_LAST_FRAG))
chunk.user_data = b'foo'
chunk.tsn = 1
run(client._receive_chunk(chunk))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [])
self.assertEqual(client._last_received_tsn, 1)
client._sack_needed = False
# receive chunk again
run(client._receive_chunk(chunk))
self.assertEqual(client._sack_needed, True)
self.assertEqual(client._sack_duplicates, [1])
self.assertEqual(client._last_received_tsn, 1)
def test_receive_shutdown(self):
async def mock_send_chunk(chunk):
pass
client_transport, _ = dummy_dtls_transport_pair()
client = RTCSctpTransport(client_transport)
client._last_received_tsn = 0
client._send_chunk = mock_send_chunk
client.state = RTCSctpTransport.State.ESTABLISHED
# receive shutdown
chunk = ShutdownChunk()
chunk.cumulative_tsn = tsn_minus_one(client._last_sacked_tsn)
run(client._receive_chunk(chunk))
self.assertEqual(client.state,
RTCSctpTransport.State.SHUTDOWN_ACK_SENT)
# receive shutdown complete
chunk = ShutdownCompleteChunk()
run(client._receive_chunk(chunk))
self.assertEqual(client.state, RTCSctpTransport.State.CLOSED)
