grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix tests with loop hack

Browse Source
This commit is contained in:
Robert Habermeier 2017-02-08 17:57:18 +01:00
parent 2ca61151ac
commit 3669d17390
7 changed files with 76 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
rpc/src/v1/helpers/mod.rs
View File

@ -28,6 +28,7 @@ mod requests;
mod signer;
mod signing_queue;
pub use self::dispatch::{Dispatcher, FullDispatcher};
pub use self::network_settings::NetworkSettings;
pub use self::poll_manager::PollManager;
pub use self::poll_filter::{PollFilter, limit_logs};

2
rpc/src/v1/impls/signing.rs
View File

@ -27,7 +27,7 @@ use jsonrpc_core::Error;
use v1::helpers::{
errors,
DefaultAccount,
SigningQueue, ConfirmationPromise, ConfirmationResult, ConfirmationPayload, SignerService
SigningQueue, ConfirmationPromise, ConfirmationResult, SignerService
};
use v1::helpers::dispatch::{self, Dispatcher};
use v1::metadata::Metadata;

6
rpc/src/v1/tests/eth.rs
View File

@ -33,6 +33,7 @@ use util::{U256, H256, Uint, Address, Hashable};
use jsonrpc_core::IoHandler;
use v1::impls::{EthClient, SigningUnsafeClient};
use v1::helpers::dispatch::FullDispatcher;
use v1::metadata::Metadata;
use v1::tests::helpers::{TestSnapshotService, TestSyncProvider, Config};
use v1::traits::eth::Eth;
@ -141,10 +142,11 @@ impl EthTester {
&external_miner,
Default::default(),
);
let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner_service));
let eth_sign = SigningUnsafeClient::new(
&client,
&account_provider,
&miner_service
dispatcher,
);
let mut handler = IoHandler::default();

5
rpc/src/v1/tests/mocked/eth.rs
View File

