fix(client): adjust TransportSenderT (#852)

* fix(client): adjust TransportSenderT

This is trait contains `WebSocket` specific details and it's difficult to fix it properly with an extension trait
in the current design.

So this PR documents and marks it clearly that these methods are optional to implement, kind of ugly but better.

* fix build

* Update core/src/client/mod.rs

Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>

* Update core/src/client/mod.rs

Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>

* increase margin for failing test

* Update core/src/client/mod.rs

Co-authored-by: James Wilson <james@jsdw.me>

* remove optional prefix in trait

Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>
Co-authored-by: James Wilson <james@jsdw.me>

client/transport/src/web.rs

@@ -54,15 +54,6 @@ impl TransportSenderT for Sender {
 		self.0.send(Message::Text(msg)).await.map_err(|e| Error::WebSocket(e))?;
 		Ok(())
 	}
-
-	async fn send_ping(&mut self) -> Result<(), Self::Error> {
-		tracing::trace!("send ping - not implemented for wasm");
-		Err(Error::NotSupported)
-	}
-
-	async fn close(&mut self) -> Result<(), Error> {
-		Ok(())
-	}
 }
 
 #[async_trait(?Send)]

core/src/client/async_client/mod.rs

@@ -260,7 +260,9 @@ impl ClientT for Client {
 				Either::Left((Err(_), _)) => Err(self.read_error_from_backend().await),
 				Either::Right((_, _)) => Err(Error::RequestTimeout),
 			}
-        }.instrument(trace.into_span()).await
+		}
+		.instrument(trace.into_span())
+		.await
 	}
 
 	async fn request<'a, R>(&self, method: &'a str, params: Option<ParamsSer<'a>>) -> Result<R, Error>
@@ -296,7 +298,9 @@ impl ClientT for Client {
 			rx_log_from_json(&Response::new(&json_value, id), self.max_log_length);
 
 			serde_json::from_value(json_value).map_err(Error::ParseError)
-        }.instrument(trace.into_span()).await
+		}
+		.instrument(trace.into_span())
+		.await
 	}
 
 	async fn batch_request<'a, R>(&self, batch: Vec<(&'a str, Option<ParamsSer<'a>>)>) -> Result<Vec<R>, Error>
@@ -338,7 +342,9 @@ impl ClientT for Client {
 			rx_log_from_json(&json_values, self.max_log_length);
 
 			json_values.into_iter().map(|val| serde_json::from_value(val).map_err(Error::ParseError)).collect()
-        }.instrument(trace.into_span()).await
+		}
+		.instrument(trace.into_span())
+		.await
 	}
 }
 
@@ -368,7 +374,8 @@ impl SubscriptionClientT for Client {
 		async {
 			let id = ids[0].clone();
 
-            let raw = serde_json::to_string(&RequestSer::new(&id, subscribe_method, params)).map_err(Error::ParseError)?;
+			let raw =
+				serde_json::to_string(&RequestSer::new(&id, subscribe_method, params)).map_err(Error::ParseError)?;
 
 			tx_log_from_str(&raw, self.max_log_length);
 
@@ -400,7 +407,9 @@ impl SubscriptionClientT for Client {
 			rx_log_from_json(&Response::new(&sub_id, id), self.max_log_length);
 
 			Ok(Subscription::new(self.to_back.clone(), notifs_rx, SubscriptionKind::Subscription(sub_id)))
-        }.instrument(trace.into_span()).await
+		}
+		.instrument(trace.into_span())
+		.await
 	}
 
 	/// Subscribe to a specific method.

core/src/client/mod.rs

@@ -132,10 +132,18 @@ pub trait TransportSenderT: MaybeSend + 'static {
 	/// Send.
 	async fn send(&mut self, msg: String) -> Result<(), Self::Error>;
 
+	/// This is optional because it's most likely relevant for WebSocket transports only.
+	/// You should only implement this is your transport supports sending periodic pings.
+	///
 	/// Send ping frame (opcode of 0x9).
-	async fn send_ping(&mut self) -> Result<(), Self::Error>;
+	async fn send_ping(&mut self) -> Result<(), Self::Error> {
+		Ok(())
+	}
 
-	/// If the transport supports sending customized close messages.
+	/// This is optional because it's most likely relevant for WebSocket transports only.
+	/// You should only implement this is your transport supports being closed.
+	///
+	/// Send customized close message.
 	async fn close(&mut self) -> Result<(), Self::Error> {
 		Ok(())
 	}

tests/tests/proc_macros.rs

@@ -314,8 +314,8 @@ async fn multiple_blocking_calls_overlap() {
 		assert_eq!(result.unwrap(), 42);
 	}
 
-	// Each request takes 50ms, added 10ms margin for scheduling
-	assert!(elapsed < Duration::from_millis(60), "Expected less than 60ms, got {:?}", elapsed);
+	// Each request takes 50ms, added 50ms margin for scheduling
+	assert!(elapsed < Duration::from_millis(100), "Expected less than 100ms, got {:?}", elapsed);
 }
 
 #[tokio::test]