new test_net holding Client

ethcore/res/authority_round.json

@@ -13,7 +13,7 @@
 		}
 	},
 	"params": {
-		"accountStartNonce": "0x0100000",
+		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x69"

sync/src/tests/consensus.rs

@@ -0,0 +1,225 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use util::*;
+use ethcore::client::{Client, BlockChainClient, BlockID, EachBlockWith};
+use chain::{SyncState};
+use super::test_net::*;
+
+#[test]
+fn two_peers() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	net.peer_mut(1).chain.add_blocks(1000, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(1000, EachBlockWith::Uncle);
+	net.sync();
+	assert!(net.peer(0).chain.block(BlockID::Number(1000)).is_some());
+	assert_eq!(*net.peer(0).chain.blocks.read(), *net.peer(1).chain.blocks.read());
+}
+
+#[test]
+fn long_chain() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(2);
+	net.peer_mut(1).chain.add_blocks(50000, EachBlockWith::Nothing);
+	net.sync();
+	assert!(net.peer(0).chain.block(BlockID::Number(50000)).is_some());
+	assert_eq!(*net.peer(0).chain.blocks.read(), *net.peer(1).chain.blocks.read());
+}
+
+#[test]
+fn status_after_sync() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	net.peer_mut(1).chain.add_blocks(1000, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(1000, EachBlockWith::Uncle);
+	net.sync();
+	let status = net.peer(0).sync.read().status();
+	assert_eq!(status.state, SyncState::Idle);
+}
+
+#[test]
+fn takes_few_steps() {
+	let mut net = TestNet::new(3);
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(100, EachBlockWith::Uncle);
+	let total_steps = net.sync();
+	assert!(total_steps < 20);
+}
+
+#[test]
+fn empty_blocks() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	for n in 0..200 {
+		let with = if n % 2 == 0 { EachBlockWith::Nothing } else { EachBlockWith::Uncle };
+		net.peer_mut(1).chain.add_blocks(5, with.clone());
+		net.peer_mut(2).chain.add_blocks(5, with);
+	}
+	net.sync();
+	assert!(net.peer(0).chain.block(BlockID::Number(1000)).is_some());
+	assert_eq!(*net.peer(0).chain.blocks.read(), *net.peer(1).chain.blocks.read());
+}
+
+#[test]
+fn forked() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	net.peer_mut(0).chain.add_blocks(300, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.add_blocks(300, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(300, EachBlockWith::Uncle);
+	net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Nothing); //fork
+	net.peer_mut(1).chain.add_blocks(200, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(200, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Uncle); //fork between 1 and 2
+	net.peer_mut(2).chain.add_blocks(10, EachBlockWith::Nothing);
+	// peer 1 has the best chain of 601 blocks
+	let peer1_chain = net.peer(1).chain.numbers.read().clone();
+	net.sync();
+	assert_eq!(*net.peer(0).chain.difficulty.read(), *net.peer(1).chain.difficulty.read());
+	assert_eq!(&*net.peer(0).chain.numbers.read(), &peer1_chain);
+	assert_eq!(&*net.peer(1).chain.numbers.read(), &peer1_chain);
+	assert_eq!(&*net.peer(2).chain.numbers.read(), &peer1_chain);
+}
+
+#[test]
+fn net_hard_fork() {
+	::env_logger::init().ok();
+	let ref_client = TestBlockChainClient::new();
+	ref_client.add_blocks(50, EachBlockWith::Uncle);
+	{
+		let mut net = TestNet::new_with_fork(2, Some((50, ref_client.block_hash(BlockID::Number(50)).unwrap())));
+		net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Uncle);
+		net.sync();
+		assert_eq!(net.peer(1).chain.chain_info().best_block_number, 100);
+	}
+	{
+		let mut net = TestNet::new_with_fork(2, Some((50, ref_client.block_hash(BlockID::Number(50)).unwrap())));
+		net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Nothing);
+		net.sync();
+		assert_eq!(net.peer(1).chain.chain_info().best_block_number, 0);
+	}
+}
+
+#[test]
+fn restart() {
+	let mut net = TestNet::new(3);
+	net.peer_mut(1).chain.add_blocks(1000, EachBlockWith::Uncle);
+	net.peer_mut(2).chain.add_blocks(1000, EachBlockWith::Uncle);
+
+	net.sync_steps(8);
+
+	// make sure that sync has actually happened
+	assert!(net.peer(0).chain.chain_info().best_block_number > 100);
+	net.restart_peer(0);
+
+	let status = net.peer(0).sync.read().status();
+	assert_eq!(status.state, SyncState::Idle);
+}
+
+#[test]
+fn status_empty() {
+	let net = TestNet::new(2);
+	assert_eq!(net.peer(0).sync.read().status().state, SyncState::Idle);
+}
+
+#[test]
+fn status_packet() {
+	let mut net = TestNet::new(2);
+	net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.add_blocks(1, EachBlockWith::Uncle);
+
+	net.start();
+
+	net.sync_step_peer(0);
+
+	assert_eq!(1, net.peer(0).queue.len());
+	assert_eq!(0x00, net.peer(0).queue[0].packet_id);
+}
+
+#[test]
+fn propagate_hashes() {
+	let mut net = TestNet::new(6);
+	net.peer_mut(1).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.sync();
+
+	net.peer_mut(0).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.sync();
+	net.trigger_chain_new_blocks(0); //first event just sets the marker
+	net.trigger_chain_new_blocks(0);
+
+	// 5 peers with NewHahses, 4 with blocks
+	assert_eq!(9, net.peer(0).queue.len());
+	let mut hashes = 0;
+	let mut blocks = 0;
+	for i in 0..net.peer(0).queue.len() {
+		if net.peer(0).queue[i].packet_id == 0x1 {
+			hashes += 1;
+		}
+		if net.peer(0).queue[i].packet_id == 0x7 {
+			blocks += 1;
+		}
+	}
+	assert_eq!(blocks, 4);
+	assert_eq!(hashes, 5);
+}
+
+#[test]
+fn propagate_blocks() {
+	let mut net = TestNet::new(20);
+	net.peer_mut(1).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.sync();
+
+	net.peer_mut(0).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.trigger_chain_new_blocks(0); //first event just sets the marker
+	net.trigger_chain_new_blocks(0);
+
+	assert!(!net.peer(0).queue.is_empty());
+	// NEW_BLOCK_PACKET
+	let blocks = net.peer(0).queue.iter().filter(|p| p.packet_id == 0x7).count();
+	assert!(blocks > 0);
+}
+
+#[test]
+fn restart_on_malformed_block() {
+	let mut net = TestNet::new(2);
+	net.peer_mut(1).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.corrupt_block(6);
+	net.sync_steps(20);
+
+	assert_eq!(net.peer(0).chain.chain_info().best_block_number, 5);
+}
+
+#[test]
+fn restart_on_broken_chain() {
+	let mut net = TestNet::new(2);
+	net.peer_mut(1).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.corrupt_block_parent(6);
+	net.sync_steps(20);
+
+	assert_eq!(net.peer(0).chain.chain_info().best_block_number, 5);
+}
+
+#[test]
+fn high_td_attach() {
+	let mut net = TestNet::new(2);
+	net.peer_mut(1).chain.add_blocks(10, EachBlockWith::Uncle);
+	net.peer_mut(1).chain.corrupt_block_parent(6);
+	net.sync_steps(20);
+
+	assert_eq!(net.peer(0).chain.chain_info().best_block_number, 5);
+}
+

