fix: post-rebase issues

src/routing/approved.rs

@@ -238,19 +238,19 @@ impl Approved {
                 let response = NetworkInfoMsg::GetSectionResponse(response);
                 debug!("Sending {:?} to {}", response, sender);
 
-                Ok(vec![Command::SendMessage {
+                vec![Command::SendMessage {
                     recipients: vec![sender],
                     delivery_group_size: 1,
                     message: MessageType::NetworkInfo(response),
-                }])
+                }]
             }
             NetworkInfoMsg::GetSectionResponse(_) => {
                 if let Some(RelocateState::InProgress(tx)) = &mut self.relocate_state {
                     trace!("Forwarding {:?} to the bootstrap task", message);
                     let _ = tx.send((MessageType::NetworkInfo(message), sender)).await;
                 }
 
-                Ok(vec![])
+                vec![]
             }
             NetworkInfoMsg::NetworkInfoUpdate(error) => {
                 error!("TargetSectionError received: {:?}", error);
@@ -1860,21 +1860,21 @@ impl Approved {
         Ok(Some(command))
     }
 
-    pub fn check_key_status(&self, bls_pk: &bls::PublicKey) -> Result<(), TagetSectionError> {
+    pub fn check_key_status(&self, bls_pk: &bls::PublicKey) -> Result<(), TargetSectionError> {
         // Whenever there is EldersInfo change candidate, it is considered as having ongoing DKG.
         if !self
             .section
             .promote_and_demote_elders(&self.node.name())
             .is_empty()
         {
-            return Err(TagetSectionError::DkgInProgress);
+            return Err(TargetSectionError::DkgInProgress);
         }
         if !self.section.chain().has_key(bls_pk) {
-            return Err(TagetSectionError::UnrecognizedSectionKey);
+            return Err(TargetSectionError::UnrecognizedSectionKey);
         }
         if bls_pk != self.section.chain().last_key() {
             if let Ok(public_key_set) = self.public_key_set() {
-                return Err(TagetSectionError::TargetSectionInfoOutdated(NetworkInfo {
+                return Err(TargetSectionError::TargetSectionInfoOutdated(NetworkInfo {
                     prefix: *self.section.prefix(),
                     pk_set: public_key_set,
                     elders: self
@@ -1885,7 +1885,7 @@ impl Approved {
                         .collect(),
                 }));
             } else {
-                return Err(TagetSectionError::DkgInProgress);
+                return Err(TargetSectionError::DkgInProgress);
             }
         }
         Ok(())

src/routing/bootstrap.rs

@@ -30,7 +30,6 @@ use std::{
     collections::{BTreeMap, VecDeque},
     mem,
     net::SocketAddr,
-    unimplemented,
 };
 use tokio::sync::mpsc;
 use tracing::Instrument;
@@ -573,7 +572,7 @@ mod tests {
     use anyhow::{Error, Result};
     use assert_matches::assert_matches;
     use futures::future::{self, Either};
-    use sn_messaging::infrastructure::NetworkInfo;
+    use sn_messaging::network_info::NetworkInfo;
     use tokio::{sync::mpsc::error::TryRecvError, task};
 
     #[tokio::test]
@@ -781,8 +780,6 @@ mod tests {
 
     #[tokio::test]
     async fn invalid_get_section_response_success() -> Result<()> {
-        let mut rng = rand::thread_rng();
-
         let (send_tx, mut send_rx) = mpsc::channel(1);
         let (mut recv_tx, recv_rx) = mpsc::channel(1);
         let recv_rx = MessageReceiver::Deserialized(recv_rx);

src/routing/stage.rs

@@ -101,13 +101,12 @@ impl Stage {
                     .handle_message(sender, message)
                     .await
             }
-            Command::HandleNetworkInfoMsg { sender, message } => {
-                self.state
-                    .lock()
-                    .await
-                    .handle_networkinfo_msg(sender, message)
-                    .await
-            }
+            Command::HandleNetworkInfoMsg { sender, message } => Ok(self
+                .state
+                .lock()
+                .await
+                .handle_networkinfo_msg(sender, message)
+                .await),
             Command::HandleTimeout(token) => self.state.lock().await.handle_timeout(token),
             Command::HandleVote { vote, proof_share } => {
                 self.state.lock().await.handle_vote(vote, proof_share)