babe: fix tests

core/consensus/babe/src/lib.rs

@@ -1426,30 +1426,27 @@ pub mod test_helpers {
 	/// Try to claim the given slot and return a `BabePreDigest` if
 	/// successful.
 	pub fn claim_slot<B, C>(
-		client: &C,
-		at: &BlockId<B>,
 		slot_number: u64,
+		parent: &B::Header,
+		client: &C,
 		c: (u64, u64),
 		keystore: &KeyStorePtr,
 	) -> Option<BabePreDigest> where
 		B: BlockT,
 		C: ProvideRuntimeApi + ProvideCache<B>,
 		C::Api: BabeApi<B>,
 	{
-		let epoch = epoch(client, at).unwrap();
+		let epoch = epoch(client, &BlockId::Hash(parent.hash())).unwrap();
+
+		let weight = find_pre_digest::<B>(parent).ok()
+			.map(|d| d.weight())?;
 
 		super::claim_slot(
 			slot_number,
+			weight,
 			&epoch,
 			c,
 			keystore,
-		).map(|((inout, vrf_proof, _), authority_index, _)| {
-			BabePreDigest {
-				vrf_proof,
-				vrf_output: inout.to_output(),
-				authority_index: authority_index as u32,
-				slot_number,
-			}
-		})
+		).map(|(digest, _)| digest)
 	}
 }

core/consensus/babe/src/tests.rs

@@ -20,22 +20,22 @@
 // https://github.com/paritytech/substrate/issues/2532
 #![allow(deprecated)]
 use super::*;
-use super::generic::DigestItem;
 
 use babe_primitives::AuthorityPair;
 use client::{LongestChain, block_builder::BlockBuilder};
 use consensus_common::NoNetwork as DummyOracle;
 use network::test::*;
 use network::test::{Block as TestBlock, PeersClient};
-use sr_primitives::traits::{Block as BlockT, DigestFor};
+use sr_primitives::{generic::DigestItem, traits::{Block as BlockT, DigestFor}};
 use network::config::ProtocolConfig;
 use tokio::runtime::current_thread;
 use keyring::sr25519::Keyring;
 use client::BlockchainEvents;
 use test_client;
 use log::debug;
 use std::{time::Duration, borrow::Borrow, cell::RefCell};
-type Item = generic::DigestItem<Hash>;
+
+type Item = DigestItem<Hash>;
 
 type Error = client::error::Error;
 
@@ -88,7 +88,14 @@ type TestHeader = <TestBlock as BlockT>::Header;
 type TestExtrinsic = <TestBlock as BlockT>::Extrinsic;
 
 pub struct TestVerifier {
-	inner: BabeVerifier<PeersFullClient, ()>,
+	inner: BabeVerifier<
+		test_client::Backend,
+		test_client::Executor,
+		TestBlock,
+		test_client::runtime::RuntimeApi,
+		PeersFullClient,
+		()
+	>,
 	mutator: Mutator,
 }
 
@@ -126,9 +133,9 @@ impl TestNetFactory for BabeTestNet {
 	fn make_verifier(&self, client: PeersClient, _cfg: &ProtocolConfig)
 		-> Self::Verifier
 	{
-		let api = client.as_full().expect("only full clients are used in test");
+		let client = client.as_full().expect("only full clients are used in test");
 		trace!(target: "babe", "Creating a verifier");
-		let config = Config::get_or_compute(&*api)
+		let config = Config::get_or_compute(&*client)
 			.expect("slot duration available");
 		let inherent_data_providers = InherentDataProviders::new();
 		register_babe_inherent_data_provider(
@@ -139,7 +146,8 @@ impl TestNetFactory for BabeTestNet {
 
 		TestVerifier {
 			inner: BabeVerifier {
-				api,
+				client: client.clone(),
+				api: client,
 				inherent_data_providers,
 				config,
 				time_source: Default::default(),
@@ -324,8 +332,11 @@ fn can_author_block() {
 		epoch_index: 1,
 		duration: 100,
 	};
+
+	let parent_weight = 0;
+
 	loop {
-		match claim_slot(i, &epoch.clone(), (3, 10), &keystore) {
+		match claim_slot(i, parent_weight, &epoch.clone(), (3, 10), &keystore) {
 			None => i += 1,
 			Some(s) => {
 				debug!(target: "babe", "Authored block {:?}", s.0);

node/cli/src/service.rs

@@ -401,9 +401,9 @@ mod tests {
 			let babe_pre_digest = loop {
 				inherent_data.replace_data(timestamp::INHERENT_IDENTIFIER, &(slot_num * SLOT_DURATION));
 				if let Some(babe_pre_digest) = babe::test_helpers::claim_slot(
-					&*service.client(),
-					&parent_id,
 					slot_num,
+					&parent_header,
+					&*service.client(),
 					(278, 1000),
 					&keystore,
 				) {