cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/subsystem-test-helpers/src/lib.rs

@@ -19,37 +19,29 @@
 #![warn(missing_docs)]
 
 use polkadot_node_subsystem::{
-	messages::AllMessages,
-	overseer,
-	FromOverseer, SubsystemContext, SubsystemError, SubsystemResult,
-	SpawnedSubsystem, OverseerSignal,
+	messages::AllMessages, overseer, FromOverseer, OverseerSignal, SpawnedSubsystem,
+	SubsystemContext, SubsystemError, SubsystemResult,
 };
 use polkadot_node_subsystem_util::TimeoutExt;
 
-use futures::channel::mpsc;
-use futures::poll;
-use futures::prelude::*;
+use futures::{channel::mpsc, poll, prelude::*};
 use parking_lot::Mutex;
 use sp_core::{testing::TaskExecutor, traits::SpawnNamed};
 
-use std::convert::Infallible;
-use std::pin::Pin;
-use std::sync::Arc;
-use std::task::{Context, Poll, Waker};
-use std::time::Duration;
+use std::{
+	convert::Infallible,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll, Waker},
+	time::Duration,
+};
 
 /// Generally useful mock data providers for unit tests.
 pub mod mock;
 
 enum SinkState<T> {
-	Empty {
-		read_waker: Option<Waker>,
-	},
-	Item {
-		item: T,
-		ready_waker: Option<Waker>,
-		flush_waker: Option<Waker>,
-	},
+	Empty { read_waker: Option<Waker> },
+	Item { item: T, ready_waker: Option<Waker>, flush_waker: Option<Waker> },
 }
 
 /// The sink half of a single-item sink that does not resolve until the item has been read.
@@ -72,13 +64,10 @@ impl<T> Sink<T> for SingleItemSink<T> {
 		let mut state = self.0.lock();
 		match *state {
 			SinkState::Empty { .. } => Poll::Ready(Ok(())),
-			SinkState::Item {
-				ref mut ready_waker,
-				..
-			} => {
+			SinkState::Item { ref mut ready_waker, .. } => {
 				*ready_waker = Some(cx.waker().clone());
 				Poll::Pending
-			}
+			},
 		}
 	}
 
@@ -86,19 +75,14 @@ impl<T> Sink<T> for SingleItemSink<T> {
 		let mut state = self.0.lock();
 
 		match *state {
-			SinkState::Empty { ref mut read_waker } => {
+			SinkState::Empty { ref mut read_waker } =>
 				if let Some(waker) = read_waker.take() {
 					waker.wake();
-				}
-			}
+				},
 			_ => panic!("start_send called outside of empty sink state ensured by poll_ready"),
 		}
 
-		*state = SinkState::Item {
-			item,
-			ready_waker: None,
-			flush_waker: None,
-		};
+		*state = SinkState::Item { item, ready_waker: None, flush_waker: None };
 
 		Ok(())
 	}
@@ -107,13 +91,10 @@ impl<T> Sink<T> for SingleItemSink<T> {
 		let mut state = self.0.lock();
 		match *state {
 			SinkState::Empty { .. } => Poll::Ready(Ok(())),
-			SinkState::Item {
-				ref mut flush_waker,
-				..
-			} => {
+			SinkState::Item { ref mut flush_waker, .. } => {
 				*flush_waker = Some(cx.waker().clone());
 				Poll::Pending
-			}
+			},
 		}
 	}
 
@@ -132,11 +113,7 @@ impl<T> Stream for SingleItemStream<T> {
 
 		match std::mem::replace(&mut *state, SinkState::Empty { read_waker }) {
 			SinkState::Empty { .. } => Poll::Pending,
-			SinkState::Item {
-				item,
-				ready_waker,
-				flush_waker,
-			} => {
+			SinkState::Item { item, ready_waker, flush_waker } => {
 				if let Some(waker) = ready_waker {
 					waker.wake();
 				}
@@ -146,7 +123,7 @@ impl<T> Stream for SingleItemStream<T> {
 				}
 
 				Poll::Ready(Some(item))
-			}
+			},
 		}
 	}
 }
