use std::sync::Arc;
use std::{fs, thread};
use std::time::{SystemTime, UNIX_EPOCH};
-use bitcoin::{BlockHash, Network};
+use bitcoin::blockdata::constants::ChainHash;
+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};
Signature::from_compact(&[0u8; 64]).unwrap()
}
-fn genesis_hash() -> BlockHash {
- bitcoin::blockdata::constants::genesis_block(Network::Bitcoin).block_hash()
+fn genesis_hash() -> ChainHash {
+ ChainHash::using_genesis_block(Network::Bitcoin)
}
fn current_time() -> u32 {
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);
});
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);
}
});
});
}
+#[tokio::test]
+async fn test_persistence_runtime() {
+ 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 (_persister, _receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
+
+ tokio::task::spawn_blocking(move || {
+ drop(_persister);
+ }).await.unwrap();
+
+ clean_test_db().await;
+}
+
+
#[tokio::test]
async fn test_trivial_setup() {
let _sanitizer = SchemaSanitizer::new();
println!("last update b: {}", last_update_seen_b);
assert_eq!(last_update_seen_a, update_result - CLIENT_BACKDATE_INTERVAL);
assert_eq!(last_update_seen_b, update_result - CLIENT_BACKDATE_INTERVAL);
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
/// If a channel has only seen updates in one direction, it should not be announced
let client_channel_count = channels.len();
assert_eq!(client_channel_count, 1);
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
+
clean_test_db().await;
}
assert_eq!(serialization.update_count_full, 0);
assert_eq!(serialization.update_count_incremental, 1);
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
+
clean_test_db().await;
}
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
let cache_path = cache_sanitizer.cache_path();
drop(receiver);
persister.persist_gossip().await;
+
+ tokio::task::spawn_blocking(move || {
+ drop(persister);
+ }).await.unwrap();
}
// regenerate snapshots