cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/network/dispute-distribution/src/tests/mod.rs

@@ -17,451 +17,448 @@
 
 //! Subsystem unit tests
 
-use std::collections::HashSet;
-use std::sync::Arc;
-use std::task::Poll;
-use std::time::Duration;
+use std::{collections::HashSet, sync::Arc, task::Poll, time::Duration};
 
 use assert_matches::assert_matches;
 use futures::{
-	channel::{oneshot, mpsc},
+	channel::{mpsc, oneshot},
 	future::poll_fn,
-	pin_mut,
-	SinkExt, Future
+	pin_mut, Future, SinkExt,
 };
 use futures_timer::Delay;
-use parity_scale_codec::{Encode, Decode};
+use parity_scale_codec::{Decode, Encode};
 
-use polkadot_node_network_protocol::PeerId;
-use polkadot_node_network_protocol::request_response::v1::DisputeRequest;
+use polkadot_node_network_protocol::{request_response::v1::DisputeRequest, PeerId};
 use sp_keyring::Sr25519Keyring;
 
-use polkadot_node_network_protocol::{IfDisconnected, request_response::{Recipient, Requests, v1::DisputeResponse}};
+use polkadot_node_network_protocol::{
+	request_response::{v1::DisputeResponse, Recipient, Requests},
+	IfDisconnected,
+};
 use polkadot_node_primitives::{CandidateVotes, UncheckedDisputeMessage};
-use polkadot_primitives::v1::{AuthorityDiscoveryId, CandidateHash, Hash, SessionIndex, SessionInfo};
-use polkadot_subsystem::messages::{DisputeCoordinatorMessage, ImportStatementsResult};
+use polkadot_primitives::v1::{
+	AuthorityDiscoveryId, CandidateHash, Hash, SessionIndex, SessionInfo,
+};
 use polkadot_subsystem::{
-	ActivatedLeaf, ActiveLeavesUpdate, FromOverseer, LeafStatus, OverseerSignal, Span,
 	messages::{
-		AllMessages, DisputeDistributionMessage, NetworkBridgeMessage, RuntimeApiMessage, RuntimeApiRequest
+		AllMessages, DisputeCoordinatorMessage, DisputeDistributionMessage, ImportStatementsResult,
+		NetworkBridgeMessage, RuntimeApiMessage, RuntimeApiRequest,
 	},
+	ActivatedLeaf, ActiveLeavesUpdate, FromOverseer, LeafStatus, OverseerSignal, Span,
+};
+use polkadot_subsystem_testhelpers::{
+	mock::make_ferdie_keystore, subsystem_test_harness, TestSubsystemContextHandle,
 };
-use polkadot_subsystem_testhelpers::{TestSubsystemContextHandle, mock::make_ferdie_keystore, subsystem_test_harness};
 
-use crate::{DisputeDistributionSubsystem, LOG_TARGET, Metrics};
 use self::mock::{
-	ALICE_INDEX, FERDIE_INDEX, make_candidate_receipt, make_dispute_message,
-	MOCK_AUTHORITY_DISCOVERY, MOCK_SESSION_INDEX, MOCK_SESSION_INFO, MOCK_NEXT_SESSION_INDEX,
-	MOCK_NEXT_SESSION_INFO, FERDIE_DISCOVERY_KEY,
+	make_candidate_receipt, make_dispute_message, ALICE_INDEX, FERDIE_DISCOVERY_KEY, FERDIE_INDEX,
+	MOCK_AUTHORITY_DISCOVERY, MOCK_NEXT_SESSION_INDEX, MOCK_NEXT_SESSION_INFO, MOCK_SESSION_INDEX,
+	MOCK_SESSION_INFO,
 };
