fixed test: needed proxiedMessage format

tools/echo-server/src/lib.rs

@@ -176,77 +176,63 @@ impl NymEchoServer {
 mod tests {
     use super::*;
     use futures::StreamExt;
-    use nym_sdk::mixnet::{MixnetClient, MixnetMessageSender, Recipient};
+    use nym_sdk::mixnet::{IncludedSurbs, MixnetClient, MixnetMessageSender, Recipient};
+    #[path = "utils.rs"]
+    mod utils;
+    use utils::{Payload, ProxiedMessage};
 
-    // debug test with known addr running alongside
     #[tokio::test]
-    async fn echoes_bytes_manual() {
-        let echo_addr = Recipient::try_from_base58_string("FAtdiqCBoTEy9m9Bq4AmrNt6YLuehCM7gpcPpBWdJDJz.DyAzs1rVNn5K9xm5UyvZUsZJVFGwNb1Ak3K3WkugcRwj@5E9DnixDjGH4jKtGPQkq5ba3tCR9Pkh8nSNV63456foJ").unwrap();
+    async fn echoes_bytes() {
+        let mut echo_server =
+            NymEchoServer::new(None, None, "../../envs/mainnet.env".to_string(), "9000")
+                .await
+                .unwrap();
+
+        let echo_addr = echo_server.nym_address().await;
         println!("{echo_addr}");
 
-        let message = "test";
+        tokio::task::spawn(async move {
+            echo_server.run().await.unwrap();
+        });
+
+        let session_id = uuid::Uuid::new_v4();
+        let message_id = 0;
+        let outgoing = ProxiedMessage::new(
+            Payload::Data("test".as_bytes().to_vec()),
+            session_id,
+            message_id,
+        );
+        let coded_message = bincode::serialize(&outgoing).unwrap();
 
         let mut client = MixnetClient::connect_new().await.unwrap();
         let sender = client.split_sender();
         let sending_task_handle = tokio::spawn(async move {
-            println!("sending to {echo_addr}");
-            sender.send_plain_message(echo_addr, message).await.unwrap();
-            println!("sent");
+            sender
+                .send_message(echo_addr, &coded_message, IncludedSurbs::Amount(10))
+                .await
+                .unwrap();
+        });
+
+        let receiving_task_handle = tokio::spawn(async move {
+            if let Some(received) = client.next().await {
+                let incoming: ProxiedMessage = bincode::deserialize(&received.message).unwrap();
+                assert_eq!(outgoing.message, incoming.message);
+            }
+            client.disconnect().await;
         });
 
         sending_task_handle.await.unwrap();
-        tokio::time::sleep(tokio::time::Duration::from_secs(100)).await;
+        receiving_task_handle.await.unwrap();
     }
 
     // #[tokio::test]
-    // async fn echoes_bytes() {
-    //     let mut echo_server =
-    //         NymEchoServer::new(None, None, "../../envs/mainnet.env".to_string(), "9000")
-    //             .await
-    //             .unwrap();
-
-    //     let echo_addr = echo_server.nym_address().await;
-
-    //     println!("{echo_addr}");
-    //     let incoming_metrics = echo_server.clone().metrics();
-    //     println!("{incoming_metrics:#?}");
-
-    //     tokio::task::spawn(async move {
-    //         echo_server.run().await.unwrap();
-    //     });
-
-    //     let message = "test";
-
-    //     let mut client = MixnetClient::connect_new().await.unwrap();
-    //     let sender = client.split_sender();
-    //     let sending_task_handle = tokio::spawn(async move {
-    //         println!("sending to {echo_addr}");
-    //         sender.send_plain_message(echo_addr, message).await.unwrap();
-    //         println!("sent");
-    //     });
-
-    // let receiving_task_handle = tokio::spawn(async move {
-    //     if let Some(received) = client.next().await {
-    //         println!("Received: {}", String::from_utf8_lossy(&received.message));
-    //         assert_eq!(
-    //             message.to_string(),
-    //             String::from_utf8_lossy(&received.message)
-    //         );
-    //     }
-    //     client.disconnect().await;
-    // });
-
-    // sending_task_handle.await.unwrap();
-    // receiving_task_handle.await.unwrap();
-
-    // assert_eq!(
-    //     incoming_metrics.bytes_recv.load(Ordering::SeqCst) as usize,
-    //     message_bytes.len()
-    // );
+    // async fn incoming_and_sent_bytes_metrics_work() {
+    //     todo!()
     // }
 
-    // #[test]
-    // fn creates_a_valid_nym_addr_with_given_gw() {
+    // #[tokio::test]
+    // async fn creates_a_valid_nym_addr_with_specified_gw() {
+    //     todo!()
     //     // check valid
     //     // parse end
     // }

tools/echo-server/src/tests/utils.rs

@@ -0,0 +1,54 @@
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use uuid::Uuid;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ProxiedMessage {
+    pub message: Payload,
+    session_id: Uuid,
+    message_id: u16,
+}
+
+impl ProxiedMessage {
+    pub fn new(message: Payload, session_id: Uuid, message_id: u16) -> Self {
+        ProxiedMessage {
+            message,
+            session_id,
+            message_id,
+        }
+    }
+
+    pub fn message(&self) -> &Payload {
+        &self.message
+    }
+
+    pub fn session_id(&self) -> Uuid {
+        self.session_id
+    }
+
+    pub fn message_id(&self) -> u16 {
+        self.message_id
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub enum Payload {
+    Data(Vec<u8>),
+    Close,
+}
+
+impl fmt::Display for ProxiedMessage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let message = match self.message() {
+            Payload::Data(ref data) => format!("Data({})", data.len()),
+            Payload::Close => "Close".to_string(),
+        };
+        write!(
+            f,
+            "ProxiedMessage {{ message: {}, session_id: {}, message_id: {} }}",
+            message,
+            self.session_id(),
+            self.message_id()
+        )
+    }
+}