495034978

Build Type

github

Committed by GitHub

Commit Message

Merge 193581a71 into 25bc54a8a

Pull Request Pull Request #231: refactor(lib): allow get/delete account by id, alias, index or address

Run Details

4866 of 22864 branches covered (21.28%)

Branch coverage included in aggregate %.

124 of 156 new or added lines in 8 files covered. (79.49%)

2 existing lines in 2 files now uncovered.

1776 of 3513 relevant lines covered (50.56%)

499.46 hits per line

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

45.45

/src/event.rs

// Copyright 2020 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use crate::{address::Address, message::Message};

use getset::Getters;
use once_cell::sync::Lazy;
use serde::Serialize;
use std::{
    ops::Deref,
    sync::{Arc, Mutex},
};

/// The balance change event data.
#[derive(Getters, Serialize)]
#[getset(get = "pub")]
pub struct BalanceEvent<'a> {
    /// The associated account identifier.
    #[serde(rename = "accountId")]
    account_id: &'a str,
    /// The associated address.
    address: &'a Address,
    /// The new balance.
    balance: u64,
}

impl<'a> BalanceEvent<'a> {
    #[doc(hidden)]
    pub fn cloned_address(&self) -> Address {
        self.address.clone()
    }
}

/// A transaction-related event data.
#[derive(Getters, Serialize)]
#[getset(get = "pub")]
pub struct TransactionEvent<'a> {
    #[serde(rename = "accountId")]
    /// The associated account identifier.
    account_id: &'a str,
    /// The event message.
    message: &'a Message,
}

impl<'a> TransactionEvent<'a> {
    #[doc(hidden)]
    pub fn cloned_message(&self) -> Message {
        self.message.clone()
    }
}

/// A transaction-related event data.
#[derive(Getters, Serialize)]
#[getset(get = "pub")]
pub struct TransactionConfirmationChangeEvent<'a> {
    #[serde(rename = "accountId")]
    /// The associated account identifier.
    account_id: &'a str,
    /// The event message.
    message: &'a Message,
    /// The confirmed state of the transaction.
    confirmed: bool,
}

impl<'a> TransactionConfirmationChangeEvent<'a> {
    #[doc(hidden)]
    pub fn cloned_message(&self) -> Message {
        self.message.clone()
    }
}

struct BalanceEventHandler {
    /// The on event callback.
    on_event: Box<dyn Fn(&BalanceEvent<'_>) + Send>,
}

struct ErrorHandler {
    /// The on error callback.
    on_error: Box<dyn Fn(&crate::Error) + Send>,
}

#[derive(PartialEq)]
pub(crate) enum TransactionEventType {
    NewTransaction,
    Reattachment,
    Broadcast,
}

struct TransactionEventHandler {
    event_type: TransactionEventType,
    /// The on event callback.
    on_event: Box<dyn Fn(&TransactionEvent<'_>) + Send>,
}

struct TransactionConfirmationChangeEventHandler {
    /// The on event callback.
    on_event: Box<dyn Fn(&TransactionConfirmationChangeEvent<'_>) + Send>,
}

type BalanceListeners = Arc<Mutex<Vec<BalanceEventHandler>>>;
type TransactionListeners = Arc<Mutex<Vec<TransactionEventHandler>>>;
type TransactionConfirmationChangeListeners = Arc<Mutex<Vec<TransactionConfirmationChangeEventHandler>>>;
type ErrorListeners = Arc<Mutex<Vec<ErrorHandler>>>;

/// Gets the balance change listeners array.
fn balance_listeners() -> &'static BalanceListeners {
    static LISTENERS: Lazy<BalanceListeners> = Lazy::new(Default::default);
    &LISTENERS
}

/// Gets the transaction listeners array.
fn transaction_listeners() -> &'static TransactionListeners {
    static LISTENERS: Lazy<TransactionListeners> = Lazy::new(Default::default);
    &LISTENERS
}

/// Gets the transaction confirmation change listeners array.
fn transaction_confirmation_change_listeners() -> &'static TransactionConfirmationChangeListeners {
    static LISTENERS: Lazy<TransactionConfirmationChangeListeners> = Lazy::new(Default::default);
    &LISTENERS
}

