Update test to reflect new reminder mechanics.

[rapid-gossip-sync-server] / src / tests / mod.rs

diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index ef25ef0782d947c1e591a1cd348c6b39c1e80fb4..33edf62d19e1965d8c41eabd7abc99c714d292a3 100644 (file)
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -9,8 +9,8 @@ use bitcoin::Network;
 use bitcoin::secp256k1::ecdsa::Signature;
 use bitcoin::secp256k1::{Secp256k1, SecretKey};
 use bitcoin::hashes::Hash;
-use bitcoin::hashes::hex::ToHex;
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+use hex_conservative::DisplayHex;
 use lightning::ln::features::ChannelFeatures;
 use lightning::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate};
 use lightning::routing::gossip::{NetworkGraph, NodeId};
@@ -121,9 +121,9 @@ impl SchemaSanitizer {
                        let thread_id = thread::current().id();
                        let preimage = format!("{:?}-{}", thread_id, timestamp_nanos);
                        println!("test schema preimage: {}", preimage);
-                       let suffix = Sha256dHash::hash(preimage.as_bytes()).into_inner().to_hex();
+                       let suffix = Sha256dHash::hash(preimage.as_bytes()).encode();
                        // the schema must start with a letter
-                       let schema = format!("test_{}_{}", timestamp_seconds, suffix);
+                       let schema = format!("test_{}_{}", timestamp_seconds, suffix.as_hex());
                        *suffix_option = Some(schema);
                });
 
@@ -136,6 +136,9 @@ impl Drop for SchemaSanitizer {
                IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
                        let is_clean_option = cleanliness_reference.borrow();
                        if let Some(is_clean) = *is_clean_option {
+                               if std::thread::panicking() {
+                                       return;
+                               }
                                assert_eq!(is_clean, true);
                        }
                });
@@ -388,6 +391,90 @@ async fn test_bidirectional_intermediate_update_consideration() {
        clean_test_db().await;
 }
 
+#[tokio::test]
+async fn test_channel_reminders() {
+       let _sanitizer = SchemaSanitizer::new();
+
+       let logger = Arc::new(TestLogger::new());
+       let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
+       let network_graph_arc = Arc::new(network_graph);
+       let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
+
+       let timestamp = current_time();
+       println!("timestamp: {}", timestamp);
+       let channel_reminder_delta = config::CHANNEL_REMINDER_AGE.as_secs() as u32;
+
+       { // seed the db
+               { // unupdated channel
+                       let short_channel_id = 1;
+                       let announcement = generate_announcement(short_channel_id);
+                       let update_1 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta - 1, 0, 0, 0, 5, 0);
+                       let update_2 = generate_update(short_channel_id, true, timestamp - channel_reminder_delta - 1, 0, 0, 0, 3, 0);
+
+                       network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
+                       network_graph_arc.update_channel_unsigned(&update_1.contents).unwrap();
+                       network_graph_arc.update_channel_unsigned(&update_2.contents).unwrap();
+
+                       receiver.send(GossipMessage::ChannelAnnouncement(announcement, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_1, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_2, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+               }
+               { // unmodified but updated channel
+                       let short_channel_id = 2;
+                       let announcement = generate_announcement(short_channel_id);
+                       let update_1 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta - 10, 0, 0, 0, 5, 0);
+                       // in the false direction, we have one update that's different prior
+                       let update_2 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta - 5, 0, 1, 0, 5, 0);
+                       let update_3 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta - 1, 0, 0, 0, 5, 0);
+                       let update_4 = generate_update(short_channel_id, true, timestamp - channel_reminder_delta - 1, 0, 0, 0, 3, 0);
+                       let update_5 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta + 10, 0, 0, 0, 5, 0);
+                       let update_6 = generate_update(short_channel_id, true, timestamp - channel_reminder_delta + 10, 0, 0, 0, 3, 0);
+                       let update_7 = generate_update(short_channel_id, false, timestamp - channel_reminder_delta + 20, 0, 0, 0, 5, 0);
+                       let update_8 = generate_update(short_channel_id, true, timestamp - channel_reminder_delta + 20, 0, 0, 0, 3, 0);
+
+                       network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
+                       network_graph_arc.update_channel_unsigned(&update_7.contents).unwrap();
+                       network_graph_arc.update_channel_unsigned(&update_8.contents).unwrap();
+
+                       receiver.send(GossipMessage::ChannelAnnouncement(announcement, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_1, Some(timestamp - channel_reminder_delta - 10))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_2, Some(timestamp - channel_reminder_delta - 5))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_3, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_4, Some(timestamp - channel_reminder_delta - 1))).await.unwrap();
+
+                       receiver.send(GossipMessage::ChannelUpdate(update_5, Some(timestamp - channel_reminder_delta + 10))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_6, Some(timestamp - channel_reminder_delta + 10))).await.unwrap();
+
+                       receiver.send(GossipMessage::ChannelUpdate(update_7, Some(timestamp - channel_reminder_delta + 20))).await.unwrap();
+                       receiver.send(GossipMessage::ChannelUpdate(update_8, Some(timestamp - channel_reminder_delta + 20))).await.unwrap();
+               }
+               drop(receiver);
+               persister.persist_gossip().await;
+       }
+
+       let channel_count = network_graph_arc.read_only().channels().len();
+       assert_eq!(channel_count, 2);
+
+       let serialization = serialize_delta(network_graph_arc.clone(), timestamp - channel_reminder_delta + 15, logger.clone()).await;
+
+       logger.assert_log_contains("rapid_gossip_sync_server::lookup", "Fetched 0 update rows of the first update in a new direction", 1);
+       logger.assert_log_contains("rapid_gossip_sync_server::lookup", "Fetched 4 update rows of the latest update in the less recently updated direction", 1);
+       logger.assert_log_contains("rapid_gossip_sync_server::lookup", "Processed 2 reference rows", 1);
+       logger.assert_log_contains("rapid_gossip_sync_server::lookup", "Processed intermediate rows (2)", 1);
+
+       assert_eq!(serialization.message_count, 4);
+       assert_eq!(serialization.announcement_count, 0);
+       assert_eq!(serialization.update_count, 4);
+       assert_eq!(serialization.update_count_full, 0);
+       assert_eq!(serialization.update_count_incremental, 4);
+
+       tokio::task::spawn_blocking(move || {
+               drop(persister);
+       }).await.unwrap();
+
+       clean_test_db().await;
+}
+
 #[tokio::test]
 async fn test_full_snapshot_recency() {
        let _sanitizer = SchemaSanitizer::new();