fixing lint pt.2

event_sidecar/src/event_stream_server/sse_server.rs

@@ -8,10 +8,13 @@ use casper_event_types::{
     sse_data::{EventFilter, SseData},
     Filter as SseFilter,
 };
-use casper_types::{ProtocolVersion, Transaction};
+use casper_types::ProtocolVersion;
+#[cfg(test)]
+use casper_types::Transaction;
 use futures::{future, Stream, StreamExt};
 use http::StatusCode;
 use hyper::Body;
+#[cfg(test)]
 use serde::Serialize;
 #[cfg(test)]
 use serde_json::Value;
@@ -97,6 +100,7 @@ type UrlProps = (
     IsLegacyFilter,
 );
 
+#[cfg(test)]
 #[derive(Serialize)]
 #[serde(rename_all = "PascalCase")]
 pub(super) struct TransactionAccepted {

event_sidecar/src/event_stream_server/tests.rs

@@ -598,11 +598,11 @@ async fn fetch_text(
 ///
 /// The expected order is:
 ///   * data:<JSON-encoded ApiVersion> (note, no ID line follows this first event)
-/// then the following three repeated for as many events as are applicable to that stream:
+///     then the following three repeated for as many events as are applicable to that stream:
 ///   * data:<JSON-encoded event>
 ///   * id:<integer>
 ///   * empty line
-/// then finally, repeated keepalive lines until the server is shut down.
+///     then finally, repeated keepalive lines until the server is shut down.
 #[allow(clippy::too_many_lines)]
 fn parse_response(response_text: String, client_id: &str) -> Vec<ReceivedEvent> {
     let mut received_events = Vec::new();

event_sidecar/src/testing/simple_sse_server.rs

@@ -28,10 +28,6 @@ pub(crate) mod tests {
         pub routes: HashMap<Vec<String>, CacheAndData>,
     }
 
-    #[derive(Debug)]
-    struct Nope;
-    impl warp::reject::Reject for Nope {}
-
     type ShutdownCallbacks = Arc<Mutex<Vec<broadcast::Sender<Option<(Option<String>, String)>>>>>;
 
     impl SimpleSseServer {

event_sidecar/src/types/database.rs

@@ -284,9 +284,29 @@ pub enum DatabaseWriteError {
     Unhandled(anyhow::Error),
 }
 
-impl ToString for DatabaseWriteError {
-    fn to_string(&self) -> String {
-        format!("{:?}", self)
+impl Display for DatabaseWriteError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DatabaseWriteError::Serialisation(error) => {
+                write!(f, "DatabaseWriteError::Serialisation: {}", error)
+            }
+            DatabaseWriteError::SqlConstruction(error) => {
+                write!(f, "DatabaseWriteError::SqlConstruction: {}", error)
+            }
+            DatabaseWriteError::UniqueConstraint(unique_constraint_error) => {
+                write!(
+                    f,
+                    "DatabaseWriteError::UniqueConstraint: table: {}, error: {}",
+                    unique_constraint_error.table, unique_constraint_error.error
+                )
+            }
+            DatabaseWriteError::Database(error) => {
+                write!(f, "DatabaseWriteError::Database: {}", error)
+            }
+            DatabaseWriteError::Unhandled(error) => {
+                write!(f, "DatabaseWriteError::Unhandled: {}", error)
+            }
+        }
     }
 }
 

event_sidecar/src/utils.rs

@@ -231,6 +231,8 @@ pub mod tests {
         let infix_str = infix.as_str();
         data.iter().any(|x| x.contains(infix_str))
     }
+
+    #[allow(dead_code)]
     pub struct MockNodeTestProperties {
         pub testing_config: TestingConfig,
         pub temp_storage_dir: TempDir,

json_rpc/src/request.rs

@@ -66,6 +66,7 @@ impl Request {
     ///   * `allow_unknown_fields` is `false` and extra fields exist
     ///
     /// Returns a `Rejection` if the "id" field is `None`.
+    #[allow(clippy::result_large_err)]
     pub(super) fn new(
         mut request: Map<String, Value>,
         allow_unknown_fields: bool,

json_rpc/src/request/params.rs

@@ -24,6 +24,7 @@ pub enum Params {
 }
 
 impl Params {
+    #[allow(clippy::result_large_err)]
     pub(super) fn try_from(request_id: &Value, params: Value) -> Result<Self, ErrorOrRejection> {
         let err_invalid_request = |additional_info: &str| {
             let error = Error::new(ReservedErrorCode::InvalidRequest, additional_info);

listener/src/connection_manager.rs

@@ -140,7 +140,6 @@ impl DefaultConnectionManagerBuilder {
 impl DefaultConnectionManager {
     /// Start handling traffic from nodes endpoint. This function is blocking, it will return a
     /// ConnectionManagerError result if something went wrong while processing.
-
     async fn connect(
         &mut self,
     ) -> Result<Pin<Box<dyn Stream<Item = EventResult> + Send + 'static>>, ConnectionManagerError>

listener/src/sse_connector.rs

@@ -8,7 +8,7 @@ use eventsource_stream::{Event, EventStream, EventStreamError, Eventsource};
 use futures::StreamExt;
 use reqwest::Client;
 use std::pin::Pin;
-use std::{fmt::Debug, sync::Arc, time::Duration};
+use std::{fmt::Debug, time::Duration};
 use tokio::select;
 use tokio_stream::Stream;
 use tracing::debug;
@@ -17,7 +17,7 @@ use url::Url;
 #[derive(Clone, Debug)]
 pub enum SseDataStreamingError {
     NoDataTimeout(),
-    ConnectionError(Arc<Error>),
+    ConnectionError(),
 }
 
 pub type EventResult = Result<Event, EventStreamError<SseDataStreamingError>>;
@@ -84,8 +84,8 @@ impl SseConnection {
                                     monitor.tick().await;
                                     yield Ok(bytes);
                                 },
-                                Err(err) => {
-                                    yield Err(SseDataStreamingError::ConnectionError(Arc::new(Error::from(err))));
+                                Err(_) => {
+                                    yield Err(SseDataStreamingError::ConnectionError());
                                     break;
                                 }
                             }
@@ -177,7 +177,6 @@ pub mod tests {
     use std::{
         convert::Infallible,
         pin::Pin,
-        sync::Arc,
         time::{Duration, Instant},
     };
     use tokio::sync::mpsc::channel;
@@ -225,9 +224,7 @@ pub mod tests {
         }
 
         pub fn build_failing_on_message() -> Self {
-            let e = SseDataStreamingError::ConnectionError(Arc::new(Error::msg(
-                "Some error on message",
-            )));
+            let e = SseDataStreamingError::ConnectionError();
             MockSseConnection {
                 data: vec![],
                 failure_on_connection: None,

listener/src/version_fetcher.rs

@@ -125,17 +125,11 @@ fn try_resolve_version(raw_response: &Value) -> Result<ProtocolVersion, Error> {
             let raw = build_version_value
                 .as_str()
                 .context("build_version_value should be a string")
-                .map_err(|e| {
-                    count_error("version_value_not_a_string");
-                    e
-                })?
+                .inspect_err(|_| count_error("version_value_not_a_string"))?
                 .split('-')
                 .next()
                 .context("splitting build_version_value should always return at least one slice")
-                .map_err(|e| {
-                    count_error("incomprehensible_build_version_form");
-                    e
-                })?;
+                .inspect_err(|_| count_error("incomprehensible_build_version_form"))?;
             ProtocolVersion::from_str(raw).map_err(|error| {
                 count_error("failed_parsing_protocol_version");
                 anyhow!("failed parsing build version from '{}': {}", raw, error)

rpc_sidecar/src/node_client.rs

@@ -1206,7 +1206,7 @@ where
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct ErrFormatter<'a, T>(pub &'a T);
 
-impl<'a, T> Display for ErrFormatter<'a, T>
+impl<T> Display for ErrFormatter<'_, T>
 where
     T: std::error::Error,
 {

sidecar/src/main.rs

@@ -9,7 +9,7 @@ use config::{SidecarConfig, SidecarConfigTarget};
 use run::run;
 use std::{
     env, fmt, io,
-    panic::{self, PanicInfo},
+    panic::{self, PanicHookInfo},
     process::{self, ExitCode},
 };
 #[cfg(not(target_env = "msvc"))]
@@ -68,7 +68,7 @@ pub fn read_config(config_path: &str) -> Result<SidecarConfigTarget, Error> {
     toml::from_str(&toml_content).context("Error parsing config into TOML format")
 }
 
-fn panic_hook(info: &PanicInfo) {
+fn panic_hook(info: &PanicHookInfo) {
     let backtrace = Backtrace::new();
 
     eprintln!("{:?}", backtrace);