chaincraft 0.3.0

A high-performance Rust-based platform for blockchain education and prototyping
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

use chaincraft::{
    storage::{MemoryStorage, Storage},
    Result,
};

#[tokio::test]
async fn test_memory_storage_basic_operations() -> Result<()> {
    let storage = MemoryStorage::new();

    // Initialize storage
    storage.initialize().await?;

    let key = "test_key";
    let value = b"test_value".to_vec();

    // Test that key doesn't exist initially
    assert!(!storage.exists(key).await?);
    assert!(storage.get(key).await?.is_none());

    // Put a value
    storage.put(key, value.clone()).await?;

    // Test that key now exists
    assert!(storage.exists(key).await?);

    // Get the value back
    let retrieved = storage.get(key).await?;
    assert!(retrieved.is_some());
    assert_eq!(retrieved.unwrap(), value);

    // Delete the key
    storage.delete(key).await?;

    // Test that key no longer exists
    assert!(!storage.exists(key).await?);
    assert!(storage.get(key).await?.is_none());

    Ok(())
}

#[tokio::test]
async fn test_memory_storage_multiple_keys() -> Result<()> {
    let storage = MemoryStorage::new();
    storage.initialize().await?;

    let keys_values = vec![
        ("key1", b"value1".to_vec()),
        ("key2", b"value2".to_vec()),
        ("key3", b"value3".to_vec()),
    ];

    // Store multiple key-value pairs
    for (key, value) in &keys_values {
        storage.put(key, value.clone()).await?;
    }

    // Verify all keys exist and have correct values
    for (key, expected_value) in &keys_values {
        assert!(storage.exists(key).await?);
        let retrieved = storage.get(key).await?;
        assert!(retrieved.is_some());
        assert_eq!(&retrieved.unwrap(), expected_value);
    }

    // Clear all data
    storage.clear().await?;

    // Verify all keys are gone
    for (key, _) in &keys_values {
        assert!(!storage.exists(key).await?);
        assert!(storage.get(key).await?.is_none());
    }

    Ok(())
}

#[tokio::test]
async fn test_memory_storage_overwrite() -> Result<()> {
    let storage = MemoryStorage::new();
    storage.initialize().await?;

    let key = "test_key";
    let value1 = b"first_value".to_vec();
    let value2 = b"second_value".to_vec();

    // Store first value
    storage.put(key, value1.clone()).await?;
    let retrieved = storage.get(key).await?;
    assert_eq!(retrieved.unwrap(), value1);

    // Overwrite with second value
    storage.put(key, value2.clone()).await?;
    let retrieved = storage.get(key).await?;
    assert_eq!(retrieved.unwrap(), value2);

    Ok(())
}

#[tokio::test]
async fn test_memory_storage_empty_value() -> Result<()> {
    let storage = MemoryStorage::new();
    storage.initialize().await?;

    let key = "empty_key";
    let empty_value = Vec::new();

    // Store empty value
    storage.put(key, empty_value.clone()).await?;

    // Verify it exists and is retrievable
    assert!(storage.exists(key).await?);
    let retrieved = storage.get(key).await?;
    assert!(retrieved.is_some());
    assert_eq!(retrieved.unwrap(), empty_value);

    Ok(())
}