absurder-sql 0.1.23

AbsurderSQL - SQLite + IndexedDB that's absurdly better than absurd-sql
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

#![cfg(not(target_arch = "wasm32"))]
use absurder_sql::storage::BlockStorage;
use serial_test::serial;
use tempfile::TempDir;
#[path = "common/mod.rs"]
mod common;

#[tokio::test]
#[serial]
async fn test_block_allocation_and_deallocation() {
    // Test that we can allocate and deallocate blocks properly
    let tmp = TempDir::new().expect("tempdir");
    // Safety: per-test isolated env var, tests are serialized
    common::set_var("ABSURDERSQL_FS_BASE", tmp.path());
    let mut storage = BlockStorage::new("test_allocation")
        .await
        .expect("Should create storage");

    // Test allocating new blocks
    let block1 = storage
        .allocate_block()
        .await
        .expect("Should allocate first block");
    let block2 = storage
        .allocate_block()
        .await
        .expect("Should allocate second block");

    // Blocks should be different
    assert_ne!(block1, block2, "Allocated blocks should have different IDs");

    // Test writing to allocated blocks
    let test_data = vec![42u8; 4096];
    storage
        .write_block(block1, test_data.clone())
        .await
        .expect("Should write to allocated block");

    // Test reading from allocated block
    let read_data = storage
        .read_block(block1)
        .await
        .expect("Should read from allocated block");
    assert_eq!(read_data, test_data, "Read data should match written data");

    // Test deallocating blocks
    storage
        .deallocate_block(block1)
        .await
        .expect("Should deallocate block");

    // After deallocation, the block should be available for reuse
    let block3 = storage
        .allocate_block()
        .await
        .expect("Should allocate block after deallocation");

    // The deallocated block should be reused
    assert_eq!(block1, block3, "Deallocated block should be reused");
}

#[tokio::test]
#[serial]
async fn test_block_allocation_tracking() {
    // Test that allocation tracking works correctly
    let tmp = TempDir::new().expect("tempdir");
    // Safety: per-test isolated env var, tests are serialized
    common::set_var("ABSURDERSQL_FS_BASE", tmp.path());
    let mut storage = BlockStorage::new("test_tracking")
        .await
        .expect("Should create storage");

    // Initially no blocks should be allocated
    assert_eq!(
        storage.get_allocated_count(),
        0,
        "Should start with 0 allocated blocks"
    );

    // Allocate some blocks
    let _block1 = storage.allocate_block().await.expect("Should allocate");
    assert_eq!(
        storage.get_allocated_count(),
        1,
        "Should have 1 allocated block"
    );

    let _block2 = storage.allocate_block().await.expect("Should allocate");
    assert_eq!(
        storage.get_allocated_count(),
        2,
        "Should have 2 allocated blocks"
    );

    // Deallocate one block
    storage
        .deallocate_block(_block1)
        .await
        .expect("Should deallocate");
    assert_eq!(
        storage.get_allocated_count(),
        1,
        "Should have 1 allocated block after deallocation"
    );
}

#[tokio::test]
#[serial]
async fn test_block_allocation_errors() {
    // Test error conditions for block allocation
    let tmp = TempDir::new().expect("tempdir");
    // Safety: per-test isolated env var, tests are serialized
    common::set_var("ABSURDERSQL_FS_BASE", tmp.path());
    let mut storage = BlockStorage::new("test_errors")
        .await
        .expect("Should create storage");

    // Test deallocating non-existent block
    let result = storage.deallocate_block(999999).await;
    assert!(
        result.is_err(),
        "Should error when deallocating non-existent block"
    );

    // Test double deallocation
    let block = storage.allocate_block().await.expect("Should allocate");
    storage
        .deallocate_block(block)
        .await
        .expect("Should deallocate first time");

    let result = storage.deallocate_block(block).await;
    assert!(result.is_err(), "Should error on double deallocation");
}