def test_QDataStreamProtocol_recv_small_message(protocol,reader): data = QDataStreamProtocol.pack_block(b''.join([QDataStreamProtocol.pack_qstring('{"some_header": true}'), QDataStreamProtocol.pack_qstring('Goodbye')])) reader.feed_data(data) message = yield from protocol.read_message() assert message == {'some_header': True, 'legacy': ['Goodbye']}
async def test_QDataStreamProtocol_recv_small_message(protocol, reader): data = QDataStreamProtocol.pack_block(b''.join([QDataStreamProtocol.pack_qstring('{"some_header": true}'), QDataStreamProtocol.pack_qstring('Goodbye')])) reader.feed_data(data) message = await protocol.read_message() assert message == {'some_header': True, 'legacy': ['Goodbye']}
async def test_QDataStreamProtocol_recv_small_message(protocol, reader): data = QDataStreamProtocol.pack_block(b"".join([QDataStreamProtocol.pack_qstring('{"some_header": true}'), QDataStreamProtocol.pack_qstring("Goodbye")])) reader.feed_data(data) message = await protocol.read_message() assert message == {"some_header": True, "legacy": ["Goodbye"]}
def unix_protocol(unix_srv, event_loop): (reader, writer) = event_loop.run_until_complete( asyncio.open_unix_connection('/tmp/test.sock') ) protocol = QDataStreamProtocol(reader, writer) yield protocol protocol.close()
def test_serverside_abort(loop, mock_context, mock_server): (reader, writer) = yield from asyncio.open_connection(*mock_context.sockets[0].getsockname()) proto = QDataStreamProtocol(reader, writer) proto.send_message({"some_junk": True}) yield from writer.drain() yield from asyncio.sleep(0.1) mock_server.on_connection_lost.assert_any_call()
def test_QDataStreamProtocol_recv_large_array(protocol, reader): reader.feed_data(QDataStreamProtocol.pack_block(b''.join( [QDataStreamProtocol.pack_qstring('{"some_header": true}')] + [QDataStreamProtocol.pack_qstring(str(i)) for i in range(1520)]))) reader.feed_eof() message = yield from protocol.read_message() assert message == {'some_header': True, 'legacy': [str(i) for i in range(1520)]}
async def test_QDataStreamProtocol_recv_large_array(protocol, reader): reader.feed_data(QDataStreamProtocol.pack_block(b"".join( [QDataStreamProtocol.pack_qstring('{"some_header": true}')] + [QDataStreamProtocol.pack_qstring(str(i)) for i in range(1520)]))) reader.feed_eof() message = await protocol.read_message() assert message == {"some_header": True, "legacy": [str(i) for i in range(1520)]}
def test_QDataStreamProtocol_recv_large_array(protocol, reader): reader.feed_data( QDataStreamProtocol.pack_block(b''.join( [QDataStreamProtocol.pack_qstring('{"some_header": true}')] + [QDataStreamProtocol.pack_qstring(str(i)) for i in range(1520)]))) reader.feed_eof() message = yield from protocol.read_message() assert message == { 'some_header': True, 'legacy': [str(i) for i in range(1520)] }
async def perform_login( proto: QDataStreamProtocol, credentials: Tuple[str, str] ) -> None: login, pw = credentials pw_hash = hashlib.sha256(pw.encode('utf-8')) proto.send_message({ 'command': 'hello', 'version': '1.0.0-dev', 'user_agent': 'faf-client', 'login': login, 'password': pw_hash.hexdigest(), 'unique_id': 'some_id' }) await proto.drain()
async def client_connected(self, stream_reader, stream_writer): self._logger.debug("%s: Client connected", self) protocol = QDataStreamProtocol(stream_reader, stream_writer) connection = self._connection_factory() try: await connection.on_connection_made( protocol, Address(*stream_writer.get_extra_info('peername'))) self.connections[connection] = protocol server.stats.gauge('user.agents.None', 1, delta=True) while True: message = await protocol.read_message() with server.stats.timer('connection.on_message_received'): await connection.on_message_received(message) with server.stats.timer('servercontext.drain'): await asyncio.sleep(0) await connection.drain() except ConnectionResetError: pass except ConnectionAbortedError: pass except TimeoutError: pass except asyncio.IncompleteReadError as ex: if not stream_reader.at_eof(): self._logger.exception(ex) except Exception as ex: self._logger.exception(ex) finally: del self.connections[connection] server.stats.gauge('user.agents.{}'.format(connection.user_agent), -1, delta=True) protocol.writer.close() await connection.on_connection_lost()
async def test_pack_unpack(protocol, reader): message = { "Some": "crazy", "Message": ["message", 10], "with": 1000 } reader.feed_data(QDataStreamProtocol.pack_message(json.dumps(message))) assert message == await protocol.read_message()
async def test_serverside_abort(event_loop, mock_context, mock_server): srv, ctx = mock_context (reader, writer) = await asyncio.open_connection(*srv.sockets[0].getsockname()) proto = QDataStreamProtocol(reader, writer) await proto.send_message({"some_junk": True}) await exhaust_callbacks(event_loop) mock_server.on_connection_lost.assert_any_call()
async def test_QDataStreamProtocol_pack_unpack(protocol, reader, message): reader.feed_data(QDataStreamProtocol.pack_message(json.dumps(message))) assert message == await protocol.read_message()
def protocol(reader, writer): return QDataStreamProtocol(reader, writer)
def mock_protocol(): return mock.create_autospec(QDataStreamProtocol(mock.Mock(), mock.Mock()))
async def connect(self, host, port): self.proto = QDataStreamProtocol( *(await asyncio.open_connection(host, port)))
async def test_types(): with pytest.raises(NotImplementedError): QDataStreamProtocol.pack_message({"Not": ["a", "string"]})
async def unix_protocol(unix_srv): (reader, writer) = await asyncio.open_unix_connection("/tmp/test.sock") protocol = QDataStreamProtocol(reader, writer) yield protocol await protocol.close()
async def connect_client(server) -> QDataStreamProtocol: return QDataStreamProtocol( *(await asyncio.open_connection(*server.sockets[0].getsockname())) )
async def test_QDataStreamProtocol_deterministic(message): assert ( QDataStreamProtocol.encode_message(message) == QDataStreamProtocol.encode_message(message) == QDataStreamProtocol.encode_message(message) )
def connect_client(server): return QDataStreamProtocol(*(yield from asyncio.open_connection( *server.sockets[0].getsockname())))
async def test_QDataStreamProtocol_encode_ping_pong(): assert QDataStreamProtocol.encode_message({"command": "ping"}) == \ b"\x00\x00\x00\x0c\x00\x00\x00\x08\x00P\x00I\x00N\x00G" assert QDataStreamProtocol.encode_message({"command": "pong"}) == \ b"\x00\x00\x00\x0c\x00\x00\x00\x08\x00P\x00O\x00N\x00G"