A lot

transport/tests/integration.rs

@@ -0,0 +1,174 @@
+use std::net::{IpAddr, Ipv4Addr};
+
+use mtp_transport::{Policy, host, connect};
+
+fn generate_self_signed_cert() -> (Vec<u8>, Vec<u8>) {
+    let key_pair = rcgen::KeyPair::generate().unwrap();
+    let params =
+        rcgen::CertificateParams::new(vec!["localhost".into(), "127.0.0.1".into()]).unwrap();
+    let cert = params.self_signed(&key_pair).unwrap();
+    let cert_pem = cert.pem();
+    let key_pem = key_pair.serialize_pem();
+    (cert_pem.into_bytes(), key_pem.into_bytes())
+}
+
+#[tokio::test]
+async fn test_host_start_and_stop() {
+    let (cert_pem, key_pem) = generate_self_signed_cert();
+    let h = host(
+        IpAddr::V4(Ipv4Addr::LOCALHOST),
+        0,
+        cert_pem,
+        key_pem,
+        Policy::default(),
+    )
+    .await
+    .unwrap();
+    let addr = h.local_addr();
+    // Port should be non-zero (OS-assigned)
+    assert!(addr.port() > 0);
+}
+
+#[tokio::test]
+async fn test_send_receive_roundtrip() {
+    let (cert_pem, key_pem) = generate_self_signed_cert();
+    let mut h = host(
+        IpAddr::V4(Ipv4Addr::LOCALHOST),
+        0,
+        cert_pem.clone(),
+        key_pem,
+        Policy::default(),
+    )
+    .await
+    .unwrap();
+    let addr = h.local_addr();
+
+    let url = format!("https://127.0.0.1:{}", addr.port());
+    let (client_tx, client_rx) =
+        connect(&url, Some(cert_pem), Policy::default()).await.unwrap();
+
+    // Accept on host side
+    let (host_tx, host_rx) = h.next().await.unwrap();
+
+    // Client sends a simple message
+    let msg = mtp_codec::CommunicationValue::new(mtp_codec::CommunicationType::Ping)
+        .add_data(
+            mtp_codec::DataTypeId(6),
+            mtp_codec::DataValue::UnsignedNumber(42),
+        );
+    client_tx.send(&msg).await.unwrap();
+
+    // Host receives it
+    let received = host_rx.receive().await.unwrap();
+    assert_eq!(received.get_type(), mtp_codec::CommunicationTypeId(19)); // Ping
+    let val = received.get_data(mtp_codec::DataTypeId(6)).clone();
+    assert_eq!(val, mtp_codec::DataValue::UnsignedNumber(42));
+
+    // Host sends a response
+    let resp = mtp_codec::CommunicationValue::new(mtp_codec::CommunicationType::Pong)
+        .add_data(
+            mtp_codec::DataTypeId(6),
+            mtp_codec::DataValue::UnsignedNumber(99),
+        );
+    host_tx.send(&resp).await.unwrap();
+
+    // Client receives it
+    let client_received = client_rx.receive().await.unwrap();
+    assert_eq!(client_received.get_type(), mtp_codec::CommunicationTypeId(20)); // Pong
+    let client_val = client_received.get_data(mtp_codec::DataTypeId(6)).clone();
+    assert_eq!(client_val, mtp_codec::DataValue::UnsignedNumber(99));
+
+    // Close both sides
+    client_tx.close();
+    host_tx.close();
+}
+
+#[tokio::test]
+async fn test_concurrent_messages() {
+    let (cert_pem, key_pem) = generate_self_signed_cert();
+    let mut h = host(
+        IpAddr::V4(Ipv4Addr::LOCALHOST),
+        0,
+        cert_pem.clone(),
+        key_pem,
+        Policy::default(),
+    )
+    .await
+    .unwrap();
+    let addr = h.local_addr();
+
+    let url = format!("https://127.0.0.1:{}", addr.port());
+    let (client_tx, _client_rx) =
+        connect(&url, Some(cert_pem), Policy::default()).await.unwrap();
+
+    let (_host_tx, host_rx) = h.next().await.unwrap();
+
+    // Send 5 messages in sequence
+    for i in 0..5u128 {
+        let msg = mtp_codec::CommunicationValue::new(mtp_codec::CommunicationType::Ping)
+            .add_data(
+                mtp_codec::DataTypeId(6),
+                mtp_codec::DataValue::UnsignedNumber(i),
+            );
+        client_tx.send(&msg).await.unwrap();
+    }
+
+    // Receive all 5 in order
+    for i in 0..5u128 {
+        let received = host_rx.receive().await.unwrap();
+        let val = received.get_data(mtp_codec::DataTypeId(6)).clone();
+        assert_eq!(val, mtp_codec::DataValue::UnsignedNumber(i));
+    }
+
+    // Send 3 responses back
+    for i in 0..3u128 {
+        let msg = mtp_codec::CommunicationValue::new(mtp_codec::CommunicationType::Pong)
+            .add_data(
+                mtp_codec::DataTypeId(6),
+                mtp_codec::DataValue::UnsignedNumber(i * 10),
+            );
+        client_tx.send(&msg).await.unwrap();
+    }
+
+    for i in 0..3u128 {
+        let received = host_rx.receive().await.unwrap();
+        let val = received.get_data(mtp_codec::DataTypeId(6)).clone();
+        assert_eq!(val, mtp_codec::DataValue::UnsignedNumber(i * 10));
+    }
+
+    client_tx.close();
+}
+
+#[tokio::test]
+async fn test_close_detection() {
+    let (cert_pem, key_pem) = generate_self_signed_cert();
+    let mut h = host(
+        IpAddr::V4(Ipv4Addr::LOCALHOST),
+        0,
+        cert_pem.clone(),
+        key_pem,
+        Policy::default(),
+    )
+    .await
+    .unwrap();
+    let addr = h.local_addr();
+
+    let url = format!("https://127.0.0.1:{}", addr.port());
+    let (client_tx, _client_rx) =
+        connect(&url, Some(cert_pem), Policy::default()).await.unwrap();
+
+    let (_host_tx, host_rx) = h.next().await.unwrap();
+
+    // Send a message then close
+    let msg = mtp_codec::CommunicationValue::new(mtp_codec::CommunicationType::Ping);
+    client_tx.send(&msg).await.unwrap();
+    client_tx.close();
+
+    // Host should still receive the message
+    let received = host_rx.receive().await.unwrap();
+    assert_eq!(received.get_type(), mtp_codec::CommunicationTypeId(19)); // Ping
+
+    // Host should get an error or closed signal on next receive
+    let result = host_rx.receive().await;
+    assert!(result.is_err());
+}