+use crate::{DisputeDistributionSubsystem, Metrics, LOG_TARGET};
 
 /// Useful mock providers.
 pub mod mock;
 
 #[test]
 fn send_dispute_sends_dispute() {
-	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>|
-		async move {
+	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>| async move {
+		let (_, _) = handle_subsystem_startup(&mut handle, None).await;
 
-			let (_, _) = handle_subsystem_startup(&mut handle, None).await;
+		let relay_parent = Hash::random();
+		let candidate = make_candidate_receipt(relay_parent);
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		handle
+			.send(FromOverseer::Communication {
+				msg: DisputeDistributionMessage::SendDispute(message.clone()),
+			})
+			.await;
+		// Requests needed session info:
+		assert_matches!(
+			handle.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(
+					hash,
+					RuntimeApiRequest::SessionInfo(session_index, tx)
+				)
+			) => {
+				assert_eq!(session_index, MOCK_SESSION_INDEX);
+				assert_eq!(
+					hash,
+					message.candidate_receipt().descriptor.relay_parent
+				);
+				tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
+			}
+		);
 
-			let relay_parent = Hash::random();
-			let candidate = make_candidate_receipt(relay_parent);
-			let message =
-				make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX,).await;
-			handle.send(
-				FromOverseer::Communication {
-					msg: DisputeDistributionMessage::SendDispute(message.clone())
-				}
-			).await;
-			// Requests needed session info:
-			assert_matches!(
-				handle.recv().await,
-				AllMessages::RuntimeApi(
-					RuntimeApiMessage::Request(
-						hash,
-						RuntimeApiRequest::SessionInfo(session_index, tx)
-					)
-				) => {
-					assert_eq!(session_index, MOCK_SESSION_INDEX);
-					assert_eq!(
-						hash,
-						message.candidate_receipt().descriptor.relay_parent
-					);
-					tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
-				}
-			);
+		let expected_receivers = {
+			let info = &MOCK_SESSION_INFO;
+			info.discovery_keys
+				.clone()
+				.into_iter()
+				.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
+				.collect()
+			// All validators are also authorities in the first session, so we are
+			// done here.
+		};
+		check_sent_requests(&mut handle, expected_receivers, true).await;
 
-			let expected_receivers = {
-				let info = &MOCK_SESSION_INFO;
-				info.discovery_keys
-					.clone()
-					.into_iter()
-					.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
-					.collect()
-				// All validators are also authorities in the first session, so we are
-				// done here.
-			};
-			check_sent_requests(&mut handle, expected_receivers, true).await;
-
-			conclude(&mut handle).await;
+		conclude(&mut handle).await;
 	};
 	test_harness(test);
 }
 
 #[test]
 fn received_request_triggers_import() {
-	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>|
-		async move {
-			let (_, mut req_tx) = handle_subsystem_startup(&mut handle, None).await;
+	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>| async move {
+		let (_, mut req_tx) = handle_subsystem_startup(&mut handle, None).await;
 
-			let relay_parent = Hash::random();
-			let candidate = make_candidate_receipt(relay_parent);
-			let message =
-				make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX,).await;
+		let relay_parent = Hash::random();
+		let candidate = make_candidate_receipt(relay_parent);
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
 
-			// Non validator request should get dropped:
+		// Non validator request should get dropped:
+		let rx_response =
+			send_network_dispute_request(&mut req_tx, PeerId::random(), message.clone().into())
+				.await;
+
+		assert_matches!(
+			rx_response.await,
+			Ok(resp) => {
+				let sc_network::config::OutgoingResponse {
+					result: _,
+					reputation_changes,
+					sent_feedback: _,
+				} = resp;
+				// Peer should get punished:
+				assert_eq!(reputation_changes.len(), 1);
+			}
+		);
+
+		// Nested valid and invalid import.
+		//
+		// Nested requests from same peer should get dropped. For the invalid request even
+		// subsequent requests should get dropped.
+		nested_network_dispute_request(
+			&mut handle,
+			&mut req_tx,
+			MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Alice),
+			message.clone().into(),
+			ImportStatementsResult::InvalidImport,
+			true,
+			move |handle, req_tx, message| {
+				nested_network_dispute_request(
+					handle,
+					req_tx,
+					MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob),
+					message.clone().into(),
+					ImportStatementsResult::ValidImport,
+					false,
+					move |_, req_tx, message| async move {
+						// Another request from Alice should get dropped (request already in
+						// flight):
+						{
+							let rx_response = send_network_dispute_request(
+								req_tx,
+								MOCK_AUTHORITY_DISCOVERY
+									.get_peer_id_by_authority(Sr25519Keyring::Alice),
+								message.clone(),
+							)
+							.await;
+
+							assert_matches!(
+								rx_response.await,
+								Err(err) => {
+									tracing::trace!(
+										target: LOG_TARGET,
+										?err,
+										"Request got dropped - other request already in flight"
+									);
+								}
+							);
+						}
+						// Another request from Bob should get dropped (request already in
+						// flight):
+						{
+							let rx_response = send_network_dispute_request(
+								req_tx,
+								MOCK_AUTHORITY_DISCOVERY
+									.get_peer_id_by_authority(Sr25519Keyring::Bob),
+								message.clone(),
+							)
+							.await;
+
+							assert_matches!(
+								rx_response.await,
+								Err(err) => {
+									tracing::trace!(
+										target: LOG_TARGET,
+										?err,
+										"Request got dropped - other request already in flight"
+									);
+								}
+							);
+						}
+					},
+				)
+			},
+		)
+		.await;
+
+		// Subsequent sends from Alice should fail (peer is banned):
+		{
 			let rx_response = send_network_dispute_request(
-				&mut req_tx,
-				PeerId::random(),
-				message.clone().into()
-			).await;
-
-			assert_matches!(
-				rx_response.await,
-				Ok(resp) => {
-					let sc_network::config::OutgoingResponse {
-						result: _,
-						reputation_changes,
-						sent_feedback: _,
-					} = resp;
-					// Peer should get punished:
-					assert_eq!(reputation_changes.len(), 1);
-				}
-			);
-
-			// Nested valid and invalid import.
-			//
-			// Nested requests from same peer should get dropped. For the invalid request even
-			// subsequent requests should get dropped.
-			nested_network_dispute_request(
-				&mut handle,
 				&mut req_tx,
 				MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Alice),
 				message.clone().into(),
-				ImportStatementsResult::InvalidImport,
-				true,
-				move |handle, req_tx, message|
-					nested_network_dispute_request(
-						handle,
-						req_tx,
-						MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob),
-						message.clone().into(),
-						ImportStatementsResult::ValidImport,
-						false,
-						move |_, req_tx, message| async move {
-							// Another request from Alice should get dropped (request already in
-							// flight):
-							{
-								let rx_response = send_network_dispute_request(
-									req_tx,
-									MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Alice),
-									message.clone(),
-								).await;
+			)
+			.await;
 
-								assert_matches!(
-									rx_response.await,
-									Err(err) => {
-										tracing::trace!(
-											target: LOG_TARGET,
-											?err,
-											"Request got dropped - other request already in flight"
-										);
-									}
-								);
-							}
-							// Another request from Bob should get dropped (request already in
-							// flight):
-							{
-								let rx_response = send_network_dispute_request(
-									req_tx,
-									MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob),
-									message.clone(),
-								).await;
+			assert_matches!(
+				rx_response.await,
+				Err(err) => {
+					tracing::trace!(
+						target: LOG_TARGET,
+						?err,
+						"Request got dropped - peer is banned."
+						);
+				}
+			);
+		}
 
