blvm-node 0.1.0

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

//! Tests for network sandbox

use blvm_node::module::sandbox::NetworkSandbox;
use blvm_node::module::traits::ModuleError;

#[test]
fn test_network_sandbox_creation() {
    let sandbox = NetworkSandbox::new();
    // Should create successfully
    assert!(true);
}

#[test]
fn test_network_sandbox_default() {
    let sandbox = NetworkSandbox::default();
    // Should create successfully
    assert!(true);
}

#[test]
fn test_network_sandbox_no_access_by_default() {
    let sandbox = NetworkSandbox::new();

    // Network access should be denied by default
    assert!(!sandbox.is_network_allowed());
}

#[test]
fn test_network_sandbox_with_allowed_endpoints() {
    let endpoints = vec!["https://api.example.com".to_string()];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Network access should be allowed if endpoints are provided
    assert!(sandbox.is_network_allowed());
}

#[test]
fn test_network_sandbox_empty_endpoints() {
    let sandbox = NetworkSandbox::with_allowed_endpoints(vec![]);

    // Network access should be denied if no endpoints
    assert!(!sandbox.is_network_allowed());
}

#[test]
fn test_validate_network_operation_denied() {
    let sandbox = NetworkSandbox::new();

    // Network operations should be denied
    let result = sandbox.validate_network_operation("connect");
    assert!(result.is_err());

    match result.unwrap_err() {
        ModuleError::OperationError(msg) => {
            assert!(msg.contains("Network access denied") || msg.contains("denied"));
        }
        _ => panic!("Expected OperationError"),
    }
}

#[test]
fn test_validate_network_operation_allowed() {
    let endpoints = vec!["https://api.example.com".to_string()];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Network operations should be allowed
    let result = sandbox.validate_network_operation("connect");
    assert!(result.is_ok());
}

#[test]
fn test_validate_endpoint_denied() {
    let sandbox = NetworkSandbox::new();

    // Endpoint validation should fail
    let result = sandbox.validate_endpoint("https://api.example.com");
    assert!(result.is_err());
}

#[test]
fn test_validate_endpoint_allowed() {
    let endpoints = vec!["https://api.example.com".to_string()];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Allowed endpoint should validate successfully
    let result = sandbox.validate_endpoint("https://api.example.com");
    assert!(result.is_ok());
}

#[test]
fn test_validate_endpoint_not_in_list() {
    let endpoints = vec!["https://api.example.com".to_string()];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Different endpoint should fail
    let result = sandbox.validate_endpoint("https://other.example.com");
    assert!(result.is_err());

    match result.unwrap_err() {
        ModuleError::OperationError(msg) => {
            assert!(msg.contains("not allowed") || msg.contains("not in allowed list"));
        }
        _ => panic!("Expected OperationError"),
    }
}

#[test]
fn test_validate_endpoint_prefix_match() {
    let endpoints = vec!["https://api.example.com".to_string()];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Endpoint with path should match prefix
    let result = sandbox.validate_endpoint("https://api.example.com/v1/endpoint");
    assert!(result.is_ok());
}

#[test]
fn test_validate_endpoint_multiple_allowed() {
    let endpoints = vec![
        "https://api1.example.com".to_string(),
        "https://api2.example.com".to_string(),
    ];
    let sandbox = NetworkSandbox::with_allowed_endpoints(endpoints);

    // Both endpoints should be allowed
    assert!(sandbox
        .validate_endpoint("https://api1.example.com")
        .is_ok());
    assert!(sandbox
        .validate_endpoint("https://api2.example.com")
        .is_ok());

    // Other endpoint should be denied
    assert!(sandbox
        .validate_endpoint("https://api3.example.com")
        .is_err());
}

#[test]
fn test_validate_endpoint_empty_allowed_list() {
    let sandbox = NetworkSandbox::with_allowed_endpoints(vec![]);

    // Even with empty list, network should be denied
    assert!(!sandbox.is_network_allowed());
    assert!(sandbox
        .validate_endpoint("https://api.example.com")
        .is_err());
}