1 //! Multi-module tests that use database fixtures
3 use std::cell::RefCell;
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};
21 const CLIENT_BACKDATE_INTERVAL: u32 = 3600 * 24 * 7; // client backdates RGS by a week
24 static DB_TEST_SCHEMA: RefCell<Option<String>> = RefCell::new(None);
25 static IS_TEST_SCHEMA_CLEAN: RefCell<Option<bool>> = RefCell::new(None);
28 fn blank_signature() -> Signature {
29 Signature::from_compact(&[0u8; 64]).unwrap()
32 fn genesis_hash() -> BlockHash {
33 bitcoin::blockdata::constants::genesis_block(Network::Bitcoin).block_hash()
36 fn current_time() -> u32 {
37 SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs() as u32
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()
47 fn generate_announcement(short_channel_id: u64) -> ChannelAnnouncement {
48 let secp_context = Secp256k1::new();
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);
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);
58 let announcement = UnsignedChannelAnnouncement {
59 features: ChannelFeatures::empty(),
60 chain_hash: genesis_hash(),
64 bitcoin_key_1: node_id_1,
65 bitcoin_key_2: node_id_2,
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);
76 bitcoin_signature_1: node_signature_1,
77 bitcoin_signature_2: node_signature_2,
78 contents: announcement,
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 };
85 signature: blank_signature(),
86 contents: UnsignedChannelUpdate {
87 chain_hash: genesis_hash(),
88 short_channel_id: scid,
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,
101 struct SchemaSanitizer {}
103 impl SchemaSanitizer {
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);
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);
128 impl Drop for SchemaSanitizer {
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);
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);
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());
158 let short_channel_id = 1;
159 let timestamp = current_time() - 10;
160 println!("timestamp: {}", timestamp);
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);
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();
171 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
172 receiver.send(GossipMessage::ChannelUpdate(update_1, None)).await.unwrap();
173 receiver.send(GossipMessage::ChannelUpdate(update_2, None)).await.unwrap();
175 persister.persist_gossip().await;
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;
182 let channel_count = network_graph_arc.read_only().channels().len();
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);
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);
198 let timestamp_delta = timestamp - update_result;
199 println!("timestamp delta: {}", timestamp_delta);
200 assert!(timestamp_delta < config::snapshot_generation_interval());
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);
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);