Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base * Second run * Add CI check * Fix compilation * More unnecessary braces * Handle weights * Use --all * Use correct attributes... * Fix UI tests * AHHHHHHHHH * 🤦 * Docs * Fix compilation * 🤷 * Please stop * 🤦 x 2 * More * make rustfmt.toml consistent with polkadot Co-authored-by: André Silva <andrerfosilva@gmail.com>
2026-06-13 17:31:05 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -18,21 +18,26 @@

 use crate::worker::schema;

-use std::{sync::{Arc, Mutex}, task::Poll};
+use std::{
+	sync::{Arc, Mutex},
+	task::Poll,
+};

 use async_trait::async_trait;
-use futures::channel::mpsc::{self, channel};
-use futures::executor::{block_on, LocalPool};
-use futures::future::FutureExt;
-use futures::sink::SinkExt;
-use futures::task::LocalSpawn;
-use libp2p::{kad, core::multiaddr, PeerId};
+use futures::{
+	channel::mpsc::{self, channel},
+	executor::{block_on, LocalPool},
+	future::FutureExt,
+	sink::SinkExt,
+	task::LocalSpawn,
+};
+use libp2p::{core::multiaddr, kad, PeerId};
 use prometheus_endpoint::prometheus::default_registry;

-use sp_api::{ProvideRuntimeApi, ApiRef};
+use sp_api::{ApiRef, ProvideRuntimeApi};
 use sp_core::crypto::Public;
 use sp_keystore::{testing::KeyStore, CryptoStore};
-use sp_runtime::traits::{Zero, Block as BlockT, NumberFor};
+use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
 use substrate_test_runtime_client::runtime::Block;

 use super::*;
@@ -46,9 +51,7 @@ impl ProvideRuntimeApi<Block> for TestApi {
 	type Api = RuntimeApi;

 	fn runtime_api<'a>(&'a self) -> ApiRef<'a, Self::Api> {
-		RuntimeApi {
-			authorities: self.authorities.clone(),
-		}.into()
+		RuntimeApi { authorities: self.authorities.clone() }.into()
 	}
 }

