Skip to content

Commit 8493258

Browse files
tnulltnull
committed
Switch to upstreamed TestStore 
1 parent 7a2a3bd commit 8493258

File tree

5 files changed

+40
-126
lines changed

5 files changed

+40
-126
lines changed

‎src/event.rs‎

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -798,11 +798,12 @@ where
798798
#[cfg(test)]
799799
mod tests {
800800
use super::*;
801-
use crate::test::utils::{TestLogger, TestStore};
801+
use crate::test::utils::TestLogger;
802+
use lightning::util::test_utils::TestStore;
802803

803804
#[test]
804805
fn event_queue_persistence() {
805-
let store = Arc::new(TestStore::new());
806+
let store = Arc::new(TestStore::new(false));
806807
let logger = Arc::new(TestLogger::new());
807808
let event_queue = EventQueue::new(Arc::clone(&store), Arc::clone(&logger));
808809
assert_eq!(event_queue.next_event(), None);
@@ -813,13 +814,11 @@ mod tests {
813814
counterparty_node_id: None,
814815
};
815816
event_queue.add_event(expected_event.clone()).unwrap();
816-
assert!(store.get_and_clear_did_persist());
817817

818818
// Check we get the expected event and that it is returned until we mark it handled.
819819
for _ in 0..5 {
820820
assert_eq!(event_queue.wait_next_event(), expected_event);
821821
assert_eq!(event_queue.next_event(), Some(expected_event.clone()));
822-
assert_eq!(false, store.get_and_clear_did_persist());
823822
}
824823

825824
// Check we can read back what we persisted.
@@ -833,11 +832,8 @@ mod tests {
833832
let deser_event_queue =
834833
EventQueue::read(&mut &persisted_bytes[..], (Arc::clone(&store), logger)).unwrap();
835834
assert_eq!(deser_event_queue.wait_next_event(), expected_event);
836-
assert!(!store.get_and_clear_did_persist());
837835

838-
// Check we persisted on `event_handled()`
839836
event_queue.event_handled().unwrap();
840-
841-
assert!(store.get_and_clear_did_persist());
837+
assert_eq!(event_queue.next_event(), None);
842838
}
843839
}

‎src/io/test_utils.rs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
11
use crate::io::sqlite_store::SqliteStore;
2-
use crate::test::utils::TestStore;
32
use lightning_persister::fs_store::FilesystemStore;
43

54
use lightning::ln::functional_test_utils::{
@@ -10,7 +9,7 @@ use lightning::util::persist::{read_channel_monitors, KVStore, KVSTORE_NAMESPACE
109

1110
use lightning::chain::channelmonitor::CLOSED_CHANNEL_UPDATE_ID;
1211
use lightning::events::ClosureReason;
13-
use lightning::util::test_utils;
12+
use lightning::util::test_utils::{self, TestStore};
1413
use lightning::{check_added_monitors, check_closed_broadcast, check_closed_event};
1514

1615
use std::panic::RefUnwindSafe;
@@ -197,7 +196,7 @@ impl TestSyncStore {
197196
Some("test_sync_table".to_string()),
198197
)
199198
.unwrap();
200-
let test_store = TestStore::new();
199+
let test_store = TestStore::new(false);
201200
Self { serializer, fs_store, sqlite_store, test_store }
202201
}
203202

‎src/payment_store.rs‎

Lines changed: 22 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -219,18 +219,28 @@ where
219219
#[cfg(test)]
220220
mod tests {
221221
use super::*;
222-
use crate::test::utils::{TestLogger, TestStore};
222+
use crate::test::utils::TestLogger;
223+
use lightning::util::test_utils::TestStore;
223224
use std::sync::Arc;
224225

225226
#[test]
226227
fn payment_info_is_persisted() {
227-
let store = Arc::new(TestStore::new());
228+
let store = Arc::new(TestStore::new(false));
228229
let logger = Arc::new(TestLogger::new());
229230
let payment_store = PaymentStore::new(Vec::new(), Arc::clone(&store), logger);
230231

231232
let hash = PaymentHash([42u8; 32]);
232233
assert!(!payment_store.get(&hash).is_some());
233234

235+
let store_key = hex_utils::to_string(&hash.0);
236+
assert!(store
237+
.read(
238+
PAYMENT_INFO_PERSISTENCE_NAMESPACE,
239+
PAYMENT_INFO_PERSISTENCE_SUB_NAMESPACE,
240+
&store_key
241+
)
242+
.is_err());
243+
234244
let payment = PaymentDetails {
235245
hash,
236246
preimage: None,
@@ -240,18 +250,23 @@ mod tests {
240250
status: PaymentStatus::Pending,
241251
};
242252

243-
assert!(!store.get_and_clear_did_persist());
244-
245253
assert_eq!(Ok(false), payment_store.insert(payment.clone()));
246-
assert!(store.get_and_clear_did_persist());
254+
assert!(payment_store.get(&hash).is_some());
255+
assert!(store
256+
.read(
257+
PAYMENT_INFO_PERSISTENCE_NAMESPACE,
258+
PAYMENT_INFO_PERSISTENCE_SUB_NAMESPACE,
259+
&store_key
260+
)
261+
.is_ok());
247262

248263
assert_eq!(Ok(true), payment_store.insert(payment));
249-
assert!(store.get_and_clear_did_persist());
264+
assert!(payment_store.get(&hash).is_some());
250265

251266
let mut update = PaymentDetailsUpdate::new(hash);
252267
update.status = Some(PaymentStatus::Succeeded);
253268
assert_eq!(Ok(true), payment_store.update(&update));
254-
assert!(store.get_and_clear_did_persist());
269+
assert!(payment_store.get(&hash).is_some());
255270

256271
assert_eq!(PaymentStatus::Succeeded, payment_store.get(&hash).unwrap().status);
257272
}

‎src/peer_store.rs‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -143,13 +143,16 @@ impl_writeable_tlv_based!(PeerInfo, {
143143
#[cfg(test)]
144144
mod tests {
145145
use super::*;
146-
use crate::test::utils::{TestLogger, TestStore};
146+
use crate::test::utils::TestLogger;
147+
148+
use lightning::util::test_utils::TestStore;
149+
147150
use std::str::FromStr;
148151
use std::sync::Arc;
149152

150153
#[test]
151154
fn peer_info_persistence() {
152-
let store = Arc::new(TestStore::new());
155+
let store = Arc::new(TestStore::new(false));
153156
let logger = Arc::new(TestLogger::new());
154157
let peer_store = PeerStore::new(Arc::clone(&store), Arc::clone(&logger));
155158

@@ -159,8 +162,14 @@ mod tests {
159162
.unwrap();
160163
let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
161164
let expected_peer_info = PeerInfo { node_id, address };
165+
assert!(store
166+
.read(
167+
PEER_INFO_PERSISTENCE_NAMESPACE,
168+
PEER_INFO_PERSISTENCE_SUB_NAMESPACE,
169+
PEER_INFO_PERSISTENCE_KEY,
170+
)
171+
.is_err());
162172
peer_store.add_peer(expected_peer_info.clone()).unwrap();
163-
assert!(store.get_and_clear_did_persist());
164173

165174
// Check we can read back what we persisted.
166175
let persisted_bytes = store
@@ -177,6 +186,5 @@ mod tests {
177186
assert_eq!(peers.len(), 1);
178187
assert_eq!(peers[0], expected_peer_info);
179188
assert_eq!(deser_peer_store.get_peer(&node_id), Some(expected_peer_info));
180-
assert!(!store.get_and_clear_did_persist());
181189
}
182190
}

‎src/test/utils.rs‎

Lines changed: 0 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,7 @@
11
use crate::builder::NodeBuilder;
22
use crate::io::test_utils::TestSyncStore;
3-
use crate::io::utils::check_namespace_key_validity;
43
use crate::{Config, Node};
54
use lightning::util::logger::{Level, Logger, Record};
6-
use lightning::util::persist::KVStore;
75

86
use bitcoin::{Address, Amount, Network, OutPoint, Txid};
97

@@ -16,12 +14,9 @@ use regex;
1614

1715
use rand::distributions::Alphanumeric;
1816
use rand::{thread_rng, Rng};
19-
use std::collections::hash_map;
2017
use std::collections::HashMap;
2118
use std::env;
22-
use std::io::{self, Write};
2319
use std::path::PathBuf;
24-
use std::sync::atomic::{AtomicBool, Ordering};
2520
use std::sync::Arc;
2621
use std::sync::Mutex;
2722
use std::time::Duration;
@@ -42,105 +37,6 @@ macro_rules! expect_event {
4237

4338
pub(crate) use expect_event;
4439

45-
pub(crate) struct TestStore {
46-
persisted_bytes: Mutex<HashMap<String, HashMap<String, Vec<u8>>>>,
47-
did_persist: Arc<AtomicBool>,
48-
}
49-
50-
impl TestStore {
51-
pub fn new() -> Self {
52-
let persisted_bytes = Mutex::new(HashMap::new());
53-
let did_persist = Arc::new(AtomicBool::new(false));
54-
55-
Self { persisted_bytes, did_persist }
56-
}
57-
58-
pub fn get_and_clear_did_persist(&self) -> bool {
59-
self.did_persist.swap(false, Ordering::Relaxed)
60-
}
61-
}
62-
63-
impl KVStore for TestStore {
64-
fn read(
65-
&self, primary_namespace: &str, secondary_namespace: &str, key: &str,
66-
) -> io::Result<Vec<u8>> {
67-
check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "read")?;
68-
let persisted_lock = self.persisted_bytes.lock().unwrap();
69-
let prefixed = if secondary_namespace.is_empty() {
70-
primary_namespace.to_string()
71-
} else {
72-
format!("{}/{}", primary_namespace, secondary_namespace)
73-
};
74-
75-
if let Some(outer_ref) = persisted_lock.get(&prefixed) {
76-
if let Some(inner_ref) = outer_ref.get(key) {
77-
let bytes = inner_ref.clone();
78-
Ok(bytes)
79-
} else {
80-
Err(io::Error::new(io::ErrorKind::NotFound, "Key not found"))
81-
}
82-
} else {
83-
Err(io::Error::new(io::ErrorKind::NotFound, "Namespace not found"))
84-
}
85-
}
86-
87-
fn write(
88-
&self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8],
89-
) -> io::Result<()> {
90-
check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "write")?;
91-
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
92-
93-
let prefixed = if secondary_namespace.is_empty() {
94-
primary_namespace.to_string()
95-
} else {
96-
format!("{}/{}", primary_namespace, secondary_namespace)
97-
};
98-
let outer_e = persisted_lock.entry(prefixed).or_insert(HashMap::new());
99-
let mut bytes = Vec::new();
100-
bytes.write_all(buf)?;
101-
outer_e.insert(key.to_string(), bytes);
102-
103-
self.did_persist.store(true, Ordering::SeqCst);
104-
105-
Ok(())
106-
}
107-
108-
fn remove(
109-
&self, primary_namespace: &str, secondary_namespace: &str, key: &str, _lazy: bool,
110-
) -> io::Result<()> {
111-
check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "remove")?;
112-
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
113-
114-
let prefixed = if secondary_namespace.is_empty() {
115-
primary_namespace.to_string()
116-
} else {
117-
format!("{}/{}", primary_namespace, secondary_namespace)
118-
};
119-
if let Some(outer_ref) = persisted_lock.get_mut(&prefixed) {
120-
outer_ref.remove(&key.to_string());
121-
}
122-
123-
self.did_persist.store(true, Ordering::SeqCst);
124-
125-
Ok(())
126-
}
127-
128-
fn list(&self, primary_namespace: &str, secondary_namespace: &str) -> io::Result<Vec<String>> {
129-
check_namespace_key_validity(primary_namespace, secondary_namespace, None, "list")?;
130-
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
131-
132-
let prefixed = if secondary_namespace.is_empty() {
133-
primary_namespace.to_string()
134-
} else {
135-
format!("{}/{}", primary_namespace, secondary_namespace)
136-
};
137-
match persisted_lock.entry(prefixed) {
138-
hash_map::Entry::Occupied(e) => Ok(e.get().keys().cloned().collect()),
139-
hash_map::Entry::Vacant(_) => Ok(Vec::new()),
140-
}
141-
}
142-
}
143-
14440
// Copied over from upstream LDK
14541
#[allow(dead_code)]
14642
pub struct TestLogger {

0 commit comments

Comments
 (0)