hubert 0.5.0

Secure distributed substrate for multiparty transactions using write-once key-value storage with ARID-based addressing
Documentation 
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

use anyhow::Result;
use bc_components::ARID;
use bc_envelope::Envelope;
use bc_ur::prelude::*;

mod cli_common;
use cli_common::*;

/// Helper to ensure tags are registered (can be called multiple times safely)
fn ensure_tags_registered() { bc_components::register_tags(); }

/// Test basic put and get roundtrip with mainline DHT
///
/// Note: This test requires network access and may be slow (several seconds)
/// as it needs to bootstrap into the mainline DHT testnet.
#[test]
#[ignore] // Ignored by default due to network requirements and slowness
fn test_mainline_put_get_roundtrip() -> Result<()> {
    ensure_tags_registered();

    // Generate test data
    let arid = ARID::new();
    let envelope = Envelope::new("Test message for CLI");

    let arid_ur = arid.ur_string();
    let envelope_ur = envelope.ur_string();

    // Put the envelope
    let put_output = run_cli(&["put", &arid_ur, &envelope_ur])?;
    assert!(
        put_output.contains("Stored envelope") || put_output.contains("✓"),
        "Put should indicate success: {}",
        put_output
    );

    // Get the envelope back
    let get_output = run_cli(&["get", &arid_ur])?;
    assert_eq!(
        get_output, envelope_ur,
        "Retrieved envelope should match original"
    );

    Ok(())
}

/// Test that putting the same ARID twice fails (write-once semantics)
#[test]
#[ignore] // Ignored by default due to network requirements and slowness
fn test_mainline_write_once() -> Result<()> {
    ensure_tags_registered();

    let arid = ARID::new();
    let envelope1 = Envelope::new("First message");
    let envelope2 = Envelope::new("Second message");

    let arid_ur = arid.ur_string();
    let envelope1_ur = envelope1.ur_string();
    let envelope2_ur = envelope2.ur_string();

    // First put should succeed
    run_cli(&["put", &arid_ur, &envelope1_ur])?;

    // Second put to same ARID should fail
    run_cli_expect_error(&["put", &arid_ur, &envelope2_ur])?;

    Ok(())
}

/// Test getting a non-existent ARID
#[test]
#[ignore] // Ignored by default due to network requirements and slowness
fn test_mainline_get_nonexistent() -> Result<()> {
    ensure_tags_registered();

    let arid = ARID::new();
    let arid_ur = arid.ur_string();

    // Getting a non-existent ARID should fail or return nothing
    let result = run_cli(&["get", &arid_ur]);
    assert!(result.is_err(), "Getting non-existent ARID should fail");

    Ok(())
}

/// Test with IPFS storage backend
///
/// Note: This test requires a running IPFS daemon at 127.0.0.1:5001
#[test]
#[ignore] // Ignored by default due to IPFS daemon requirement
fn test_ipfs_put_get_roundtrip() -> Result<()> {
    ensure_tags_registered();

    // Check if IPFS is available first
    if run_cli(&["check", "--storage", "ipfs"]).is_err() {
        println!("Skipping test: IPFS daemon not available");
        return Ok(());
    }

    let arid = ARID::new();
    let envelope = Envelope::new("Test message for IPFS");

    let arid_ur = arid.ur_string();
    let envelope_ur = envelope.ur_string();

    // Put the envelope using IPFS
    run_cli(&["put", "--storage", "ipfs", &arid_ur, &envelope_ur])?;

    // Get the envelope back using IPFS
    let get_output = run_cli(&["get", "--storage", "ipfs", &arid_ur])?;
    assert_eq!(
        get_output, envelope_ur,
        "Retrieved envelope should match original"
    );

    Ok(())
}

/// Test that mixing storage backends fails
/// (can't put to mainline and get from IPFS)
#[test]
#[ignore] // Ignored by default due to network requirements
fn test_storage_backend_isolation() -> Result<()> {
    ensure_tags_registered();

    let arid = ARID::new();
    let envelope = Envelope::new("Backend isolation test");

    let arid_ur = arid.ur_string();
    let envelope_ur = envelope.ur_string();

    // Put to mainline
    run_cli(&["put", "--storage", "mainline", &arid_ur, &envelope_ur])?;

    // Try to get from IPFS - should fail (different storage)
    let result = run_cli(&["get", "--storage", "ipfs", &arid_ur]);
    assert!(
        result.is_err(),
        "Getting from different storage backend should fail"
    );

    Ok(())
}