-								assert_matches!(
-									rx_response.await,
-									Err(err) => {
-										tracing::trace!(
-											target: LOG_TARGET,
-											?err,
-											"Request got dropped - other request already in flight"
-										);
-									}
-								);
-							}
-						}
-					)
-			).await;
+		// But should work fine for Bob:
+		nested_network_dispute_request(
+			&mut handle,
+			&mut req_tx,
+			MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob),
+			message.clone().into(),
+			ImportStatementsResult::ValidImport,
+			false,
+			|_, _, _| async {},
+		)
+		.await;
 
-			// Subsequent sends from Alice should fail (peer is banned):
-			{
-				let rx_response = send_network_dispute_request(
-					&mut req_tx,
-					MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Alice),
-					message.clone().into()
-				).await;
-
-				assert_matches!(
-					rx_response.await,
-					Err(err) => {
-						tracing::trace!(
-							target: LOG_TARGET,
-							?err,
-							"Request got dropped - peer is banned."
-							);
-					}
-				);
-			}
-
-			// But should work fine for Bob:
-			nested_network_dispute_request(
-				&mut handle,
-				&mut req_tx,
-				MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob),
-				message.clone().into(),
-				ImportStatementsResult::ValidImport,
-				false,
-				|_, _, _| async {}
-			).await;
-
-			tracing::trace!(target: LOG_TARGET, "Concluding.");
-			conclude(&mut handle).await;
+		tracing::trace!(target: LOG_TARGET, "Concluding.");
+		conclude(&mut handle).await;
 	};
 	test_harness(test);
 }
 
 #[test]
 fn disputes_are_recovered_at_startup() {
-	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>|
-		async move {
+	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>| async move {
+		let relay_parent = Hash::random();
+		let candidate = make_candidate_receipt(relay_parent);
 
-			let relay_parent = Hash::random();
-			let candidate = make_candidate_receipt(relay_parent);
+		let (_, _) = handle_subsystem_startup(&mut handle, Some(candidate.hash())).await;
 
-			let (_, _) = handle_subsystem_startup(&mut handle, Some(candidate.hash())).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		// Requests needed session info:
+		assert_matches!(
+			handle.recv().await,
+			AllMessages::DisputeCoordinator(
+				DisputeCoordinatorMessage::QueryCandidateVotes(
+					query,
+					tx,
+				)
+			) => {
+				let (session_index, candidate_hash) = query.get(0).unwrap().clone();
+				assert_eq!(session_index, MOCK_SESSION_INDEX);
+				assert_eq!(candidate_hash, candidate.hash());
+				let unchecked: UncheckedDisputeMessage = message.into();
+				tx.send(vec![(session_index, candidate_hash, CandidateVotes {
+					candidate_receipt: candidate,
+					valid: vec![(
+						unchecked.valid_vote.kind,
+						unchecked.valid_vote.validator_index,
+						unchecked.valid_vote.signature
+					)],
+					invalid: vec![(
+						unchecked.invalid_vote.kind,
+						unchecked.invalid_vote.validator_index,
+						unchecked.invalid_vote.signature
+					)],
+				})])
+				.expect("Receiver should stay alive.");
+			}
+		);
 
-			let message =
-				make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX,).await;
-			// Requests needed session info:
-			assert_matches!(
-				handle.recv().await,
-				AllMessages::DisputeCoordinator(
-					DisputeCoordinatorMessage::QueryCandidateVotes(
-						query,
-						tx,
-					)
-				) => {
-					let (session_index, candidate_hash) = query.get(0).unwrap().clone();
-					assert_eq!(session_index, MOCK_SESSION_INDEX);
-					assert_eq!(candidate_hash, candidate.hash());
-					let unchecked: UncheckedDisputeMessage = message.into();
-					tx.send(vec![(session_index, candidate_hash, CandidateVotes {
-						candidate_receipt: candidate,
-						valid: vec![(
-							unchecked.valid_vote.kind,
-							unchecked.valid_vote.validator_index,
-							unchecked.valid_vote.signature
-						)],
-						invalid: vec![(
-							unchecked.invalid_vote.kind,
-							unchecked.invalid_vote.validator_index,
-							unchecked.invalid_vote.signature
-						)],
-					})])
-					.expect("Receiver should stay alive.");
-				}
-			);
+		let expected_receivers = {
+			let info = &MOCK_SESSION_INFO;
+			info.discovery_keys
+				.clone()
+				.into_iter()
+				.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
+				.collect()
+			// All validators are also authorities in the first session, so we are
+			// done here.
+		};
+		check_sent_requests(&mut handle, expected_receivers, true).await;
 
-			let expected_receivers = {
-				let info = &MOCK_SESSION_INFO;
-				info.discovery_keys
-					.clone()
-					.into_iter()
-					.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
-					.collect()
-				// All validators are also authorities in the first session, so we are
-				// done here.
-			};
-			check_sent_requests(&mut handle, expected_receivers, true).await;
-
-			conclude(&mut handle).await;
+		conclude(&mut handle).await;
 	};
 	test_harness(test);
 }
 
 #[test]
 fn send_dispute_gets_cleaned_up() {
-	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>|
-		async move {
+	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>| async move {
+		let (old_head, _) = handle_subsystem_startup(&mut handle, None).await;
 
-			let (old_head, _) = handle_subsystem_startup(&mut handle, None).await;
+		let relay_parent = Hash::random();
+		let candidate = make_candidate_receipt(relay_parent);
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		handle
+			.send(FromOverseer::Communication {
+				msg: DisputeDistributionMessage::SendDispute(message.clone()),
+			})
+			.await;
+		// Requests needed session info:
+		assert_matches!(
+			handle.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(
+					hash,
+					RuntimeApiRequest::SessionInfo(session_index, tx)
+				)
+			) => {
+				assert_eq!(session_index, MOCK_SESSION_INDEX);
+				assert_eq!(
+					hash,
+					message.candidate_receipt().descriptor.relay_parent
+				);
+				tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
+			}
+		);
 
-			let relay_parent = Hash::random();
-			let candidate = make_candidate_receipt(relay_parent);
-			let message =
-				make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX,).await;
-			handle.send(
-				FromOverseer::Communication {
-					msg: DisputeDistributionMessage::SendDispute(message.clone())
-				}
-			).await;
-			// Requests needed session info:
-			assert_matches!(
-				handle.recv().await,
-				AllMessages::RuntimeApi(
-					RuntimeApiMessage::Request(
-						hash,
-						RuntimeApiRequest::SessionInfo(session_index, tx)
-					)
-				) => {
-					assert_eq!(session_index, MOCK_SESSION_INDEX);
-					assert_eq!(
-						hash,
-						message.candidate_receipt().descriptor.relay_parent
-					);
-					tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
-				}
-			);
+		let expected_receivers = {
+			let info = &MOCK_SESSION_INFO;
+			info.discovery_keys
+				.clone()
+				.into_iter()
+				.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
+				.collect()
+			// All validators are also authorities in the first session, so we are
+			// done here.
+		};
+		check_sent_requests(&mut handle, expected_receivers, false).await;
 
-			let expected_receivers = {
-				let info = &MOCK_SESSION_INFO;
-				info.discovery_keys
-					.clone()
-					.into_iter()
-					.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
-					.collect()
-				// All validators are also authorities in the first session, so we are
-				// done here.
-			};
-			check_sent_requests(&mut handle, expected_receivers, false).await;
+		// Give tasks a chance to finish:
+		Delay::new(Duration::from_millis(20)).await;
 
-			// Give tasks a chance to finish:
-			Delay::new(Duration::from_millis(20)).await;
+		activate_leaf(
+			&mut handle,
+			Hash::random(),
+			Some(old_head),
+			MOCK_SESSION_INDEX,
+			None,
+			// No disputes any more:
+			Vec::new(),
+		)
+		.await;
 
-			activate_leaf(
-				&mut handle,
-				Hash::random(),
-				Some(old_head),
-				MOCK_SESSION_INDEX,
-				None,
-				// No disputes any more:
-				Vec::new(),
-			).await;
+		// Yield, so subsystem can make progess:
+		Delay::new(Duration::from_millis(2)).await;
 
-			// Yield, so subsystem can make progess:
-			Delay::new(Duration::from_millis(2)).await;
-
-			conclude(&mut handle).await;
+		conclude(&mut handle).await;
 	};
 	test_harness(test);
 }
 
 #[test]
 fn dispute_retries_and_works_across_session_boundaries() {
-	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>|
-		async move {
+	let test = |mut handle: TestSubsystemContextHandle<DisputeDistributionMessage>| async move {
+		let (old_head, _) = handle_subsystem_startup(&mut handle, None).await;
 
-			let (old_head, _) = handle_subsystem_startup(&mut handle, None).await;
+		let relay_parent = Hash::random();
+		let candidate = make_candidate_receipt(relay_parent);
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		handle
+			.send(FromOverseer::Communication {
+				msg: DisputeDistributionMessage::SendDispute(message.clone()),
+			})
+			.await;
+		// Requests needed session info:
+		assert_matches!(
+			handle.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(
+					hash,
+					RuntimeApiRequest::SessionInfo(session_index, tx)
+				)
+			) => {
+				assert_eq!(session_index, MOCK_SESSION_INDEX);
+				assert_eq!(
+					hash,
+					message.candidate_receipt().descriptor.relay_parent
+				);
+				tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
+			}
+		);
 
-			let relay_parent = Hash::random();
-			let candidate = make_candidate_receipt(relay_parent);
-			let message =
-				make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX,).await;
-			handle.send(
-				FromOverseer::Communication {
-					msg: DisputeDistributionMessage::SendDispute(message.clone())
-				}
-			).await;
-			// Requests needed session info:
-			assert_matches!(
-				handle.recv().await,
-				AllMessages::RuntimeApi(
-					RuntimeApiMessage::Request(
-						hash,
-						RuntimeApiRequest::SessionInfo(session_index, tx)
-					)
-				) => {
-					assert_eq!(session_index, MOCK_SESSION_INDEX);
-					assert_eq!(
-						hash,
-						message.candidate_receipt().descriptor.relay_parent
-					);
-					tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
-				}
-			);
+		let expected_receivers: HashSet<_> = {
+			let info = &MOCK_SESSION_INFO;
+			info.discovery_keys
+				.clone()
+				.into_iter()
+				.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
+				.collect()
+			// All validators are also authorities in the first session, so we are
+			// done here.
+		};
+		// Requests don't get confirmed - dispute is carried over to next session.
+		check_sent_requests(&mut handle, expected_receivers.clone(), false).await;
 
-			let expected_receivers: HashSet<_> = {
-				let info = &MOCK_SESSION_INFO;
-				info.discovery_keys
-					.clone()
-					.into_iter()
-					.filter(|a| a != &Sr25519Keyring::Ferdie.public().into())
-					.collect()
-				// All validators are also authorities in the first session, so we are
-				// done here.
-			};
-			// Requests don't get confirmed - dispute is carried over to next session.
-			check_sent_requests(&mut handle, expected_receivers.clone(), false).await;
+		// Give tasks a chance to finish:
+		Delay::new(Duration::from_millis(20)).await;
 
-			// Give tasks a chance to finish:
-			Delay::new(Duration::from_millis(20)).await;
+		// Trigger retry:
+		let old_head2 = Hash::random();
+		activate_leaf(
+			&mut handle,
+			old_head2,
+			Some(old_head),
+			MOCK_SESSION_INDEX,
+			None,
+			vec![(MOCK_SESSION_INDEX, candidate.hash())],
+		)
+		.await;
 
-			// Trigger retry:
-			let old_head2 = Hash::random();
-			activate_leaf(
-				&mut handle,
-				old_head2,
-				Some(old_head),
-				MOCK_SESSION_INDEX,
-				None,
-				vec![(MOCK_SESSION_INDEX, candidate.hash())]
-			).await;
+		check_sent_requests(&mut handle, expected_receivers.clone(), false).await;
+		// Give tasks a chance to finish:
+		Delay::new(Duration::from_millis(20)).await;
 
-			check_sent_requests(&mut handle, expected_receivers.clone(), false).await;
-			// Give tasks a chance to finish:
-			Delay::new(Duration::from_millis(20)).await;
+		// Session change:
+		activate_leaf(
+			&mut handle,
+			Hash::random(),
+			Some(old_head2),
+			MOCK_NEXT_SESSION_INDEX,
+			Some(MOCK_NEXT_SESSION_INFO.clone()),
+			vec![(MOCK_SESSION_INDEX, candidate.hash())],
+		)
+		.await;
 
-			// Session change:
-			activate_leaf(
-				&mut handle,
-				Hash::random(),
-				Some(old_head2),
-				MOCK_NEXT_SESSION_INDEX,
-				Some(MOCK_NEXT_SESSION_INFO.clone()),
-				vec![(MOCK_SESSION_INDEX, candidate.hash())]
-			).await;
+		let expected_receivers = {
+			let validator_count = MOCK_SESSION_INFO.validators.len();
+			let old_validators = MOCK_SESSION_INFO
+				.discovery_keys
+				.clone()
+				.into_iter()
+				.take(validator_count)
+				.filter(|a| *a != *FERDIE_DISCOVERY_KEY);
 
-			let expected_receivers = {
-				let validator_count = MOCK_SESSION_INFO.validators.len();
-				let old_validators = MOCK_SESSION_INFO
-					.discovery_keys
-					.clone()
-					.into_iter()
-					.take(validator_count)
-					.filter(|a| *a != *FERDIE_DISCOVERY_KEY);
+			MOCK_NEXT_SESSION_INFO
+				.discovery_keys
+				.clone()
+				.into_iter()
+				.filter(|a| *a != *FERDIE_DISCOVERY_KEY)
+				.chain(old_validators)
+				.collect()
+		};
+		check_sent_requests(&mut handle, expected_receivers, true).await;
 
-				MOCK_NEXT_SESSION_INFO
-					.discovery_keys
-					.clone()
-					.into_iter()
-					.filter(|a| *a != *FERDIE_DISCOVERY_KEY)
-					.chain(old_validators)
-					.collect()
-			};
-			check_sent_requests(&mut handle, expected_receivers, true).await;
-
-			conclude(&mut handle).await;
+		conclude(&mut handle).await;
 	};
 	test_harness(test);
 }
