if let Some((find_route_query, find_route_res)) = self.next_routes.lock().unwrap().pop_front() {
assert_eq!(find_route_query, *params);
if let Ok(ref route) = find_route_res {
+ assert_eq!(route.route_params.as_ref().unwrap().final_value_msat, find_route_query.final_value_msat);
let scorer = self.scorer.read().unwrap();
let scorer = ScorerAccountingForInFlightHtlcs::new(scorer, &inflight_htlcs);
for path in &route.paths {
}
}
impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
- fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<TestChannelSigner>) -> chain::ChannelMonitorUpdateStatus {
+ fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<TestChannelSigner>) -> Result<chain::ChannelMonitorUpdateStatus, ()> {
// At every point where we get a monitor update, we should be able to send a useful monitor
// to a watchtower and disk...
let mut w = TestVecWriter(Vec::new());
}
}
-pub(crate) struct TestStore {
+pub struct TestStore {
persisted_bytes: Mutex<HashMap<String, HashMap<String, Vec<u8>>>>,
read_only: bool,
}
}
impl KVStore for TestStore {
- fn read(&self, namespace: &str, sub_namespace: &str, key: &str) -> io::Result<Vec<u8>> {
+ fn read(&self, primary_namespace: &str, secondary_namespace: &str, key: &str) -> io::Result<Vec<u8>> {
let persisted_lock = self.persisted_bytes.lock().unwrap();
- let prefixed = if sub_namespace.is_empty() {
- namespace.to_string()
+ let prefixed = if secondary_namespace.is_empty() {
+ primary_namespace.to_string()
} else {
- format!("{}/{}", namespace, sub_namespace)
+ format!("{}/{}", primary_namespace, secondary_namespace)
};
if let Some(outer_ref) = persisted_lock.get(&prefixed) {
}
}
- fn write(&self, namespace: &str, sub_namespace: &str, key: &str, buf: &[u8]) -> io::Result<()> {
+ fn write(&self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8]) -> io::Result<()> {
if self.read_only {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
}
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
- let prefixed = if sub_namespace.is_empty() {
- namespace.to_string()
+ let prefixed = if secondary_namespace.is_empty() {
+ primary_namespace.to_string()
} else {
- format!("{}/{}", namespace, sub_namespace)
+ format!("{}/{}", primary_namespace, secondary_namespace)
};
let outer_e = persisted_lock.entry(prefixed).or_insert(HashMap::new());
let mut bytes = Vec::new();
Ok(())
}
- fn remove(&self, namespace: &str, sub_namespace: &str, key: &str, _lazy: bool) -> io::Result<()> {
+ fn remove(&self, primary_namespace: &str, secondary_namespace: &str, key: &str, _lazy: bool) -> io::Result<()> {
if self.read_only {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
- let prefixed = if sub_namespace.is_empty() {
- namespace.to_string()
+ let prefixed = if secondary_namespace.is_empty() {
+ primary_namespace.to_string()
} else {
- format!("{}/{}", namespace, sub_namespace)
+ format!("{}/{}", primary_namespace, secondary_namespace)
};
if let Some(outer_ref) = persisted_lock.get_mut(&prefixed) {
outer_ref.remove(&key.to_string());
Ok(())
}
- fn list(&self, namespace: &str, sub_namespace: &str) -> io::Result<Vec<String>> {
+ fn list(&self, primary_namespace: &str, secondary_namespace: &str) -> io::Result<Vec<String>> {
let mut persisted_lock = self.persisted_bytes.lock().unwrap();
- let prefixed = if sub_namespace.is_empty() {
- namespace.to_string()
+ let prefixed = if secondary_namespace.is_empty() {
+ primary_namespace.to_string()
} else {
- format!("{}/{}", namespace, sub_namespace)
+ format!("{}/{}", primary_namespace, secondary_namespace)
};
match persisted_lock.entry(prefixed) {
hash_map::Entry::Occupied(e) => Ok(e.get().keys().cloned().collect()),