@@ -169,19 +146,13 @@ pub struct TestSubsystemSender {
 /// Construct a sender/receiver pair.
 pub fn sender_receiver() -> (TestSubsystemSender, mpsc::UnboundedReceiver<AllMessages>) {
 	let (tx, rx) = mpsc::unbounded();
-	(
-		TestSubsystemSender { tx },
-		rx,
-	)
+	(TestSubsystemSender { tx }, rx)
 }
 
 #[async_trait::async_trait]
 impl overseer::SubsystemSender<AllMessages> for TestSubsystemSender {
 	async fn send_message(&mut self, msg: AllMessages) {
-		self.tx
-			.send(msg)
-			.await
-			.expect("test overseer no longer live");
+		self.tx.send(msg).await.expect("test overseer no longer live");
 	}
 
 	async fn send_messages<T>(&mut self, msgs: T)
@@ -190,10 +161,7 @@ impl overseer::SubsystemSender<AllMessages> for TestSubsystemSender {
 		T::IntoIter: Send,
 	{
 		let mut iter = stream::iter(msgs.into_iter().map(Ok));
-		self.tx
-			.send_all(&mut iter)
-			.await
-			.expect("test overseer no longer live");
+		self.tx.send_all(&mut iter).await.expect("test overseer no longer live");
 	}
 
 	fn send_unbounded_message(&mut self, msg: AllMessages) {
@@ -209,8 +177,7 @@ pub struct TestSubsystemContext<M, S> {
 }
 
 #[async_trait::async_trait]
-impl<M, S> overseer::SubsystemContext
-	for TestSubsystemContext<M, S>
+impl<M, S> overseer::SubsystemContext for TestSubsystemContext<M, S>
 where
 	M: std::fmt::Debug + Send + 'static,
 	AllMessages: From<M>,
@@ -231,7 +198,9 @@ where
 	}
 
 	async fn recv(&mut self) -> SubsystemResult<FromOverseer<M>> {
-		self.rx.next().await
+		self.rx
+			.next()
+			.await
 			.ok_or_else(|| SubsystemError::Context("Receiving end closed".to_owned()))
 	}
 
@@ -244,9 +213,11 @@ where
 		Ok(())
 	}
 
-	fn spawn_blocking(&mut self, name: &'static str, s: Pin<Box<dyn Future<Output = ()> + Send>>)
-		-> SubsystemResult<()>
-	{
+	fn spawn_blocking(
+		&mut self,
+		name: &'static str,
+		s: Pin<Box<dyn Future<Output = ()> + Send>>,
+	) -> SubsystemResult<()> {
 		self.spawn.spawn_blocking(name, s);
 		Ok(())
 	}
@@ -272,10 +243,7 @@ impl<M> TestSubsystemContextHandle<M> {
 	/// Send a message or signal to the subsystem. This resolves at the point in time where the
 	/// subsystem has _read_ the message.
 	pub async fn send(&mut self, from_overseer: FromOverseer<M>) {
-		self.tx
-			.send(from_overseer)
-			.await
-			.expect("Test subsystem no longer live");
+		self.tx.send(from_overseer).await.expect("Test subsystem no longer live");
 	}
 
 	/// Receive the next message from the subsystem.
@@ -302,10 +270,7 @@ pub fn make_subsystem_context<M, S>(
 			rx: overseer_rx,
 			spawn,
 		},
-		TestSubsystemContextHandle {
-			tx: overseer_tx,
-			rx: all_messages_rx,
-		},
+		TestSubsystemContextHandle { tx: overseer_tx, rx: all_messages_rx },
 	)
 }
 
@@ -365,43 +330,47 @@ where
 			}
 		});
 
-		SpawnedSubsystem {
-			name: "forward-subsystem",
-			future,
-		}
+		SpawnedSubsystem { name: "forward-subsystem", future }
 	}
 }
 
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use polkadot_overseer::{Overseer, Handle, HeadSupportsParachains, AllSubsystems};
 	use futures::executor::block_on;
-	use polkadot_primitives::v1::Hash;
 	use polkadot_node_subsystem::messages::CollatorProtocolMessage;
+	use polkadot_overseer::{AllSubsystems, Handle, HeadSupportsParachains, Overseer};
+	use polkadot_primitives::v1::Hash;
 
 	struct AlwaysSupportsParachains;
 	impl HeadSupportsParachains for AlwaysSupportsParachains {
-		fn head_supports_parachains(&self, _head: &Hash) -> bool { true }
+		fn head_supports_parachains(&self, _head: &Hash) -> bool {
+			true
+		}
 	}
 
 	#[test]
 	fn forward_subsystem_works() {
 		let spawner = sp_core::testing::TaskExecutor::new();
 		let (tx, rx) = mpsc::channel(2);
-		let all_subsystems = AllSubsystems::<()>::dummy().replace_collator_protocol(ForwardSubsystem(tx));
+		let all_subsystems =
+			AllSubsystems::<()>::dummy().replace_collator_protocol(ForwardSubsystem(tx));
 		let (overseer, handle) = Overseer::new(
 			Vec::new(),
 			all_subsystems,
 			None,
 			AlwaysSupportsParachains,
 			spawner.clone(),
-		).unwrap();
+		)
+		.unwrap();
 		let mut handle = Handle::Connected(handle);
 
 		spawner.spawn("overseer", overseer.run().then(|_| async { () }).boxed());
 
 		block_on(handle.send_msg_anon(CollatorProtocolMessage::CollateOn(Default::default())));
-		assert!(matches!(block_on(rx.into_future()).0.unwrap(), CollatorProtocolMessage::CollateOn(_)));
+		assert!(matches!(
+			block_on(rx.into_future()).0.unwrap(),
+			CollatorProtocolMessage::CollateOn(_)
+		));
 	}
 }

polkadot/node/subsystem-test-helpers/src/mock.rs

@@ -14,17 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-
-
 use std::sync::Arc;
 
 use sc_keystore::LocalKeystore;
 use sp_application_crypto::AppKey;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{SyncCryptoStorePtr, SyncCryptoStore};
-
-use polkadot_primitives::v1::{ValidatorId, AuthorityDiscoveryId};
+use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 
+use polkadot_primitives::v1::{AuthorityDiscoveryId, ValidatorId};
 
 /// Get mock keystore with `Ferdie` key.
 pub fn make_ferdie_keystore() -> SyncCryptoStorePtr {
@@ -43,4 +40,3 @@ pub fn make_ferdie_keystore() -> SyncCryptoStorePtr {
 	.expect("Insert key into keystore");
 	keystore
 }
-