@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/tests/state_persistence_integration.rs

@@ -1,365 +0,0 @@
-//! Comprehensive tests for FeltDB State Model persistence
-//!
-//! This test suite verifies that:
-//! 1. State revisions persist to disk through FeltDB
-//! 2. Current pointer persists correctly
-//! 3. Branches persist and recover
-//! 4. Restart recovery works (close database, reopen and recover state)
-//! 5. Deterministic StateIds survive restart
-//! 6. Volatile stores remain unchanged
-
-#[cfg(test)]
-mod state_persistence_tests {
-    use feltdb::state_model::StateStore;
-    use std::sync::Arc;
-    use tempfile::TempDir;
-
-    #[test]
-    fn test_persistent_store_saves_revisions_to_disk() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // Create initial state with FeltDB persistence
-        let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .expect("create");
-        let rev2 = store1
-            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
-            .expect("commit");
-
-        let id1 = rev1.id.clone();
-        let id2 = rev2.id.clone();
-        let id2_hex = id2.as_hex().to_string();
-
-        // Verify both revisions exist
-        assert!(store1.exists(&id1), "rev1 should exist");
-        assert!(store1.exists(&id2), "rev2 should exist");
-        assert_eq!(
-            store1.get(&id2).map(|r| r.id.as_hex().to_string()),
-            Some(id2_hex.clone())
-        );
-
-        // Drop store and database (simulate restart)
-        drop(store1);
-
-        // New process: recover from disk
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery setup");
-
-        // Verify all revisions still exist
-        assert!(store2.exists(&id1), "rev1 should survive restart");
-        assert!(store2.exists(&id2), "rev2 should survive restart");
-        assert_eq!(
-            store2.get(&id2).map(|r| r.id.as_hex().to_string()),
-            Some(id2_hex),
-            "the revision is retrievable by identity after restart"
-        );
-
-        // Verify content is correct
-        let recovered_rev2 = store2.get(&id2).expect("get rev2");
-        assert_eq!(recovered_rev2.content, r#"{"v":2}"#);
-        assert_eq!(recovered_rev2.authority, "auth");
-    }
-
-    #[test]
-    fn test_persistent_store_preserves_state_id_determinism() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1
-            .create(
-                "docs:1",
-                r#"{"fixed":"content"}"#.to_string(),
-                "auth".to_string(),
-            )
-            .expect("create");
-        let id1 = rev1.id.clone();
-        drop(store1);
-
-        // Recover and recreate the same content
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
-        let recovered = store2.get(&id1).expect("get");
-
-        // Content hash must be the same for identical content
-        assert_eq!(
-            recovered.id.as_hex(),
-            id1.as_hex(),
-            "StateId should be deterministic"
-        );
-    }
-
-    #[test]
-    fn test_persistent_store_handles_branch_persistence() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // Create store and initial state
-        let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .expect("create");
-
-        let id1 = rev1.id.clone();
-        let id1_hex = id1.as_hex().to_string();
-
-        // There are no named branches. A revision is addressed by its own
-        // content-derived identity, which is what a name would have pointed at.
-        assert_eq!(
-            store1.get(&id1).map(|id| id.id.as_hex().to_string()),
-            Some(id1_hex.clone())
-        );
-        drop(store1);
-
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("reopen");
-        assert_eq!(
-            store2.get(&id1).map(|id| id.id.as_hex().to_string()),
-            Some(id1_hex),
-            "the revision survives restart under its own identity"
-        );
-    }
-
-    #[test]
-    fn test_volatile_store_does_not_persist() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // Create volatile store
-        let store1 = StateStore::new_volatile();
-        let rev1 = store1
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .expect("create");
-        drop(store1);
-
-        // Try to recover from disk (should be empty)
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("create store");
-        assert!(
-            !store2.exists(&rev1.id),
-            "volatile store should not persist"
-        );
-        assert!(
-            store2.get(&rev1.id).is_none(),
-            "nothing from the volatile store reached disk"
-        );
-    }
-
-    #[test]
-    fn test_persistent_store_tracks_ancestry_across_restart() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // Create chain of revisions
-        let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .expect("create");
-        let rev2 = store1
-            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
-            .expect("commit");
-        let rev3 = store1
-            .commit(r#"{"v":3}"#.to_string(), &rev2, "auth".to_string())
-            .expect("commit");
-
-        let id1 = rev1.id.clone();
-        let id2 = rev2.id.clone();
-        let id3 = rev3.id.clone();
-        drop(store1);
-
-        // Recover and verify parent pointers
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
-
-        let recovered_rev3 = store2.get(&id3).expect("get rev3");
-        assert_eq!(
-            recovered_rev3.parent_id.as_ref().map(|id| id.as_hex()),
-            Some(id2.as_hex()),
-            "rev3 parent should be rev2"
-        );
-
-        let recovered_rev2 = store2.get(&id2).expect("get rev2");
-        assert_eq!(
-            recovered_rev2.parent_id.as_ref().map(|id| id.as_hex()),
-            Some(id1.as_hex()),
-            "rev2 parent should be rev1"
-        );
-
-        let recovered_rev1 = store2.get(&id1).expect("get rev1");
-        assert!(
-            recovered_rev1.parent_id.is_none(),
-            "rev1 should have no parent"
-        );
-    }
-
-    #[test]
-    fn test_persistent_store_multiple_commits_in_sequence() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        let db = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-
-        // Commit sequence
-        let rev1 = store
-            .create("docs:1", r#"{"step":1}"#.to_string(), "app".to_string())
-            .expect("1");
-        let rev2 = store
-            .commit(r#"{"step":2}"#.to_string(), &rev1, "app".to_string())
-            .expect("2");
-        let rev3 = store
-            .commit(r#"{"step":3}"#.to_string(), &rev2, "app".to_string())
-            .expect("3");
-        let rev4 = store
-            .commit(r#"{"step":4}"#.to_string(), &rev3, "app".to_string())
-            .expect("4");
-        let rev5 = store
-            .commit(r#"{"step":5}"#.to_string(), &rev4, "app".to_string())
-            .expect("5");
-
-        let id1 = rev1.id.clone();
-        let id2 = rev2.id.clone();
-        let id3 = rev3.id.clone();
-        let id4 = rev4.id.clone();
-        let id5 = rev5.id.clone();
-
-        // All should exist
-        assert!(store.exists(&id1));
-        assert!(store.exists(&id2));
-        assert!(store.exists(&id3));
-        assert!(store.exists(&id4));
-        assert!(store.exists(&id5));
-        let id5_hex = id5.as_hex().to_string();
-        assert_eq!(
-            store.get(&id5).map(|r| r.id.as_hex().to_string()),
-            Some(id5_hex)
-        );
-    }
-
-    #[test]
-    fn test_persistence_with_corrupted_content() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // Create and persist
-        let db1 = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store1 = StateStore::with_feltdb(Arc::new(db1)).expect("create store");
-        let rev1 = store1
-            .create(
-                "docs:1",
-                r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#.to_string(),
-                "auth".to_string(),
-            )
-            .expect("create");
-        let id1 = rev1.id.clone();
-        drop(store1);
-
-        // Recover
-        let db2 = feltdb::FeltDb::open(&temp_path).expect("open db again");
-        let store2 = StateStore::with_feltdb(Arc::new(db2)).expect("recovery");
-        let recovered = store2.get(&id1).expect("get");
-        assert_eq!(
-            recovered.content,
-            r#"{"complex":{"nested":{"data":[1,2,3],"unicode":"αβγ"}}}"#
-        );
-    }
-
-    #[test]
-    fn test_concurrent_access_to_persistent_store() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        let db = feltdb::FeltDb::open(&temp_path).expect("open db");
-        let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-        let rev1 = store
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .expect("create");
-        let id1 = rev1.id.clone();
-
-        // Clone the store for concurrent access
-        let store_clone1 = store.clone();
-        let store_clone2 = store.clone();
-
-        let id1_hex = id1.as_hex().to_string();
-
-        // Both can read
-        assert_eq!(
-            store_clone1.get(&id1).map(|r| r.id.as_hex().to_string()),
-            Some(id1_hex.clone())
-        );
-        assert_eq!(
-            store_clone2.get(&id1).map(|r| r.id.as_hex().to_string()),
-            Some(id1_hex)
-        );
-
-        // Commit from one
-        let rev2 = store_clone1
-            .commit(r#"{"v":2}"#.to_string(), &rev1, "auth".to_string())
-            .expect("commit");
-        let id2 = rev2.id.clone();
-
-        // Both should see the new revision
-        assert!(store.exists(&id2));
-        assert!(store_clone2.exists(&id2));
-    }
-
-    #[test]
-    fn test_persistent_store_recovery_after_multiple_crashes() {
-        let temp_dir = TempDir::new().unwrap();
-        let temp_path = temp_dir.path().join("test.log");
-
-        // The caller carries the ids it cares about across restarts.
-        let rev2_id;
-        let rev3_id;
-
-        // Cycle 1: create initial state
-        {
-            let db = feltdb::FeltDb::open(&temp_path).expect("open db");
-            let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-            let rev1 = store
-                .create("docs:1", r#"{"cycle":1}"#.to_string(), "auth".to_string())
-                .expect("create1");
-            rev2_id = store
-                .commit(r#"{"cycle":1.5}"#.to_string(), &rev1, "auth".to_string())
-                .expect("commit1")
-                .id;
-        }
-
-        // Cycle 2: reopen and add more, starting from the id we carried
-        {
-            let db = feltdb::FeltDb::open(&temp_path).expect("open db");
-            let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-            let rev2 = store.get(&rev2_id).expect("rev2 survives");
-            rev3_id = store
-                .commit(r#"{"cycle":2}"#.to_string(), &rev2, "auth".to_string())
-                .expect("commit2")
-                .id;
-        }
-
-        // Cycle 3: verify all history
-        {
-            let db = feltdb::FeltDb::open(&temp_path).expect("open db");
-            let store = StateStore::with_feltdb(Arc::new(db)).expect("create store");
-
-            // Walk the chain backwards - count how many nodes we can reach
-            let mut rev = store.get(&rev3_id).expect("rev3 survives every cycle");
-            let mut count = 1; // Start with 1 for the current node
-            while let Some(parent_id) = &rev.parent_id {
-                rev = store.get(parent_id).expect("get parent");
-                count += 1;
-            }
-
-            assert!(
-                count >= 3,
-                "should have chain of at least 3 revisions, got {}",
-                count
-            );
-        }
-    }
-}