all tests fixed

ethcore/src/client/test_client.rs

@@ -28,6 +28,7 @@ use receipt::{Receipt, LocalizedReceipt};
 use blockchain::extras::BlockReceipts;
 use error::{ImportResult};
 use evm::Factory as EvmFactory;
+use miner::Miner;
 
 use block_queue::BlockQueueInfo;
 use block::{SealedBlock, ClosedBlock, LockedBlock};
@@ -64,6 +65,8 @@ pub struct TestBlockChainClient {
 	pub receipts: RwLock<HashMap<TransactionID, LocalizedReceipt>>,
 	/// Block queue size.
 	pub queue_size: AtomicUsize,
+	/// Miner
+	pub miner: Arc<Miner>,
 }
 
 #[derive(Clone)]
@@ -102,6 +105,7 @@ impl TestBlockChainClient {
 			execution_result: RwLock::new(None),
 			receipts: RwLock::new(HashMap::new()),
 			queue_size: AtomicUsize::new(0),
+			miner: Arc::new(Miner::default()),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().unwrap().clone();

ethcore/src/json_tests/chain.rs

@@ -22,6 +22,7 @@ use tests::helpers::*;
 use devtools::*;
 use spec::Genesis;
 use ethjson;
+use miner::Miner;
 
 pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	init_log();
@@ -53,7 +54,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 
 			let temp = RandomTempPath::new();
 			{
-				let client = Client::new(ClientConfig::default(), spec, temp.as_path(), IoChannel::disconnected()).unwrap();
+				let client = Client::new(ClientConfig::default(), spec, temp.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 				for b in &blockchain.blocks_rlp() {
 					if Block::is_good(&b) {
 						let _ = client.import_block(b.clone());

ethcore/src/miner/miner.rs

@@ -585,11 +585,11 @@ impl MinerService for Miner {
 #[cfg(test)]
 mod tests {
 
-	use MinerService;
+	use super::super::MinerService;
-	use super::{Miner};
+	use super::Miner;
 	use util::*;
-	use ethcore::client::{TestBlockChainClient, EachBlockWith};
+	use client::{TestBlockChainClient, EachBlockWith};
-	use ethcore::block::*;
+	use block::*;
 
 	// TODO [ToDr] To uncomment` when TestBlockChainClient can actually return a ClosedBlock.
 	#[ignore]

ethcore/src/miner/transaction_queue.rs

@@ -778,8 +778,8 @@ mod test {
 	extern crate rustc_serialize;
 	use util::table::*;
 	use util::*;
-	use ethcore::transaction::*;
+	use transaction::*;
-	use ethcore::error::{Error, TransactionError};
+	use error::{Error, TransactionError};
 	use super::*;
 	use super::{TransactionSet, TransactionOrder, VerifiedTransaction};
 

ethcore/src/service.rs

@@ -142,12 +142,14 @@ mod tests {
 	use util::network::*;
 	use devtools::*;
 	use client::ClientConfig;
+	use std::sync::Arc;
+	use miner::Miner;
 
 	#[test]
 	fn it_can_be_started() {
 		let spec = get_test_spec();
 		let temp_path = RandomTempPath::new();
-		let service = ClientService::start(ClientConfig::default(), spec, NetworkConfiguration::new_local(), &temp_path.as_path());
+		let service = ClientService::start(ClientConfig::default(), spec, NetworkConfiguration::new_local(), &temp_path.as_path(), Arc::new(Miner::default()));
 		assert!(service.is_ok());
 	}
 }

ethcore/src/tests/client.rs

@@ -14,16 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use client::{BlockChainClient, Client, ClientConfig, BlockID};
+use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockID};
 use block::IsBlock;
 use tests::helpers::*;
 use common::*;
 use devtools::*;
+use miner::Miner;
 
 #[test]
 fn imports_from_empty() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	client.import_verified_blocks(&IoChannel::disconnected());
 	client.flush_queue();
 }
@@ -41,7 +42,7 @@ fn returns_state_root_basic() {
 #[test]
 fn imports_good_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	let good_block = get_good_dummy_block();
 	if let Err(_) = client.import_block(good_block) {
 		panic!("error importing block being good by definition");
@@ -56,7 +57,7 @@ fn imports_good_block() {
 #[test]
 fn query_none_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 
     let non_existant = client.block_header(BlockID::Number(188));
 	assert!(non_existant.is_none());

ethcore/src/tests/helpers.rs

@@ -23,6 +23,7 @@ use evm::Schedule;
 use engine::*;
 use ethereum;
 use devtools::*;
+use miner::Miner;
 
 #[cfg(feature = "json-tests")]
 pub enum ChainEra {
@@ -139,7 +140,7 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[&SignedTrans
 pub fn generate_dummy_client(block_number: u32) -> GuardedTempResult<Arc<Client>> {
 	let dir = RandomTempPath::new();
 
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	let test_spec = get_test_spec();
 	let test_engine = &test_spec.engine;
 	let state_root = test_spec.genesis_header().state_root;
@@ -205,7 +206,7 @@ pub fn push_blocks_to_client(client: &Arc<Client>, timestamp_salt: u64, starting
 
 pub fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> GuardedTempResult<Arc<Client>> {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	for block in &blocks {
 		if let Err(_) = client.import_block(block.clone()) {
 			panic!("panic importing block which is well-formed");

rpc/src/v1/tests/eth.rs

@@ -19,12 +19,12 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::str::FromStr;
 
-use ethcore::client::{MiningBlockChainClient, Client, ClientConfig};
+use ethcore::client::{MiningBlockChainClient, BlockChainClient, Client, ClientConfig};
 use ethcore::spec::Genesis;
 use ethcore::block::Block;
 use ethcore::ethereum;
 use ethcore::transaction::{Transaction, Action};
-use ethcore::miner::{MinerService, ExternalMiner};
+use ethcore::miner::{MinerService, ExternalMiner, Miner};
 use devtools::RandomTempPath;
 use util::io::IoChannel;
 use util::hash::Address;
@@ -195,7 +195,7 @@ fn chain_harness<F, U>(chain: BlockChain, mut cb: F) -> U
 	assert!(spec.is_state_root_valid());
 
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), spec, dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), spec, dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	let sync_provider = sync_provider();
 	let miner_service = miner_service();
 	let account_provider = account_provider();

sync/src/chain.rs

@@ -101,7 +101,7 @@ use io::SyncIo;
 use time;
 use super::SyncConfig;
 use blocks::BlockCollection;
-use ethcore::miner::{AccountDetails, TransactionImportResult};
+use ethcore::miner::{AccountDetails, TransactionImportResult, MinerService};
 
 known_heap_size!(0, PeerInfo);
 
@@ -1297,6 +1297,7 @@ mod tests {
 	use ethcore::header::*;
 	use ethcore::client::*;
 	use ethcore::spec::Spec;
+	use ethcore::miner::MinerService;
 
 	fn get_dummy_block(order: u32, parent_hash: H256) -> Bytes {
 		let mut header = Header::new();
@@ -1702,8 +1703,8 @@ mod tests {
 			let mut queue = VecDeque::new();
 			let mut io = TestIo::new(&mut client, &mut queue, None);
 			sync.chain_new_blocks(&mut io, &[], &[], &[], &good_blocks);
-			assert_eq!(sync.miner.status().transactions_in_future_queue, 0);
+			assert_eq!(io.chain.miner.status().transactions_in_future_queue, 0);
-			assert_eq!(sync.miner.status().transactions_in_pending_queue, 1);
+			assert_eq!(io.chain.miner.status().transactions_in_pending_queue, 1);
 		}
 		// We need to update nonce status (because we say that the block has been imported)
 		for h in &[good_blocks[0]] {
@@ -1718,7 +1719,7 @@ mod tests {
 		}
 
 		// then
-		let status = sync.miner.status();
+		let status = client.miner.status();
 		assert_eq!(status.transactions_in_pending_queue, 1);
 		assert_eq!(status.transactions_in_future_queue, 0);
 	}
@@ -1740,12 +1741,12 @@ mod tests {
 
 		// when
 		sync.chain_new_blocks(&mut io, &[], &[], &[], &good_blocks);
-		assert_eq!(sync.miner.status().transactions_in_future_queue, 0);
+		assert_eq!(io.chain.miner.status().transactions_in_future_queue, 0);
-		assert_eq!(sync.miner.status().transactions_in_pending_queue, 0);
+		assert_eq!(io.chain.miner.status().transactions_in_pending_queue, 0);
 		sync.chain_new_blocks(&mut io, &[], &[], &good_blocks, &retracted_blocks);
 
 		// then
-		let status = sync.miner.status();
+		let status = io.chain.miner.status();
 		assert_eq!(status.transactions_in_pending_queue, 0);
 		assert_eq!(status.transactions_in_future_queue, 0);
 	}

sync/src/tests/chain.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
-use ethcore::client::{MiningClient, BlockID, EachBlockWith};
+use ethcore::client::{BlockChainClient, BlockID, EachBlockWith};
 use chain::{SyncState};
 use super::helpers::*;
 

sync/src/tests/helpers.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
-use ethcore::client::{TestBlockChainClient, BlockChainClient};
+use ethcore::client::{TestBlockChainClient, MiningBlockChainClient, BlockChainClient};
 use ethcore::spec::Spec;
 use io::SyncIo;
 use chain::ChainSync;
@@ -62,7 +62,7 @@ impl<'p> SyncIo for TestIo<'p> {
 		Ok(())
 	}
 
-	fn chain(&self) -> &MiningClient {
+	fn chain(&self) -> &BlockChainClient {
 		self.chain
 	}
 }