Merge pull request #352 from ethcore/sync-tests-i3

test efforts, receipt requests

ethcore/src/lib.rs

@@ -83,6 +83,7 @@ pub mod header;
 pub mod service;
 pub mod spec;
 pub mod views;
+pub mod receipt;
 
 mod common;
 mod basic_types;
@@ -98,7 +99,6 @@ mod state;
 mod account;
 mod action_params;
 mod transaction;
-mod receipt;
 mod null_engine;
 mod builtin;
 mod extras;

ethcore/src/receipt.rs

@@ -1,3 +1,5 @@
+//! Receipt
+
 use util::*;
 use basic_types::LogBloom;
 use log_entry::LogEntry;

sync/cov.sh

@@ -5,5 +5,5 @@ fi
 
 cargo test --no-run || exit $?
 mkdir -p target/coverage
-kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1 --include-pattern sync/src --verify target/coverage target/debug/ethsync*
+kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1,sync/src/tests --include-pattern sync/src --verify target/coverage target/debug/ethsync*
 xdg-open target/coverage/index.html

sync/src/chain.rs

@@ -177,6 +177,7 @@ pub struct ChainSync {
 	have_common_block: bool,
 }
 
+type RlpResponseResult = Result<Option<(PacketId, RlpStream)>, PacketDecodeError>;
 
 impl ChainSync {
 	/// Create a new instance of syncing strategy.
@@ -845,7 +846,7 @@ impl ChainSync {
 	}
 
 	/// Respond to GetBlockHeaders request
-	fn return_block_headers(&self, io: &mut SyncIo, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+	fn return_block_headers(io: &SyncIo, r: &UntrustedRlp) -> RlpResponseResult {
 		// Packet layout:
 		// [ block: { P , B_32 }, maxHeaders: P, skip: P, reverse: P in { 0 , 1 } ]
 		let max_headers: usize = try!(r.val_at(1));
@@ -892,18 +893,16 @@ impl ChainSync {
 		}
 		let mut rlp = RlpStream::new_list(count as usize);
 		rlp.append_raw(&data, count as usize);
-		io.respond(BLOCK_HEADERS_PACKET, rlp.out()).unwrap_or_else(|e|
-			debug!(target: "sync", "Error sending headers: {:?}", e));
 		trace!(target: "sync", "-> GetBlockHeaders: returned {} entries", count);
-		Ok(())
+		Ok(Some((BLOCK_HEADERS_PACKET, rlp)))
 	}
 
 	/// Respond to GetBlockBodies request
-	fn return_block_bodies(&self, io: &mut SyncIo, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+	fn return_block_bodies(io: &SyncIo, r: &UntrustedRlp) -> RlpResponseResult {
 		let mut count = r.item_count();
 		if count == 0 {
 			debug!(target: "sync", "Empty GetBlockBodies request, ignoring.");
-			return Ok(());
+			return Ok(None);
 		}
 		trace!(target: "sync", "-> GetBlockBodies: {} entries", count);
 		count = min(count, MAX_BODIES_TO_SEND);
@@ -917,18 +916,16 @@ impl ChainSync {
 		}
 		let mut rlp = RlpStream::new_list(added);
 		rlp.append_raw(&data, added);
-		io.respond(BLOCK_BODIES_PACKET, rlp.out()).unwrap_or_else(|e|
-			debug!(target: "sync", "Error sending headers: {:?}", e));
 		trace!(target: "sync", "-> GetBlockBodies: returned {} entries", added);
-		Ok(())
+		Ok(Some((BLOCK_BODIES_PACKET, rlp)))
 	}
 
 	/// Respond to GetNodeData request
-	fn return_node_data(&self, io: &mut SyncIo, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+	fn return_node_data(io: &SyncIo, r: &UntrustedRlp) -> RlpResponseResult {
 		let mut count = r.item_count();
 		if count == 0 {
 			debug!(target: "sync", "Empty GetNodeData request, ignoring.");
-			return Ok(());
+			return Ok(None);
 		}
 		count = min(count, MAX_NODE_DATA_TO_SEND);
 		let mut added = 0usize;
@@ -941,33 +938,44 @@ impl ChainSync {
 		}
 		let mut rlp = RlpStream::new_list(added);
 		rlp.append_raw(&data, added);
-		io.respond(NODE_DATA_PACKET, rlp.out()).unwrap_or_else(|e|
+		Ok(Some((NODE_DATA_PACKET, rlp)))
-			debug!(target: "sync", "Error sending headers: {:?}", e));
-		Ok(())
 	}
 
-	/// Respond to GetReceipts request
+	fn return_receipts(io: &SyncIo, rlp: &UntrustedRlp) -> RlpResponseResult {
-	fn return_receipts(&self, io: &mut SyncIo, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+		let mut count = rlp.item_count();
-		let mut count = r.item_count();
 		if count == 0 {
 			debug!(target: "sync", "Empty GetReceipts request, ignoring.");
-			return Ok(());
+			return Ok(None);
 		}
 		count = min(count, MAX_RECEIPTS_TO_SEND);
 		let mut added = 0usize;
 		let mut data = Bytes::new();
 		for i in 0..count {
-			if let Some(mut hdr) = io.chain().block_receipts(&try!(r.val_at::<H256>(i))) {
+			if let Some(mut hdr) = io.chain().block_receipts(&try!(rlp.val_at::<H256>(i))) {
 				data.append(&mut hdr);
 				added += 1;
 			}
 		}
-		let mut rlp = RlpStream::new_list(added);
+		let mut rlp_result = RlpStream::new_list(added);
-		rlp.append_raw(&data, added);
+		rlp_result.append_raw(&data, added);
-		io.respond(RECEIPTS_PACKET, rlp.out()).unwrap_or_else(|e|
+		Ok(Some((RECEIPTS_PACKET, rlp_result)))
-			debug!(target: "sync", "Error sending headers: {:?}", e));
+	}
+
+	fn return_rlp<FRlp, FError>(&self, io: &mut SyncIo, rlp: &UntrustedRlp, rlp_func: FRlp, error_func: FError) -> Result<(), PacketDecodeError>
+		where FRlp : Fn(&SyncIo, &UntrustedRlp) -> RlpResponseResult,
+			FError : FnOnce(UtilError) -> String
+	{
+		let response = rlp_func(io, rlp);
+		match response {
+			Err(e) => Err(e),
+			Ok(Some((packet_id, rlp_stream))) => {
+				io.respond(packet_id, rlp_stream.out()).unwrap_or_else(
+					|e| debug!(target: "sync", "{:?}", error_func(e)));
 				Ok(())
 			}
+			_ => Ok(())
+		}
+	}
 
 	/// Dispatch incoming requests and responses
 	pub fn on_packet(&mut self, io: &mut SyncIo, peer: PeerId, packet_id: u8, data: &[u8]) {
@@ -975,14 +983,27 @@ impl ChainSync {
 		let result = match packet_id {
 			STATUS_PACKET => self.on_peer_status(io, peer, &rlp),
 			TRANSACTIONS_PACKET => self.on_peer_transactions(io, peer, &rlp),
-			GET_BLOCK_HEADERS_PACKET => self.return_block_headers(io, &rlp),
 			BLOCK_HEADERS_PACKET => self.on_peer_block_headers(io, peer, &rlp),
-			GET_BLOCK_BODIES_PACKET => self.return_block_bodies(io, &rlp),
 			BLOCK_BODIES_PACKET => self.on_peer_block_bodies(io, peer, &rlp),
 			NEW_BLOCK_PACKET => self.on_peer_new_block(io, peer, &rlp),
 			NEW_BLOCK_HASHES_PACKET => self.on_peer_new_hashes(io, peer, &rlp),
-			GET_NODE_DATA_PACKET => self.return_node_data(io, &rlp),
+
-			GET_RECEIPTS_PACKET => self.return_receipts(io, &rlp),
+			GET_BLOCK_BODIES_PACKET => self.return_rlp(io, &rlp,
+				ChainSync::return_block_bodies,
+				|e| format!("Error sending block bodies: {:?}", e)),
+
+			GET_BLOCK_HEADERS_PACKET => self.return_rlp(io, &rlp,
+				ChainSync::return_block_headers,
+				|e| format!("Error sending block headers: {:?}", e)),
+
+			GET_RECEIPTS_PACKET => self.return_rlp(io, &rlp,
+				ChainSync::return_receipts,
+				|e| format!("Error sending receipts: {:?}", e)),
+
+			GET_NODE_DATA_PACKET => self.return_rlp(io, &rlp,
+				ChainSync::return_node_data,
+				|e| format!("Error sending nodes: {:?}", e)),
+				
 			_ => {
 				debug!(target: "sync", "Unknown packet {}", packet_id);
 				Ok(())
@@ -1016,4 +1037,75 @@ impl ChainSync {
 
 #[cfg(test)]
 mod tests {
+	use tests::helpers::*;
+	use super::*;
+	use util::*;
+
+	#[test]
+	fn return_receipts_empty() {
+		let mut client = TestBlockChainClient::new();
+		let mut queue = VecDeque::new();
+		let io = TestIo::new(&mut client, &mut queue, None);
+
+		let result = ChainSync::return_receipts(&io, &UntrustedRlp::new(&[0xc0]));
+
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn return_receipts() {
+		let mut client = TestBlockChainClient::new();
+		let mut queue = VecDeque::new();
+		let mut io = TestIo::new(&mut client, &mut queue, None);
+
+		let mut receipt_list = RlpStream::new_list(4);
+		receipt_list.append(&H256::from("0000000000000000000000000000000000000000000000005555555555555555"));
+		receipt_list.append(&H256::from("ff00000000000000000000000000000000000000000000000000000000000000"));
+		receipt_list.append(&H256::from("fff0000000000000000000000000000000000000000000000000000000000000"));
+		receipt_list.append(&H256::from("aff0000000000000000000000000000000000000000000000000000000000000"));
+
+		let receipts_request = receipt_list.out();
+		// it returns rlp ONLY for hashes started with "f"
+		let result = ChainSync::return_receipts(&io, &UntrustedRlp::new(&receipts_request.clone()));
+
+		assert!(result.is_ok());
+		let rlp_result = result.unwrap();
+		assert!(rlp_result.is_some());
+
+		// the length of two rlp-encoded receipts
+		assert_eq!(597, rlp_result.unwrap().1.out().len());
+
+		let mut sync = ChainSync::new();
+		io.sender = Some(2usize);
+		sync.on_packet(&mut io, 1usize, super::GET_RECEIPTS_PACKET, &receipts_request);
+		assert_eq!(1, io.queue.len());
+	}
+
+	#[test]
+	fn return_nodes() {
+		let mut client = TestBlockChainClient::new();
+		let mut queue = VecDeque::new();
+		let mut io = TestIo::new(&mut client, &mut queue, None);
+
+		let mut node_list = RlpStream::new_list(3);
+		node_list.append(&H256::from("0000000000000000000000000000000000000000000000005555555555555555"));
+		node_list.append(&H256::from("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa"));
+		node_list.append(&H256::from("aff0000000000000000000000000000000000000000000000000000000000000"));
+
+		let node_request = node_list.out();
+		// it returns rlp ONLY for hashes started with "f"
+		let result = ChainSync::return_node_data(&io, &UntrustedRlp::new(&node_request.clone()));
+
+		assert!(result.is_ok());
+		let rlp_result = result.unwrap();
+		assert!(rlp_result.is_some());
+
+		// the length of one rlp-encoded hashe
+		assert_eq!(34, rlp_result.unwrap().1.out().len());
+
+		let mut sync = ChainSync::new();
+		io.sender = Some(2usize);
+		sync.on_packet(&mut io, 1usize, super::GET_NODE_DATA_PACKET, &node_request);
+		assert_eq!(1, io.queue.len());
+	}
 }

sync/src/tests/chain.rs

@@ -5,7 +5,7 @@ use chain::{SyncState};
 use super::helpers::*;
 
 #[test]
-fn chain_two_peers() {
+fn two_peers() {
 	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(1000, false);
@@ -16,7 +16,7 @@ fn chain_two_peers() {
 }
 
 #[test]
-fn chain_status_after_sync() {
+fn status_after_sync() {
 	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(1000, false);
@@ -27,7 +27,7 @@ fn chain_status_after_sync() {
 }
 
 #[test]
-fn chain_takes_few_steps() {
+fn takes_few_steps() {
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(100, false);
 	net.peer_mut(2).chain.add_blocks(100, false);
@@ -36,7 +36,7 @@ fn chain_takes_few_steps() {
 }
 
 #[test]
-fn chain_empty_blocks() {
+fn empty_blocks() {
 	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	for n in 0..200 {
@@ -49,7 +49,7 @@ fn chain_empty_blocks() {
 }
 
 #[test]
-fn chain_forked() {
+fn forked() {
 	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	net.peer_mut(0).chain.add_blocks(300, false);
@@ -69,7 +69,7 @@ fn chain_forked() {
 }
 
 #[test]
-fn chain_restart() {
+fn restart() {
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(1000, false);
 	net.peer_mut(2).chain.add_blocks(1000, false);
@@ -85,7 +85,7 @@ fn chain_restart() {
 }
 
 #[test]
-fn chain_status_empty() {
+fn status_empty() {
 	let net = TestNet::new(2);
 	assert_eq!(net.peer(0).sync.status().state, SyncState::NotSynced);
 }

sync/src/tests/helpers.rs

@@ -5,6 +5,7 @@ use ethcore::header::{Header as BlockHeader, BlockNumber};
 use ethcore::error::*;
 use io::SyncIo;
 use chain::{ChainSync};
+use ethcore::receipt::Receipt;
 
 pub struct TestBlockChainClient {
 	pub blocks: RwLock<HashMap<H256, Bytes>>,
@@ -15,7 +16,7 @@ pub struct TestBlockChainClient {
 }
 
 impl TestBlockChainClient {
-	fn new() -> TestBlockChainClient {
+	pub fn new() -> TestBlockChainClient {
 
 		let mut client = TestBlockChainClient {
 			blocks: RwLock::new(HashMap::new()),
@@ -116,11 +117,28 @@ impl BlockChainClient for TestBlockChainClient {
 		})
 	}
 
-	fn state_data(&self, _h: &H256) -> Option<Bytes> {
+	// TODO: returns just hashes instead of node state rlp(?)
+	fn state_data(&self, hash: &H256) -> Option<Bytes> {
+		// starts with 'f' ?
+		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
+			let mut rlp = RlpStream::new();
+			rlp.append(&hash.clone());
+			return Some(rlp.out());
+		}
 		None
 	}
 
-	fn block_receipts(&self, _h: &H256) -> Option<Bytes> {
+	fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
+		// starts with 'f' ?
+		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
+			let receipt = Receipt::new(
+				H256::zero(),
+				U256::zero(),
+				vec![]);
+			let mut rlp = RlpStream::new();
+			rlp.append(&receipt);
+			return Some(rlp.out());
+		}
 		None
 	}
 
@@ -196,7 +214,7 @@ pub struct TestIo<'p> {
 }
 
 impl<'p> TestIo<'p> {
-	fn new(chain: &'p mut TestBlockChainClient, queue: &'p mut VecDeque<TestPacket>, sender: Option<PeerId>) -> TestIo<'p> {
+	pub fn new(chain: &'p mut TestBlockChainClient, queue: &'p mut VecDeque<TestPacket>, sender: Option<PeerId>) -> TestIo<'p> {
 		TestIo {
 			chain: chain,
 			queue: queue,