eidetica 0.2.0

Decentralized DB. Remember Everything. Everywhere. All At Once.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use eidetica::sync::Address;

use super::helpers::*;

#[tokio::test]
async fn test_sync_with_http_transport() {
    use eidetica::Entry;

    let (_base_db, sync) = setup();

    // Enable HTTP transport
    sync.enable_http_transport().unwrap();

    // Start server on port 0 (OS assigns available port)
    sync.start_server_async("127.0.0.1:0").await.unwrap();

    // Get the actual bound address
    let server_addr = sync.get_server_address_async().await.unwrap();
    let http_address = Address::http(&server_addr);

    // Test the new protocol by sending entries
    let entry = Entry::root_builder()
        .set_subtree_data("data", r#"{"test": "value"}"#)
        .build()
        .expect("Entry should build successfully");

    sync.send_entries_async(vec![entry], &http_address)
        .await
        .unwrap();

    // Stop server
    sync.stop_server_async().await.unwrap();
}

#[tokio::test]
async fn test_multiple_sync_instances_communication() {
    use eidetica::Entry;

    // Create two separate sync instances
    let (_base_db1, sync_server) = setup();
    let (_base_db2, sync_client) = setup();

    // Enable HTTP transport on both
    sync_server.enable_http_transport().unwrap();
    sync_client.enable_http_transport().unwrap();

    // Start server on first instance (port 0 for auto-assignment)
    sync_server.start_server_async("127.0.0.1:0").await.unwrap();

    // Get the actual bound address from the server instance
    let server_addr = sync_server.get_server_address_async().await.unwrap();

    // Test communication by sending entries from client to server
    let entry = Entry::root_builder()
        .set_subtree_data("data", r#"{"message": "hello from client"}"#)
        .build()
        .expect("Entry should build successfully");

    let http_address = Address::http(&server_addr);
    sync_client
        .send_entries_async(vec![entry], &http_address)
        .await
        .unwrap();

    // Clean up
    sync_server.stop_server_async().await.unwrap();
}

#[tokio::test]
async fn test_send_entries_http() {
    use eidetica::Entry;

    // Create two separate sync instances
    let (_base_db1, sync_server) = setup();
    let (_base_db2, sync_client) = setup();

    // Enable HTTP transport on both
    sync_server.enable_http_transport().unwrap();
    sync_client.enable_http_transport().unwrap();

    // Start server on first instance (port 0 for auto-assignment)
    sync_server.start_server_async("127.0.0.1:0").await.unwrap();

    // Get the actual bound address from the server instance
    let server_addr = sync_server.get_server_address_async().await.unwrap();

    // Create some test entries
    let entry1 = Entry::root_builder()
        .set_subtree_data("users", r#"{"user1": "data1"}"#)
        .build()
        .expect("Entry should build successfully");
    let entry2 = Entry::root_builder()
        .set_subtree_data("users", r#"{"user2": "data2"}"#)
        .build()
        .expect("Entry should build successfully");
    let entries = vec![entry1, entry2];

    // Send entries from client to server
    let http_address = Address::http(&server_addr);
    sync_client
        .send_entries_async(entries, &http_address)
        .await
        .unwrap();

    // Clean up
    sync_server.stop_server_async().await.unwrap();
}

#[test]
fn test_sync_without_transport_enabled() {
    use eidetica::Entry;

    let (_base_db, sync) = setup();

    // Attempting to send entries without enabling transport should fail
    let entry = Entry::root_builder()
        .build()
        .expect("Root entry should build successfully");
    let result = sync.send_entries(vec![entry], &Address::http("127.0.0.1:8084"));
    assert!(result.is_err());
    let err = result.unwrap_err();
    match err {
        eidetica::Error::Sync(sync_err) => {
            assert!(sync_err.is_configuration_error());
        }
        _ => panic!("Expected Sync error, got {err:?}"),
    }
}

#[test]
fn test_sync_server_without_transport_enabled() {
    let (_base_db, sync) = setup();

    // Attempting to start server without enabling transport should fail
    let result = sync.start_server("127.0.0.1:8085");
    assert!(result.is_err());
    let err = result.unwrap_err();
    match err {
        eidetica::Error::Sync(sync_err) => {
            assert!(sync_err.is_configuration_error());
        }
        _ => panic!("Expected Sync error, got {err:?}"),
    }
}

#[test]
fn test_sync_connect_to_invalid_address() {
    use eidetica::Entry;

    let (_base_db, sync) = setup();
    sync.enable_http_transport().unwrap();

    // Try to send entries to a non-existent server
    let entry = Entry::root_builder()
        .build()
        .expect("Root entry should build successfully");
    let result = sync.send_entries(vec![entry], &Address::http("127.0.0.1:19998"));
    assert!(result.is_err());
}