/// Gets the balance change listeners array.
fn error_listeners() -> &'static ErrorListeners {
    static LISTENERS: Lazy<ErrorListeners> = Lazy::new(Default::default);
    &LISTENERS
}

/// Listen to balance changes.
pub fn on_balance_change<F: Fn(&BalanceEvent<'_>) + Send + 'static>(cb: F) {
    let mut l = balance_listeners()
        .lock()
        .expect("Failed to lock balance_listeners: on_balance_change()");
    l.push(BalanceEventHandler { on_event: Box::new(cb) })
}

/// Emits a balance change event.
pub(crate) fn emit_balance_change(account_id: &str, address: &Address, balance: u64) {
    let listeners = balance_listeners()
        .lock()
        .expect("Failed to lock balance_listeners: emit_balance_change()");
    let event = BalanceEvent {
        account_id,
        address: &address,
        balance,
    };
    for listener in listeners.deref() {
        (listener.on_event)(&event);
    }
}

/// Emits a transaction-related event.
pub(crate) fn emit_transaction_event(event_type: TransactionEventType, account_id: &str, message: &Message) {
    let listeners = transaction_listeners()
        .lock()
        .expect("Failed to lock balance_listeners: emit_balance_change()");
    let event = TransactionEvent {
        account_id,
        message: &message,
    };
    for listener in listeners.deref() {
        if listener.event_type == event_type {
            (listener.on_event)(&event);
        }
    }
}

/// Emits a transaction confirmation state change event.
pub(crate) fn emit_confirmation_state_change(account_id: &str, message: &Message, confirmed: bool) {
    let listeners = transaction_confirmation_change_listeners()
        .lock()
        .expect("Failed to lock transaction_confirmation_change_listeners: emit_confirmation_state_change()");
    let event = TransactionConfirmationChangeEvent {
        account_id,
        message: &message,
        confirmed,
    };
    for listener in listeners.deref() {
        (listener.on_event)(&event);
    }
}

/// Adds a transaction-related event listener.
fn add_transaction_listener<F: Fn(&TransactionEvent<'_>) + Send + 'static>(event_type: TransactionEventType, cb: F) {
    let mut l = transaction_listeners()
        .lock()
        .expect("Failed to lock transaction_listeners: add_transaction_listener()");
    l.push(TransactionEventHandler {
        event_type,
        on_event: Box::new(cb),
    })
}

/// Listen to new messages.
pub fn on_new_transaction<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
    add_transaction_listener(TransactionEventType::NewTransaction, cb);
}

/// Listen to transaction confirmation state change.
pub fn on_confirmation_state_change<F: Fn(&TransactionConfirmationChangeEvent<'_>) + Send + 'static>(cb: F) {
    let mut l = transaction_confirmation_change_listeners()
        .lock()
        .expect("Failed to lock transaction_confirmation_change_listeners: on_confirmation_state_change()");
    l.push(TransactionConfirmationChangeEventHandler { on_event: Box::new(cb) })
}

/// Listen to transaction reattachment.
pub fn on_reattachment<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
    add_transaction_listener(TransactionEventType::Reattachment, cb);
}

/// Listen to transaction broadcast.
pub fn on_broadcast<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
    add_transaction_listener(TransactionEventType::Broadcast, cb);
}

pub(crate) fn emit_error(error: &crate::Error) {
    let listeners = error_listeners()
        .lock()
        .expect("Failed to lock error_listeners: emit_error()");
    for listener in listeners.deref() {
        (listener.on_error)(&error)
    }
}

/// Listen to errors.
pub fn on_error<F: Fn(&crate::Error) + Send + 'static>(cb: F) {
    let mut l = error_listeners()
        .lock()
        .expect("Failed to lock error_listeners: on_error()");
    l.push(ErrorHandler { on_error: Box::new(cb) })
}

