blvm-node 0.1.2

Bitcoin Commons BLVM: Minimal Bitcoin node implementation using blvm-protocol and blvm-consensus
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Tests for async request-response routing enhancements

use blvm_node::network::{transport::TransportPreference, NetworkManager};
use std::net::SocketAddr;
use tokio::time::{sleep, Duration};

#[tokio::test(flavor = "multi_thread")]
async fn test_request_id_matching() {
    // Test that requests are matched by request_id, not FIFO
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);

    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    // Register multiple requests
    let (id1, rx1) = manager.register_request(peer_addr);
    let (id2, rx2) = manager.register_request(peer_addr);
    let (id3, rx3) = manager.register_request(peer_addr);

    // Complete requests out of order
    let response2 = vec![2, 2, 2];
    let response1 = vec![1, 1, 1];
    let response3 = vec![3, 3, 3];

    assert!(manager.complete_request(id2, response2.clone()));
    assert!(manager.complete_request(id1, response1.clone()));
    assert!(manager.complete_request(id3, response3.clone()));

    // Verify each receiver got the correct response
    tokio::select! {
        result = rx1 => {
            assert_eq!(result.unwrap(), response1);
        }
        _ = sleep(Duration::from_millis(100)) => {
            panic!("Request 1 timeout");
        }
    }

    tokio::select! {
        result = rx2 => {
            assert_eq!(result.unwrap(), response2);
        }
        _ = sleep(Duration::from_millis(100)) => {
            panic!("Request 2 timeout");
        }
    }

    tokio::select! {
        result = rx3 => {
            assert_eq!(result.unwrap(), response3);
        }
        _ = sleep(Duration::from_millis(100)) => {
            panic!("Request 3 timeout");
        }
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn test_request_cancellation() {
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);
    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    let (request_id, rx) = manager.register_request(peer_addr);

    // Cancel the request
    assert!(manager.cancel_request(request_id));

    // Try to complete it (should fail)
    assert!(!manager.complete_request(request_id, vec![1, 2, 3]));

    // Receiver should be closed
    assert!(rx.await.is_err());
}

#[tokio::test(flavor = "multi_thread")]
async fn test_timestamp_cleanup() {
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);
    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    // Register a request
    let (request_id, _rx) = manager.register_request(peer_addr);

    // Wait at least 1 second to ensure the request is older than 0 seconds
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    // Cleanup requests older than 0 seconds (should remove all)
    let cleaned = manager.cleanup_expired_requests(0);
    assert_eq!(cleaned, 1);

    // Request should be gone
    assert!(!manager.complete_request(request_id, vec![1, 2, 3]));
}

#[tokio::test(flavor = "multi_thread")]
async fn test_multiple_concurrent_requests_per_peer() {
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);
    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    // Register multiple requests from same peer
    let (id1, rx1) = manager.register_request(peer_addr);
    let (id2, rx2) = manager.register_request(peer_addr);
    let (id3, rx3) = manager.register_request(peer_addr);

    // All should be registered
    let pending = manager.get_pending_requests_for_peer(peer_addr);
    assert_eq!(pending.len(), 3);
    assert!(pending.contains(&id1));
    assert!(pending.contains(&id2));
    assert!(pending.contains(&id3));

    // Complete all
    manager.complete_request(id1, vec![1]);
    manager.complete_request(id2, vec![2]);
    manager.complete_request(id3, vec![3]);

    // All should receive responses
    assert_eq!(rx1.await.unwrap(), vec![1]);
    assert_eq!(rx2.await.unwrap(), vec![2]);
    assert_eq!(rx3.await.unwrap(), vec![3]);
}

#[tokio::test(flavor = "multi_thread")]
async fn test_request_metrics() {
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);
    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    // Register and complete a request
    let (id1, _rx1) = manager.register_request(peer_addr);
    manager.complete_request(id1, vec![1, 2, 3]);

    // Smoke test: register + complete only. Per-peer metrics helpers are not on NetworkManager yet.
}

#[tokio::test(flavor = "multi_thread")]
async fn test_request_priority() {
    let listen_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let manager =
        NetworkManager::with_transport_preference(listen_addr, 100, TransportPreference::TCP_ONLY);
    let peer_addr: SocketAddr = "127.0.0.1:8333".parse().unwrap();

    // Register requests with different priorities
    let (_id1, _rx1) = manager.register_request_with_priority(peer_addr, 0);
    let (_id2, _rx2) = manager.register_request_with_priority(peer_addr, 5);
    let (_id3, _rx3) = manager.register_request_with_priority(peer_addr, 10);

    // All should be registered
    let pending = manager.get_pending_requests_for_peer(peer_addr);
    assert_eq!(pending.len(), 3);
}