Add test for NodeInfo

Author: tnull

lightning/src/routing/gossip.rs

@@ -1109,7 +1109,7 @@ impl MaybeReadable for NodeAnnouncementInfoDeserWrapper {
 	fn read<R: io::Read>(reader: &mut R) -> Result<Option<Self>, DecodeError> {
 		match ::util::ser::Readable::read(reader) {
 			Ok(node_announcement) => Ok(Some(Self(node_announcement))),
-			Err(DecodeError::ShortRead) => Ok(None),
+			Err(DecodeError::InvalidValue) => Ok(None),
 			Err(err) => Err(err),
 		}
 	}
@@ -1822,7 +1822,7 @@ mod tests {
 	use chain;
 	use ln::PaymentHash;
 	use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
-	use routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo};
+	use routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo, NodeAnnouncementInfo, NodeInfo};
 	use ln::msgs::{Init, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
 		UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate,
 		ReplyChannelRange, QueryChannelRange, QueryShortChannelIds, MAX_VALUE_MSAT};
@@ -2950,7 +2950,7 @@ mod tests {
 	}
 
 	#[test]
-	fn written_channel_info_is_readable() {
+	fn channel_info_is_readable() {
 		let chanmon_cfgs = ::ln::functional_test_utils::create_chanmon_cfgs(2);
 		let node_cfgs = ::ln::functional_test_utils::create_node_cfgs(2, &chanmon_cfgs);
 		let node_chanmgrs = ::ln::functional_test_utils::create_node_chanmgrs(2, &node_cfgs, &[None, None, None, None]);
@@ -3043,6 +3043,47 @@ mod tests {
 		assert_eq!(read_chan_info.one_to_two, None);
 		assert_eq!(read_chan_info.two_to_one, None);
 	}
+
+	#[test]
+	fn node_info_is_readable() {
+		use std::convert::TryFrom;
+
+		// 1. Check we can read a valid NodeAnnouncementInfo and fail on an invalid one
+		let valid_netaddr = ::ln::msgs::NetAddress::Hostname { hostname: ::util::ser::Hostname::try_from("A".to_string()).unwrap(), port: 1234 };
+		let valid_node_ann_info = NodeAnnouncementInfo {
+			features: NodeFeatures::known(),
+			last_update: 0,
+			rgb: [0u8; 3],
+			alias: NodeAlias([0u8; 32]),
+			addresses: vec![valid_netaddr],
+			announcement_message: None,
+		};
+
+		let mut encoded_valid_node_ann_info = Vec::new();
+		assert!(valid_node_ann_info.write(&mut encoded_valid_node_ann_info).is_ok());
+		let read_valid_node_ann_info: NodeAnnouncementInfo = ::util::ser::Readable::read(&mut encoded_valid_node_ann_info.as_slice()).unwrap();
+		assert_eq!(read_valid_node_ann_info, valid_node_ann_info);
+
+		let encoded_invalid_node_ann_info = hex::decode("3f0009000788a000080a51a20204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014004d2").unwrap();
+		let read_invalid_node_ann_info_res: Result<NodeAnnouncementInfo, ::ln::msgs::DecodeError> = ::util::ser::Readable::read(&mut encoded_invalid_node_ann_info.as_slice());
+		assert!(read_invalid_node_ann_info_res.is_err());
+
+		// 2. Check we can read a NodeInfo anyways, but set the NodeAnnouncementInfo to None if invalid
+		let valid_node_info = NodeInfo {
+			channels: Vec::new(),
+			lowest_inbound_channel_fees: None,
+			announcement_info: Some(valid_node_ann_info),
+		};
+
+		let mut encoded_valid_node_info = Vec::new();
+		assert!(valid_node_info.write(&mut encoded_valid_node_info).is_ok());
+		let read_valid_node_info: NodeInfo = ::util::ser::Readable::read(&mut encoded_valid_node_info.as_slice()).unwrap();
+		assert_eq!(read_valid_node_info, valid_node_info);
+
+		let encoded_invalid_node_info_hex = hex::decode("4402403f0009000788a000080a51a20204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014004d20400").unwrap();
+		let read_invalid_node_info: NodeInfo = ::util::ser::Readable::read(&mut encoded_invalid_node_info_hex.as_slice()).unwrap();
+		assert_eq!(read_invalid_node_info.announcement_info, None);
+	}
 }
 
 #[cfg(all(test, feature = "_bench_unstable"))]