remove connected disconnected state, 3rd attempt (#3898)

* overseer: remove mut in connector

* rename SelectRelayChainWFallback -> SelectRelayChain

* split Basics

* introduce the OverseerConnector, use it

* introduce is_relay_chain to RelayChainSelection

* chore: rename var

* avoid dummy import in subsystem

* actually remove Disconnecte/Connected enum

* extract DummySubsystem into mod dummy.

* Handle::Connected -> Handle::new

* chore: fmt

* fix test

* select relay chain takes no arg, simplification

* fmt

* Update node/service/src/lib.rs

Co-authored-by: Andronik Ordian <write@reusable.software>

* chore: improve malus tests

* avoid the deferred setting of `is_relay_chain` in `RelayChainSelection`

* positive assertion is not mandated, only the negative one, to avoid a stall

* chore: fmt

* assure the `RelayChainSelection` is not used before the overseer is up and running

Co-authored-by: Andronik Ordian <write@reusable.software>

polkadot/node/malus/src/tests.rs

@@ -20,8 +20,8 @@ use polkadot_node_subsystem_test_helpers::*;
 
 use polkadot_node_subsystem::{
 	messages::{AllMessages, AvailabilityStoreMessage},
-	overseer::{gen::TimeoutExt, Subsystem},
-	DummySubsystem,
+	overseer::{dummy::DummySubsystem, gen::TimeoutExt, Subsystem},
+	SubsystemError,
 };
 
 #[derive(Clone, Debug)]
@@ -48,34 +48,38 @@ where
 	}
 }
 
+#[derive(Clone, Debug)]
+struct PassInterceptor;
+
+impl<Sender> MessageInterceptor<Sender> for PassInterceptor
+where
+	Sender: overseer::SubsystemSender<AllMessages>
+		+ overseer::SubsystemSender<AvailabilityStoreMessage>
+		+ Clone
+		+ 'static,
+{
+	type Message = AvailabilityStoreMessage;
+}
+
 async fn overseer_send<T: Into<AllMessages>>(overseer: &mut TestSubsystemContextHandle<T>, msg: T) {
 	overseer.send(FromOverseer::Communication { msg }).await;
 }
 
-#[test]
-fn integrity_test() {
+fn launch_harness<F, M, Sub, G>(test_gen: G)
+where
+	F: Future<Output = TestSubsystemContextHandle<M>> + Send,
+	M: Into<AllMessages> + std::fmt::Debug + Send + 'static,
+	AllMessages: From<M>,
+	Sub: Subsystem<TestSubsystemContext<M, sp_core::testing::TaskExecutor>, SubsystemError>,
+	G: Fn(TestSubsystemContextHandle<M>) -> (F, Sub),
+{
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, mut overseer) = make_subsystem_context(pool);
+	let (context, overseer) = make_subsystem_context(pool);
 
-	let sub = DummySubsystem;
-
-	let sub_intercepted = InterceptedSubsystem::new(sub, BlackHoleInterceptor);
-
-	// Try to send a message we know is going to be filtered.
-	let test_fut = async move {
-		let (tx, rx) = futures::channel::oneshot::channel();
-		overseer_send(
-			&mut overseer,
-			AvailabilityStoreMessage::QueryChunk(Default::default(), 0.into(), tx),
-		)
-		.await;
-		let _ = rx.timeout(std::time::Duration::from_millis(100)).await.unwrap();
-		overseer
-	};
+	let (test_fut, subsystem) = test_gen(overseer);
 	let subsystem = async move {
-		sub_intercepted.start(context).future.await.unwrap();
+		subsystem.start(context).future.await.unwrap();
 	};
-
 	futures::pin_mut!(test_fut);
 	futures::pin_mut!(subsystem);
 
@@ -88,3 +92,49 @@ fn integrity_test() {
 	))
 	.1;
 }
+
+#[test]
+fn integrity_test_intercept() {
+	launch_harness(|mut overseer| {
+		let sub = DummySubsystem;
+
+		let sub_intercepted = InterceptedSubsystem::new(sub, BlackHoleInterceptor);
+
+		(
+			async move {
+				let (tx, rx) = futures::channel::oneshot::channel();
+				overseer_send(
+					&mut overseer,
+					AvailabilityStoreMessage::QueryChunk(Default::default(), 0.into(), tx),
+				)
+				.await;
+				let _ = rx.timeout(std::time::Duration::from_millis(100)).await.unwrap();
+				overseer
+			},
+			sub_intercepted,
+		)
+	})
+}
+
+#[test]
+fn integrity_test_pass() {
+	launch_harness(|mut overseer| {
+		let sub = DummySubsystem;
+
+		let sub_intercepted = InterceptedSubsystem::new(sub, PassInterceptor);
+
+		(
+			async move {
+				let (tx, rx) = futures::channel::oneshot::channel();
+				overseer_send(
+					&mut overseer,
+					AvailabilityStoreMessage::QueryChunk(Default::default(), 0.into(), tx),
+				)
+				.await;
+				let _ = rx.timeout(std::time::Duration::from_millis(100)).await.unwrap();
+				overseer
+			},
+			sub_intercepted,
+		)
+	})
+}