@@ -135,10 +138,7 @@ impl Default for TestNetwork {
 		let (tx, rx) = mpsc::unbounded();
 		TestNetwork {
 			peer_id: PeerId::random(),
-			external_addresses: vec![
-				"/ip6/2001:db8::/tcp/30333"
-					.parse().unwrap(),
-			],
+			external_addresses: vec!["/ip6/2001:db8::/tcp/30333".parse().unwrap()],
 			put_value_call: Default::default(),
 			get_value_call: Default::default(),
 			event_sender: tx,
@@ -151,11 +151,17 @@ impl Default for TestNetwork {
 impl NetworkProvider for TestNetwork {
 	fn put_value(&self, key: kad::record::Key, value: Vec<u8>) {
 		self.put_value_call.lock().unwrap().push((key.clone(), value.clone()));
-		self.event_sender.clone().unbounded_send(TestNetworkEvent::PutCalled(key, value)).unwrap();
+		self.event_sender
+			.clone()
+			.unbounded_send(TestNetworkEvent::PutCalled(key, value))
+			.unwrap();
 	}
 	fn get_value(&self, key: &kad::record::Key) {
 		self.get_value_call.lock().unwrap().push(key.clone());
-		self.event_sender.clone().unbounded_send(TestNetworkEvent::GetCalled(key.clone())).unwrap();
+		self.event_sender
+			.clone()
+			.unbounded_send(TestNetworkEvent::GetCalled(key.clone()))
+			.unwrap();
 	}
 }

@@ -175,9 +181,8 @@ async fn build_dht_event(
 	key_store: &KeyStore,
 ) -> (libp2p::kad::record::Key, Vec<u8>) {
 	let mut serialized_addresses = vec![];
-	schema::AuthorityAddresses {
-		addresses: addresses.into_iter().map(|a| a.to_vec()).collect()
-	}.encode(&mut serialized_addresses)
+	schema::AuthorityAddresses { addresses: addresses.into_iter().map(|a| a.to_vec()).collect() }
+		.encode(&mut serialized_addresses)
 		.map_err(Error::EncodingProto)
 		.unwrap();

@@ -192,11 +197,9 @@ async fn build_dht_event(
 		.unwrap();

 	let mut signed_addresses = vec![];
-	schema::SignedAuthorityAddresses {
-		addresses: serialized_addresses.clone(),
-		signature,
-	}
-	.encode(&mut signed_addresses).unwrap();
+	schema::SignedAuthorityAddresses { addresses: serialized_addresses.clone(), signature }
+		.encode(&mut signed_addresses)
+		.unwrap();

 	let key = hash_authority_id(&public_key.to_raw_vec());
 	let value = signed_addresses;
@@ -208,9 +211,7 @@ fn new_registers_metrics() {
 	let (_dht_event_tx, dht_event_rx) = mpsc::channel(1000);
 	let network: Arc<TestNetwork> = Arc::new(Default::default());
 	let key_store = KeyStore::new();
-	let test_api = Arc::new(TestApi {
-		authorities: vec![],
-	});
+	let test_api = Arc::new(TestApi { authorities: vec![] });

 	let registry = prometheus_endpoint::Registry::new();

@@ -275,65 +276,67 @@ fn publish_discover_cycle() {

 	let key_store = KeyStore::new();

-	let _ = pool.spawner().spawn_local_obj(async move {
-		let node_a_public = key_store
-			.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
-			.await
-			.unwrap();
-		let test_api = Arc::new(TestApi {
-			authorities: vec![node_a_public.into()],
-		});
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			let node_a_public = key_store
+				.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+				.await
+				.unwrap();
+			let test_api = Arc::new(TestApi { authorities: vec![node_a_public.into()] });

-		let (_to_worker, from_service) = mpsc::channel(0);
-		let mut worker = Worker::new(
-			from_service,
-			test_api,
-			network.clone(),
-			Box::pin(dht_event_rx),
-			Role::PublishAndDiscover(key_store.into()),
-			None,
-			Default::default(),
-		);
+			let (_to_worker, from_service) = mpsc::channel(0);
+			let mut worker = Worker::new(
+				from_service,
+				test_api,
+				network.clone(),
+				Box::pin(dht_event_rx),
+				Role::PublishAndDiscover(key_store.into()),
+				None,
+				Default::default(),
+			);

-		worker.publish_ext_addresses(false).await.unwrap();
+			worker.publish_ext_addresses(false).await.unwrap();

-		// Expect authority discovery to put a new record onto the dht.
-		assert_eq!(network.put_value_call.lock().unwrap().len(), 1);
+			// Expect authority discovery to put a new record onto the dht.
+			assert_eq!(network.put_value_call.lock().unwrap().len(), 1);

-		let dht_event = {
-			let (key, value) = network.put_value_call.lock().unwrap().pop().unwrap();
-			sc_network::DhtEvent::ValueFound(vec![(key, value)])
-		};
+			let dht_event = {
+				let (key, value) = network.put_value_call.lock().unwrap().pop().unwrap();
+				sc_network::DhtEvent::ValueFound(vec![(key, value)])
+			};

-		// Node B discovering node A's address.
+			// Node B discovering node A's address.

-		let (mut dht_event_tx, dht_event_rx) = channel(1000);
-		let test_api = Arc::new(TestApi {
-			// Make sure node B identifies node A as an authority.
-			authorities: vec![node_a_public.into()],
-		});
-		let network: Arc<TestNetwork> = Arc::new(Default::default());
-		let key_store = KeyStore::new();
+			let (mut dht_event_tx, dht_event_rx) = channel(1000);
+			let test_api = Arc::new(TestApi {
+				// Make sure node B identifies node A as an authority.
+				authorities: vec![node_a_public.into()],
+			});
+			let network: Arc<TestNetwork> = Arc::new(Default::default());
+			let key_store = KeyStore::new();

-		let (_to_worker, from_service) = mpsc::channel(0);
-		let mut worker = Worker::new(
-			from_service,
-			test_api,
-			network.clone(),
-			Box::pin(dht_event_rx),
-			Role::PublishAndDiscover(key_store.into()),
-			None,
-			Default::default(),
-		);
+			let (_to_worker, from_service) = mpsc::channel(0);
+			let mut worker = Worker::new(
+				from_service,
+				test_api,
+				network.clone(),
+				Box::pin(dht_event_rx),
+				Role::PublishAndDiscover(key_store.into()),
+				None,
+				Default::default(),
+			);

-		dht_event_tx.try_send(dht_event.clone()).unwrap();
+			dht_event_tx.try_send(dht_event.clone()).unwrap();

-		worker.refill_pending_lookups_queue().await.unwrap();
-		worker.start_new_lookups();
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.start_new_lookups();

-		// Make authority discovery handle the event.
-		worker.handle_dht_event(dht_event).await;
-	}.boxed_local().into());
+			// Make authority discovery handle the event.
+			worker.handle_dht_event(dht_event).await;
+		}
+		.boxed_local()
+		.into(),
+	);

 	pool.run();
 }
@@ -345,9 +348,7 @@ fn terminate_when_event_stream_terminates() {
 	let (dht_event_tx, dht_event_rx) = channel(1000);
 	let network: Arc<TestNetwork> = Arc::new(Default::default());
 	let key_store = KeyStore::new();
-	let test_api = Arc::new(TestApi {
-		authorities: vec![],
-	});
+	let test_api = Arc::new(TestApi { authorities: vec![] });

 	let (to_worker, from_service) = mpsc::channel(0);
 	let worker = Worker::new(
@@ -358,7 +359,8 @@ fn terminate_when_event_stream_terminates() {
 		Role::PublishAndDiscover(key_store.into()),
 		None,
 		Default::default(),
-	).run();
+	)
+	.run();
 	futures::pin_mut!(worker);

 	block_on(async {
@@ -367,7 +369,8 @@ fn terminate_when_event_stream_terminates() {
 		// Drop sender side of service channel.
 		drop(to_worker);
 		assert_eq!(
-			Poll::Pending, futures::poll!(&mut worker),
+			Poll::Pending,
+			futures::poll!(&mut worker),
 			"Expect the authority discovery module not to terminate once the \
 			sender side of the service channel is closed.",
 		);
@@ -377,7 +380,8 @@ fn terminate_when_event_stream_terminates() {
 		drop(dht_event_tx);

 		assert_eq!(
-			Poll::Ready(()), futures::poll!(&mut worker),
+			Poll::Ready(()),
+			futures::poll!(&mut worker),
 			"Expect the authority discovery module to terminate once the \
 			 sending side of the dht event channel is closed.",
 		);
@@ -390,14 +394,13 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 		let peer_id = PeerId::random();
 		let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();

-		address.with(multiaddr::Protocol::P2p(
-			peer_id.into(),
-		))
+		address.with(multiaddr::Protocol::P2p(peer_id.into()))
 	};
 	let remote_key_store = KeyStore::new();
-	let remote_public_key: AuthorityId = block_on(
-		remote_key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None),
-	).unwrap().into();
+	let remote_public_key: AuthorityId =
+		block_on(remote_key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
+			.unwrap()
+			.into();

 	let (mut dht_event_tx, dht_event_rx) = channel(1);
 	let (network, mut network_events) = {
@@ -407,9 +410,7 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 	};

 	let key_store = KeyStore::new();
-	let test_api = Arc::new(TestApi {
-		authorities: vec![remote_public_key.clone()],
-	});
+	let test_api = Arc::new(TestApi { authorities: vec![remote_public_key.clone()] });
 	let mut pool = LocalPool::new();

 	let (mut to_worker, from_service) = mpsc::channel(1);
@@ -427,30 +428,35 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 	//
 	// As this is a local pool, only one future at a time will have the CPU and
 	// can make progress until the future returns `Pending`.
-	let _ = pool.spawner().spawn_local_obj(async move {
-		// Refilling `pending_lookups` only happens every X minutes. Fast
-		// forward by calling `refill_pending_lookups_queue` directly.
-		worker.refill_pending_lookups_queue().await.unwrap();
-		worker.run().await
-	}.boxed_local().into());
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			// Refilling `pending_lookups` only happens every X minutes. Fast
+			// forward by calling `refill_pending_lookups_queue` directly.
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.run().await
+		}
+		.boxed_local()
+		.into(),
+	);

 	pool.run_until(async {
 		// Assert worker to trigger a lookup for the one and only authority.
-		assert!(matches!(
-			network_events.next().await,
-			Some(TestNetworkEvent::GetCalled(_))
-		));
+		assert!(matches!(network_events.next().await, Some(TestNetworkEvent::GetCalled(_))));

 		// Send an event that should generate an error
-		dht_event_tx.send(DhtEvent::ValueFound(Default::default())).await
+		dht_event_tx
+			.send(DhtEvent::ValueFound(Default::default()))
+			.await
 			.expect("Channel has capacity of 1.");

 		// Make previously triggered lookup succeed.
 		let dht_event = {
 			let (key, value) = build_dht_event(
 				vec![remote_multiaddr.clone()],
-				remote_public_key.clone(), &remote_key_store,
-			).await;
+				remote_public_key.clone(),
+				&remote_key_store,
+			)
+			.await;
 			sc_network::DhtEvent::ValueFound(vec![(key, value)])
 		};
 		dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
@@ -458,10 +464,10 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 		// Expect authority discovery to function normally, now knowing the
 		// address for the remote node.
 		let (sender, addresses) = futures::channel::oneshot::channel();
-		to_worker.send(ServicetoWorkerMsg::GetAddressesByAuthorityId(
-			remote_public_key,
-			sender,
-		)).await.expect("Channel has capacity of 1.");
+		to_worker
+			.send(ServicetoWorkerMsg::GetAddressesByAuthorityId(remote_public_key, sender))
+			.await
+			.expect("Channel has capacity of 1.");
 		assert_eq!(Some(vec![remote_multiaddr]), addresses.await.unwrap());
 	});
 }
@@ -469,23 +475,19 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 #[test]
 fn limit_number_of_addresses_added_to_cache_per_authority() {
 	let remote_key_store = KeyStore::new();
-	let remote_public = block_on(remote_key_store
-		.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
-		.unwrap();
+	let remote_public =
+		block_on(remote_key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
+			.unwrap();

-	let addresses = (0..100).map(|_| {
-		let peer_id = PeerId::random();
-		let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();
-		address.with(multiaddr::Protocol::P2p(
-			peer_id.into(),
-		))
-	}).collect();
+	let addresses = (0..100)
+		.map(|_| {
+			let peer_id = PeerId::random();
+			let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();
+			address.with(multiaddr::Protocol::P2p(peer_id.into()))
+		})
+		.collect();

-	let dht_event = block_on(build_dht_event(
-		addresses,
-		remote_public.into(),
-		&remote_key_store,
-	));
+	let dht_event = block_on(build_dht_event(addresses, remote_public.into(), &remote_key_store));

 	let (_dht_event_tx, dht_event_rx) = channel(1);

@@ -506,16 +508,20 @@ fn limit_number_of_addresses_added_to_cache_per_authority() {
 	worker.handle_dht_value_found_event(vec![dht_event]).unwrap();
 	assert_eq!(
 		MAX_ADDRESSES_PER_AUTHORITY,
-		worker.addr_cache.get_addresses_by_authority_id(&remote_public.into()).unwrap().len(),
+		worker
+			.addr_cache
+			.get_addresses_by_authority_id(&remote_public.into())
+			.unwrap()
+			.len(),
 	);
 }

 #[test]
 fn do_not_cache_addresses_without_peer_id() {
 	let remote_key_store = KeyStore::new();
-	let remote_public = block_on(remote_key_store
-		.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
-		.unwrap();
+	let remote_public =
+		block_on(remote_key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
+			.unwrap();

 	let multiaddr_with_peer_id = {
 		let peer_id = PeerId::random();
@@ -524,21 +530,17 @@ fn do_not_cache_addresses_without_peer_id() {
 		address.with(multiaddr::Protocol::P2p(peer_id.into()))
 	};

-	let multiaddr_without_peer_id: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();
+	let multiaddr_without_peer_id: Multiaddr =
+		"/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();

 	let dht_event = block_on(build_dht_event(
-		vec![
-			multiaddr_with_peer_id.clone(),
-			multiaddr_without_peer_id,
-		],
+		vec![multiaddr_with_peer_id.clone(), multiaddr_without_peer_id],
 		remote_public.into(),
 		&remote_key_store,
 	));

 	let (_dht_event_tx, dht_event_rx) = channel(1);
-	let local_test_api = Arc::new(TestApi {
-		authorities: vec![remote_public.into()],
-	});
+	let local_test_api = Arc::new(TestApi { authorities: vec![remote_public.into()] });
 	let local_network: Arc<TestNetwork> = Arc::new(Default::default());
 	let local_key_store = KeyStore::new();

@@ -578,9 +580,7 @@ fn addresses_to_publish_adds_p2p() {
 	let (_to_worker, from_service) = mpsc::channel(0);
 	let worker = Worker::new(
 		from_service,
-		Arc::new(TestApi {
-			authorities: vec![],
-		}),
+		Arc::new(TestApi { authorities: vec![] }),
 		network.clone(),
 		Box::pin(dht_event_rx),
 		Role::PublishAndDiscover(Arc::new(KeyStore::new())),
@@ -605,17 +605,16 @@ fn addresses_to_publish_respects_existing_p2p_protocol() {
 	let network: Arc<TestNetwork> = Arc::new(TestNetwork {
 		external_addresses: vec![
 			"/ip6/2001:db8::/tcp/30333/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC"
-				.parse().unwrap(),
+				.parse()
+				.unwrap(),
 		],
-		.. Default::default()
+		..Default::default()
 	});

 	let (_to_worker, from_service) = mpsc::channel(0);
 	let worker = Worker::new(
 		from_service,
-		Arc::new(TestApi {
-			authorities: vec![],
-		}),
+		Arc::new(TestApi { authorities: vec![] }),
 		network.clone(),
 		Box::pin(dht_event_rx),
 		Role::PublishAndDiscover(Arc::new(KeyStore::new())),
@@ -624,7 +623,8 @@ fn addresses_to_publish_respects_existing_p2p_protocol() {
 	);

 	assert_eq!(
-		network.external_addresses, worker.addresses_to_publish().collect::<Vec<_>>(),
+		network.external_addresses,
+		worker.addresses_to_publish().collect::<Vec<_>>(),
 		"Expected Multiaddr from `TestNetwork` to not be altered.",
 	);
 }
@@ -635,21 +635,21 @@ fn lookup_throttling() {
 		let peer_id = PeerId::random();
 		let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();

-		address.with(multiaddr::Protocol::P2p(
-			peer_id.into(),
-		))
+		address.with(multiaddr::Protocol::P2p(peer_id.into()))
 	};
 	let remote_key_store = KeyStore::new();
-	let remote_public_keys: Vec<AuthorityId> = (0..20).map(|_| {
-		block_on(remote_key_store
-				 .sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
-				 .unwrap().into()
-	}).collect();
-	let remote_hash_to_key = remote_public_keys.iter()
+	let remote_public_keys: Vec<AuthorityId> = (0..20)
+		.map(|_| {
+			block_on(remote_key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None))
+				.unwrap()
+				.into()
+		})
+		.collect();
+	let remote_hash_to_key = remote_public_keys
+		.iter()
 		.map(|k| (hash_authority_id(k.as_ref()), k.clone()))
 		.collect::<HashMap<_, _>>();

-
 	let (mut dht_event_tx, dht_event_rx) = channel(1);
 	let (_to_worker, from_service) = mpsc::channel(0);
 	let mut network = TestNetwork::default();
@@ -668,56 +668,61 @@ fn lookup_throttling() {
 	let mut pool = LocalPool::new();
 	let metrics = worker.metrics.clone().unwrap();

-	let _ = pool.spawner().spawn_local_obj(async move {
-		// Refilling `pending_lookups` only happens every X minutes. Fast
-		// forward by calling `refill_pending_lookups_queue` directly.
-		worker.refill_pending_lookups_queue().await.unwrap();
-		worker.run().await
-	}.boxed_local().into());
-
-	pool.run_until(async {
-		// Assert worker to trigger MAX_IN_FLIGHT_LOOKUPS lookups.
-		for _ in 0..MAX_IN_FLIGHT_LOOKUPS {
-			assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			// Refilling `pending_lookups` only happens every X minutes. Fast
+			// forward by calling `refill_pending_lookups_queue` directly.
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.run().await
 		}
-		assert_eq!(
-			metrics.requests_pending.get(),
-			(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS) as u64
-		);
-		assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+		.boxed_local()
+		.into(),
+	);

-		// Make first lookup succeed.
-		let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
-		let remote_key: AuthorityId = remote_hash_to_key.get(&remote_hash).unwrap().clone();
-		let dht_event = {
-			let (key, value) = build_dht_event(
-				vec![remote_multiaddr.clone()],
-				remote_key,
-				&remote_key_store
-			).await;
-			sc_network::DhtEvent::ValueFound(vec![(key, value)])
-		};
-		dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+	pool.run_until(
+		async {
+			// Assert worker to trigger MAX_IN_FLIGHT_LOOKUPS lookups.
+			for _ in 0..MAX_IN_FLIGHT_LOOKUPS {
+				assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			}
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);

-		// Assert worker to trigger another lookup.
-		assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
-		assert_eq!(
-			metrics.requests_pending.get(),
-			(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 1) as u64
-		);
-		assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+			// Make first lookup succeed.
+			let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
+			let remote_key: AuthorityId = remote_hash_to_key.get(&remote_hash).unwrap().clone();
+			let dht_event = {
+				let (key, value) =
+					build_dht_event(vec![remote_multiaddr.clone()], remote_key, &remote_key_store)
+						.await;
+				sc_network::DhtEvent::ValueFound(vec![(key, value)])
+			};
+			dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");

-		// Make second one fail.
-		let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
-		let dht_event = sc_network::DhtEvent::ValueNotFound(remote_hash);
-		dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+			// Assert worker to trigger another lookup.
+			assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 1) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);

-		// Assert worker to trigger another lookup.
-		assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
-		assert_eq!(
-			metrics.requests_pending.get(),
-			(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 2) as u64
-		);
-		assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
-	}.boxed_local());
+			// Make second one fail.
+			let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
+			let dht_event = sc_network::DhtEvent::ValueNotFound(remote_hash);
+			dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+
+			// Assert worker to trigger another lookup.
+			assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 2) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+		}
+		.boxed_local(),
+	);
 }