From da2f117aef64aa08af43145055edaea540770b04 Mon Sep 17 00:00:00 2001 From: keorn Date: Tue, 13 Sep 2016 15:58:32 +0200 Subject: [PATCH] new test_net holding Client --- ethcore/res/authority_round.json | 2 +- sync/src/tests/consensus.rs | 225 +++++++++++++++++++++++++++++ sync/src/tests/mod.rs | 2 + sync/src/tests/test_net.rs | 234 +++++++++++++++++++++++++++++++ 4 files changed, 462 insertions(+), 1 deletion(-) create mode 100644 sync/src/tests/consensus.rs create mode 100644 sync/src/tests/test_net.rs diff --git a/ethcore/res/authority_round.json b/ethcore/res/authority_round.json index eccd5d5eb..b4e35b29b 100644 --- a/ethcore/res/authority_round.json +++ b/ethcore/res/authority_round.json @@ -13,7 +13,7 @@ } }, "params": { - "accountStartNonce": "0x0100000", + "accountStartNonce": "0x0", "maximumExtraDataSize": "0x20", "minGasLimit": "0x1388", "networkID" : "0x69" diff --git a/sync/src/tests/consensus.rs b/sync/src/tests/consensus.rs new file mode 100644 index 000000000..9835132f7 --- /dev/null +++ b/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 . + +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); +} + diff --git a/sync/src/tests/mod.rs b/sync/src/tests/mod.rs index bdb4ae4f9..ffd858e54 100644 --- a/sync/src/tests/mod.rs +++ b/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; diff --git a/sync/src/tests/test_net.rs b/sync/src/tests/test_net.rs new file mode 100644 index 000000000..5d06d0697 --- /dev/null +++ b/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 . + +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, + pub sender: Option, +} + +impl<'p> TestIo<'p> { + pub fn new(chain: &'p mut Arc, ss: &'p TestSnapshotService, queue: &'p mut VecDeque, sender: Option) -> 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) -> 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) -> 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, + pub snapshot_service: Arc, + pub sync: RwLock, + pub queue: VecDeque, +} + +pub struct TestNet { + pub peers: Vec, + 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(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), &[], &[], &[], &[], &[]); + } +}