@@ -472,11 +469,8 @@ async fn send_network_dispute_request(
 	message: DisputeRequest,
 ) -> oneshot::Receiver<sc_network::config::OutgoingResponse> {
 	let (pending_response, rx_response) = oneshot::channel();
-	let req = sc_network::config::IncomingRequest {
-		peer,
-		payload: message.encode(),
-		pending_response,
-	};
+	let req =
+		sc_network::config::IncomingRequest { peer, payload: message.encode(), pending_response };
 	req_tx.feed(req).await.unwrap();
 	rx_response
 }
@@ -492,30 +486,27 @@ async fn nested_network_dispute_request<'a, F, O>(
 	import_result: ImportStatementsResult,
 	need_session_info: bool,
 	inner: F,
-)
-	where
-		F: FnOnce(
-				&'a mut TestSubsystemContextHandle<DisputeDistributionMessage>,
-				&'a mut mpsc::Sender<sc_network::config::IncomingRequest>,
-				DisputeRequest,
-			) -> O + 'a,
-		O: Future<Output = ()> + 'a
+) where
+	F: FnOnce(
+			&'a mut TestSubsystemContextHandle<DisputeDistributionMessage>,
+			&'a mut mpsc::Sender<sc_network::config::IncomingRequest>,
+			DisputeRequest,
+		) -> O
+		+ 'a,
+	O: Future<Output = ()> + 'a,
 {
-	let rx_response = send_network_dispute_request(
-		req_tx,
-		peer,
-		message.clone().into()
-	).await;
+	let rx_response = send_network_dispute_request(req_tx, peer, message.clone().into()).await;
 
 	if need_session_info {
 		// Subsystem might need `SessionInfo` for determining indices:
 		match handle.recv().await {
 			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
-					_,
-					RuntimeApiRequest::SessionInfo(_, tx)
+				_,
+				RuntimeApiRequest::SessionInfo(_, tx),
 			)) => {
-				tx.send(Ok(Some(MOCK_SESSION_INFO.clone()))).expect("Receiver should stay alive.");
-			}
+				tx.send(Ok(Some(MOCK_SESSION_INFO.clone())))
+					.expect("Receiver should stay alive.");
+			},
 			unexpected => panic!("Unexpected message {:?}", unexpected),
 		}
 	}
