_ Git - rapid-gossip-sync-server/blob - src/tests/mod.rs

   1 //! Multi-module tests that use database fixtures
   2
   3 use std::cell::RefCell;
   4 use std::sync::Arc;
   5 use std::time::{SystemTime, UNIX_EPOCH};
   6 use bitcoin::{BlockHash, Network};
   7 use bitcoin::secp256k1::ecdsa::Signature;
   8 use bitcoin::secp256k1::{Secp256k1, SecretKey};
   9 use bitcoin::hashes::Hash;
  10 use bitcoin::hashes::hex::ToHex;
  11 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
  12 use lightning::ln::features::ChannelFeatures;
  13 use lightning::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate};
  14 use lightning::routing::gossip::{NetworkGraph, NodeId};
  15 use lightning::util::ser::Writeable;
  16 use lightning_rapid_gossip_sync::RapidGossipSync;
  17 use crate::{config, serialize_delta};
  18 use crate::persistence::GossipPersister;
  19 use crate::types::{GossipMessage, tests::TestLogger};
  20
  21 const CLIENT_BACKDATE_INTERVAL: u32 = 3600 * 24 * 7; // client backdates RGS by a week
  22
  23 thread_local! {
  24         static DB_TEST_SCHEMA: RefCell<Option<String>> = RefCell::new(None);
  25         static IS_TEST_SCHEMA_CLEAN: RefCell<Option<bool>> = RefCell::new(None);
  26 }
  27
  28 fn blank_signature() -> Signature {
  29         Signature::from_compact(&[0u8; 64]).unwrap()
  30 }
  31
  32 fn genesis_hash() -> BlockHash {
  33         bitcoin::blockdata::constants::genesis_block(Network::Bitcoin).block_hash()
  34 }
  35
  36 fn current_time() -> u32 {
  37         SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs() as u32
  38 }
  39
  40 pub(crate) fn db_test_schema() -> String {
  41         DB_TEST_SCHEMA.with(|suffix_reference| {
  42                 let mut suffix_option = suffix_reference.borrow();
  43                 suffix_option.as_ref().unwrap().clone()
  44         })
  45 }
  46
  47 fn generate_announcement(short_channel_id: u64) -> ChannelAnnouncement {
  48         let secp_context = Secp256k1::new();
  49
  50         let random_private_key_1 = SecretKey::from_slice(&[1; 32]).unwrap();
  51         let random_public_key_1 = random_private_key_1.public_key(&secp_context);
  52         let node_id_1 = NodeId::from_pubkey(&random_public_key_1);
  53
  54         let random_private_key_2 = SecretKey::from_slice(&[2; 32]).unwrap();
  55         let random_public_key_2 = random_private_key_2.public_key(&secp_context);
  56         let node_id_2 = NodeId::from_pubkey(&random_public_key_2);
  57
  58         let announcement = UnsignedChannelAnnouncement {
  59                 features: ChannelFeatures::empty(),
  60                 chain_hash: genesis_hash(),
  61                 short_channel_id,
  62                 node_id_1,
  63                 node_id_2,
  64                 bitcoin_key_1: node_id_1,
  65                 bitcoin_key_2: node_id_2,
  66                 excess_data: vec![],
  67         };
  68
  69         let msg_hash = bitcoin::secp256k1::Message::from_slice(&Sha256dHash::hash(&announcement.encode()[..])[..]).unwrap();
  70         let node_signature_1 = secp_context.sign_ecdsa(&msg_hash, &random_private_key_1);
  71         let node_signature_2 = secp_context.sign_ecdsa(&msg_hash, &random_private_key_2);
  72
  73         ChannelAnnouncement {
  74                 node_signature_1,
  75                 node_signature_2,
  76                 bitcoin_signature_1: node_signature_1,
  77                 bitcoin_signature_2: node_signature_2,
  78                 contents: announcement,
  79         }
  80 }
  81
  82 fn generate_update(scid: u64, direction: bool, timestamp: u32, expiry_delta: u16, min_msat: u64, max_msat: u64, base_msat: u32, fee_rate: u32) -> ChannelUpdate {
  83         let flag_mask = if direction { 1 } else { 0 };
  84         ChannelUpdate {
  85                 signature: blank_signature(),
  86                 contents: UnsignedChannelUpdate {
  87                         chain_hash: genesis_hash(),
  88                         short_channel_id: scid,
  89                         timestamp,
  90                         flags: 0 | flag_mask,
  91                         cltv_expiry_delta: expiry_delta,
  92                         htlc_minimum_msat: min_msat,
  93                         htlc_maximum_msat: max_msat,
  94                         fee_base_msat: base_msat,
  95                         fee_proportional_millionths: fee_rate,
  96                         excess_data: vec![],
  97                 },
  98         }
  99 }
 100
 101 struct SchemaSanitizer {}
 102
 103 impl SchemaSanitizer {
 104         fn new() -> Self {
 105                 IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
 106                         let mut is_clean_option = cleanliness_reference.borrow_mut();
 107                         assert!(is_clean_option.is_none());
 108                         *is_clean_option = Some(false);
 109                 });
 110
 111                 DB_TEST_SCHEMA.with(|suffix_reference| {
 112                         let mut suffix_option = suffix_reference.borrow_mut();
 113                         let current_time = SystemTime::now();
 114                         let unix_time = current_time.duration_since(UNIX_EPOCH).expect("Time went backwards");
 115                         let timestamp_seconds = unix_time.as_secs();
 116                         let timestamp_nanos = unix_time.as_nanos();
 117                         let preimage = format!("{}", timestamp_nanos);
 118                         let suffix = Sha256dHash::hash(preimage.as_bytes()).into_inner().to_hex();
 119                         // the schema must start with a letter
 120                         let schema = format!("test_{}_{}", timestamp_seconds, suffix);
 121                         *suffix_option = Some(schema);
 122                 });
 123
 124                 return Self {};
 125         }
 126 }
 127
 128 impl Drop for SchemaSanitizer {
 129         fn drop(&mut self) {
 130                 IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
 131                         let is_clean_option = cleanliness_reference.borrow();
 132                         if let Some(is_clean) = *is_clean_option {
 133                                 assert_eq!(is_clean, true);
 134                         }
 135                 });
 136         }
 137 }
 138
 139
 140 async fn clean_test_db() {
 141         let client = crate::connect_to_db().await;
 142         let schema = db_test_schema();
 143         client.execute(&format!("DROP SCHEMA IF EXISTS {} CASCADE", schema), &[]).await.unwrap();
 144         IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
 145                 let mut is_clean_option = cleanliness_reference.borrow_mut();
 146                 *is_clean_option = Some(true);
 147         });
 148 }
 149
 150 #[tokio::test]
 151 async fn test_trivial_setup() {
 152         let _sanitizer = SchemaSanitizer::new();
 153         let logger = Arc::new(TestLogger::new());
 154         let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 155         let network_graph_arc = Arc::new(network_graph);
 156         let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
 157
 158         let short_channel_id = 1;
 159         let timestamp = current_time() - 10;
 160         println!("timestamp: {}", timestamp);
 161
 162         { // seed the db
 163                 let announcement = generate_announcement(short_channel_id);
 164                 let update_1 = generate_update(short_channel_id, false, timestamp, 0, 0, 0, 5, 0);
 165                 let update_2 = generate_update(short_channel_id, true, timestamp, 0, 0, 0, 10, 0);
 166
 167                 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
 168                 network_graph_arc.update_channel_unsigned(&update_1.contents).unwrap();
 169                 network_graph_arc.update_channel_unsigned(&update_2.contents).unwrap();
 170
 171                 receiver.send(GossipMessage::ChannelAnnouncement(announcement)).await.unwrap();
 172                 receiver.send(GossipMessage::ChannelUpdate(update_1)).await.unwrap();
 173                 receiver.send(GossipMessage::ChannelUpdate(update_2)).await.unwrap();
 174                 drop(receiver);
 175                 persister.persist_gossip().await;
 176         }
 177
 178         let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
 179         logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
 180         clean_test_db().await;
 181
 182         let channel_count = network_graph_arc.read_only().channels().len();
 183
 184         assert_eq!(channel_count, 1);
 185         assert_eq!(serialization.message_count, 3);
 186         assert_eq!(serialization.announcement_count, 1);
 187         assert_eq!(serialization.update_count, 2);
 188
 189         let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 190         let client_graph_arc = Arc::new(client_graph);
 191         let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
 192         let update_result = rgs.update_network_graph(&serialization.data).unwrap();
 193         println!("update result: {}", update_result);
 194         // the update result must be a multiple of our snapshot granularity
 195         assert_eq!(update_result % config::snapshot_generation_interval(), 0);
 196         assert!(update_result < timestamp);
 197
 198         let timestamp_delta = timestamp - update_result;
 199         println!("timestamp delta: {}", timestamp_delta);
 200         assert!(timestamp_delta < config::snapshot_generation_interval());
 201
 202         let readonly_graph = client_graph_arc.read_only();
 203         let channels = readonly_graph.channels();
 204         let client_channel_count = channels.len();
 205         assert_eq!(client_channel_count, 1);
 206
 207         let first_channel = channels.get(&short_channel_id).unwrap();
 208         assert!(&first_channel.announcement_message.is_none());
 209         assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.base_msat, 5);
 210         assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.base_msat, 10);
 211         let last_update_seen_a = first_channel.one_to_two.as_ref().unwrap().last_update;
 212         let last_update_seen_b = first_channel.two_to_one.as_ref().unwrap().last_update;
 213         println!("last update a: {}", last_update_seen_a);
 214         println!("last update b: {}", last_update_seen_b);
 215         assert_eq!(last_update_seen_a, update_result - CLIENT_BACKDATE_INTERVAL);
 216         assert_eq!(last_update_seen_b, update_result - CLIENT_BACKDATE_INTERVAL);
 217 }