@ -34,6 +34,7 @@ use ethsync::SyncState;
use jsonrpc_core::IoHandler;
use v1::{Eth, EthClient, EthClientOptions, EthFilter, EthFilterClient, EthSigning, SigningUnsafeClient};
use v1::helpers::dispatch::FullDispatcher;
use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService, TestSnapshotService};
use v1::metadata::Metadata;
@ -88,7 +89,9 @@ impl EthTester {
let external_miner = Arc::new(ExternalMiner::new(hashrates.clone()));
let eth = EthClient::new(&client, &snapshot, &sync, &ap, &miner, &external_miner, options).to_delegate();
let filter = EthFilterClient::new(&client, &miner).to_delegate();
let sign = SigningUnsafeClient::new(&client, &ap, &miner).to_delegate();
let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
let sign = SigningUnsafeClient::new(&ap, dispatcher).to_delegate();
let mut io: IoHandler<Metadata> = IoHandler::default();
io.extend_with(eth);
io.extend_with(sign);

15
rpc/src/v1/tests/mocked/personal.rs
View File

@ -16,13 +16,16 @@
use std::sync::Arc;
use std::str::FromStr;
use jsonrpc_core::IoHandler;
use util::{U256, Uint, Address};
use ethcore::account_provider::AccountProvider;
use v1::{PersonalClient, Personal, Metadata};
use v1::tests::helpers::TestMinerService;
use ethcore::client::TestBlockChainClient;
use ethcore::transaction::{Action, Transaction};
use jsonrpc_core::IoHandler;
use util::{U256, Uint, Address};
use v1::{PersonalClient, Personal, Metadata};
use v1::helpers::dispatch::FullDispatcher;
use v1::tests::helpers::TestMinerService;
struct PersonalTester {
accounts: Arc<AccountProvider>,
@ -50,7 +53,9 @@ fn setup() -> PersonalTester {
let accounts = accounts_provider();
let client = blockchain_client();
let miner = miner_service();
let personal = PersonalClient::new(&accounts, &client, &miner, false);
let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
let personal = PersonalClient::new(&accounts, dispatcher, false);
let mut io = IoHandler::default();
io.extend_with(personal.to_delegate());

4
rpc/src/v1/tests/mocked/signer.rs
View File

@ -29,6 +29,7 @@ use v1::{SignerClient, Signer};
use v1::metadata::Metadata;
use v1::tests::helpers::TestMinerService;
use v1::helpers::{SigningQueue, SignerService, FilledTransactionRequest, ConfirmationPayload};
use v1::helpers::dispatch::FullDispatcher;
struct SignerTester {
signer: Arc<SignerService>,
@ -59,8 +60,9 @@ fn signer_tester() -> SignerTester {
let client = blockchain_client();
let miner = miner_service();
let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
let mut io = IoHandler::default();
io.extend_with(SignerClient::new(&accounts, &client, &miner, &signer).to_delegate());
io.extend_with(SignerClient::new(&accounts, dispatcher, &signer).to_delegate());
SignerTester {
signer: signer,

62
rpc/src/v1/tests/mocked/signing.rs
View File

@ -16,13 +16,14 @@
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use rlp;
use jsonrpc_core::{IoHandler, Success};
use v1::impls::SigningQueueClient;
use v1::metadata::Metadata;
use v1::traits::{EthSigning, ParitySigning, Parity};
use v1::helpers::{SignerService, SigningQueue};
use v1::helpers::{SignerService, SigningQueue, FullDispatcher};
use v1::types::ConfirmationResponse;
use v1::tests::helpers::TestMinerService;
use v1::tests::mocked::parity;
@ -51,9 +52,12 @@ impl Default for SigningTester {
let miner = Arc::new(TestMinerService::default());
let accounts = Arc::new(AccountProvider::transient_provider());
let mut io = IoHandler::default();
let rpc = SigningQueueClient::new(&signer, &client, &miner, &accounts);
let dispatcher = FullDispatcher::new(Arc::downgrade(&client), Arc::downgrade(&miner));
let rpc = SigningQueueClient::new(&signer, dispatcher.clone(), &accounts);
io.extend_with(EthSigning::to_delegate(rpc));
let rpc = SigningQueueClient::new(&signer, &client, &miner, &accounts);
let rpc = SigningQueueClient::new(&signer, dispatcher, &accounts);
io.extend_with(ParitySigning::to_delegate(rpc));
SigningTester {
@ -91,9 +95,17 @@ fn should_add_sign_to_queue() {
// then
let promise = tester.io.handle_request(&request);
assert_eq!(tester.signer.requests().len(), 1);
// the future must be polled at least once before request is queued.
let signer = tester.signer.clone();
::std::thread::spawn(move || loop {
if signer.requests().len() == 1 {
// respond
tester.signer.request_confirmed(1.into(), Ok(ConfirmationResponse::Signature(0.into())));
signer.request_confirmed(1.into(), Ok(ConfirmationResponse::Signature(0.into())));
break
}
::std::thread::sleep(Duration::from_millis(100))
});
let res = promise.wait().unwrap();
assert_eq!(res, Some(response.to_owned()));
@ -229,9 +241,17 @@ fn should_add_transaction_to_queue() {
// then
let promise = tester.io.handle_request(&request);
assert_eq!(tester.signer.requests().len(), 1);
// the future must be polled at least once before request is queued.
let signer = tester.signer.clone();
::std::thread::spawn(move || loop {
if signer.requests().len() == 1 {
// respond
tester.signer.request_confirmed(1.into(), Ok(ConfirmationResponse::SendTransaction(0.into())));
signer.request_confirmed(1.into(), Ok(ConfirmationResponse::SendTransaction(0.into())));
break
}
::std::thread::sleep(Duration::from_millis(100))
});
let res = promise.wait().unwrap();
assert_eq!(res, Some(response.to_owned()));
@ -296,9 +316,17 @@ fn should_add_sign_transaction_to_the_queue() {
// then
tester.miner.last_nonces.write().insert(address.clone(), U256::zero());
let promise = tester.io.handle_request(&request);
assert_eq!(tester.signer.requests().len(), 1);
// the future must be polled at least once before request is queued.
let signer = tester.signer.clone();
::std::thread::spawn(move || loop {
if signer.requests().len() == 1 {
// respond
tester.signer.request_confirmed(1.into(), Ok(ConfirmationResponse::SignTransaction(t.into())));
signer.request_confirmed(1.into(), Ok(ConfirmationResponse::SignTransaction(t.into())));
break
}
::std::thread::sleep(Duration::from_millis(100))
});
let res = promise.wait().unwrap();
assert_eq!(res, Some(response.to_owned()));
@ -391,12 +419,22 @@ fn should_add_decryption_to_the_queue() {
}"#;
let response = r#"{"jsonrpc":"2.0","result":"0x0102","id":1}"#;
// then
let promise = tester.io.handle_request(&request);
assert_eq!(tester.signer.requests().len(), 1);
// respond
tester.signer.request_confirmed(1.into(), Ok(ConfirmationResponse::Decrypt(vec![0x1, 0x2].into())));
// the future must be polled at least once before request is queued.
let signer = tester.signer.clone();
::std::thread::spawn(move || loop {
if signer.requests().len() == 1 {
// respond
signer.request_confirmed(1.into(), Ok(ConfirmationResponse::Decrypt(vec![0x1, 0x2].into())));
break
}
::std::thread::sleep(Duration::from_millis(100))
});
// check response: will deadlock if unsuccessful.
let res = promise.wait().unwrap();
assert_eq!(res, Some(response.to_owned()));
}