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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

//! Tests for automatic sync-on-commit functionality.
//!
//! These tests verify that the global callback registered in Instance::enable_sync()
//! correctly triggers sync operations based on combined settings.
//!
//! Note: Since we can't directly test the private callback registration from integration tests,
//! we test the observable behavior: that enable_sync() works and doesn't crash when commits occur.

use crate::helpers::test_instance;
use eidetica::{
    crdt::Doc,
    user::types::{DatabasePreferences, SyncSettings},
};

/// Test that commits work correctly when sync is enabled
/// This verifies the callback doesn't break normal operation
#[test]
fn test_commits_work_with_sync_enabled() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    // Create user and database
    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");

    let mut db_settings = Doc::new();
    db_settings.set_string("name", "test_db");
    let key_id = user.get_default_key().expect("Get default key");
    let db = user
        .create_database(db_settings, &key_id)
        .expect("Create database");
    let db_id = db.root_id().clone();

    // Add database with sync enabled
    user.add_database(DatabasePreferences {
        database_id: db_id.clone(),
        key_id: key_id.clone(),
        sync_settings: SyncSettings {
            sync_enabled: true,
            sync_on_commit: true,
            interval_seconds: None,
            properties: Default::default(),
        },
    })
    .expect("Add database");

    // Register user with sync
    let sync = instance.sync().expect("Sync should exist");
    sync.sync_user(user.user_uuid(), user.user_database().root_id())
        .expect("Register user");

    std::thread::sleep(std::time::Duration::from_millis(50));

    // Make a write - callback should be invoked but handle gracefully (no transport)
    let tx = db.new_transaction().expect("Create transaction");
    let store = tx
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc = Doc::new();
    doc.set_string("message", "Test");
    store.set("key1", doc).expect("Set doc");

    let entry_id = tx.commit().expect("Commit should succeed");

    // Verify the entry was actually committed
    let fetched = instance.backend().get(&entry_id).expect("Get entry");
    assert_eq!(fetched.id(), &entry_id, "Entry should exist in backend");
}

/// Test that multiple commits work correctly
#[test]
fn test_multiple_commits_with_sync_enabled() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");

    let mut db_settings = Doc::new();
    db_settings.set_string("name", "test_db");
    let key_id = user.get_default_key().expect("Get default key");
    let db = user
        .create_database(db_settings, &key_id)
        .expect("Create database");

    // Make 5 writes - all should succeed
    for i in 0..5 {
        let tx = db.new_transaction().expect("Create transaction");
        let store = tx
            .get_store::<eidetica::store::DocStore>("data")
            .expect("Get store");
        let mut doc = Doc::new();
        doc.set_string("message", format!("Message {}", i));
        store.set(format!("key{}", i), doc).expect("Set doc");
        tx.commit()
            .unwrap_or_else(|_| panic!("Commit {} should succeed", i));
    }
}

/// Test that commits work when sync_enabled=false
#[test]
fn test_commits_with_sync_disabled() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");

    let mut db_settings = Doc::new();
    db_settings.set_string("name", "test_db");
    let key_id = user.get_default_key().expect("Get default key");
    let db = user
        .create_database(db_settings, &key_id)
        .expect("Create database");
    let db_id = db.root_id().clone();

    // Add database with sync disabled
    user.add_database(DatabasePreferences {
        database_id: db_id.clone(),
        key_id: key_id.clone(),
        sync_settings: SyncSettings {
            sync_enabled: false,
            sync_on_commit: true,
            interval_seconds: None,
            properties: Default::default(),
        },
    })
    .expect("Add database");

    // Commit should work fine
    let tx = db.new_transaction().expect("Create transaction");
    let store = tx
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc = Doc::new();
    doc.set_string("message", "Sync disabled");
    store.set("key1", doc).expect("Set doc");
    tx.commit().expect("Commit should succeed");
}

/// Test that commits work when sync_on_commit=false
#[test]
fn test_commits_with_sync_on_commit_disabled() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");

    let mut db_settings = Doc::new();
    db_settings.set_string("name", "test_db");
    let key_id = user.get_default_key().expect("Get default key");
    let db = user
        .create_database(db_settings, &key_id)
        .expect("Create database");
    let db_id = db.root_id().clone();

    // Add database with sync_on_commit=false
    user.add_database(DatabasePreferences {
        database_id: db_id.clone(),
        key_id: key_id.clone(),
        sync_settings: SyncSettings {
            sync_enabled: true,
            sync_on_commit: false,
            interval_seconds: Some(3600),
            properties: Default::default(),
        },
    })
    .expect("Add database");

    // Commit should work fine
    let tx = db.new_transaction().expect("Create transaction");
    let store = tx
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc = Doc::new();
    doc.set_string("message", "Sync on commit disabled");
    store.set("key1", doc).expect("Set doc");
    tx.commit().expect("Commit should succeed");
}

/// Test that commits work before transport is enabled
#[test]
fn test_commits_before_transport_enabled() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");

    let mut db_settings = Doc::new();
    db_settings.set_string("name", "test_db");
    let key_id = user.get_default_key().expect("Get default key");
    let db = user
        .create_database(db_settings, &key_id)
        .expect("Create database");

    // Don't enable transport, but commits should still work
    let tx = db.new_transaction().expect("Create transaction");
    let store = tx
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc = Doc::new();
    doc.set_string("message", "No transport");
    store.set("key1", doc).expect("Set doc");
    tx.commit()
        .expect("Commit should succeed even without transport");
}

/// Test that commits work with multiple databases
#[test]
fn test_commits_with_multiple_databases() {
    let instance = test_instance();
    instance.enable_sync().expect("Enable sync");

    instance.create_user("testuser", None).expect("Create user");
    let mut user = instance.login_user("testuser", None).expect("Login user");
    let key_id = user.get_default_key().expect("Get default key");

    // Create two databases
    let mut db1_settings = Doc::new();
    db1_settings.set_string("name", "db1");
    let db1 = user
        .create_database(db1_settings, &key_id)
        .expect("Create db1");

    let mut db2_settings = Doc::new();
    db2_settings.set_string("name", "db2");
    let db2 = user
        .create_database(db2_settings, &key_id)
        .expect("Create db2");

    // Write to both
    let tx1 = db1.new_transaction().expect("Create transaction");
    let store1 = tx1
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc1 = Doc::new();
    doc1.set_string("message", "DB1");
    store1.set("key1", doc1).expect("Set doc");
    tx1.commit().expect("Commit db1");

    let tx2 = db2.new_transaction().expect("Create transaction");
    let store2 = tx2
        .get_store::<eidetica::store::DocStore>("data")
        .expect("Get store");
    let mut doc2 = Doc::new();
    doc2.set_string("message", "DB2");
    store2.set("key1", doc2).expect("Set doc");
    tx2.commit().expect("Commit db2");
}

/// Test that sync can be enabled multiple times (idempotent)
#[test]
fn test_enable_sync_is_idempotent() {
    let instance = test_instance();

    instance.enable_sync().expect("First enable_sync");
    instance
        .enable_sync()
        .expect("Second enable_sync should be no-op");
    instance
        .enable_sync()
        .expect("Third enable_sync should be no-op");

    // Should still work
    assert!(instance.sync().is_some(), "Sync should exist");
}