sync/src/tests/mod.rs

@@ -16,5 +16,7 @@
 
 pub mod helpers;
 pub mod snapshot;
+pub mod test_net;
 mod chain;
 mod rpc;
+mod consensus;

sync/src/tests/test_net.rs

@@ -0,0 +1,234 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use util::*;
+use network::*;
+use tests::snapshot::*;
+use ethcore::client::{Client, BlockChainClient};
+use ethcore::tests::helpers::*;
+use ethcore::header::BlockNumber;
+use ethcore::spec::Spec;
+use ethcore::snapshot::SnapshotService;
+use sync_io::SyncIo;
+use chain::ChainSync;
+use ::SyncConfig;
+
+pub struct TestIo<'p> {
+	pub chain: &'p mut Client,
+	pub snapshot_service: &'p TestSnapshotService,
+	pub queue: &'p mut VecDeque<TestPacket>,
+	pub sender: Option<PeerId>,
+}
+
+impl<'p> TestIo<'p> {
+	pub fn new(chain: &'p mut Arc<Client>, ss: &'p TestSnapshotService, queue: &'p mut VecDeque<TestPacket>, sender: Option<PeerId>) -> TestIo<'p> {
+		TestIo {
+			chain: Arc::get_mut(chain).unwrap(),
+			snapshot_service: ss,
+			queue: queue,
+			sender: sender
+		}
+	}
+}
+
+impl<'p> SyncIo for TestIo<'p> {
+	fn disable_peer(&mut self, _peer_id: PeerId) {
+	}
+
+	fn disconnect_peer(&mut self, _peer_id: PeerId) {
+	}
+
+	fn is_expired(&self) -> bool {
+		false
+	}
+
+	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError> {
+		self.queue.push_back(TestPacket {
+			data: data,
+			packet_id: packet_id,
+			recipient: self.sender.unwrap()
+		});
+		Ok(())
+	}
+
+	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError> {
+		self.queue.push_back(TestPacket {
+			data: data,
+			packet_id: packet_id,
+			recipient: peer_id,
+		});
+		Ok(())
+	}
+
+	fn chain(&self) -> &BlockChainClient {
+		self.chain
+	}
+
+	fn snapshot_service(&self) -> &SnapshotService {
+		self.snapshot_service
+	}
+
+	fn eth_protocol_version(&self, _peer: PeerId) -> u8 {
+		64
+	}
+}
+
+pub struct TestPacket {
+	pub data: Bytes,
+	pub packet_id: PacketId,
+	pub recipient: PeerId,
+}
+
+pub struct TestPeer {
+	pub chain: Arc<Client>,
+	pub snapshot_service: Arc<TestSnapshotService>,
+	pub sync: RwLock<ChainSync>,
+	pub queue: VecDeque<TestPacket>,
+}
+
+pub struct TestNet {
+	pub peers: Vec<TestPeer>,
+	pub started: bool,
+}
+
+impl TestNet {
+	pub fn new(n: usize) -> TestNet {
+		Self::new_with_fork(n, None)
+	}
+
+	pub fn new_with_fork(n: usize, fork: Option<(BlockNumber, H256)>) -> TestNet {
+		let mut net = TestNet {
+			peers: Vec::new(),
+			started: false,
+		};
+		for _ in 0..n {
+			let mut chain = generate_dummy_client(1);
+			let mut config = SyncConfig::default();
+			config.fork_block = fork;
+			let ss = Arc::new(TestSnapshotService::new());
+			let sync = ChainSync::new(config, chain.reference().as_ref());
+			net.peers.push(TestPeer {
+				sync: RwLock::new(sync),
+				snapshot_service: ss,
+				chain: chain.take(),
+				queue: VecDeque::new(),
+			});
+		}
+		net
+	}
+
+	pub fn new_with_spec_file<R, S>(n: usize, get_spec: &S) -> TestNet where
+		R: Read + Clone,
+		S: Fn()->Spec {
+		let mut net = TestNet {
+			peers: Vec::new(),
+			started: false,
+		};
+		for _ in 0..n {
+			let mut chain = generate_dummy_client_with_spec(get_spec, 1);
+			let sync = ChainSync::new(SyncConfig::default(), chain.reference().as_ref());
+			net.peers.push(TestPeer {
+				sync: RwLock::new(sync),
+				snapshot_service: Arc::new(TestSnapshotService::new()),
+				chain: chain.take(),
+				queue: VecDeque::new(),
+			});
+		}
+		net
+	}
+
+	pub fn peer(&self, i: usize) -> &TestPeer {
+		self.peers.get(i).unwrap()
+	}
+
+	pub fn peer_mut(&mut self, i: usize) -> &mut TestPeer {
+		self.peers.get_mut(i).unwrap()
+	}
+
+	pub fn start(&mut self) {
+		for peer in 0..self.peers.len() {
+			for client in 0..self.peers.len() {
+				if peer != client {
+					let mut p = self.peers.get_mut(peer).unwrap();
+					p.sync.write().on_peer_connected(&mut TestIo::new(&mut p.chain,
+													 &p.snapshot_service,
+													 &mut p.queue,
+													 Some(client as PeerId)),
+													 client as PeerId);
+				}
+			}
+		}
+	}
+
+	pub fn sync_step(&mut self) {
+		for peer in 0..self.peers.len() {
+			if let Some(packet) = self.peers[peer].queue.pop_front() {
+				let mut p = self.peers.get_mut(packet.recipient).unwrap();
+				trace!("--- {} -> {} ---", peer, packet.recipient);
+				ChainSync::dispatch_packet(&p.sync,
+										   &mut TestIo::new(&mut p.chain,
+										   &p.snapshot_service,
+										   &mut p.queue,
+										   Some(peer as PeerId)),
+										   peer as PeerId,
+										   packet.packet_id,
+										   &packet.data);
+				trace!("----------------");
+			}
+			let mut p = self.peers.get_mut(peer).unwrap();
+			p.sync.write().maintain_sync(&mut TestIo::new(&mut p.chain, &p.snapshot_service, &mut p.queue, None));
+		}
+	}
+
+	pub fn sync_step_peer(&mut self, peer_num: usize) {
+		let mut peer = self.peer_mut(peer_num);
+		peer.sync.write().maintain_sync(&mut TestIo::new(&mut peer.chain, &peer.snapshot_service, &mut peer.queue, None));
+	}
+
+	pub fn restart_peer(&mut self, i: usize) {
+		let peer = self.peer_mut(i);
+		peer.sync.write().restart(&mut TestIo::new(&mut peer.chain, &peer.snapshot_service, &mut peer.queue, None));
+	}
+
+	pub fn sync(&mut self) -> u32 {
+		self.start();
+		let mut total_steps = 0;
+		while !self.done() {
+			self.sync_step();
+			total_steps += 1;
+		}
+		total_steps
+	}
+
+	pub fn sync_steps(&mut self, count: usize) {
+		if !self.started {
+			self.start();
+			self.started = true;
+		}
+		for _ in 0..count {
+			self.sync_step();
+		}
+	}
+
+	pub fn done(&self) -> bool {
+		self.peers.iter().all(|p| p.queue.is_empty())
+	}
+
+	pub fn trigger_chain_new_blocks(&mut self, peer_id: usize) {
+		let mut peer = self.peer_mut(peer_id);
+		peer.sync.write().chain_new_blocks(&mut TestIo::new(&mut peer.chain, &peer.snapshot_service, &mut peer.queue, None), &[], &[], &[], &[], &[]);
+	}
+}