#[cfg(test)]
mod tests {
    use super::{emit_balance_change, on_balance_change, on_error};
    use crate::address::{AddressBuilder, AddressWrapper, IotaAddress};
    use iota::message::prelude::Ed25519Address;
    use rusty_fork::rusty_fork_test;

    fn _create_and_drop_error() {
        let _ = crate::Error::AccountNotFound;
    }

    // have to fork this test so other errors dropped doesn't affect it
    rusty_fork_test! {
        #[test]
        fn error_events() {
            on_error(|error| {
                assert!(matches!(error, crate::Error::AccountNotFound));
            });
            _create_and_drop_error();
        }
    }

    #[test]
    fn balance_events() {
        on_balance_change(|event| {
            assert!(event.account_id == hex::encode([1; 32]));
            assert!(event.balance == 0);
        });

        emit_balance_change(
            &hex::encode([1; 32]),
            &AddressBuilder::new()
                .address(AddressWrapper::new(
                    IotaAddress::Ed25519(Ed25519Address::new([0; 32])),
                    "iota".to_string(),
                ))
                .balance(0)
                .key_index(0)
                .outputs(vec![])
                .build()
                .expect("failed to build address"),
            0,
        );
    }
}

1	// Copyright 2020 IOTA Stiftung
2	// SPDX-License-Identifier: Apache-2.0
3
4	use crate::{address::Address, message::Message};
5
6	use getset::Getters;
7	use once_cell::sync::Lazy;
8	use serde::Serialize;
9	use std::{
10	ops::Deref,
11	sync::{Arc, Mutex},
12	};
13
14	/// The balance change event data.
15	#[derive(Getters, Serialize)]
16	#[getset(get = "pub")]
17	pub struct BalanceEvent<'a> {
18	/// The associated account identifier.
19	#[serde(rename = "accountId")]
20	account_id: &'a str,
21	/// The associated address.
22	address: &'a Address,
23	/// The new balance.
24	balance: u64,
25	}
26
27	impl<'a> BalanceEvent<'a> {
28	#[doc(hidden)]
29	pub fn cloned_address(&self) -> Address {	×
30	self.address.clone()	×
31	}	×
32	}
33
34	/// A transaction-related event data.
35	#[derive(Getters, Serialize)]
36	#[getset(get = "pub")]
37	pub struct TransactionEvent<'a> {
38	#[serde(rename = "accountId")]
39	/// The associated account identifier.
40	account_id: &'a str,
41	/// The event message.
42	message: &'a Message,
43	}
44
45	impl<'a> TransactionEvent<'a> {
46	#[doc(hidden)]
47	pub fn cloned_message(&self) -> Message {	×
48	self.message.clone()	×
49	}	×
50	}
51
52	/// A transaction-related event data.
53	#[derive(Getters, Serialize)]
54	#[getset(get = "pub")]
55	pub struct TransactionConfirmationChangeEvent<'a> {
56	#[serde(rename = "accountId")]
57	/// The associated account identifier.
58	account_id: &'a str,
59	/// The event message.
60	message: &'a Message,
61	/// The confirmed state of the transaction.
62	confirmed: bool,
63	}
64
65	impl<'a> TransactionConfirmationChangeEvent<'a> {
66	#[doc(hidden)]
67	pub fn cloned_message(&self) -> Message {	×
68	self.message.clone()	×
69	}	×
70	}
71
72	struct BalanceEventHandler {
73	/// The on event callback.
74	on_event: Box<dyn Fn(&BalanceEvent<'_>) + Send>,
75	}
76
77	struct ErrorHandler {
78	/// The on error callback.
79	on_error: Box<dyn Fn(&crate::Error) + Send>,
80	}
81
82	#[derive(PartialEq)]	×
83	pub(crate) enum TransactionEventType {
84	NewTransaction,
85	Reattachment,
86	Broadcast,
87	}
88
89	struct TransactionEventHandler {
90	event_type: TransactionEventType,
91	/// The on event callback.
92	on_event: Box<dyn Fn(&TransactionEvent<'_>) + Send>,
93	}
94
95	struct TransactionConfirmationChangeEventHandler {
96	/// The on event callback.
97	on_event: Box<dyn Fn(&TransactionConfirmationChangeEvent<'_>) + Send>,
98	}
99
100	type BalanceListeners = Arc<Mutex<Vec<BalanceEventHandler>>>;
101	type TransactionListeners = Arc<Mutex<Vec<TransactionEventHandler>>>;
102	type TransactionConfirmationChangeListeners = Arc<Mutex<Vec<TransactionConfirmationChangeEventHandler>>>;
103	type ErrorListeners = Arc<Mutex<Vec<ErrorHandler>>>;
104
105	/// Gets the balance change listeners array.
106	fn balance_listeners() -> &'static BalanceListeners {	4✔
107	static LISTENERS: Lazy<BalanceListeners> = Lazy::new(Default::default);
108	&LISTENERS	4✔
109	}	4✔
110
111	/// Gets the transaction listeners array.
112	fn transaction_listeners() -> &'static TransactionListeners {	×
113	static LISTENERS: Lazy<TransactionListeners> = Lazy::new(Default::default);
114	&LISTENERS	×
115	}	×
116
117	/// Gets the transaction confirmation change listeners array.
118	fn transaction_confirmation_change_listeners() -> &'static TransactionConfirmationChangeListeners {	×
119	static LISTENERS: Lazy<TransactionConfirmationChangeListeners> = Lazy::new(Default::default);
120	&LISTENERS	×
121	}	×
122
123	/// Gets the balance change listeners array.
124	fn error_listeners() -> &'static ErrorListeners {	9,936✔
125	static LISTENERS: Lazy<ErrorListeners> = Lazy::new(Default::default);
126	&LISTENERS	9,936✔
127	}	9,917✔
128
129	/// Listen to balance changes.
130	pub fn on_balance_change<F: Fn(&BalanceEvent<'_>) + Send + 'static>(cb: F) {	2✔
131	let mut l = balance_listeners()	2!
132	.lock()
133	.expect("Failed to lock balance_listeners: on_balance_change()");
134	l.push(BalanceEventHandler { on_event: Box::new(cb) })	4!
135	}	2!
136
137	/// Emits a balance change event.
138	pub(crate) fn emit_balance_change(account_id: &str, address: &Address, balance: u64) {	2✔
139	let listeners = balance_listeners()	2✔
140	.lock()
141	.expect("Failed to lock balance_listeners: emit_balance_change()");
142	let event = BalanceEvent {	2✔
143	account_id,
144	address: &address,	2✔
145	balance,
146	};
147	for listener in listeners.deref() {	4!
148	(listener.on_event)(&event);	2!
149	}
150	}	2✔
151
152	/// Emits a transaction-related event.
NEW 153	pub(crate) fn emit_transaction_event(event_type: TransactionEventType, account_id: &str, message: &Message) {	×
UNCOV 154	let listeners = transaction_listeners()	×
155	.lock()
156	.expect("Failed to lock balance_listeners: emit_balance_change()");
157	let event = TransactionEvent {	×
158	account_id,
159	message: &message,	×
160	};
161	for listener in listeners.deref() {	×
162	if listener.event_type == event_type {	×
163	(listener.on_event)(&event);	×
164	}
165	}
166	}	×
167
168	/// Emits a transaction confirmation state change event.
NEW 169	pub(crate) fn emit_confirmation_state_change(account_id: &str, message: &Message, confirmed: bool) {	×
170	let listeners = transaction_confirmation_change_listeners()	×
171	.lock()
172	.expect("Failed to lock transaction_confirmation_change_listeners: emit_confirmation_state_change()");
173	let event = TransactionConfirmationChangeEvent {	×
174	account_id,
175	message: &message,	×
176	confirmed,
177	};
178	for listener in listeners.deref() {	×
179	(listener.on_event)(&event);	×
180	}
181	}	×
182
183	/// Adds a transaction-related event listener.
184	fn add_transaction_listener<F: Fn(&TransactionEvent<'_>) + Send + 'static>(event_type: TransactionEventType, cb: F) {
185	let mut l = transaction_listeners()
186	.lock()
187	.expect("Failed to lock transaction_listeners: add_transaction_listener()");
188	l.push(TransactionEventHandler {
189	event_type,
190	on_event: Box::new(cb),
191	})
192	}
193
194	/// Listen to new messages.
195	pub fn on_new_transaction<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
196	add_transaction_listener(TransactionEventType::NewTransaction, cb);
197	}
198
199	/// Listen to transaction confirmation state change.
200	pub fn on_confirmation_state_change<F: Fn(&TransactionConfirmationChangeEvent<'_>) + Send + 'static>(cb: F) {
201	let mut l = transaction_confirmation_change_listeners()
202	.lock()
203	.expect("Failed to lock transaction_confirmation_change_listeners: on_confirmation_state_change()");
204	l.push(TransactionConfirmationChangeEventHandler { on_event: Box::new(cb) })
205	}
206
207	/// Listen to transaction reattachment.
208	pub fn on_reattachment<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
209	add_transaction_listener(TransactionEventType::Reattachment, cb);
210	}
211
212	/// Listen to transaction broadcast.
213	pub fn on_broadcast<F: Fn(&TransactionEvent<'_>) + Send + 'static>(cb: F) {
214	add_transaction_listener(TransactionEventType::Broadcast, cb);
215	}
216
217	pub(crate) fn emit_error(error: &crate::Error) {	9,935✔
218	let listeners = error_listeners()	9,935✔
219	.lock()
220	.expect("Failed to lock error_listeners: emit_error()");
221	for listener in listeners.deref() {	9,967!
222	(listener.on_error)(&error)	2!
223	}
224	}	9,965✔
225
226	/// Listen to errors.
227	pub fn on_error<F: Fn(&crate::Error) + Send + 'static>(cb: F) {	2✔
228	let mut l = error_listeners()	2!
229	.lock()
230	.expect("Failed to lock error_listeners: on_error()");
231	l.push(ErrorHandler { on_error: Box::new(cb) })	4!
232	}	2!
233
234	#[cfg(test)]
235	mod tests {
236	use super::{emit_balance_change, on_balance_change, on_error};
237	use crate::address::{AddressBuilder, AddressWrapper, IotaAddress};
238	use iota::message::prelude::Ed25519Address;
239	use rusty_fork::rusty_fork_test;
240
241	fn _create_and_drop_error() {	2✔
242	let _ = crate::Error::AccountNotFound;	2✔
243	}	2✔
244
245	// have to fork this test so other errors dropped doesn't affect it
246	rusty_fork_test! {
247	#[test]
248	fn error_events() {
249	on_error(\|error\| {	2✔
250	assert!(matches!(error, crate::Error::AccountNotFound));	2!
251	});	2✔
252	_create_and_drop_error();
253	}
254	}
255
256	#[test]
257	fn balance_events() {	4✔
258	on_balance_change(\|event\| {	4✔
259	assert!(event.account_id == hex::encode([1; 32]));	2!
260	assert!(event.balance == 0);	2!
261	});	2✔
262
263	emit_balance_change(	2!
264	&hex::encode([1; 32]),	2!
265	&AddressBuilder::new()	6!
266	.address(AddressWrapper::new(	4!
267	IotaAddress::Ed25519(Ed25519Address::new([0; 32])),	2!
268	"iota".to_string(),	2!
269	))	2!
270	.balance(0)
271	.key_index(0)	2✔
272	.outputs(vec![])	4!
273	.build()
274	.expect("failed to build address"),
275	0,
276	);	2!
277	}	4✔
278	}

iotaledger / wallet.rs / 495034978

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