def test_send_ping(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/ping')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
messages = request.connection.get_written_control_messages(2)
self.assertEqual(common.OPCODE_PING, messages[0]['opcode'])
self.assertEqual('Ping!', messages[0]['message'])
def test_receive_drop_channel(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
drop_channel = mux._create_drop_channel(channel_id=2,
outer_frame_mask=True)
request.connection.put_bytes(drop_channel)
# Terminate implicitly opened channel.
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
exception = dispatcher.channel_events[2].exception
self.assertTrue(exception.__class__ == ConnectionTerminatedException)
def test_quota_violation_by_client(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS, 0)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
control_blocks = request.connection.get_written_control_blocks()
# The first block is FlowControl for channel id 1.
# The next two blocks are NewChannelSlot and AddChannelResponse.
# The 4th block or the last block should be DropChannels for channel 2.
# (The order can be mixed up)
# The remaining block should be FlowControl for 'Goodbye'.
self.assertEqual(5, len(control_blocks))
expected_opcode_and_flag = ((mux._MUX_OPCODE_DROP_CHANNEL << 5) |
(1 << 4))
self.assertTrue((expected_opcode_and_flag ==
(ord(control_blocks[3][0]) & 0xf0)) or
(expected_opcode_and_flag ==
(ord(control_blocks[4][0]) & 0xf0)))
def test_quota_violation_by_client(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS, 0)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
control_blocks = request.connection.get_written_control_blocks()
# The first block is FlowControl for channel id 1.
# The next two blocks are NewChannelSlot and AddChannelResponse.
# The 4th block or the last block should be DropChannels for channel 2.
# (The order can be mixed up)
# The remaining block should be FlowControl for 'Goodbye'.
self.assertEqual(5, len(control_blocks))
expected_opcode_and_flag = ((mux._MUX_OPCODE_DROP_CHANNEL << 5) |
(1 << 4))
self.assertTrue(
(expected_opcode_and_flag == (ord(control_blocks[3][0]) & 0xf0)) or
(expected_opcode_and_flag == (ord(control_blocks[4][0]) & 0xf0)))
def test_no_send_quota_on_server(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=1)
# No message should be sent on channel 2.
self.assertRaises(KeyError,
request.connection.get_written_messages,
2)
def test_send_ping(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/ping')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
messages = request.connection.get_written_control_messages(2)
self.assertEqual(common.OPCODE_PING, messages[0]['opcode'])
self.assertEqual('Ping!', messages[0]['message'])
def test_receive_drop_channel(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
drop_channel = mux._create_drop_channel(channel_id=2,
outer_frame_mask=True)
request.connection.put_bytes(drop_channel)
# Terminate implicitly opened channel.
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
exception = dispatcher.channel_events[2].exception
self.assertTrue(exception.__class__ == ConnectionTerminatedException)
def test_add_channel_invalid_version_handshake(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = (
'GET /echo HTTP/1.1\r\n'
'Host: example.com\r\n'
'Connection: Upgrade\r\n'
'Sec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\n'
'Sec-WebSocket-Protocol: sample\r\n'
'Upgrade: WebSocket\r\n'
'Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\n'
'Origin: http://example.com\r\n'
'\r\n'
'^n:ds[4U')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertTrue(1 in dispatcher.channel_events)
self.assertTrue(not 2 in dispatcher.channel_events)
def test_add_channel_invalid_version_handshake(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = ('GET /echo HTTP/1.1\r\n'
'Host: example.com\r\n'
'Connection: Upgrade\r\n'
'Sec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\n'
'Sec-WebSocket-Protocol: sample\r\n'
'Upgrade: WebSocket\r\n'
'Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\n'
'Origin: http://example.com\r\n'
'\r\n'
'^n:ds[4U')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertTrue(1 in dispatcher.channel_events)
self.assertTrue(not 2 in dispatcher.channel_events)
def test_add_channel(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=3, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=3,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Hello'))
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='World'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertEqual([], dispatcher.channel_events[1].messages)
self.assertEqual(['Hello'], dispatcher.channel_events[2].messages)
self.assertEqual(['World'], dispatcher.channel_events[3].messages)
# Channel 2
messages = request.connection.get_written_messages(2)
self.assertEqual(1, len(messages))
self.assertEqual('Hello', messages[0])
# Channel 3
messages = request.connection.get_written_messages(3)
self.assertEqual(1, len(messages))
self.assertEqual('World', messages[0])
control_blocks = request.connection.get_written_control_blocks()
# There should be 8 control blocks:
# - 1 NewChannelSlot
# - 2 AddChannelResponses for channel id 2 and 3
# - 6 FlowControls for channel id 1 (initialize), 'Hello', 'World',
# and 3 'Goodbye's
self.assertEqual(9, len(control_blocks))
def test_channel_slot_violation_by_client(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(slots=1,
send_quota=mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=10,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Hello'))
# This request should be rejected.
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=3, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=3,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='Hello'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertEqual(['Hello'], dispatcher.channel_events[2].messages)
self.assertFalse(dispatcher.channel_events.has_key(3))
def test_channel_slot_violation_by_client(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(slots=1,
send_quota=mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=10,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Hello'))
# This request should be rejected.
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=3, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=3,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='Hello'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertEqual(['Hello'], dispatcher.channel_events[2].messages)
self.assertFalse(dispatcher.channel_events.has_key(3))
def test_add_channel_incomplete_handshake(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
incomplete_encoded_handshake = 'GET /echo HTTP/1.1'
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=incomplete_encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertTrue(1 in dispatcher.channel_events)
self.assertTrue(not 2 in dispatcher.channel_events)
def test_two_flow_control(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
# Replenish 5 bytes.
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
# Send 10 bytes. The server will try echo back 10 bytes.
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
# Replenish 5 bytes again.
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
messages = request.connection.get_written_messages(2)
self.assertEqual(['HelloWorld'], messages)
def test_add_channel_incomplete_handshake(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
incomplete_encoded_handshake = 'GET /echo HTTP/1.1'
add_channel_request = _create_add_channel_request_frame(
channel_id=2,
encoding=0,
encoded_handshake=incomplete_encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertTrue(1 in dispatcher.channel_events)
self.assertTrue(not 2 in dispatcher.channel_events)
def test_two_flow_control(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
# Replenish 5 bytes.
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
# Send 10 bytes. The server will try echo back 10 bytes.
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
# Replenish 5 bytes again.
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
messages = request.connection.get_written_messages(2)
self.assertEqual(['HelloWorld'], messages)
def test_no_send_quota_on_server(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0, encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='HelloWorld'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
mux_handler.wait_until_done(timeout=1)
# No message should be sent on channel 2.
self.assertRaises(KeyError, request.connection.get_written_messages, 2)
def test_add_channel(self):
request = _create_mock_request()
dispatcher = _MuxMockDispatcher()
mux_handler = mux._MuxHandler(request, dispatcher)
mux_handler.start()
mux_handler.add_channel_slots(mux._INITIAL_NUMBER_OF_CHANNEL_SLOTS,
mux._INITIAL_QUOTA_FOR_CLIENT)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=2, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=2,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
encoded_handshake = _create_request_header(path='/echo')
add_channel_request = _create_add_channel_request_frame(
channel_id=3, encoding=0,
encoded_handshake=encoded_handshake)
request.connection.put_bytes(add_channel_request)
flow_control = mux._create_flow_control(channel_id=3,
replenished_quota=5,
outer_frame_mask=True)
request.connection.put_bytes(flow_control)
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Hello'))
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='World'))
request.connection.put_bytes(
_create_logical_frame(channel_id=1, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=2, message='Goodbye'))
request.connection.put_bytes(
_create_logical_frame(channel_id=3, message='Goodbye'))
mux_handler.wait_until_done(timeout=2)
self.assertEqual([], dispatcher.channel_events[1].messages)
self.assertEqual(['Hello'], dispatcher.channel_events[2].messages)
self.assertEqual(['World'], dispatcher.channel_events[3].messages)
# Channel 2
messages = request.connection.get_written_messages(2)
self.assertEqual(1, len(messages))
self.assertEqual('Hello', messages[0])
# Channel 3
messages = request.connection.get_written_messages(3)
self.assertEqual(1, len(messages))
self.assertEqual('World', messages[0])
control_blocks = request.connection.get_written_control_blocks()
# There should be 8 control blocks:
# - 1 NewChannelSlot
# - 2 AddChannelResponses for channel id 2 and 3
# - 6 FlowControls for channel id 1 (initialize), 'Hello', 'World',
# and 3 'Goodbye's
self.assertEqual(9, len(control_blocks))
