Keep the minimul amount of code needed to compile tests

test-utils/client/src/lib.rs

@@ -47,6 +47,9 @@ use std::{
 	pin::Pin,
 	sync::Arc,
 };
+use sc_service::RpcSession;
+use serde::Deserialize;
+use serde_json::Value;
 
 /// Test client light database backend.
 pub type LightBackend<Block> =
@@ -297,41 +300,38 @@ impl<Block: BlockT, D, Backend, G: GenesisInit>
 	}
 }
 
-// TODO: (dp) This is **not** dead code; used in polkadot and cumulus for testing. See https://github.com/paritytech/substrate/pull/9264
-// 		 We need a solution for this.
-
-// /// The output of an RPC transaction.
-// pub struct RpcTransactionOutput {
-// 	/// The output string of the transaction if any.
-// 	pub result: Option<String>,
-// 	/// The session object.
-// 	pub session: RpcSession,
-// 	/// An async receiver if data will be returned via a callback.
-// 	pub receiver: futures::channel::mpsc::UnboundedReceiver<String>,
-// }
-
-// impl std::fmt::Debug for RpcTransactionOutput {
-// 	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-// 		write!(f, "RpcTransactionOutput {{ result: {:?}, session, receiver }}", self.result)
-// 	}
-// }
+// TODO: (dp) I don't think we actually need this but leaving for now.
+/// The output of an RPC transaction.
+pub struct RpcTransactionOutput {
+	/// The output string of the transaction if any.
+	pub result: Option<String>,
+	/// The session object.
+	pub session: RpcSession,
+	/// An async receiver if data will be returned via a callback.
+	pub receiver: futures::channel::mpsc::UnboundedReceiver<String>,
+}
 
-// /// An error for when the RPC call fails.
-// #[derive(Deserialize, Debug)]
-// pub struct RpcTransactionError {
-// 	/// A Number that indicates the error type that occurred.
-// 	pub code: i64,
-// 	/// A String providing a short description of the error.
-// 	pub message: String,
-// 	/// A Primitive or Structured value that contains additional information about the error.
-// 	pub data: Option<serde_json::Value>,
-// }
+impl std::fmt::Debug for RpcTransactionOutput {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "RpcTransactionOutput {{ result: {:?}, session, receiver }}", self.result)
+	}
+}
+/// An error for when the RPC call fails.
+#[derive(Deserialize, Debug)]
+pub struct RpcTransactionError {
+	/// A Number that indicates the error type that occurred.
+	pub code: i64,
+	/// A String providing a short description of the error.
+	pub message: String,
+	/// A Primitive or Structured value that contains additional information about the error.
+	pub data: Option<serde_json::Value>,
+}
 
-// impl std::fmt::Display for RpcTransactionError {
-// 	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-// 		std::fmt::Debug::fmt(self, f)
-// 	}
-// }
+impl std::fmt::Display for RpcTransactionError {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		std::fmt::Debug::fmt(self, f)
+	}
+}
 
 // /// An extension trait for `RpcHandlers`.
 // pub trait RpcHandlersExt {
@@ -367,25 +367,48 @@ impl<Block: BlockT, D, Backend, G: GenesisInit>
 // 	}
 // }
 
-// pub(crate) fn parse_rpc_result(
-// 	result: Option<String>,
-// 	session: RpcSession,
-// 	receiver: futures::channel::mpsc::UnboundedReceiver<String>,
-// ) -> Result<RpcTransactionOutput, RpcTransactionError> {
-// 	if let Some(ref result) = result {
-// 		let json: serde_json::Value =
-// 			serde_json::from_str(result).expect("the result can only be a JSONRPC string; qed");
-// 		let error = json.as_object().expect("JSON result is always an object; qed").get("error");
-
-// 		if let Some(error) = error {
-// 			return Err(serde_json::from_value(error.clone())
-// 				.expect("the JSONRPC result's error is always valid; qed"))
-// 		}
+// /// The output of an RPC transaction.
+// pub struct RpcTransactionOutput {
+// 	/// The output string of the transaction if any.
+// 	pub result: Option<String>,
+// 	/// The session object.
+// 	pub session: RpcSession,
+// 	/// An async receiver if data will be returned via a callback.
+// 	pub receiver: futures::channel::mpsc::UnboundedReceiver<String>,
+// }
+// impl std::fmt::Debug for RpcTransactionOutput {
+// 	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+// 		write!(f, "RpcTransactionOutput {{ result: {:?}, session, receiver }}", self.result)
 // 	}
+// }
 
-// 	Ok(RpcTransactionOutput { result, session, receiver })
+// /// bla bla
+// #[derive(Deserialize, Debug)]
+// pub struct RpcTransactionError {
+//     pub code: i64,
+//     pub message: String,
+//     pub data: Option<Value>,
 // }
 
+pub(crate) fn parse_rpc_result(
+	result: Option<String>,
+	session: RpcSession,
+	receiver: futures::channel::mpsc::UnboundedReceiver<String>,
+) -> Result<RpcTransactionOutput, RpcTransactionError> {
+	if let Some(ref result) = result {
+		let json: serde_json::Value =
+			serde_json::from_str(result).expect("the result can only be a JSONRPC string; qed");
+		let error = json.as_object().expect("JSON result is always an object; qed").get("error");
+
+		if let Some(error) = error {
+			return Err(serde_json::from_value(error.clone())
+				.expect("the JSONRPC result's error is always valid; qed"))
+		}
+	}
+
+	Ok(RpcTransactionOutput { result, session, receiver })
+}
+
 /// An extension trait for `BlockchainEvents`.
 pub trait BlockchainEventsExt<C, B>
 where
@@ -433,7 +456,7 @@ mod tests {
 
 		(mem, rx)
 	}
-
+	// TODO: (dp) This test is testing the testing code. Seems pretty pointless to me.
 	#[test]
 	fn parses_error_properly() {
 		let (mem, rx) = create_session_and_receiver();