def reads_back_a_written_value(self):
'''
This test uses low-level sockets to check if the Server is respecting the protocol when setting a value from memcached.
'''
host = '127.0.0.1'
port = 22322
request_bytes = binascii.unhexlify(b'80010003080000000000000e0000000000000000000000000000000000000000666f6f626172')
response_bytes = binascii.unhexlify(b'81010000000000000000000000000000000000000000012b')
server = Server(io_loop=self.io_loop)
server.listen(port, address=host)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
stream = iostream.IOStream(s, io_loop=self.io_loop)
def start_test():
stream.connect((host, port), send_request)
def send_request():
stream.write(request_bytes, write_finished)
def write_finished(*args, **kwargs):
stream.read_bytes(len(response_bytes), receive_response)
def receive_response(data):
self.assertEqual(self.response_without_cas(data), self.response_without_cas(response_bytes))
stream.close()
self.stop()
self.io_loop.add_callback(start_test)
self.wait()
def assert_response_matches_request(self, request_bytes, response_bytes):
host = "127.0.0.1"
port = 22322
server = Server(io_loop=self.io_loop)
server.set_handler("text")
server.listen(port, address=host)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
stream = iostream.IOStream(s, io_loop=self.io_loop)
def start_test():
stream.connect((host, port), send_request)
def send_request():
stream.write(request_bytes, write_finished)
def write_finished(*args, **kwargs):
stream.read_bytes(len(response_bytes), receive_response)
def receive_response(data):
self.assertEqual(data, response_bytes)
stream.close()
self.stop()
self.io_loop.add_callback(start_test)
self.wait()
def passes_request_to_handler(self):
server = Server(io_loop=self.io_loop)
handler = MagicMock(spec=BinaryProtocolHandler)
stream = MagicMock(iostream.IOStream)
stream.closed.side_effect = [False, True]
with patch.object(server, 'handler', handler):
server.backend = 'some backend'
server.handle_stream(stream, 'some address')
handler.process.assert_called_with(stream, 'some backend', callback=ANY)
def passes_request_to_handler(self):
server = Server(io_loop=self.io_loop)
handler = MagicMock(spec=BinaryProtocolHandler)
stream = MagicMock(iostream.IOStream)
stream.closed.side_effect = [False, True]
with patch.object(server, 'handler', handler):
server.backend = 'some backend'
server.handle_stream(stream, 'some address')
handler.process.assert_called_with(stream,
'some backend',
callback=ANY)
def assert_response_matches_request(self, request_bytes, response_bytes):
host = '127.0.0.1'
port = 22322
server = Server(io_loop=self.io_loop)
server.set_handler('text')
server.listen(port, address=host)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
stream = iostream.IOStream(s, io_loop=self.io_loop)
def start_test():
stream.connect((host, port), send_request)
def send_request():
stream.write(request_bytes, write_finished)
def write_finished(*args, **kwargs):
stream.read_bytes(len(response_bytes), receive_response)
def receive_response(data):
self.assertEqual(data, response_bytes)
stream.close()
self.stop()
self.io_loop.add_callback(start_test)
self.wait()
def reads_back_a_written_value(self):
'''
This test uses low-level sockets to check if the Server is respecting the protocol when setting a value from memcached.
'''
host = '127.0.0.1'
port = 22322
request_bytes = binascii.unhexlify(
b'80010003080000000000000e0000000000000000000000000000000000000000666f6f626172'
)
response_bytes = binascii.unhexlify(
b'81010000000000000000000000000000000000000000012b')
server = Server(io_loop=self.io_loop)
server.listen(port, address=host)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
stream = iostream.IOStream(s, io_loop=self.io_loop)
def start_test():
stream.connect((host, port), send_request)
def send_request():
stream.write(request_bytes, write_finished)
def write_finished(*args, **kwargs):
stream.read_bytes(len(response_bytes), receive_response)
def receive_response(data):
self.assertEqual(self.response_without_cas(data),
self.response_without_cas(response_bytes))
stream.close()
self.stop()
self.io_loop.add_callback(start_test)
self.wait()
def passes_io_loop_to_protocol(self):
server = Server(io_loop=self.io_loop)
self.assertIs(server.io_loop, server.handler.io_loop)
def starts_with_binary_protocol_handler_by_default(self):
server = Server(io_loop=self.io_loop)
self.assertIsInstance(server.handler, BinaryProtocolHandler)
def passes_io_loop_to_new_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('text')
self.assertIs(server.io_loop, server.handler.io_loop)
def sets_a_binary_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('binary')
self.assertIsInstance(server.handler, BinaryProtocolHandler)
def sets_a_text_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('text')
self.assertIsInstance(server.handler, TextProtocolHandler)
def sets_a_text_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('text')
self.assertIsInstance(server.handler, TextProtocolHandler)
def passes_io_loop_to_new_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('text')
self.assertIs(server.io_loop, server.handler.io_loop)
def sets_a_binary_handler(self):
server = Server(io_loop=self.io_loop)
server.set_handler('binary')
self.assertIsInstance(server.handler, BinaryProtocolHandler)
