tenzro-network 0.1.0

P2P networking layer for Tenzro Network — libp2p gossipsub, Kademlia DHT, NAT traversal via AutoNAT v2 + Circuit-Relay v2 + DCUtR
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Integration tests for tenzro-network

use tenzro_network::{
    NetworkConfig, NetworkMessage, NetworkService, TenzroNetworkService, MessagePayload,
};

#[tokio::test]
async fn test_network_service_creation() {
    let config = NetworkConfig::local();
    let result = TenzroNetworkService::new(config).await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_local_peer_id() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    let peer_id = network.local_peer_id().await;
    assert!(peer_id.is_ok());
}

#[tokio::test]
async fn test_topic_subscription() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    let result = network.subscribe("tenzro/test").await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_broadcast_message() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    // Subscribe first
    network.subscribe("tenzro/test").await.unwrap();

    // Broadcast message — may fail when no peers are subscribed to the topic,
    // which is expected in a single-node test environment
    let message = NetworkMessage::new(MessagePayload::Ping);
    let _result = network.broadcast("tenzro/test", message).await;
}

#[tokio::test]
async fn test_connected_peers() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    let peers = network.connected_peers().await;
    assert!(peers.is_ok());

    // Initially, should have no connected peers
    let peers = peers.unwrap();
    assert_eq!(peers.len(), 0);
}

#[tokio::test]
async fn test_peer_info() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    let peer_id = network.local_peer_id().await.unwrap();
    let info = network.peer_info(&peer_id).await;
    assert!(info.is_ok());
}

#[tokio::test]
async fn test_config_validation() {
    // Valid config
    let config = NetworkConfig::default();
    assert!(config.validate().is_ok());

    // Invalid config - no listen addresses
    let invalid_config = NetworkConfig {
        listen_addresses: vec![],
        ..Default::default()
    };
    assert!(invalid_config.validate().is_err());

    // Invalid config - no topics
    let invalid_config = NetworkConfig {
        gossip_topics: vec![],
        ..Default::default()
    };
    assert!(invalid_config.validate().is_err());
}

#[tokio::test]
async fn test_message_serialization_roundtrip() {
    let msg = NetworkMessage::new(MessagePayload::Ping);
    let bytes = msg.to_bytes().unwrap();
    let decoded = NetworkMessage::from_bytes(&bytes).unwrap();

    assert_eq!(msg.message_id, decoded.message_id);
    assert_eq!(msg.timestamp, decoded.timestamp);
}

#[tokio::test]
async fn test_multiple_subscriptions() {
    let config = NetworkConfig::local();
    let network = TenzroNetworkService::new(config).await.unwrap();

    // Subscribe to multiple topics
    let topics = vec![
        "tenzro/blocks",
        "tenzro/transactions",
        "tenzro/consensus",
    ];

    for topic in topics {
        let result = network.subscribe(topic).await;
        assert!(result.is_ok());
    }
}