Browse Source
458: Roll-out usage of a mocking framework in actor tests r=klochowicz a=klochowicz
Mockall is a mocking framework that removes the need for writing more actors,
making tests easier to write.
Summary:
- add one more layer of indirection (a trait per actor type: Wallet, Oracle, Monitor)
- Mocks implementing the actor traits (with default stubbed implementations if no extra
behaviour needed)
- references to the mocks are being passed into the tests (via Arc<Mutex>>), allowing
for dynamically changing the behaviour and adding assertions. This also
aids readability, as the mock setup can be collocated with a particular
test, if the test needs something extra
Co-authored-by: Mariusz Klochowicz <mariusz@klochowicz.com>
burn-down-handle
bors[bot]
3 years ago
committed by
GitHub
GitHub
8 changed files with 376 additions and 189 deletions
@ -1,3 +1,57 @@ |
|||||
|
use std::sync::Arc; |
||||
|
|
||||
|
use tokio::sync::{Mutex, MutexGuard}; |
||||
|
|
||||
|
use self::monitor::MonitorActor; |
||||
|
use self::oracle::OracleActor; |
||||
|
use self::wallet::WalletActor; |
||||
|
|
||||
pub mod monitor; |
pub mod monitor; |
||||
pub mod oracle; |
pub mod oracle; |
||||
pub mod wallet; |
pub mod wallet; |
||||
|
|
||||
|
#[derive(Clone)] |
||||
|
pub struct Mocks { |
||||
|
pub wallet: Arc<Mutex<wallet::MockWallet>>, |
||||
|
pub monitor: Arc<Mutex<monitor::MockMonitor>>, |
||||
|
pub oracle: Arc<Mutex<oracle::MockOracle>>, |
||||
|
} |
||||
|
|
||||
|
impl Mocks { |
||||
|
pub async fn wallet(&mut self) -> MutexGuard<'_, wallet::MockWallet> { |
||||
|
self.wallet.lock().await |
||||
|
} |
||||
|
|
||||
|
#[allow(dead_code)] // will be used soon
|
||||
|
pub async fn monitor(&mut self) -> MutexGuard<'_, monitor::MockMonitor> { |
||||
|
self.monitor.lock().await |
||||
|
} |
||||
|
|
||||
|
pub async fn oracle(&mut self) -> MutexGuard<'_, oracle::MockOracle> { |
||||
|
self.oracle.lock().await |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
impl Default for Mocks { |
||||
|
fn default() -> Self { |
||||
|
Self { |
||||
|
oracle: Arc::new(Mutex::new(oracle::MockOracle::new())), |
||||
|
monitor: Arc::new(Mutex::new(monitor::MockMonitor::new())), |
||||
|
wallet: Arc::new(Mutex::new(wallet::MockWallet::new())), |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// Creates actors with embedded mock handlers
|
||||
|
pub fn create_actors(mocks: &Mocks) -> (OracleActor, MonitorActor, WalletActor) { |
||||
|
let oracle = OracleActor { |
||||
|
mock: mocks.oracle.clone(), |
||||
|
}; |
||||
|
let monitor = MonitorActor { |
||||
|
mock: mocks.monitor.clone(), |
||||
|
}; |
||||
|
let wallet = WalletActor { |
||||
|
mock: mocks.wallet.clone(), |
||||
|
}; |
||||
|
(oracle, monitor, wallet) |
||||
|
} |
||||
|
|||||
@ -1,29 +1,53 @@ |
|||||
|
use std::sync::Arc; |
||||
|
|
||||
use daemon::{monitor, oracle}; |
use daemon::{monitor, oracle}; |
||||
|
use mockall::*; |
||||
|
use tokio::sync::Mutex; |
||||
use xtra_productivity::xtra_productivity; |
use xtra_productivity::xtra_productivity; |
||||
|
|
||||
/// Test Stub simulating the Monitor actor
|
/// Test Stub simulating the Monitor actor.
|
||||
pub struct Monitor; |
/// Serves as an entrypoint for injected mock handlers.
|
||||
impl xtra::Actor for Monitor {} |
pub struct MonitorActor { |
||||
|
pub mock: Arc<Mutex<dyn Monitor + Send>>, |
||||
|
} |
||||
|
|
||||
|
impl xtra::Actor for MonitorActor {} |
||||
|
impl Monitor for MonitorActor {} |
||||
|
|
||||
#[xtra_productivity(message_impl = false)] |
#[xtra_productivity(message_impl = false)] |
||||
impl Monitor { |
impl MonitorActor { |
||||
async fn handle(&mut self, _msg: monitor::Sync) {} |
async fn handle(&mut self, msg: monitor::Sync) { |
||||
|
self.mock.lock().await.sync(msg) |
||||
|
} |
||||
|
|
||||
async fn handle(&mut self, _msg: monitor::StartMonitoring) { |
async fn handle(&mut self, msg: monitor::StartMonitoring) { |
||||
todo!("stub this if needed") |
self.mock.lock().await.start_monitoring(msg) |
||||
} |
} |
||||
|
|
||||
async fn handle(&mut self, _msg: monitor::CollaborativeSettlement) { |
async fn handle(&mut self, msg: monitor::CollaborativeSettlement) { |
||||
todo!("stub this if needed") |
self.mock.lock().await.collaborative_settlement(msg) |
||||
} |
} |
||||
|
|
||||
async fn handle(&mut self, _msg: oracle::Attestation) { |
async fn handle(&mut self, msg: oracle::Attestation) { |
||||
todo!("stub this if needed") |
self.mock.lock().await.oracle_attestation(msg) |
||||
} |
} |
||||
} |
} |
||||
|
|
||||
impl Default for Monitor { |
#[automock] |
||||
fn default() -> Self { |
pub trait Monitor { |
||||
Monitor |
fn sync(&mut self, _msg: monitor::Sync) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
|
|
||||
|
fn start_monitoring(&mut self, _msg: monitor::StartMonitoring) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
|
|
||||
|
fn collaborative_settlement(&mut self, _msg: monitor::CollaborativeSettlement) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
|
|
||||
|
fn oracle_attestation(&mut self, _msg: oracle::Attestation) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
} |
} |
||||
} |
} |
||||
|
|||||
@ -1,45 +1,57 @@ |
|||||
|
use crate::harness::cfd_protocol::OliviaData; |
||||
use daemon::model::BitMexPriceEventId; |
use daemon::model::BitMexPriceEventId; |
||||
use daemon::oracle; |
use daemon::oracle; |
||||
|
use mockall::*; |
||||
|
use std::sync::Arc; |
||||
use time::OffsetDateTime; |
use time::OffsetDateTime; |
||||
|
use tokio::sync::Mutex; |
||||
use xtra_productivity::xtra_productivity; |
use xtra_productivity::xtra_productivity; |
||||
|
|
||||
pub struct Oracle { |
/// Test Stub simulating the Oracle actor.
|
||||
announcement: Option<oracle::Announcement>, |
/// Serves as an entrypoint for injected mock handlers.
|
||||
|
pub struct OracleActor { |
||||
|
pub mock: Arc<Mutex<dyn Oracle + Send>>, |
||||
} |
} |
||||
|
|
||||
impl Oracle { |
impl xtra::Actor for OracleActor {} |
||||
pub fn with_dummy_announcement( |
impl Oracle for OracleActor {} |
||||
mut self, |
|
||||
dummy_announcement: cfd_protocol::Announcement, |
#[xtra_productivity(message_impl = false)] |
||||
) -> Self { |
impl OracleActor { |
||||
self.announcement = Some(oracle::Announcement { |
async fn handle(&mut self, msg: oracle::GetAnnouncement) -> Option<oracle::Announcement> { |
||||
id: BitMexPriceEventId::new(OffsetDateTime::UNIX_EPOCH, 0), |
self.mock.lock().await.get_announcement(msg) |
||||
expected_outcome_time: OffsetDateTime::now_utc(), |
|
||||
nonce_pks: dummy_announcement.nonce_pks, |
|
||||
}); |
|
||||
|
|
||||
self |
|
||||
} |
} |
||||
} |
|
||||
|
|
||||
impl xtra::Actor for Oracle {} |
async fn handle(&mut self, msg: oracle::MonitorAttestation) { |
||||
|
self.mock.lock().await.monitor_attestation(msg) |
||||
|
} |
||||
|
|
||||
#[xtra_productivity(message_impl = false)] |
async fn handle(&mut self, msg: oracle::Sync) { |
||||
impl Oracle { |
self.mock.lock().await.sync(msg) |
||||
async fn handle_get_announcement( |
|
||||
&mut self, |
|
||||
_msg: oracle::GetAnnouncement, |
|
||||
) -> Option<oracle::Announcement> { |
|
||||
self.announcement.clone() |
|
||||
} |
} |
||||
|
} |
||||
|
|
||||
async fn handle(&mut self, _msg: oracle::MonitorAttestation) {} |
#[automock] |
||||
|
pub trait Oracle { |
||||
|
fn get_announcement(&mut self, _msg: oracle::GetAnnouncement) -> Option<oracle::Announcement> { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
|
|
||||
|
fn monitor_attestation(&mut self, _msg: oracle::MonitorAttestation) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
|
|
||||
async fn handle(&mut self, _msg: oracle::Sync) {} |
fn sync(&mut self, _msg: oracle::Sync) { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
|
} |
||||
} |
} |
||||
|
|
||||
impl Default for Oracle { |
pub fn dummy_announcement() -> oracle::Announcement { |
||||
fn default() -> Self { |
let announcement = OliviaData::example_0().announcement(); |
||||
Oracle { announcement: None } |
|
||||
|
oracle::Announcement { |
||||
|
id: BitMexPriceEventId::new(OffsetDateTime::UNIX_EPOCH, 0), |
||||
|
expected_outcome_time: OffsetDateTime::now_utc(), |
||||
|
nonce_pks: announcement.nonce_pks, |
||||
} |
} |
||||
} |
} |
||||
|
|||||
@ -1,93 +1,81 @@ |
|||||
use crate::harness::cfd_protocol::dummy_wallet; |
use crate::harness::cfd_protocol::dummy_wallet; |
||||
use anyhow::{anyhow, Result}; |
use anyhow::Result; |
||||
use bdk::bitcoin::util::psbt::PartiallySignedTransaction; |
use bdk::bitcoin::util::psbt::PartiallySignedTransaction; |
||||
use bdk::bitcoin::{ecdsa, Amount, Txid}; |
use bdk::bitcoin::{ecdsa, Amount, Txid}; |
||||
use cfd_protocol::secp256k1_zkp::Secp256k1; |
use cfd_protocol::secp256k1_zkp::Secp256k1; |
||||
use cfd_protocol::{PartyParams, WalletExt}; |
use cfd_protocol::{PartyParams, WalletExt}; |
||||
use daemon::model::{Timestamp, WalletInfo}; |
use daemon::model::{Timestamp, WalletInfo}; |
||||
use daemon::wallet; |
use daemon::wallet::{self}; |
||||
|
use mockall::*; |
||||
use rand::thread_rng; |
use rand::thread_rng; |
||||
|
use std::sync::Arc; |
||||
|
use tokio::sync::Mutex; |
||||
use xtra_productivity::xtra_productivity; |
use xtra_productivity::xtra_productivity; |
||||
|
|
||||
pub struct Wallet { |
/// Test Stub simulating the Wallet actor.
|
||||
party_params: bool, |
/// Serves as an entrypoint for injected mock handlers.
|
||||
wallet_info: Option<WalletInfo>, |
pub struct WalletActor { |
||||
psbt: Option<PartiallySignedTransaction>, |
pub mock: Arc<Mutex<dyn Wallet + Send>>, |
||||
txid: Option<Txid>, |
|
||||
} |
} |
||||
|
|
||||
impl Wallet { |
impl xtra::Actor for WalletActor {} |
||||
pub fn with_party_params(mut self) -> Self { |
|
||||
self.party_params = true; |
|
||||
self |
|
||||
} |
|
||||
|
|
||||
pub fn with_wallet_info(mut self) -> Self { |
#[xtra_productivity(message_impl = false)] |
||||
let s = Secp256k1::new(); |
impl WalletActor { |
||||
let public_key = ecdsa::PublicKey::new(s.generate_keypair(&mut thread_rng()).1); |
async fn handle(&mut self, msg: wallet::BuildPartyParams) -> Result<PartyParams> { |
||||
let address = bdk::bitcoin::Address::p2pkh(&public_key, bdk::bitcoin::Network::Testnet); |
self.mock.lock().await.build_party_params(msg) |
||||
|
} |
||||
|
async fn handle(&mut self, msg: wallet::Sync) -> Result<WalletInfo> { |
||||
|
tracing::info!("We are handling the wallet sync msg"); |
||||
|
self.mock.lock().await.sync(msg) |
||||
|
} |
||||
|
async fn handle(&mut self, msg: wallet::Sign) -> Result<PartiallySignedTransaction> { |
||||
|
self.mock.lock().await.sign(msg) |
||||
|
} |
||||
|
async fn handle(&mut self, msg: wallet::TryBroadcastTransaction) -> Result<Txid> { |
||||
|
self.mock.lock().await.broadcast(msg) |
||||
|
} |
||||
|
} |
||||
|
|
||||
self.wallet_info = Some(WalletInfo { |
#[automock] |
||||
balance: bdk::bitcoin::Amount::ONE_BTC, |
pub trait Wallet { |
||||
address, |
fn build_party_params(&mut self, _msg: wallet::BuildPartyParams) -> Result<PartyParams> { |
||||
last_updated_at: Timestamp::now().unwrap(), |
unreachable!("mockall will reimplement this method") |
||||
}); |
} |
||||
|
|
||||
self |
fn sign(&mut self, _msg: wallet::Sign) -> Result<PartiallySignedTransaction> { |
||||
|
unreachable!("mockall will reimplement this method") |
||||
} |
} |
||||
|
|
||||
pub fn with_psbt(mut self, psbt: PartiallySignedTransaction) -> Self { |
fn broadcast(&mut self, _msg: wallet::TryBroadcastTransaction) -> Result<Txid> { |
||||
self.psbt = Some(psbt); |
unreachable!("mockall will reimplement this method") |
||||
self |
|
||||
} |
} |
||||
|
|
||||
pub fn with_txid(mut self, txid: Txid) -> Self { |
fn sync(&mut self, _msg: wallet::Sync) -> Result<WalletInfo> { |
||||
self.txid = Some(txid); |
unreachable!("mockall will reimplement this method") |
||||
self |
|
||||
} |
} |
||||
} |
} |
||||
|
|
||||
impl xtra::Actor for Wallet {} |
#[allow(dead_code)] |
||||
|
/// tells the user they have plenty of moneys
|
||||
#[xtra_productivity(message_impl = false)] |
fn dummy_wallet_info() -> Result<WalletInfo> { |
||||
impl Wallet { |
let s = Secp256k1::new(); |
||||
async fn handle(&mut self, msg: wallet::BuildPartyParams) -> Result<PartyParams> { |
let public_key = ecdsa::PublicKey::new(s.generate_keypair(&mut thread_rng()).1); |
||||
if self.party_params { |
let address = bdk::bitcoin::Address::p2pkh(&public_key, bdk::bitcoin::Network::Testnet); |
||||
let mut rng = thread_rng(); |
|
||||
let wallet = dummy_wallet(&mut rng, Amount::from_btc(0.4).unwrap(), 5).unwrap(); |
|
||||
|
|
||||
let party_params = wallet |
|
||||
.build_party_params(msg.amount, msg.identity_pk) |
|
||||
.unwrap(); |
|
||||
|
|
||||
return Ok(party_params); |
Ok(WalletInfo { |
||||
} |
balance: bdk::bitcoin::Amount::ONE_BTC, |
||||
|
address, |
||||
panic!("Stub not configured to return party params") |
last_updated_at: Timestamp::now()?, |
||||
} |
}) |
||||
async fn handle(&mut self, _msg: wallet::Sync) -> Result<WalletInfo> { |
|
||||
self.wallet_info |
|
||||
.clone() |
|
||||
.ok_or_else(|| anyhow!("Stub not configured to return WalletInfo")) |
|
||||
} |
|
||||
async fn handle(&mut self, _msg: wallet::Sign) -> Result<PartiallySignedTransaction> { |
|
||||
self.psbt |
|
||||
.clone() |
|
||||
.ok_or_else(|| anyhow!("Stub not configured to return PartiallySignedTransaction")) |
|
||||
} |
|
||||
async fn handle(&mut self, _msg: wallet::TryBroadcastTransaction) -> Result<Txid> { |
|
||||
self.txid |
|
||||
.ok_or_else(|| anyhow!("Stub not configured to return Txid")) |
|
||||
} |
|
||||
} |
} |
||||
|
|
||||
impl Default for Wallet { |
pub fn build_party_params(msg: wallet::BuildPartyParams) -> Result<PartyParams> { |
||||
fn default() -> Self { |
let mut rng = thread_rng(); |
||||
Wallet { |
let wallet = dummy_wallet(&mut rng, Amount::from_btc(0.4).unwrap(), 5).unwrap(); |
||||
party_params: false, |
|
||||
wallet_info: None, |
let party_params = wallet |
||||
psbt: None, |
.build_party_params(msg.amount, msg.identity_pk) |
||||
txid: None, |
.unwrap(); |
||||
} |
Ok(party_params) |
||||
} |
|
||||
} |
} |
||||
|
|||||
Loading…
Reference in new issue