@@ -580,21 +571,16 @@ async fn nested_network_dispute_request<'a, F, O>(
 	);
 }
 
-async fn conclude(
-	handle: &mut TestSubsystemContextHandle<DisputeDistributionMessage>,
-) {
+async fn conclude(handle: &mut TestSubsystemContextHandle<DisputeDistributionMessage>) {
 	// No more messages should be in the queue:
 	poll_fn(|ctx| {
 		let fut = handle.recv();
 		pin_mut!(fut);
 		// No requests should be inititated, as there is no longer any dispute active:
-		assert_matches!(
-			fut.poll(ctx),
-			Poll::Pending,
-			"No requests expected"
-			);
+		assert_matches!(fut.poll(ctx), Poll::Pending, "No requests expected");
 		Poll::Ready(())
-	}).await;
+	})
+	.await;
 
 	handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
 }
@@ -612,19 +598,17 @@ async fn activate_leaf(
 	active_disputes: Vec<(SessionIndex, CandidateHash)>,
 ) {
 	let has_active_disputes = !active_disputes.is_empty();
-	handle.send(FromOverseer::Signal(
-		OverseerSignal::ActiveLeaves(
-			ActiveLeavesUpdate {
-				activated: Some(ActivatedLeaf {
-					hash: activate,
-					number: 10,
-					status: LeafStatus::Fresh,
-					span: Arc::new(Span::Disabled),
-				}),
-				deactivated: deactivate.into_iter().collect(),
-			}
-	)))
-	.await;
+	handle
+		.send(FromOverseer::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate {
+			activated: Some(ActivatedLeaf {
+				hash: activate,
+				number: 10,
+				status: LeafStatus::Fresh,
+				span: Arc::new(Span::Disabled),
+			}),
+			deactivated: deactivate.into_iter().collect(),
+		})))
+		.await;
 	assert_matches!(
 		handle.recv().await,
 		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
@@ -667,10 +651,7 @@ async fn check_sent_requests(
 	confirm_receive: bool,
 ) {
 	let expected_receivers: HashSet<_> =
-		expected_receivers
-			.into_iter()
-			.map(Recipient::Authority)
-			.collect();
+		expected_receivers.into_iter().map(Recipient::Authority).collect();
 
 	// Sends to concerned validators:
 	assert_matches!(
@@ -710,11 +691,11 @@ async fn handle_subsystem_startup(
 	ongoing_dispute: Option<CandidateHash>,
 ) -> (Hash, mpsc::Sender<sc_network::config::IncomingRequest>) {
 	let (request_tx, request_rx) = mpsc::channel(5);
-	handle.send(
-		FromOverseer::Communication {
+	handle
+		.send(FromOverseer::Communication {
 			msg: DisputeDistributionMessage::DisputeSendingReceiver(request_rx),
-		}
-	).await;
+		})
+		.await;
 
 	let relay_parent = Hash::random();
 	activate_leaf(
@@ -723,19 +704,19 @@ async fn handle_subsystem_startup(
 		None,
 		MOCK_SESSION_INDEX,
 		Some(MOCK_SESSION_INFO.clone()),
-		ongoing_dispute.into_iter().map(|c| (MOCK_SESSION_INDEX, c)).collect()
-	).await;
+		ongoing_dispute.into_iter().map(|c| (MOCK_SESSION_INDEX, c)).collect(),
+	)
+	.await;
 	(relay_parent, request_tx)
 }
 
-
 /// Launch subsystem and provided test function
 ///
 /// which simulates the overseer.
 fn test_harness<TestFn, Fut>(test: TestFn)
 where
 	TestFn: FnOnce(TestSubsystemContextHandle<DisputeDistributionMessage>) -> Fut,
-	Fut: Future<Output = ()>
+	Fut: Future<Output = ()>,
 {
 	sp_tracing::try_init_simple();
 	let keystore = make_ferdie_keystore();
@@ -743,7 +724,7 @@ where
 	let subsystem = DisputeDistributionSubsystem::new(
 		keystore,
 		MOCK_AUTHORITY_DISCOVERY.clone(),
-		Metrics::new_dummy()
+		Metrics::new_dummy(),
 	);
 
 	let subsystem = |ctx| async {
@@ -755,9 +736,8 @@ where
 					?fatal,
 					"Dispute distribution exited with fatal error."
 				);
-			}
+			},
 		}
 	};
 	subsystem_test_harness(test, subsystem);
 }
-