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

//! Tests for validation utilities

use blvm_node::utils::validation::{
    ensure, ensure_fmt, ensure_not_empty, ensure_range, ensure_some,
};

#[test]
fn test_ensure_success() {
    let result = ensure(true, "Should not error");
    assert!(result.is_ok());
}

#[test]
fn test_ensure_failure() {
    let result = ensure(false, "Should error");
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Should error");
}

#[test]
fn test_ensure_fmt_success() {
    let result = ensure_fmt(true, || "Should not error".to_string());
    assert!(result.is_ok());
}

#[test]
fn test_ensure_fmt_failure() {
    let value = 42;
    let result = ensure_fmt(false, || format!("Value {value} must be positive"));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("Value 42"));
}

#[test]
fn test_ensure_range_valid() {
    let result = ensure_range(5, 0, 10, "value");
    assert!(result.is_ok());
}

#[test]
fn test_ensure_range_too_low() {
    let result = ensure_range(-1, 0, 10, "value");
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("between 0 and 10"));
}

#[test]
fn test_ensure_range_too_high() {
    let result = ensure_range(11, 0, 10, "value");
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("between 0 and 10"));
}

#[test]
fn test_ensure_range_boundary() {
    // Test boundaries
    assert!(ensure_range(0, 0, 10, "value").is_ok());
    assert!(ensure_range(10, 0, 10, "value").is_ok());
}

#[test]
fn test_ensure_not_empty_valid() {
    let vec = vec![1, 2, 3];
    let result = ensure_not_empty(&vec, "items");
    assert!(result.is_ok());
}

#[test]
fn test_ensure_not_empty_invalid() {
    let vec: Vec<i32> = vec![];
    let result = ensure_not_empty(&vec, "items");
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("items must not be empty"));
}

#[test]
fn test_ensure_some_valid() {
    let value = Some(42);
    let result = ensure_some(value, "value");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

#[test]
fn test_ensure_some_invalid() {
    let value: Option<i32> = None;
    let result = ensure_some(value, "value");
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("value must be set"));
}