blvm-node 0.1.13

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

//! Tests for module manager lifecycle

use blvm_node::module::manager::ModuleManager;
use blvm_node::module::traits::{ModuleError, ModuleMetadata};
use std::collections::HashMap;
use std::path::PathBuf;
use tempfile::TempDir;

fn create_test_metadata(name: &str) -> ModuleMetadata {
    ModuleMetadata {
        name: name.to_string(),
        version: "1.0.0".to_string(),
        description: "Test module".to_string(),
        author: "Test Author".to_string(),
        capabilities: Vec::new(),
        rpc_overrides: Vec::new(),
        dependencies: HashMap::new(),
        optional_dependencies: HashMap::new(),
        entry_point: format!("{name}.so"),
    }
}

#[tokio::test]
async fn test_module_manager_new() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    // Manager should be created successfully
    assert!(true);
}

#[tokio::test]
async fn test_module_manager_with_config() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let config = blvm_node::config::ModuleResourceLimitsConfig::default();
    let manager = ModuleManager::with_config(&modules_dir, &data_dir, &socket_dir, Some(&config));
    // Manager should be created with config
    assert!(true);
}

#[tokio::test]
async fn test_module_manager_list_modules_empty() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    let modules = manager.list_modules().await;

    assert!(modules.is_empty());
}

#[tokio::test]
async fn test_module_manager_get_module_state_nonexistent() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    let state = manager.get_module_state("nonexistent").await;

    assert!(state.is_none());
}

#[tokio::test]
async fn test_module_manager_event_manager() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    let event_manager = manager.event_manager();

    // Event manager should be accessible
    assert!(true);
}

#[tokio::test]
async fn test_module_manager_unload_nonexistent_module() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let mut manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    let result = manager.unload_module("nonexistent").await;

    assert!(result.is_err());
    assert!(matches!(
        result.unwrap_err(),
        ModuleError::ModuleNotFound(_)
    ));
}

#[tokio::test]
async fn test_module_manager_reload_nonexistent_module() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let data_dir = temp_dir.path().join("data");
    let socket_dir = temp_dir.path().join("sockets");

    let mut manager = ModuleManager::new(&modules_dir, &data_dir, &socket_dir);
    let metadata = create_test_metadata("test-module");
    let binary_path = PathBuf::from("/nonexistent/binary.so");
    let result = manager
        .reload_module("nonexistent", &binary_path, metadata, HashMap::new())
        .await;

    // Reload will try to unload first, which will fail, but then try to load
    // The load will fail because binary doesn't exist
    assert!(result.is_err());
}