def test_unpack_record_float(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RECORD, params=([1.1, 2.2, 3.3], )).getvalue() dummy.feed_data(output) record = deserialize_message(buf) assert record.fields == [1.1, 2.2, 3.3]
def test_unpack_record_string(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RECORD, params=(['a', 'b', 'c'], )).getvalue() dummy.feed_data(output) record = deserialize_message(buf) assert record.fields == ['a', 'b', 'c']
def test_pack_good_run_message(): output = serialize_message(Message.RUN, params=("RETURN 1 AS num", {})) expected = """0 13 b2 10 8f 52 45 54 55 52 4e 20 31 20 41 53 20 6e 75 6d a0 0 0""".replace(' ', '').replace('\n', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_unpack_good_run_message(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RUN, params=("RETURN 1 AS num", {})).getvalue() dummy.feed_data(output) run = deserialize_message(buf) assert run.statement == "RETURN 1 AS num" assert run.parameters == {}
def test_unpack_record_int_sizes(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RECORD, params=([1, 1234, -1234, 40000, -40000], )).getvalue() dummy.feed_data(output) record = deserialize_message(buf) assert record.fields == [1, 1234, -1234, 40000, -40000]
def test_unpack_record_mixed_types(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RECORD, params=([1, 'hello', { 'hello': 'world' }], )).getvalue() dummy.feed_data(output) record = deserialize_message(buf) assert record.fields == [1, 'hello', {'hello': 'world'}]
def test_pack_run_message(): output = serialize_message(Message.RUN, params=("This will cause a syntax error", {})) expected = """0 23 b2 10 d0 1e 54 68 69 73 20 77 69 6c 6c 20 63 61 75 73 65 20 61 20 73 79 6e 74 61 78 20 65 72 72 6f 72 a0 0 0""".replace(' ', '').replace('\n', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_unpack_success_message(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.SUCCESS, params=({ "server": "Neo4j/3.1.0" }, )).getvalue() dummy.feed_data(output) success = deserialize_message(buf) assert success.metadata == {"server": "Neo4j/3.1.0"}
def test_pack_success_message(): output = serialize_message(Message.SUCCESS, params=({ "server": "Neo4j/3.1.0" }, )) expected = """0 16 B1 70 A1 86 73 65 72 76 65 72 8B 4E 65 6F 34 6A 2F 33 2E 31 2E 30 0 0""".replace(' ', '').replace( '\n', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
async def run(self, statement=None, parameters=None, *, get_eof=False): """Submit a statement and parameters to the Bolt server and pull all results""" if statement is not None: if parameters is None: parameters = {} self.pipeline(statement, parameters) self._protocol.flush() while self._inflight > 0: try: # Wait for the result of run task and verify success success_msg = await self._protocol.read() assert success_msg[0] == Message.SUCCESS except (ServerFailedError, AssertionError) as e: # Failed run. Send ack and read ignored messages until server succeeds with reset self._inflight -= 1 serialize_message(self._on_failure, buf=self._protocol.write_buffer) self._protocol.flush() while True: try: msg = await self._protocol.read() except ServerIgnoredError: self._inflight -= 1 pass else: assert msg[0] == Message.SUCCESS raise ServerFailedError( "Server failed. Reset with '{}'".format( self._on_failure)) from e else: # Successful execution of run task, iterate results success_meta = success_msg[1] self._inflight -= 1 while True: msg = await self._protocol.read() if msg[0] == Message.SUCCESS: self._inflight -= 1 if get_eof: # EOF message with final meta yield client_response(None, msg[1], True) break yield client_response(msg.fields, success_meta, False)
def test_pack_init_message(): output = serialize_message(Message.INIT, params=("MyClient/1.0", collections.OrderedDict([ ("scheme", "basic"), ("principal", "neo4j"), ("credentials", "secret") ]))) expected = """0 40 B2 1 8C 4D 79 43 6C 69 65 6E 74 2F 31 2E 30 A3 86 73 63 68 65 6D 65 85 62 61 73 69 63 89 70 72 69 6E 63 69 70 61 6C 85 6E 65 6F 34 6A 8B 63 72 65 64 65 6E 74 69 61 6C 73 86 73 65 63 72 65 74 0 0""".replace(' ', '').replace('\n', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_unpack_init_message(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.INIT, params=("MyClient/1.0", collections.OrderedDict([ ("scheme", "basic"), ("principal", "neo4j"), ("credentials", "secret") ]))).getvalue() dummy.feed_data(output) init = deserialize_message(buf) assert init.client_name == "MyClient/1.0" assert init.auth_token["scheme"] == "basic" assert init.auth_token["principal"] == "neo4j" assert init.auth_token["credentials"] == "secret"
def test_unpack_record_mixed_types_containers(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.RECORD, params=([ 1, 'hello', { 'hello': ['world', 'hello', None, True, False] }, [1, 2, 3] ], )).getvalue() dummy.feed_data(output) record = deserialize_message(buf) assert record.fields == [ 1, 'hello', { 'hello': ['world', 'hello', None, True, False] }, [1, 2, 3] ]
def test_pack_failure_message(): output = serialize_message( Message.FAILURE, params=(collections.OrderedDict([ ("code", "Neo.ClientError.Statement.SyntaxError"), ("message", """Invalid input 'T': expected <init> (line 1, column 1 (offset: 0)) "This will cause a syntax error"^""") ]))) expected = """0 9E B1 7F A2 84 63 6F 64 65 D0 25 4E 65 6F 2E 43 6C 69 65 6E 74 45 72 72 6F 72 2E 53 74 61 74 65 6D 65 6E 74 2E 53 79 6E 74 61 78 45 72 72 6F 72 87 6D 65 73 73 61 67 65 D0 65 49 6E 76 61 6C 69 64 20 69 6E 70 75 74 20 27 54 27 3A 20 65 78 70 65 63 74 65 64 20 3C 69 6E 69 74 3E 20 28 6C 69 6E 65 20 31 2C 20 63 6F 6C 75 6D 6E 20 31 20 28 6F 66 66 73 65 74 3A 20 30 29 29 A 22 54 68 69 73 20 77 69 6C 6C 20 63 61 75 73 65 20 61 20 73 79 6E 74 61 78 20 65 72 72 6F 72 22 A 20 5E 0 0""".replace(' ', '').replace('\n', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def discard_all(self): messaging.serialize_message(messaging.Message.DISCARD_ALL, buf=self.write_buffer)
def run(self, statement, parameters): messaging.serialize_message(messaging.Message.RUN, buf=self.write_buffer, params=(statement, parameters))
def init(self, client_name, auth_token): messaging.serialize_message(messaging.Message.INIT, buf=self.write_buffer, params=(client_name, auth_token))
def ignored(self, metadata): messaging.serialize_message(messaging.Message.IGNORED, buf=self.write_buffer, params=(metadata, ))
def failure(self, metadata): messaging.serialize_message(messaging.Message.FAILURE, buf=self.write_buffer, params=(metadata, ))
def reset(self): messaging.serialize_message(messaging.Message.RESET, buf=self.write_buffer)
def test_pack_ignored(): output = serialize_message(Message.IGNORED) expected = """0 2 b0 7e 0 0""".replace(' ', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_pack_pull_all(): output = serialize_message(Message.PULL_ALL) expected = """0 2 b0 3f 0 0""".replace(' ', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_pack_ack_failure(): output = serialize_message(Message.ACK_FAILURE) expected = """0 2 B0 E 0 0""".replace(' ', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_pack_record(): output = serialize_message(Message.RECORD, params=([1], )) expected = """0 4 b1 71 91 1 0 0""".replace(' ', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def test_unpack_pull_all(dummy_read_buffer_pair): dummy, buf = dummy_read_buffer_pair output = serialize_message(Message.PULL_ALL).getvalue() dummy.feed_data(output) pull_all = deserialize_message(buf) assert pull_all.signature == Message.PULL_ALL
def pull_all(self): messaging.serialize_message(messaging.Message.PULL_ALL, buf=self.write_buffer)
def ack_failure(self): messaging.serialize_message(messaging.Message.ACK_FAILURE, buf=self.write_buffer)
def record(self, fields): messaging.serialize_message(messaging.Message.RECORD, buf=self.write_buffer, params=(fields, ))
def test_pack_reset(): output = serialize_message(Message.RESET) expected = """0 2 b0 f 0 0""".replace(' ', '').lower() output = get_hexbytes(output.getvalue()) assert output.replace('0x', '').lower() == expected
def success(self, metadata): messaging.serialize_message(messaging.Message.SUCCESS, buf=self.write_buffer, params=(metadata, ))