def test_bolt_01_csv(): # We can create a namespace from the csv. ns = MessageNamespace(bolt1.csv) # string [expected string] for t in [['init globalfeatures= features=80', 'init globalfeatures= features=80 tlvs={}'], ['init globalfeatures= features=80 tlvs={}'], ['init globalfeatures= features=80 tlvs={networks={chains=[6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000]}}'], ['init globalfeatures= features=80 tlvs={networks={chains=[6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000,1fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000]}}'], ['error channel_id=0000000000000000000000000000000000000000000000000000000000000000 data=00'], ['ping num_pong_bytes=0 ignored='], ['ping num_pong_bytes=3 ignored=0000'], ['pong ignored='], ['pong ignored=000000']]: m = Message.from_str(bolt1.namespace, t[0]) b = io.BytesIO() m.write(b) # Works with our manually-made namespace, and the builtin one. b.seek(0) m2 = Message.read(bolt1.namespace, b) assert m2.to_str() == t[-1] b.seek(0) m2 = Message.read(ns, b) assert m2.to_str() == t[-1]
def test_tlv_complex(): # A real example from the spec. ns = MessageNamespace([ "msgtype,reply_channel_range,264,gossip_queries", "msgdata,reply_channel_range,chain_hash,chain_hash,", "msgdata,reply_channel_range,first_blocknum,u32,", "msgdata,reply_channel_range,number_of_blocks,u32,", "msgdata,reply_channel_range,full_information,byte,", "msgdata,reply_channel_range,len,u16,", "msgdata,reply_channel_range,encoded_short_ids,byte,len", "msgdata,reply_channel_range,tlvs,reply_channel_range_tlvs,", "tlvtype,reply_channel_range_tlvs,timestamps_tlv,1", "tlvdata,reply_channel_range_tlvs,timestamps_tlv,encoding_type,byte,", "tlvdata,reply_channel_range_tlvs,timestamps_tlv,encoded_timestamps,byte,...", "tlvtype,reply_channel_range_tlvs,checksums_tlv,3", "tlvdata,reply_channel_range_tlvs,checksums_tlv,checksums,channel_update_checksums,...", "subtype,channel_update_timestamps", "subtypedata,channel_update_timestamps,timestamp_node_id_1,u32,", "subtypedata,channel_update_timestamps,timestamp_node_id_2,u32,", "subtype,channel_update_checksums", "subtypedata,channel_update_checksums,checksum_node_id_1,u32,", "subtypedata,channel_update_checksums,checksum_node_id_2,u32," ]) binmsg = bytes.fromhex( '010806226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000000670000000701001100000067000001000000006d000001000003101112fa300000000022d7a4a79bece840' ) msg = Message.read(ns, io.BytesIO(binmsg)) buf = io.BytesIO() msg.write(buf) assert buf.getvalue() == binmsg
def test_subtype(): ns = MessageNamespace() ns.load_csv([ 'msgtype,test1,1', 'msgdata,test1,test_sub,channel_update_timestamps,4', 'subtype,channel_update_timestamps', 'subtypedata,' + 'channel_update_timestamps,timestamp_node_id_1,u32,', 'subtypedata,' + 'channel_update_timestamps,timestamp_node_id_2,u32,' ]) for test in [[ "test1 test_sub=[" "{timestamp_node_id_1=1,timestamp_node_id_2=2}" ",{timestamp_node_id_1=3,timestamp_node_id_2=4}" ",{timestamp_node_id_1=5,timestamp_node_id_2=6}" ",{timestamp_node_id_1=7,timestamp_node_id_2=8}]", bytes([0, 1] + [0, 0, 0, 1, 0, 0, 0, 2] + [0, 0, 0, 3, 0, 0, 0, 4] + [0, 0, 0, 5, 0, 0, 0, 6] + [0, 0, 0, 7, 0, 0, 0, 8]) ]]: m = Message.from_str(ns, test[0]) assert m.to_str() == test[0] buf = io.BytesIO() m.write(buf) assert buf.getvalue() == test[1] assert Message.read(ns, io.BytesIO(test[1])).to_str() == test[0] # Test missing field logic. m = Message.from_str(ns, "test1", incomplete_ok=True) assert m.missing_fields()
def action(self, runner: 'Runner') -> bool: super().action(runner) conn = self.find_conn(runner) while True: binmsg = runner.get_output_message(conn, self) if binmsg is None: raise EventError(self, "Did not receive a message from runner") for e in conn.must_not_events: if e.matches(binmsg): raise EventError(self, "Got msg banned by {}: {}" .format(e, binmsg.hex())) # Might be completely unknown to namespace. try: msg = Message.read(event_namespace, io.BytesIO(binmsg)) except ValueError as ve: raise EventError(self, "Runner gave bad msg {}: {}".format(binmsg.hex(), ve)) # Ignore function may tell us to respond. response = self.ignore(msg) if response is not None: for msg in response: binm = io.BytesIO() msg.write(binm) runner.recv(self, conn, binm.getvalue()) continue err = self.message_match(runner, msg) if err: raise EventError(self, "{}: message was {}".format(err, msg.to_str())) break return True
def test_subtype_array(): ns = MessageNamespace() ns.load_csv([ 'msgtype,tx_signatures,1', 'msgdata,tx_signatures,num_witnesses,u16,', 'msgdata,tx_signatures,witness_stack,witness_stack,num_witnesses', 'subtype,witness_stack', 'subtypedata,witness_stack,num_input_witness,u16,', 'subtypedata,witness_stack,witness_element,witness_element,num_input_witness', 'subtype,witness_element', 'subtypedata,witness_element,len,u16,', 'subtypedata,witness_element,witness,byte,len' ]) for test in [[ "tx_signatures witness_stack=" "[{witness_element=[{witness=3045022100ac0fdee3e157f50be3214288cb7f11b03ce33e13b39dadccfcdb1a174fd3729a02200b69b286ac9f0fc5c51f9f04ae5a9827ac11d384cc203a0eaddff37e8d15c1ac01},{witness=02d6a3c2d0cf7904ab6af54d7c959435a452b24a63194e1c4e7c337d3ebbb3017b}]}]", bytes.fromhex( '00010001000200483045022100ac0fdee3e157f50be3214288cb7f11b03ce33e13b39dadccfcdb1a174fd3729a02200b69b286ac9f0fc5c51f9f04ae5a9827ac11d384cc203a0eaddff37e8d15c1ac01002102d6a3c2d0cf7904ab6af54d7c959435a452b24a63194e1c4e7c337d3ebbb3017b' ) ]]: m = Message.from_str(ns, test[0]) assert m.to_str() == test[0] buf = io.BytesIO() m.write(buf) assert buf.getvalue().hex() == test[1].hex() assert Message.read(ns, io.BytesIO(test[1])).to_str() == test[0]
def test_tlv(): ns = MessageNamespace() ns.load_csv([ 'msgtype,test1,1', 'msgdata,test1,tlvs,test_tlvstream,', 'tlvtype,test_tlvstream,tlv1,1', 'tlvdata,test_tlvstream,tlv1,field1,byte,4', 'tlvdata,test_tlvstream,tlv1,field2,u32,', 'tlvtype,test_tlvstream,tlv2,255', 'tlvdata,test_tlvstream,tlv2,field3,byte,...' ]) for test in [ [ "test1 tlvs={tlv1={field1=01020304,field2=5}}", bytes([0, 1] + [1, 8, 1, 2, 3, 4, 0, 0, 0, 5]) ], [ "test1 tlvs={tlv1={field1=01020304,field2=5},tlv2={field3=01020304}}", bytes([0, 1] + [1, 8, 1, 2, 3, 4, 0, 0, 0, 5] + [253, 0, 255, 4, 1, 2, 3, 4]) ], [ "test1 tlvs={tlv1={field1=01020304,field2=5},4=010203,tlv2={field3=01020304}}", bytes([0, 1] + [1, 8, 1, 2, 3, 4, 0, 0, 0, 5] + [4, 3, 1, 2, 3] + [253, 0, 255, 4, 1, 2, 3, 4]) ] ]: m = Message.from_str(ns, test[0]) assert m.to_str() == test[0] buf = io.BytesIO() m.write(buf) assert buf.getvalue() == test[1] assert Message.read(ns, io.BytesIO(test[1])).to_str() == test[0] # Ordering test (turns into canonical ordering) m = Message.from_str( ns, 'test1 tlvs={tlv1={field1=01020304,field2=5},tlv2={field3=01020304},4=010203}' ) buf = io.BytesIO() m.write(buf) assert buf.getvalue() == bytes([0, 1] + [1, 8, 1, 2, 3, 4, 0, 0, 0, 5] + [4, 3, 1, 2, 3] + [253, 0, 255, 4, 1, 2, 3, 4])
def test_static_array(): ns = MessageNamespace() ns.load_csv(['msgtype,test1,1', 'msgdata,test1,test_arr,byte,4']) ns.load_csv( ['msgtype,test2,2', 'msgdata,test2,test_arr,short_channel_id,4']) for test in [["test1 test_arr=00010203", bytes([0, 1] + [0, 1, 2, 3])], [ "test2 test_arr=[0x1x2,4x5x6,7x8x9,10x11x12]", bytes([0, 2] + [0, 0, 0, 0, 0, 1, 0, 2] + [0, 0, 4, 0, 0, 5, 0, 6] + [0, 0, 7, 0, 0, 8, 0, 9] + [0, 0, 10, 0, 0, 11, 0, 12]) ]]: m = Message.from_str(ns, test[0]) assert m.to_str() == test[0] buf = io.BytesIO() m.write(buf) assert buf.getvalue() == test[1] assert Message.read(ns, io.BytesIO(test[1])).to_str() == test[0]
def action(self, runner: 'Runner') -> bool: super().action(runner) # Check they all use the same conn! conn: Optional[Conn] = None for s in self.sequences: c = cast(ExpectMsg, s.events[0]).find_conn(runner) if conn is None: conn = c elif c != conn: raise SpecFileError(self, "sequences do not all use the same conn?") assert conn while True: binmsg = runner.get_output_message(conn, self.sequences[0].events[0]) if binmsg is None: raise EventError(self, "Did not receive a message from runner") try: msg = Message.read(namespace(), io.BytesIO(binmsg)) except ValueError as ve: raise EventError(self, "Invalid msg {}: {}".format(binmsg.hex(), ve)) ignored = Sequence.ignored_by_all(msg, self.enabled_sequences(runner)) # If they gave us responses, send those now. if ignored is not None: for msg in ignored: binm = io.BytesIO() msg.write(binm) runner.recv(self, conn, binm.getvalue()) continue seq = Sequence.match_which_sequence(runner, msg, self.enabled_sequences(runner)) if seq is not None: # We found the sequence, run it return seq.action(runner, skip_first=True) raise EventError(self, "None of the sequences {} matched {}".format(self.enabled_sequences(runner), msg.to_str()))
def action(self, runner: 'Runner') -> bool: super().action(runner) # Check they all use the same conn! conn = None for s in self.sequences: c = cast(ExpectMsg, s.events[0]).find_conn(runner) if conn is None: conn = c elif c != conn: raise SpecFileError(self, "sequences do not all use the same conn?") assert conn all_done = True sequences = self.enabled_sequences(runner) while sequences != []: # Get message binmsg = runner.get_output_message(conn, sequences[0].events[0]) if binmsg is None: raise EventError(self, "Did not receive a message from runner, still expecting {}" .format([s.events[0] for s in sequences])) try: msg = Message.read(namespace(), io.BytesIO(binmsg)) except ValueError as ve: raise EventError(self, "Invalid msg {}: {}".format(binmsg.hex(), ve)) if Sequence.ignored_by_all(msg, sequences): continue seq = Sequence.match_which_sequence(runner, msg, sequences) if seq is not None: sequences.remove(seq) all_done &= seq.action(runner, skip_first=True) continue raise EventError(self, "Message did not match any sequences {}: {}" .format([s.events[0] for s in sequences], msg.to_str())) return all_done