Add more tests (#240)

* add wallet-rpc-compatibility tests

* fmt + clippy

* add wallet-rpc receive tests

* add (0,0) subaddress check to standard address
This commit is contained in:
akildemir 2023-01-24 23:22:07 +03:00 committed by GitHub
parent 19664967ed
commit f12cc2cca6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23

View file

@ -3,26 +3,52 @@ use std::{
str::FromStr, str::FromStr,
}; };
use rand_core::{RngCore, OsRng}; use rand_core::{OsRng, RngCore};
use serde::Deserialize;
use serde_json::json;
use monero_rpc::{ use monero_rpc::{
monero::{Amount, Address}, monero::{
TransferOptions, Amount, Address,
cryptonote::{hash::Hash, subaddress::Index},
util::address::PaymentId,
},
TransferOptions, WalletClient,
}; };
use monero_serai::{ use monero_serai::{
wallet::address::{Network, AddressSpec, SubaddressIndex}, wallet::address::{Network, AddressSpec, SubaddressIndex},
wallet::Scanner, wallet::{Scanner, address::MoneroAddress},
rpc::Rpc,
transaction::Transaction,
}; };
mod runner; mod runner;
async fn test_from_wallet_rpc_to_self(spec: AddressSpec) { async fn make_integrated_address(payment_id: [u8; 8]) -> String {
#[derive(Deserialize, Debug)]
struct IntegratedAddressResponse {
integrated_address: String,
}
let rpc = Rpc::new("http://127.0.0.1:6061".to_string()).unwrap();
let res = rpc
.json_rpc_call::<IntegratedAddressResponse>(
"make_integrated_address",
Some(json!({ "payment_id": hex::encode(payment_id) })),
)
.await
.unwrap();
res.integrated_address
}
async fn initialize_rpcs() -> (WalletClient, Rpc, monero_rpc::monero::Address) {
let wallet_rpc = let wallet_rpc =
monero_rpc::RpcClientBuilder::new().build("http://127.0.0.1:6061").unwrap().wallet(); monero_rpc::RpcClientBuilder::new().build("http://127.0.0.1:6061").unwrap().wallet();
let daemon_rpc = runner::rpc().await; let daemon_rpc = runner::rpc().await;
// initialize wallet rpc
let address_resp = wallet_rpc.get_address(0, None).await; let address_resp = wallet_rpc.get_address(0, None).await;
let wallet_rpc_addr = if address_resp.is_ok() { let wallet_rpc_addr = if address_resp.is_ok() {
address_resp.unwrap().address address_resp.unwrap().address
@ -32,6 +58,12 @@ async fn test_from_wallet_rpc_to_self(spec: AddressSpec) {
daemon_rpc.generate_blocks(&addr.to_string(), 70).await.unwrap(); daemon_rpc.generate_blocks(&addr.to_string(), 70).await.unwrap();
addr addr
}; };
(wallet_rpc, daemon_rpc, wallet_rpc_addr)
}
async fn test_from_wallet_rpc_to_self(spec: AddressSpec) {
// initialize rpc
let (wallet_rpc, daemon_rpc, wallet_rpc_addr) = initialize_rpcs().await;
// make an addr // make an addr
let (_, view_pair, _) = runner::random_address(); let (_, view_pair, _) = runner::random_address();
@ -89,3 +121,82 @@ async_sequential!(
test_from_wallet_rpc_to_self(AddressSpec::Integrated(payment_id)).await; test_from_wallet_rpc_to_self(AddressSpec::Integrated(payment_id)).await;
} }
); );
test!(
test_send_to_wallet_rpc_standard,
(
|_, mut builder: Builder, _| async move {
// initialize rpc
let (wallet_rpc, _, wallet_rpc_addr) = initialize_rpcs().await;
// add destination
builder.add_payment(
MoneroAddress::from_str(Network::Mainnet, &wallet_rpc_addr.to_string()).unwrap(),
1000000,
);
(builder.build().unwrap(), (wallet_rpc,))
},
|_, tx: Transaction, _, data: (WalletClient,)| async move {
// confirm receipt
data.0.refresh(None).await.unwrap();
let transfer =
data.0.get_transfer(Hash::from_slice(&tx.hash()), None).await.unwrap().unwrap();
assert_eq!(transfer.amount.as_pico(), 1000000);
assert_eq!(transfer.subaddr_index, Index { major: 0, minor: 0 });
},
),
);
test!(
test_send_to_wallet_rpc_subaddress,
(
|_, mut builder: Builder, _| async move {
// initialize rpc
let (wallet_rpc, _, _) = initialize_rpcs().await;
// make the addr
let (subaddress, index) = wallet_rpc.create_address(0, None).await.unwrap();
builder.add_payment(
MoneroAddress::from_str(Network::Mainnet, &subaddress.to_string()).unwrap(),
1000000,
);
(builder.build().unwrap(), (wallet_rpc, index))
},
|_, tx: Transaction, _, data: (WalletClient, u32)| async move {
// confirm receipt
data.0.refresh(None).await.unwrap();
let transfer =
data.0.get_transfer(Hash::from_slice(&tx.hash()), None).await.unwrap().unwrap();
assert_eq!(transfer.amount.as_pico(), 1000000);
assert_eq!(transfer.subaddr_index, Index { major: 0, minor: data.1 });
},
),
);
test!(
test_send_to_wallet_rpc_integrated,
(
|_, mut builder: Builder, _| async move {
// initialize rpc
let (wallet_rpc, _, _) = initialize_rpcs().await;
// make the addr
let mut payment_id = [0u8; 8];
OsRng.fill_bytes(&mut payment_id);
let addr = make_integrated_address(payment_id).await;
builder.add_payment(MoneroAddress::from_str(Network::Mainnet, &addr).unwrap(), 1000000);
(builder.build().unwrap(), (wallet_rpc, payment_id))
},
|_, tx: Transaction, _, data: (WalletClient, [u8; 8])| async move {
// confirm receipt
data.0.refresh(None).await.unwrap();
let transfer =
data.0.get_transfer(Hash::from_slice(&tx.hash()), None).await.unwrap().unwrap();
assert_eq!(transfer.amount.as_pico(), 1000000);
assert_eq!(transfer.subaddr_index, Index { major: 0, minor: 0 });
assert_eq!(transfer.payment_id.0, PaymentId::from_slice(&data.1));
},
),
);