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

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

mod cli_common;
use cli_common::*;

#[test]
fn test_invalid_command() -> Result<()> {
    run_cli_expect_error(&["invalid"])?;
    Ok(())
}

#[test]
fn test_missing_arguments() -> Result<()> {
    run_cli_expect_error(&["put"])?;
    run_cli_expect_error(&["get"])?;
    Ok(())
}

#[test]
fn test_invalid_arid_format() -> Result<()> {
    run_cli_expect_error(&[
        "put",
        "not-a-valid-arid",
        "ur:envelope/tpsoiyfdihjzjzjldmksbaoede",
    ])?;
    run_cli_expect_error(&["get", "not-a-valid-arid"])?;
    Ok(())
}

#[test]
fn test_invalid_envelope_format() -> Result<()> {
    run_cli_expect_error(&[
        "put",
        "ur:arid/hdcxuestvsdemusrdlkngwtosweortdwbasrdrfxhssgfmvlrflthdplatjydmmwahgdwlflguqz",
        "not-a-valid-envelope",
    ])?;
    Ok(())
}

#[test]
fn test_storage_backend_option() -> Result<()> {
    // Storage option is now command-specific, not global
    run_cli_contains(
        &["check", "--storage", "mainline", "--help"],
        "mainline",
    )?;
    run_cli_contains(&["put", "--storage", "ipfs", "--help"], "ipfs")?;
    Ok(())
}

#[test]
fn test_invalid_storage_backend() -> Result<()> {
    // Storage option is now command-specific
    run_cli_expect_error(&["check", "--storage", "invalid"])?;
    Ok(())
}

#[test]
fn test_generate_help() -> Result<()> {
    run_cli_contains(
        &["generate", "--help"],
        "Generate a new ARID or example Envelope",
    )?;
    run_cli_contains(&["generate", "--help"], "arid")?;
    Ok(())
}

#[test]
fn test_generate_arid() -> Result<()> {
    // Register tags for UR parsing
    bc_components::register_tags();

    // Generate two ARIDs and verify they're different and valid
    let output1 = run_cli(&["generate", "arid"])?;
    let output2 = run_cli(&["generate", "arid"])?;

    // Should be different
    assert_ne!(output1, output2, "Generated ARIDs should be unique");

    // Should be valid ur:arid format
    assert!(
        output1.starts_with("ur:arid/"),
        "Should start with ur:arid/"
    );
    assert!(
        output2.starts_with("ur:arid/"),
        "Should start with ur:arid/"
    );

    // Should be parseable as ARID
    ARID::from_ur_string(&output1)?;
    ARID::from_ur_string(&output2)?;

    Ok(())
}

#[test]
fn test_hex_arid_not_accepted() -> Result<()> {
    // Hex ARIDs should NOT be accepted (only ur:arid)
    run_cli_expect_error(&[
        "put",
        "dec7e82893c32f7a4fcec633c02c0ec32a4361ca3ee3bc8758ae07742e940550",
        "ur:envelope/tpsoiyfdihjzjzjldmksbaoede",
    ])?;
    Ok(())
}