blvm-node 0.1.29

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

//! RpcServer request dispatch and module endpoint registration.

use async_trait::async_trait;
use blvm_node::module::rpc::handler::ModuleRpcHandler;
use blvm_node::rpc::errors::RpcError;
use blvm_node::rpc::server::RpcServer;
use serde_json::Value;
use std::net::SocketAddr;
use std::sync::Arc;

struct EchoHandler;

#[async_trait]
impl ModuleRpcHandler for EchoHandler {
    async fn handle(&self, params: Value) -> Result<Value, RpcError> {
        Ok(params)
    }
}

fn localhost() -> SocketAddr {
    "127.0.0.1:0".parse().unwrap()
}

#[tokio::test]
async fn rpc_server_process_request_help_and_invalid_json() {
    let help_req = r#"{"jsonrpc":"2.0","method":"help","params":[],"id":1}"#;
    let help_resp = RpcServer::process_request(help_req).await;
    assert!(help_resp.contains("\"result\""));
    assert!(help_resp.contains("\"id\":1"));

    let bad = RpcServer::process_request("not-json").await;
    assert!(bad.contains("error"));
}

#[tokio::test]
async fn rpc_server_process_batch_request() {
    let batch = r#"[
        {"jsonrpc":"2.0","method":"uptime","params":[],"id":1},
        {"jsonrpc":"2.0","method":"getrpcinfo","params":[],"id":2}
    ]"#;
    let resp = RpcServer::process_request(batch).await;
    assert!(resp.starts_with('['));
    assert!(resp.contains("\"id\":1"));
    assert!(resp.contains("\"id\":2"));
}

#[tokio::test]
async fn rpc_server_module_endpoint_register_and_unregister() {
    let server = Arc::new(RpcServer::new(localhost()).with_batch_rate_multiplier_cap(8));

    server
        .register_module_endpoint("covmod_ping".into(), "covmod".into(), Arc::new(EchoHandler))
        .await
        .unwrap();

    server
        .unregister_module_endpoint("covmod_ping")
        .await
        .unwrap();
    assert!(server
        .unregister_module_endpoint("missing_method")
        .await
        .is_err());
    assert!(server
        .register_module_endpoint("getblock".into(), "bad".into(), Arc::new(EchoHandler),)
        .await
        .is_err());
}

#[tokio::test]
async fn rpc_server_core_override_register_and_cleanup() {
    let server = Arc::new(RpcServer::new(localhost()));

    server
        .register_core_rpc_override(
            "getdescriptorinfo".into(),
            "covmod".into(),
            Arc::new(EchoHandler),
        )
        .await
        .unwrap();

    server
        .unregister_core_rpc_override("getdescriptorinfo")
        .await
        .unwrap();
    server.unregister_all_for_module("covmod").await;
    assert!(server
        .register_core_rpc_override("getblock".into(), "covmod".into(), Arc::new(EchoHandler))
        .await
        .is_err());
}