test: add test case to the change flow for the route

Author: driftluo

network/src/protocols/hole_punching/component/connection_request.rs

@@ -15,6 +15,7 @@ use crate::{
         SupportProtocols,
         hole_punching::{
             ADDRS_COUNT_LIMIT, HolePunching, MAX_TTL, PENETRATED_INTERVAL,
+            component::{forword_request, init_delivered},
             status::{Status, StatusCode},
         },
     },
@@ -92,7 +93,7 @@ impl<'a> ConnectionRequestProcess<'a> {
         } else if ttl == 0u8 {
             StatusCode::ReachedMaxTTL.into()
         } else {
-            self.forward_message(self_peer_id, ttl, &to_peer_id).await
+            self.forward_message(self_peer_id, &to_peer_id).await
         }
     }
 
@@ -125,34 +126,7 @@ impl<'a> ConnectionRequestProcess<'a> {
                 packed::AddressVec::new_builder().extend(iter).build()
             }
         };
-        let message = self.message.to_entity();
-        let new_route = packed::BytesVec::new_builder()
-            .extend(
-                message
-                    .route()
-                    .into_iter()
-                    .take(self.message.route().len() - 1),
-            )
-            .build();
-        let sync_route = packed::BytesVec::new_builder()
-            .extend(
-                message
-                    .route()
-                    .into_iter()
-                    .chain(vec![to_peer_id.as_bytes().pack()].into_iter())
-                    .collect::<Vec<_>>()
-                    .into_iter()
-                    .rev()
-                    .take(self.message.route().len()),
-            )
-            .build();
-        let content = packed::ConnectionRequestDelivered::new_builder()
-            .from(message.from())
-            .to(message.to())
-            .route(new_route)
-            .sync_route(sync_route)
-            .listen_addrs(listen_addrs)
-            .build();
+        let content = init_delivered(self.message, listen_addrs);
         let new_message = packed::HolePunchingMessage::new_builder()
             .set(content)
             .build()
@@ -208,18 +182,8 @@ impl<'a> ConnectionRequestProcess<'a> {
         Status::ok()
     }
 
-    async fn forward_message(&self, self_peer_id: &PeerId, ttl: u8, to_peer_id: &PeerId) -> Status {
-        let message = self.message.to_entity();
-        let new_route = message
-            .route()
-            .as_builder()
-            .push(self_peer_id.as_bytes().pack())
-            .build();
-        let content = message
-            .as_builder()
-            .ttl((ttl - 1).into())
-            .route(new_route)
-            .build();
+    async fn forward_message(&self, self_peer_id: &PeerId, to_peer_id: &PeerId) -> Status {
+        let content = forword_request(self.message, self_peer_id);
         let new_message = packed::HolePunchingMessage::new_builder()
             .set(content)
             .build()

network/src/protocols/hole_punching/component/connection_request_delivered.rs

@@ -17,7 +17,7 @@ use crate::{
         SupportProtocols,
         hole_punching::{
             ADDRS_COUNT_LIMIT, HolePunching,
-            component::try_nat_traversal,
+            component::{forward_delivered, init_sync, try_nat_traversal},
             status::{Status, StatusCode},
         },
     },
@@ -76,11 +76,7 @@ impl<'a> ConnectionRequestDeliveredProcess<'a> {
 
                 match target_sid {
                     Some(next_peer) => {
-                        let message = self.message.to_entity();
-                        let new_route = packed::BytesVec::new_builder()
-                            .extend(message.route().into_iter().take(route.len() - 1))
-                            .build();
-                        let content = message.as_builder().route(new_route).build();
+                        let content = forward_delivered(self.message);
                         let new_message = packed::HolePunchingMessage::new_builder()
                             .set(content)
                             .build()
@@ -147,20 +143,7 @@ impl<'a> ConnectionRequestDeliveredProcess<'a> {
     }
 
     async fn respond_sync(&self, from_peer_id: PeerId) -> Status {
-        let message = self.message.to_entity();
-        let new_route = packed::BytesVec::new_builder()
-            .extend(
-                message
-                    .sync_route()
-                    .into_iter()
-                    .take(self.message.sync_route().len() - 1),
-            )
-            .build();
-        let content = packed::ConnectionSync::new_builder()
-            .from(message.from())
-            .to(message.to())
-            .route(new_route)
-            .build();
+        let content = init_sync(self.message);
         let new_message = packed::HolePunchingMessage::new_builder()
             .set(content)
             .build()
@@ -232,7 +215,7 @@ impl<'a> ConnectionRequestDeliveredProcess<'a> {
         }
 
         runtime::spawn(async move {
-            tokio::time::sleep(std::time::Duration::from_millis(ttl / 2)).await;
+            runtime::delay_for(std::time::Duration::from_millis(ttl / 2)).await;
             if let Ok(((stream, addr), _)) = select_ok(tasks).await {
                 debug!("NAT traversal success, addr: {:?}", addr);
                 let _ignore = control

network/src/protocols/hole_punching/component/connection_sync.rs

@@ -16,7 +16,7 @@ use crate::{
         SupportProtocols,
         hole_punching::{
             HolePunching,
-            component::try_nat_traversal,
+            component::{forword_sync, try_nat_traversal},
             status::{Status, StatusCode},
         },
     },
@@ -68,11 +68,7 @@ impl<'a> ConnectionSyncProcess<'a> {
 
                 match target_sid {
                     Some(next_peer) => {
-                        let message = self.message.to_entity();
-                        let new_route = packed::BytesVec::new_builder()
-                            .extend(message.route().into_iter().take(route.len() - 1))
-                            .build();
-                        let content = message.as_builder().route(new_route).build();
+                        let content = forword_sync(self.message);
                         let new_message = packed::HolePunchingMessage::new_builder()
                             .set(content)
                             .build()