tests compile after changes

substrate/core/finality-grandpa/src/tests.rs

@@ -6,16 +6,34 @@ use parking_lot::Mutex;
 use tokio::runtime::current_thread;
 use keyring::Keyring;
 use client::BlockchainEvents;
-use test_client;
+use test_client::{self, runtime::BlockNumber};
 
 type PeerData = Mutex<Option<LinkHalf<test_client::Backend, test_client::Executor, Block>>>;
 type GrandpaPeer = Peer<PassThroughVerifier, PeerData>;
 
 struct GrandpaTestNet {
 	peers: Vec<Arc<GrandpaPeer>>,
+	test_config: TestApi,
 	started: bool
 }
 
+impl GrandpaTestNet {
+	fn new(test_config: TestApi, n_peers: usize) -> Self {
+		let mut net = GrandpaTestNet {
+			peers: Vec::with_capacity(n_peers),
+			started: false,
+			test_config,
+		};
+		let config = Self::default_config();
+
+		for _ in 0..n_peers {
+			net.add_peer(&config);
+		}
+
+		net
+	}
+}
+
 impl TestNetFactory for GrandpaTestNet {
 	type Verifier = PassThroughVerifier;
 	type PeerData = PeerData;
@@ -24,6 +42,7 @@ impl TestNetFactory for GrandpaTestNet {
 	fn from_config(_config: &ProtocolConfig) -> Self {
 		GrandpaTestNet {
 			peers: Vec::new(),
+			test_config: Default::default(),
 			started: false
 		}
 	}
@@ -37,7 +56,7 @@ impl TestNetFactory for GrandpaTestNet {
 	fn make_block_import(&self, client: Arc<PeersClient>)
 		-> (Arc<BlockImport<Block,Error=ClientError> + Send + Sync>, PeerData)
 	{
-		let (import, link) = block_import(client).expect("Could not create block import for fresh peer.");
+		let (import, link) = block_import(client, self.test_config.clone()).expect("Could not create block import for fresh peer.");
 		(Arc::new(import), Mutex::new(Some(link)))
 	}
 
@@ -113,43 +132,74 @@ impl Network for MessageRouting {
 	}
 }
 
+#[derive(Default, Clone)]
+struct TestApi {
+	genesis_authorities: Vec<(AuthorityId, u64)>,
+	scheduled_changes: HashMap<BlockNumber, ScheduledChange<BlockNumber>>,
+}
+
+impl TestApi {
+	fn new(genesis_authorities: Vec<(AuthorityId, u64)>) -> Self {
+		TestApi {
+			genesis_authorities,
+			scheduled_changes: HashMap::new(),
+		}
+	}
+}
+
+impl ApiClient<Block> for TestApi {
+	fn genesis_authorities(&self) -> Result<Vec<(AuthorityId, u64)>, ClientError> {
+		Ok(self.genesis_authorities.clone())
+	}
+
+	fn scheduled_change(&self, header: &<Block as BlockT>::Header)
+		-> Result<Option<ScheduledChange<NumberFor<Block>>>, ClientError>
+	{
+		// we take only scheduled changes at given block number where there are no
+		// extrinsics.
+		Ok(self.scheduled_changes.get(header.number()).map(|c| c.clone()))
+	}
+}
+
 const TEST_GOSSIP_DURATION: Duration = Duration::from_millis(500);
 const TEST_ROUTING_INTERVAL: Duration = Duration::from_millis(50);
 
 #[test]
-fn finalize_20_unanimous_3_peers() {
-	let mut net = GrandpaTestNet::new(3);
+fn finalize_3_voters_no_observers() {
+	let peers = &[Keyring::Alice, Keyring::Bob, Keyring::Charlie];
+	let voters: Vec<_> = peers.iter()
+		.map(|key| AuthorityId(key.to_raw_public()))
+		.map(|id| (id, 1))
+		.collect();
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 3);
 	net.peer(0).push_blocks(20, false);
 	net.sync();
 
-	let net = Arc::new(Mutex::new(net));
-	let peers = &[
-		(0, Keyring::Alice),
-		(1, Keyring::Bob),
-		(2, Keyring::Charlie),
-	];
+	for i in 0..3 {
+		assert_eq!(net.peer(i).client().info().unwrap().chain.best_number, 20,
+			"Peer #{} failed to sync", i);
+	}
 
-	let voters: Vec<_> = peers.iter()
-		.map(|&(_, ref key)| AuthorityId(key.to_raw_public()))
-		.collect();
+	let net = Arc::new(Mutex::new(net));
 
 	let mut finality_notifications = Vec::new();
-
 	let mut runtime = current_thread::Runtime::new().unwrap();
-	for (peer_id, key) in peers {
+
+	for (peer_id, key) in peers.iter().enumerate() {
 		let (client, link) = {
 			let mut net = net.lock();
 			// temporary needed for some reason
-			let link = net.peers[*peer_id].data.lock().take().expect("link initialized at startup; qed");
+			let link = net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");
 			(
-				net.peers[*peer_id].client().clone(),
+				net.peers[peer_id].client().clone(),
 				link,
 			)
 		};
 		finality_notifications.push(
 			client.finality_notification_stream()
 				.take_while(|n| Ok(n.header.number() < &20))
-				.for_each(move |_| Ok(()))
+				.for_each(|_| Ok(()))
 		);
 		let voter = run_grandpa(
 			Config {
@@ -157,7 +207,7 @@ fn finalize_20_unanimous_3_peers() {
 				local_key: Some(Arc::new(key.clone().into())),
 			},
 			link,
-			MessageRouting::new(net.clone(), *peer_id),
+			MessageRouting::new(net.clone(), peer_id),
 		).expect("all in order with client and network");
 
 		runtime.spawn(voter);
@@ -177,31 +227,27 @@ fn finalize_20_unanimous_3_peers() {
 }
 
 #[test]
-fn observer_can_finalize() {
-	let mut net = GrandpaTestNet::new(4);
+fn finalize_3_voters_1_observer() {
+	let peers = &[Keyring::Alice, Keyring::Bob, Keyring::Charlie];
+	let voters: Vec<_> = peers.iter()
+		.map(|key| AuthorityId(key.to_raw_public()))
+		.map(|id| (id, 1))
+		.collect();
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 4);
 	net.peer(0).push_blocks(20, false);
 	net.sync();
 
 	let net = Arc::new(Mutex::new(net));
-	let peers = &[
-		(0, Keyring::Alice),
-		(1, Keyring::Bob),
-		(2, Keyring::Charlie),
-	];
-
-	let voters: HashMap<_, _> = peers.iter()
-		.map(|&(_, ref key)| (AuthorityId(key.to_raw_public()), 1))
-		.collect();
-
 	let mut finality_notifications = Vec::new();
 
 	let mut runtime = current_thread::Runtime::new().unwrap();
 	let all_peers = peers.iter()
 		.cloned()
-		.map(|(id, key)| (id, Some(Arc::new(key.into()))))
-		.chain(::std::iter::once((3, None)));
+		.map(|key| Some(Arc::new(key.into())))
+		.chain(::std::iter::once(None));
 
-	for (peer_id, local_key) in all_peers {
+	for (peer_id, local_key) in all_peers.enumerate() {
 		let (client, link) = {
 			let mut net = net.lock();
 			let link = net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");