Add tests for handling htlc fail channel updates

Author: naumenkogs

lightning/src/ln/router.rs

@@ -1058,7 +1058,7 @@ mod tests {
 	use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
 	use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 	use ln::msgs::{ErrorAction, LightningError, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
-	                UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate};
+	                UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate, HTLCFailChannelUpdate};
 	use util::test_utils;
 	use util::test_utils::TestVecWriter;
 	use util::logger::Logger;
@@ -2229,4 +2229,108 @@ mod tests {
 		};
 
 	}
+
+	#[test]
+	fn handling_htlc_fail_channel_update() {
+		let (secp_ctx, our_id, router) = create_router();
+		let secret_key = &SecretKey::from_slice(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap();
+		let public_key = PublicKey::from_secret_key(&secp_ctx, secret_key);
+
+		let channel_id = 0;
+		let channel_key = NetworkMap::get_key(channel_id, genesis_block(Network::Testnet).header.bitcoin_hash());
+		let channel_time = 100;
+
+		{
+			let mut network = router.network_map.write().unwrap();
+			assert_eq!(network.channels.len(), 0);
+			network.channels.insert(channel_key, ChannelInfo {
+				features: ChannelFeatures::empty(),
+				one_to_two: DirectionalChannelInfo {
+					src_node_id: public_key.clone(),
+					last_update: channel_time,
+					enabled: false,
+					cltv_expiry_delta: u16::max_value(),
+					htlc_minimum_msat: 0,
+					fee_base_msat: u32::max_value(),
+					fee_proportional_millionths: u32::max_value(),
+					last_update_message: None,
+				}, two_to_one: DirectionalChannelInfo {
+					src_node_id: our_id.clone(),
+					last_update: channel_time,
+					enabled: true,
+					cltv_expiry_delta: 0,
+					htlc_minimum_msat: 0,
+					fee_base_msat: u32::max_value(),
+					fee_proportional_millionths: 0,
+					last_update_message: None,
+				},
+				announcement_message: None,
+			});
+			assert_eq!(network.channels.len(), 1);
+		}
+
+		let channel_close_msg = HTLCFailChannelUpdate::ChannelClosed {
+			short_channel_id: channel_id,
+			is_permanent: false
+		};
+
+	 	router.handle_htlc_fail_channel_update(&channel_close_msg);
+
+		{
+			// Non-permanent closing just disables a channel
+			let mut network = router.network_map.write().unwrap();
+			match network.channels.get_mut(&channel_key) {
+				None => panic!(),
+				Some(channel_info) => {
+					assert!(!channel_info.one_to_two.enabled);
+					assert!(!channel_info.two_to_one.enabled);
+				}
+			}
+		}
+
+		let channel_close_msg = HTLCFailChannelUpdate::ChannelClosed {
+			short_channel_id: channel_id,
+			is_permanent: true
+		};
+
+		// This triggers a panic on the local node because the channel is pointing
+		// to an unknown node. Should this be handled?
+		// It also panics when a node has a channel to itself, even if node is in the db. I know it's handled
+		// earlier, but maybe it's good idea to add an extra assert in (remove_channel_in_nodes)?
+	 	// router.handle_htlc_fail_channel_update(&channel_close_msg);
+
+		{
+			let mut network = router.network_map.write().unwrap();
+			network.nodes.insert(public_key.clone(), NodeInfo {
+				channels: vec!(channel_key),
+				lowest_inbound_channel_fee_base_msat: u32::max_value(),
+				lowest_inbound_channel_fee_proportional_millionths: 0,
+				features: NodeFeatures::empty(),
+				last_update: Some(1),
+				rgb: [0; 3],
+				alias: [0; 32],
+				addresses: Vec::new(),
+				announcement_message: None,
+			});
+		}
+
+	 	router.handle_htlc_fail_channel_update(&channel_close_msg);
+
+		{
+			// Permanent closing deletes a channel
+			let network = router.network_map.write().unwrap();
+			assert_eq!(network.channels.len(), 0);
+			// Node is also deleted because there are no associated channels
+			assert_eq!(network.nodes.len(), 0);
+		}
+
+		// This message is not implemented yet: causes panic.
+		// let node_failure_msg = HTLCFailChannelUpdate::NodeFailure {
+		// 	node_id: public_key,
+		// 	is_permanent: false
+		// };
+	 	// router.handle_htlc_fail_channel_update(&node_failure_msg);
+	}
+
+
 }