14175090533

Committed 31 Mar 2025 03:17PM UTC coverage: 81.754% (+0.1%) from 81.653%

Build # 14175090533

Build Type

push

github

Committed by

web-flow

Commit Message

Move testing constants to payjoin-test-utils (#613)

Pull out the test constant commit from #586 into its own PR

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

138 existing lines in 11 files now uncovered.

5211 of 6374 relevant lines covered (81.75%)

725.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.38

/payjoin-cli/src/db/v2.rs

use std::sync::Arc;

use bitcoincore_rpc::jsonrpc::serde_json;
use payjoin::persist::{Persister, Value};
use payjoin::receive::v2::{Receiver, ReceiverToken};
use payjoin::send::v2::{Sender, SenderToken};
use sled::Tree;
use url::Url;

use super::*;

pub(crate) struct SenderPersister(Arc<Database>);
impl SenderPersister {
    pub fn new(db: Arc<Database>) -> Self { Self(db) }
}

impl Persister<Sender> for SenderPersister {
    type Token = SenderToken;
    type Error = crate::db::error::Error;
    fn save(&mut self, value: Sender) -> std::result::Result<SenderToken, Self::Error> {
        let send_tree = self.0 .0.open_tree("send_sessions")?;
        let key = value.key();
        let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;
        send_tree.insert(key.clone(), value.as_slice())?;
        send_tree.flush()?;
        Ok(key)
    }

    fn load(&self, key: SenderToken) -> std::result::Result<Sender, Self::Error> {
        let send_tree = self.0 .0.open_tree("send_sessions")?;
        let value = send_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;
        serde_json::from_slice(&value).map_err(Error::Deserialize)
    }
}

pub(crate) struct ReceiverPersister(Arc<Database>);
impl ReceiverPersister {
    pub fn new(db: Arc<Database>) -> Self { Self(db) }
}

impl Persister<Receiver> for ReceiverPersister {
    type Token = ReceiverToken;
    type Error = crate::db::error::Error;
    fn save(&mut self, value: Receiver) -> std::result::Result<ReceiverToken, Self::Error> {
        let recv_tree = self.0 .0.open_tree("recv_sessions")?;
        let key = value.key();
        let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;
        recv_tree.insert(key.clone(), value.as_slice())?;
        recv_tree.flush()?;
        Ok(key)
    }
    fn load(&self, key: ReceiverToken) -> std::result::Result<Receiver, Self::Error> {
        let recv_tree = self.0 .0.open_tree("recv_sessions")?;
        let value = recv_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;
        serde_json::from_slice(&value).map_err(Error::Deserialize)
    }
}

impl Database {
    pub(crate) fn get_recv_sessions(&self) -> Result<Vec<Receiver>> {
        let recv_tree = self.0.open_tree("recv_sessions")?;
        let mut sessions = Vec::new();
        for item in recv_tree.iter() {
            let (_, value) = item?;
            let session: Receiver = serde_json::from_slice(&value).map_err(Error::Deserialize)?;
            sessions.push(session);
        }
        Ok(sessions)
    }

    pub(crate) fn clear_recv_session(&self) -> Result<()> {
        let recv_tree: Tree = self.0.open_tree("recv_sessions")?;
        recv_tree.clear()?;
        recv_tree.flush()?;
        Ok(())
    }

    pub(crate) fn get_send_sessions(&self) -> Result<Vec<Sender>> {
        let send_tree: Tree = self.0.open_tree("send_sessions")?;
        let mut sessions = Vec::new();
        for item in send_tree.iter() {
            let (_, value) = item?;
            let session: Sender = serde_json::from_slice(&value).map_err(Error::Deserialize)?;
            sessions.push(session);
        }
        Ok(sessions)
    }

    pub(crate) fn get_send_session(&self, pj_url: &Url) -> Result<Option<Sender>> {
        let send_tree = self.0.open_tree("send_sessions")?;
        if let Some(val) = send_tree.get(pj_url.as_str())? {
            let session: Sender = serde_json::from_slice(&val).map_err(Error::Deserialize)?;
            Ok(Some(session))
        } else {
            Ok(None)
        }
    }

    pub(crate) fn clear_send_session(&self, pj_url: &Url) -> Result<()> {
        let send_tree: Tree = self.0.open_tree("send_sessions")?;
        send_tree.remove(pj_url.as_str())?;
        send_tree.flush()?;
        Ok(())
    }
}

1	use std::sync::Arc;
2
3	use bitcoincore_rpc::jsonrpc::serde_json;
4	use payjoin::persist::{Persister, Value};
5	use payjoin::receive::v2::{Receiver, ReceiverToken};
6	use payjoin::send::v2::{Sender, SenderToken};
7	use sled::Tree;
8	use url::Url;
9
10	use super::*;
11
12	pub(crate) struct SenderPersister(Arc<Database>);
13	impl SenderPersister {
14	pub fn new(db: Arc<Database>) -> Self { Self(db) }	1✔
15	}
16
17	impl Persister<Sender> for SenderPersister {
18	type Token = SenderToken;
19	type Error = crate::db::error::Error;
20	fn save(&mut self, value: Sender) -> std::result::Result<SenderToken, Self::Error> {	1✔
21	let send_tree = self.0 .0.open_tree("send_sessions")?;	1✔
22	let key = value.key();	1✔
23	let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;	1✔
24	send_tree.insert(key.clone(), value.as_slice())?;	1✔
25	send_tree.flush()?;	1✔
26	Ok(key)	1✔
27	}	1✔
28
29	fn load(&self, key: SenderToken) -> std::result::Result<Sender, Self::Error> {	1✔
30	let send_tree = self.0 .0.open_tree("send_sessions")?;	1✔
31	let value = send_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;	1✔
32	serde_json::from_slice(&value).map_err(Error::Deserialize)	1✔
33	}	1✔
34	}
35
36	pub(crate) struct ReceiverPersister(Arc<Database>);
37	impl ReceiverPersister {
38	pub fn new(db: Arc<Database>) -> Self { Self(db) }	1✔
39	}
40
41	impl Persister<Receiver> for ReceiverPersister {
42	type Token = ReceiverToken;
43	type Error = crate::db::error::Error;
44	fn save(&mut self, value: Receiver) -> std::result::Result<ReceiverToken, Self::Error> {	1✔
45	let recv_tree = self.0 .0.open_tree("recv_sessions")?;	1✔
46	let key = value.key();	1✔
47	let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;	1✔
48	recv_tree.insert(key.clone(), value.as_slice())?;	1✔
49	recv_tree.flush()?;	1✔
50	Ok(key)	1✔
51	}	1✔
52	fn load(&self, key: ReceiverToken) -> std::result::Result<Receiver, Self::Error> {	1✔
53	let recv_tree = self.0 .0.open_tree("recv_sessions")?;	1✔
54	let value = recv_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;	1✔
55	serde_json::from_slice(&value).map_err(Error::Deserialize)	1✔
56	}	1✔
57	}
58
59	impl Database {
60	pub(crate) fn get_recv_sessions(&self) -> Result<Vec<Receiver>> {	1✔
61	let recv_tree = self.0.open_tree("recv_sessions")?;	1✔
62	let mut sessions = Vec::new();	1✔
63	for item in recv_tree.iter() {	1✔
64	let (_, value) = item?;	1✔
65	let session: Receiver = serde_json::from_slice(&value).map_err(Error::Deserialize)?;	1✔
66	sessions.push(session);	1✔
67	}
68	Ok(sessions)	1✔
69	}	1✔
70
71	pub(crate) fn clear_recv_session(&self) -> Result<()> {	1✔
72	let recv_tree: Tree = self.0.open_tree("recv_sessions")?;	1✔
73	recv_tree.clear()?;	1✔
74	recv_tree.flush()?;	1✔
75	Ok(())	1✔
76	}	1✔
77
78	pub(crate) fn get_send_sessions(&self) -> Result<Vec<Sender>> {	1✔
79	let send_tree: Tree = self.0.open_tree("send_sessions")?;	1✔
80	let mut sessions = Vec::new();	1✔
81	for item in send_tree.iter() {	1✔
UNCOV 82	let (_, value) = item?;	×
UNCOV 83	let session: Sender = serde_json::from_slice(&value).map_err(Error::Deserialize)?;	×
UNCOV 84	sessions.push(session);	×
85	}
86	Ok(sessions)	1✔
87	}	1✔
88
89	pub(crate) fn get_send_session(&self, pj_url: &Url) -> Result<Option<Sender>> {	2✔
90	let send_tree = self.0.open_tree("send_sessions")?;	2✔
91	if let Some(val) = send_tree.get(pj_url.as_str())? {	2✔
92	let session: Sender = serde_json::from_slice(&val).map_err(Error::Deserialize)?;	1✔
93	Ok(Some(session))	1✔
94	} else {
95	Ok(None)	1✔
96	}
97	}	2✔
98
99	pub(crate) fn clear_send_session(&self, pj_url: &Url) -> Result<()> {	1✔
100	let send_tree: Tree = self.0.open_tree("send_sessions")?;	1✔
101	send_tree.remove(pj_url.as_str())?;	1✔
102	send_tree.flush()?;	1✔
103	Ok(())	1✔
104	}	1✔
105	}

payjoin / rust-payjoin / 14175090533

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous